To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 541
- compare with another revision
- download diff
- download tarball
- view history from revision 541
- Committer: Teddy Hogeborn
- Date: 2011-12-31 20:07:11 UTC
- mfrom: (535.1.9 wireless-network-hook)
- Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook. Fix bridge network hook to use
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- network-hooks.d
- files removed:
- plugins.d/usplash
- files renamed:
- plugins.d/password-request.c => plugins.d/mandos-client.c
- plugins.d/password-request.xml => plugins.d/mandos-client.xml
- files modified:
- .bzrignore
added
removed
plugin-runner.c
1
/* -*- coding: utf-8 -*- */
1
/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
* Mandos plugin runner - Run Mandos plugins
4
4
*
5
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
5
* Copyright © 2008-2011 Teddy Hogeborn
6
* Copyright © 2008-2011 Björn Påhlsson
6
7
*
7
8
* This program is free software: you can redistribute it and/or
8
9
* modify it under the terms of the GNU General Public License as
18
19
* along with this program. If not, see
19
20
* <http://www.gnu.org/licenses/>.
20
21
*
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
* Contact the authors at <mandos@recompile.se>.
22
23
*/
23
24
24
25
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
26
asprintf(), O_CLOEXEC */
26
27
#include <stddef.h> /* size_t, NULL */
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
EXIT_SUCCESS, realloc() */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,
29
realloc() */
29
30
#include <stdbool.h> /* bool, true, false */
30
#include <stdio.h> /* perror, popen(), fileno(),
31
fprintf(), stderr, STDOUT_FILENO */
32
#include <sys/types.h> /* DIR, opendir(), stat(), struct
31
#include <stdio.h> /* fileno(), fprintf(),
32
stderr, STDOUT_FILENO */
33
#include <sys/types.h> /* DIR, fdopendir(), stat(), struct
33
34
stat, waitpid(), WIFEXITED(),
34
35
WEXITSTATUS(), wait(), pid_t,
35
36
uid_t, gid_t, getuid(), getgid(),
37
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
38
39
FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
40
WEXITSTATUS() */
41
WEXITSTATUS(), WTERMSIG(),
42
WCOREDUMP() */
41
43
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
42
44
#include <iso646.h> /* and, or, not */
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
45
#include <dirent.h> /* DIR, struct dirent, fdopendir(),
44
46
readdir(), closedir(), dirfd() */
45
47
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
46
48
fcntl(), setuid(), setgid(),
47
49
F_GETFD, F_SETFD, FD_CLOEXEC,
48
50
access(), pipe(), fork(), close()
49
dup2, STDOUT_FILENO, _exit(),
51
dup2(), STDOUT_FILENO, _exit(),
50
52
execv(), write(), read(),
51
53
close() */
52
54
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
55
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), asprintf() */
56
#include <string.h> /* strsep, strlen(), asprintf(),
57
strsignal(), strcmp(), strncmp() */
55
58
#include <errno.h> /* errno */
56
59
#include <argp.h> /* struct argp_option, struct
57
60
argp_state, struct argp,
61
64
#include <signal.h> /* struct sigaction, sigemptyset(),
62
65
sigaddset(), sigaction(),
63
66
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
SIG_UNBLOCK, kill() */
67
SIG_UNBLOCK, kill(), sig_atomic_t
68
*/
65
69
#include <errno.h> /* errno, EBADF */
70
#include <inttypes.h> /* intmax_t, PRIdMAX, strtoimax() */
71
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
72
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
#include <errno.h> /* errno */
74
#include <error.h> /* error() */
66
75
67
76
#define BUFFER_SIZE 256
68
77
69
78
#define PDIR "/lib/mandos/plugins.d"
70
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
71
80
72
const char *argp_program_version = "plugin-runner 1.0";
73
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
74
75
struct process;
76
77
typedef struct process{
78
pid_t pid;
79
int fd;
80
char *buffer;
81
size_t buffer_size;
82
size_t buffer_length;
83
bool eof;
84
volatile bool completed;
85
volatile int status;
86
struct process *next;
87
} process;
81
const char *argp_program_version = "plugin-runner " VERSION;
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
88
83
89
84
typedef struct plugin{
90
85
char *name; /* can be NULL or any plugin name */
93
88
char **environ;
94
89
int envc;
95
90
bool disabled;
91
92
/* Variables used for running processes*/
93
pid_t pid;
94
int fd;
95
char *buffer;
96
size_t buffer_size;
97
size_t buffer_length;
98
bool eof;
99
volatile sig_atomic_t completed;
100
int status;
96
101
struct plugin *next;
97
102
} plugin;
98
103
99
static plugin *getplugin(char *name, plugin **plugin_list){
100
for (plugin *p = *plugin_list; p != NULL; p = p->next){
101
if ((p->name == name)
102
or (p->name and name and (strcmp(p->name, name) == 0))){
104
static plugin *plugin_list = NULL;
105
106
/* Gets an existing plugin based on name,
107
or if none is found, creates a new one */
108
static plugin *getplugin(char *name){
109
/* Check for existing plugin with that name */
110
for(plugin *p = plugin_list; p != NULL; p = p->next){
111
if((p->name == name)
112
or (p->name and name and (strcmp(p->name, name) == 0))){
103
113
return p;
104
114
}
105
115
}
106
116
/* Create a new plugin */
107
plugin *new_plugin = malloc(sizeof(plugin));
108
if (new_plugin == NULL){
117
plugin *new_plugin = NULL;
118
do {
119
new_plugin = malloc(sizeof(plugin));
120
} while(new_plugin == NULL and errno == EINTR);
121
if(new_plugin == NULL){
109
122
return NULL;
110
123
}
111
124
char *copy_name = NULL;
112
125
if(name != NULL){
113
copy_name = strdup(name);
126
do {
127
copy_name = strdup(name);
128
} while(copy_name == NULL and errno == EINTR);
114
129
if(copy_name == NULL){
130
int e = errno;
131
free(new_plugin);
132
errno = e;
115
133
return NULL;
116
134
}
117
135
}
118
136
119
*new_plugin = (plugin) { .name = copy_name,
120
.argc = 1,
121
.envc = 0,
122
.disabled = false,
123
.next = *plugin_list };
137
*new_plugin = (plugin){ .name = copy_name,
138
.argc = 1,
139
.disabled = false,
140
.next = plugin_list };
124
141
125
new_plugin->argv = malloc(sizeof(char *) * 2);
126
if (new_plugin->argv == NULL){
142
do {
143
new_plugin->argv = malloc(sizeof(char *) * 2);
144
} while(new_plugin->argv == NULL and errno == EINTR);
145
if(new_plugin->argv == NULL){
146
int e = errno;
127
147
free(copy_name);
128
148
free(new_plugin);
149
errno = e;
129
150
return NULL;
130
151
}
131
152
new_plugin->argv[0] = copy_name;
132
153
new_plugin->argv[1] = NULL;
133
134
new_plugin->environ = malloc(sizeof(char *));
154
155
do {
156
new_plugin->environ = malloc(sizeof(char *));
157
} while(new_plugin->environ == NULL and errno == EINTR);
135
158
if(new_plugin->environ == NULL){
159
int e = errno;
136
160
free(copy_name);
137
161
free(new_plugin->argv);
138
162
free(new_plugin);
163
errno = e;
139
164
return NULL;
140
165
}
141
166
new_plugin->environ[0] = NULL;
167
142
168
/* Append the new plugin to the list */
143
*plugin_list = new_plugin;
169
plugin_list = new_plugin;
144
170
return new_plugin;
145
171
}
146
172
147
173
/* Helper function for add_argument and add_environment */
174
__attribute__((nonnull))
148
175
static bool add_to_char_array(const char *new, char ***array,
149
176
int *len){
150
177
/* Resize the pointed-to array to hold one more pointer */
151
*array = realloc(*array, sizeof(char *)
152
* (size_t) ((*len) + 2));
178
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} while(*array == NULL and errno == EINTR);
153
182
/* Malloc check */
154
183
if(*array == NULL){
155
184
return false;
156
185
}
157
186
/* Make a copy of the new string */
158
char *copy = strdup(new);
187
char *copy;
188
do {
189
copy = strdup(new);
190
} while(copy == NULL and errno == EINTR);
159
191
if(copy == NULL){
160
192
return false;
161
193
}
168
200
}
169
201
170
202
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
171
204
static bool add_argument(plugin *p, const char *arg){
172
205
if(p == NULL){
173
206
return false;
176
209
}
177
210
178
211
/* Add to a plugin's environment */
179
static bool add_environment(plugin *p, const char *def){
212
__attribute__((nonnull(2)))
213
static bool add_environment(plugin *p, const char *def, bool replace){
180
214
if(p == NULL){
181
215
return false;
182
216
}
217
/* namelen = length of name of environment variable */
218
size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
/* Search for this environment variable */
220
for(char **e = p->environ; *e != NULL; e++){
221
if(strncmp(*e, def, namelen + 1) == 0){
222
/* It already exists */
223
if(replace){
224
char *new;
225
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
228
if(new == NULL){
229
return false;
230
}
231
*e = new;
232
strcpy(*e, def);
233
}
234
return true;
235
}
236
}
183
237
return add_to_char_array(def, &(p->environ), &(p->envc));
184
238
}
185
239
186
187
240
/*
188
241
* Based on the example in the GNU LibC manual chapter 13.13 "File
189
242
* Descriptor Flags".
190
* *Note File Descriptor Flags:(libc)Descriptor Flags.
243
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
191
244
*/
192
static int set_cloexec_flag(int fd)
193
{
194
int ret = fcntl(fd, F_GETFD, 0);
245
static int set_cloexec_flag(int fd){
246
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
195
247
/* If reading the flags failed, return error indication now. */
196
248
if(ret < 0){
197
249
return ret;
198
250
}
199
251
/* Store modified flag word in the descriptor. */
200
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
252
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
ret | FD_CLOEXEC));
201
254
}
202
255
203
process *process_list = NULL;
204
256
205
257
/* Mark processes as completed when they exit, and save their exit
206
258
status. */
207
void handle_sigchld(__attribute__((unused)) int sig){
259
static void handle_sigchld(__attribute__((unused)) int sig){
260
int old_errno = errno;
208
261
while(true){
209
process *proc = process_list;
262
plugin *proc = plugin_list;
210
263
int status;
211
264
pid_t pid = waitpid(-1, &status, WNOHANG);
212
265
if(pid == 0){
214
267
break;
215
268
}
216
269
if(pid == -1){
217
if (errno != ECHILD){
218
perror("waitpid");
270
if(errno == ECHILD){
271
/* No child processes */
272
break;
219
273
}
220
/* No child processes */
221
break;
274
error(0, errno, "waitpid");
222
275
}
223
276
224
277
/* A child exited, find it in process_list */
225
278
while(proc != NULL and proc->pid != pid){
226
279
proc = proc->next;
230
283
continue;
231
284
}
232
285
proc->status = status;
233
proc->completed = true;
286
proc->completed = 1;
234
287
}
288
errno = old_errno;
235
289
}
236
290
237
bool print_out_password(const char *buffer, size_t length){
291
/* Prints out a password to stdout */
292
__attribute__((nonnull))
293
static bool print_out_password(const char *buffer, size_t length){
238
294
ssize_t ret;
239
if(length>0 and buffer[length-1] == '\n'){
240
length--;
241
}
242
295
for(size_t written = 0; written < length; written += (size_t)ret){
243
296
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
244
297
length - written));
249
302
return true;
250
303
}
251
304
252
static void free_plugin_list(plugin *plugin_list){
253
for(plugin *next; plugin_list != NULL; plugin_list = next){
254
next = plugin_list->next;
255
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
256
free(*arg);
257
}
258
free(plugin_list->argv);
259
for(char **env = plugin_list->environ; *env != NULL; env++){
260
free(*env);
261
}
262
free(plugin_list->environ);
263
free(plugin_list);
305
/* Removes and free a plugin from the plugin list */
306
__attribute__((nonnull))
307
static void free_plugin(plugin *plugin_node){
308
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
310
free(*arg);
311
}
312
free(plugin_node->argv);
313
for(char **env = plugin_node->environ; *env != NULL; env++){
314
free(*env);
315
}
316
free(plugin_node->environ);
317
free(plugin_node->buffer);
318
319
/* Removes the plugin from the singly-linked list */
320
if(plugin_node == plugin_list){
321
/* First one - simple */
322
plugin_list = plugin_list->next;
323
} else {
324
/* Second one or later */
325
for(plugin *p = plugin_list; p != NULL; p = p->next){
326
if(p->next == plugin_node){
327
p->next = plugin_node->next;
328
break;
329
}
330
}
331
}
332
333
free(plugin_node);
334
}
335
336
static void free_plugin_list(void){
337
while(plugin_list != NULL){
338
free_plugin(plugin_list);
264
339
}
265
340
}
266
341
274
349
struct stat st;
275
350
fd_set rfds_all;
276
351
int ret, maxfd = 0;
352
ssize_t sret;
277
353
uid_t uid = 65534;
278
354
gid_t gid = 65534;
279
355
bool debug = false;
288
364
sigemptyset(&sigchld_action.sa_mask);
289
365
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
290
366
if(ret == -1){
291
perror("sigaddset");
292
exitstatus = EXIT_FAILURE;
367
error(0, errno, "sigaddset");
368
exitstatus = EX_OSERR;
293
369
goto fallback;
294
370
}
295
371
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
296
372
if(ret == -1){
297
perror("sigaction");
298
exitstatus = EXIT_FAILURE;
373
error(0, errno, "sigaction");
374
exitstatus = EX_OSERR;
299
375
goto fallback;
300
376
}
301
377
304
380
{ .name = "global-options", .key = 'g',
305
381
.arg = "OPTION[,OPTION[,...]]",
306
382
.doc = "Options passed to all plugins" },
307
{ .name = "global-envs", .key = 'e',
383
{ .name = "global-env", .key = 'G',
308
384
.arg = "VAR=value",
309
385
.doc = "Environment variable passed to all plugins" },
310
386
{ .name = "options-for", .key = 'o',
311
387
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
312
388
.doc = "Options passed only to specified plugin" },
313
{ .name = "envs-for", .key = 'f',
389
{ .name = "env-for", .key = 'E',
314
390
.arg = "PLUGIN:ENV=value",
315
391
.doc = "Environment variable passed to specified plugin" },
316
392
{ .name = "disable", .key = 'd',
317
393
.arg = "PLUGIN",
318
394
.doc = "Disable a specific plugin", .group = 1 },
395
{ .name = "enable", .key = 'e',
396
.arg = "PLUGIN",
397
.doc = "Enable a specific plugin", .group = 1 },
319
398
{ .name = "plugin-dir", .key = 128,
320
399
.arg = "DIRECTORY",
321
400
.doc = "Specify a different plugin directory", .group = 2 },
330
409
.doc = "Group ID the plugins will run as", .group = 3 },
331
410
{ .name = "debug", .key = 132,
332
411
.doc = "Debug mode", .group = 4 },
412
/*
413
* These reproduce what we would get without ARGP_NO_HELP
414
*/
415
{ .name = "help", .key = '?',
416
.doc = "Give this help list", .group = -1 },
417
{ .name = "usage", .key = -3,
418
.doc = "Give a short usage message", .group = -1 },
419
{ .name = "version", .key = 'V',
420
.doc = "Print program version", .group = -1 },
333
421
{ .name = NULL }
334
422
};
335
423
336
error_t parse_opt (int key, char *arg, struct argp_state *state) {
337
/* Get the INPUT argument from `argp_parse', which we know is a
338
pointer to our plugin list pointer. */
339
plugin **plugins = state->input;
340
switch (key) {
341
case 'g':
342
if (arg != NULL){
343
char *p;
344
while((p = strsep(&arg, ",")) != NULL){
345
if(p[0] == '\0'){
346
continue;
347
}
348
if(not add_argument(getplugin(NULL, plugins), p)){
349
perror("add_argument");
350
return ARGP_ERR_UNKNOWN;
351
}
352
}
353
}
354
break;
355
case 'e':
356
if(arg == NULL){
357
break;
358
}
359
{
360
char *envdef = strdup(arg);
361
if(envdef == NULL){
362
break;
363
}
364
if(not add_environment(getplugin(NULL, plugins), envdef)){
365
perror("add_environment");
366
}
367
}
368
break;
369
case 'o':
370
if (arg != NULL){
371
char *p_name = strsep(&arg, ":");
372
if(p_name[0] == '\0'){
373
break;
374
}
375
char *opt = strsep(&arg, ":");
376
if(opt[0] == '\0'){
377
break;
378
}
379
if(opt != NULL){
380
char *p;
381
while((p = strsep(&opt, ",")) != NULL){
382
if(p[0] == '\0'){
383
continue;
384
}
385
if(not add_argument(getplugin(p_name, plugins), p)){
386
perror("add_argument");
387
return ARGP_ERR_UNKNOWN;
388
}
389
}
390
}
391
}
392
break;
393
case 'f':
394
if(arg == NULL){
395
break;
396
}
424
__attribute__((nonnull(3)))
425
error_t parse_opt(int key, char *arg, struct argp_state *state){
426
errno = 0;
427
switch(key){
428
char *tmp;
429
intmax_t tmp_id;
430
case 'g': /* --global-options */
431
{
432
char *plugin_option;
433
while((plugin_option = strsep(&arg, ",")) != NULL){
434
if(not add_argument(getplugin(NULL), plugin_option)){
435
break;
436
}
437
}
438
}
439
break;
440
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
442
break;
443
case 'o': /* --options-for */
444
{
445
char *option_list = strchr(arg, ':');
446
if(option_list == NULL){
447
argp_error(state, "No colon in \"%s\"", arg);
448
errno = EINVAL;
449
break;
450
}
451
*option_list = '\0';
452
option_list++;
453
if(arg[0] == '\0'){
454
argp_error(state, "Empty plugin name");
455
errno = EINVAL;
456
break;
457
}
458
char *option;
459
while((option = strsep(&option_list, ",")) != NULL){
460
if(not add_argument(getplugin(arg), option)){
461
break;
462
}
463
}
464
}
465
break;
466
case 'E': /* --env-for */
397
467
{
398
468
char *envdef = strchr(arg, ':');
399
469
if(envdef == NULL){
400
break;
401
}
402
char *p_name = strndup(arg, (size_t) (envdef-arg));
403
if(p_name == NULL){
404
break;
405
}
470
argp_error(state, "No colon in \"%s\"", arg);
471
errno = EINVAL;
472
break;
473
}
474
*envdef = '\0';
406
475
envdef++;
407
if(not add_environment(getplugin(p_name, plugins), envdef)){
408
perror("add_environment");
409
}
410
}
411
break;
412
case 'd':
413
if (arg != NULL){
414
plugin *p = getplugin(arg, plugins);
415
if(p == NULL){
416
return ARGP_ERR_UNKNOWN;
417
}
418
p->disabled = true;
419
}
420
break;
421
case 128:
476
if(arg[0] == '\0'){
477
argp_error(state, "Empty plugin name");
478
errno = EINVAL;
479
break;
480
}
481
add_environment(getplugin(arg), envdef, true);
482
}
483
break;
484
case 'd': /* --disable */
485
{
486
plugin *p = getplugin(arg);
487
if(p != NULL){
488
p->disabled = true;
489
}
490
}
491
break;
492
case 'e': /* --enable */
493
{
494
plugin *p = getplugin(arg);
495
if(p != NULL){
496
p->disabled = false;
497
}
498
}
499
break;
500
case 128: /* --plugin-dir */
501
free(plugindir);
422
502
plugindir = strdup(arg);
423
if(plugindir == NULL){
424
perror("strdup");
425
}
426
break;
427
case 129:
503
break;
504
case 129: /* --config-file */
505
/* This is already done by parse_opt_config_file() */
506
break;
507
case 130: /* --userid */
508
tmp_id = strtoimax(arg, &tmp, 10);
509
if(errno != 0 or tmp == arg or *tmp != '\0'
510
or tmp_id != (uid_t)tmp_id){
511
argp_error(state, "Bad user ID number: \"%s\", using %"
512
PRIdMAX, arg, (intmax_t)uid);
513
break;
514
}
515
uid = (uid_t)tmp_id;
516
break;
517
case 131: /* --groupid */
518
tmp_id = strtoimax(arg, &tmp, 10);
519
if(errno != 0 or tmp == arg or *tmp != '\0'
520
or tmp_id != (gid_t)tmp_id){
521
argp_error(state, "Bad group ID number: \"%s\", using %"
522
PRIdMAX, arg, (intmax_t)gid);
523
break;
524
}
525
gid = (gid_t)tmp_id;
526
break;
527
case 132: /* --debug */
528
debug = true;
529
break;
530
/*
531
* These reproduce what we would get without ARGP_NO_HELP
532
*/
533
case '?': /* --help */
534
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
536
case -3: /* --usage */
537
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
argp_state_help(state, state->out_stream,
539
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
540
case 'V': /* --version */
541
fprintf(state->out_stream, "%s\n", argp_program_version);
542
exit(EXIT_SUCCESS);
543
break;
544
/*
545
* When adding more options before this line, remember to also add a
546
* "case" to the "parse_opt_config_file" function below.
547
*/
548
case ARGP_KEY_ARG:
549
/* Cryptsetup always passes an argument, which is an empty
550
string if "none" was specified in /etc/crypttab. So if
551
argument was empty, we ignore it silently. */
552
if(arg[0] == '\0'){
553
break;
554
}
555
default:
556
return ARGP_ERR_UNKNOWN;
557
}
558
return errno; /* Set to 0 at start */
559
}
560
561
/* This option parser is the same as parse_opt() above, except it
562
ignores everything but the --config-file option. */
563
error_t parse_opt_config_file(int key, char *arg,
564
__attribute__((unused))
565
struct argp_state *state){
566
errno = 0;
567
switch(key){
568
case 'g': /* --global-options */
569
case 'G': /* --global-env */
570
case 'o': /* --options-for */
571
case 'E': /* --env-for */
572
case 'd': /* --disable */
573
case 'e': /* --enable */
574
case 128: /* --plugin-dir */
575
break;
576
case 129: /* --config-file */
577
free(argfile);
428
578
argfile = strdup(arg);
429
if(argfile == NULL){
430
perror("strdup");
431
}
432
break;
433
case 130:
434
uid = (uid_t)strtol(arg, NULL, 10);
435
break;
436
case 131:
437
gid = (gid_t)strtol(arg, NULL, 10);
438
break;
439
case 132:
440
debug = true;
441
break;
579
break;
580
case 130: /* --userid */
581
case 131: /* --groupid */
582
case 132: /* --debug */
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
442
586
case ARGP_KEY_ARG:
443
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
444
break;
445
case ARGP_KEY_END:
446
587
break;
447
588
default:
448
589
return ARGP_ERR_UNKNOWN;
449
590
}
450
return 0;
591
return errno;
451
592
}
452
593
453
plugin *plugin_list = NULL;
454
455
struct argp argp = { .options = options, .parser = parse_opt,
456
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
594
struct argp argp = { .options = options,
595
.parser = parse_opt_config_file,
596
.args_doc = "",
457
597
.doc = "Mandos plugin runner -- Run plugins" };
458
598
459
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
460
if (ret == ARGP_ERR_UNKNOWN){
461
fprintf(stderr, "Unknown error while parsing arguments\n");
462
exitstatus = EXIT_FAILURE;
599
/* Parse using parse_opt_config_file() in order to get the custom
600
config file location, if any. */
601
ret = argp_parse(&argp, argc, argv,
602
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
603
NULL, NULL);
604
switch(ret){
605
case 0:
606
break;
607
case ENOMEM:
608
default:
609
errno = ret;
610
error(0, errno, "argp_parse");
611
exitstatus = EX_OSERR;
612
goto fallback;
613
case EINVAL:
614
exitstatus = EX_USAGE;
463
615
goto fallback;
464
616
}
465
466
if (argfile == NULL){
617
618
/* Reset to the normal argument parser */
619
argp.parser = parse_opt;
620
621
/* Open the configfile if available */
622
if(argfile == NULL){
467
623
conffp = fopen(AFILE, "r");
468
624
} else {
469
625
conffp = fopen(argfile, "r");
470
626
}
471
472
627
if(conffp != NULL){
473
628
char *org_line = NULL;
474
629
char *p, *arg, *new_arg, *line;
475
630
size_t size = 0;
476
ssize_t sret;
477
631
const char whitespace_delims[] = " \r\t\f\v\n";
478
632
const char comment_delim[] = "#";
479
633
480
634
custom_argc = 1;
481
635
custom_argv = malloc(sizeof(char*) * 2);
482
636
if(custom_argv == NULL){
483
perror("malloc");
484
exitstatus = EXIT_FAILURE;
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
485
639
goto fallback;
486
640
}
487
641
custom_argv[0] = argv[0];
488
642
custom_argv[1] = NULL;
489
643
644
/* for each line in the config file, strip whitespace and ignore
645
commented text */
490
646
while(true){
491
647
sret = getline(&org_line, &size, conffp);
492
648
if(sret == -1){
493
649
break;
494
650
}
495
651
496
652
line = org_line;
497
653
arg = strsep(&line, comment_delim);
498
654
while((p = strsep(&arg, whitespace_delims)) != NULL){
501
657
}
502
658
new_arg = strdup(p);
503
659
if(new_arg == NULL){
504
perror("strdup");
505
exitstatus = EXIT_FAILURE;
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
506
662
free(org_line);
507
663
goto fallback;
508
664
}
511
667
custom_argv = realloc(custom_argv, sizeof(char *)
512
668
* ((unsigned int) custom_argc + 1));
513
669
if(custom_argv == NULL){
514
perror("realloc");
515
exitstatus = EXIT_FAILURE;
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
516
672
free(org_line);
517
673
goto fallback;
518
674
}
519
675
custom_argv[custom_argc-1] = new_arg;
520
custom_argv[custom_argc] = NULL;
676
custom_argv[custom_argc] = NULL;
521
677
}
522
678
}
679
do {
680
ret = fclose(conffp);
681
} while(ret == EOF and errno == EINTR);
682
if(ret == EOF){
683
error(0, errno, "fclose");
684
exitstatus = EX_IOERR;
685
goto fallback;
686
}
523
687
free(org_line);
524
} else{
688
} else {
525
689
/* Check for harmful errors and go to fallback. Other errors might
526
690
not affect opening plugins */
527
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
528
perror("fopen");
529
exitstatus = EXIT_FAILURE;
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
530
694
goto fallback;
531
695
}
532
696
}
533
697
/* If there were any arguments from the configuration file, pass
698
them to parser as command line arguments */
534
699
if(custom_argv != NULL){
535
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
536
if (ret == ARGP_ERR_UNKNOWN){
537
fprintf(stderr, "Unknown error while parsing arguments\n");
538
exitstatus = EXIT_FAILURE;
700
ret = argp_parse(&argp, custom_argc, custom_argv,
701
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
702
NULL, NULL);
703
switch(ret){
704
case 0:
705
break;
706
case ENOMEM:
707
default:
708
errno = ret;
709
error(0, errno, "argp_parse");
710
exitstatus = EX_OSERR;
711
goto fallback;
712
case EINVAL:
713
exitstatus = EX_CONFIG;
539
714
goto fallback;
540
715
}
541
716
}
542
717
718
/* Parse actual command line arguments, to let them override the
719
config file */
720
ret = argp_parse(&argp, argc, argv,
721
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
722
NULL, NULL);
723
switch(ret){
724
case 0:
725
break;
726
case ENOMEM:
727
default:
728
errno = ret;
729
error(0, errno, "argp_parse");
730
exitstatus = EX_OSERR;
731
goto fallback;
732
case EINVAL:
733
exitstatus = EX_USAGE;
734
goto fallback;
735
}
736
543
737
if(debug){
544
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
545
739
fprintf(stderr, "Plugin: %s has %d arguments\n",
547
741
for(char **a = p->argv; *a != NULL; a++){
548
742
fprintf(stderr, "\tArg: %s\n", *a);
549
743
}
550
fprintf(stderr, "...and %u environment variables\n", p->envc);
744
fprintf(stderr, "...and %d environment variables\n", p->envc);
551
745
for(char **a = p->environ; *a != NULL; a++){
552
746
fprintf(stderr, "\t%s\n", *a);
553
747
}
554
748
}
555
749
}
556
750
751
if(getuid() == 0){
752
/* Work around Debian bug #633582:
753
<http://bugs.debian.org/633582> */
754
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
if(plugindir_fd == -1){
756
error(0, errno, "open");
757
} else {
758
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
if(ret == -1){
760
error(0, errno, "fstat");
761
} else {
762
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
763
ret = fchown(plugindir_fd, uid, gid);
764
if(ret == -1){
765
error(0, errno, "fchown");
766
}
767
}
768
}
769
TEMP_FAILURE_RETRY(close(plugindir_fd));
770
}
771
}
772
773
/* Lower permissions */
774
setgid(gid);
775
if(ret == -1){
776
error(0, errno, "setgid");
777
}
557
778
ret = setuid(uid);
558
if (ret == -1){
559
perror("setuid");
560
}
561
562
setgid(gid);
563
if (ret == -1){
564
perror("setgid");
565
}
566
567
if (plugindir == NULL){
568
dir = opendir(PDIR);
569
} else {
570
dir = opendir(plugindir);
571
}
572
573
if(dir == NULL){
574
perror("Could not open plugin dir");
575
exitstatus = EXIT_FAILURE;
576
goto fallback;
577
}
578
579
/* Set the FD_CLOEXEC flag on the directory, if possible */
779
if(ret == -1){
780
error(0, errno, "setuid");
781
}
782
783
/* Open plugin directory with close_on_exec flag */
580
784
{
581
int dir_fd = dirfd(dir);
582
if(dir_fd >= 0){
583
ret = set_cloexec_flag(dir_fd);
584
if(ret < 0){
585
perror("set_cloexec_flag");
586
exitstatus = EXIT_FAILURE;
587
goto fallback;
588
}
785
int dir_fd = -1;
786
if(plugindir == NULL){
787
dir_fd = open(PDIR, O_RDONLY |
788
#ifdef O_CLOEXEC
789
O_CLOEXEC
790
#else /* not O_CLOEXEC */
791
0
792
#endif /* not O_CLOEXEC */
793
);
794
} else {
795
dir_fd = open(plugindir, O_RDONLY |
796
#ifdef O_CLOEXEC
797
O_CLOEXEC
798
#else /* not O_CLOEXEC */
799
0
800
#endif /* not O_CLOEXEC */
801
);
802
}
803
if(dir_fd == -1){
804
error(0, errno, "Could not open plugin dir");
805
exitstatus = EX_UNAVAILABLE;
806
goto fallback;
807
}
808
809
#ifndef O_CLOEXEC
810
/* Set the FD_CLOEXEC flag on the directory */
811
ret = set_cloexec_flag(dir_fd);
812
if(ret < 0){
813
error(0, errno, "set_cloexec_flag");
814
TEMP_FAILURE_RETRY(close(dir_fd));
815
exitstatus = EX_OSERR;
816
goto fallback;
817
}
818
#endif /* O_CLOEXEC */
819
820
dir = fdopendir(dir_fd);
821
if(dir == NULL){
822
error(0, errno, "Could not open plugin dir");
823
TEMP_FAILURE_RETRY(close(dir_fd));
824
exitstatus = EX_OSERR;
825
goto fallback;
589
826
}
590
827
}
591
828
592
829
FD_ZERO(&rfds_all);
593
830
831
/* Read and execute any executable in the plugin directory*/
594
832
while(true){
595
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
596
836
597
// All directory entries have been processed
837
/* All directory entries have been processed */
598
838
if(dirst == NULL){
599
if (errno == EBADF){
600
perror("readdir");
601
exitstatus = EXIT_FAILURE;
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
602
842
goto fallback;
603
843
}
604
844
break;
606
846
607
847
d_name_len = strlen(dirst->d_name);
608
848
609
// Ignore dotfiles, backup files and other junk
849
/* Ignore dotfiles, backup files and other junk */
610
850
{
611
851
bool bad_name = false;
612
852
614
854
615
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
616
856
".dpkg-old",
857
".dpkg-bak",
617
858
".dpkg-divert", NULL };
618
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
619
860
size_t pre_len = strlen(*pre);
627
868
break;
628
869
}
629
870
}
630
631
871
if(bad_name){
632
872
continue;
633
873
}
634
635
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
636
875
size_t suf_len = strlen(*suf);
637
876
if((d_name_len >= suf_len)
638
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
639
878
== 0)){
640
879
if(debug){
641
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
650
889
continue;
651
890
}
652
891
}
653
892
654
893
char *filename;
655
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
894
if(plugindir == NULL){
895
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
dirst->d_name));
897
} else {
898
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
plugindir,
900
dirst->d_name));
901
}
656
902
if(ret < 0){
657
perror("asprintf");
903
error(0, errno, "asprintf");
658
904
continue;
659
905
}
660
906
661
ret = stat(filename, &st);
662
if (ret == -1){
663
perror("stat");
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
908
if(ret == -1){
909
error(0, errno, "stat");
664
910
free(filename);
665
911
continue;
666
912
}
667
913
668
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
914
/* Ignore non-executable files */
915
if(not S_ISREG(st.st_mode)
916
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
669
917
if(debug){
670
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
671
919
" with bad type or mode\n", filename);
673
921
free(filename);
674
922
continue;
675
923
}
676
plugin *p = getplugin(dirst->d_name, &plugin_list);
924
925
plugin *p = getplugin(dirst->d_name);
677
926
if(p == NULL){
678
perror("getplugin");
927
error(0, errno, "getplugin");
679
928
free(filename);
680
929
continue;
681
930
}
689
938
}
690
939
{
691
940
/* Add global arguments to argument list for this plugin */
692
plugin *g = getplugin(NULL, &plugin_list);
941
plugin *g = getplugin(NULL);
693
942
if(g != NULL){
694
943
for(char **a = g->argv + 1; *a != NULL; a++){
695
944
if(not add_argument(p, *a)){
696
perror("add_argument");
945
error(0, errno, "add_argument");
697
946
}
698
947
}
699
948
/* Add global environment variables */
700
949
for(char **e = g->environ; *e != NULL; e++){
701
if(not add_environment(p, *e)){
702
perror("add_environment");
950
if(not add_environment(p, *e, false)){
951
error(0, errno, "add_environment");
703
952
}
704
953
}
705
954
}
709
958
process, too. */
710
959
if(p->environ[0] != NULL){
711
960
for(char **e = environ; *e != NULL; e++){
712
char *copy = strdup(*e);
713
if(copy == NULL){
714
perror("strdup");
715
continue;
716
}
717
if(not add_environment(p, copy)){
718
perror("add_environment");
961
if(not add_environment(p, *e, false)){
962
error(0, errno, "add_environment");
719
963
}
720
964
}
721
965
}
722
966
723
967
int pipefd[2];
724
ret = pipe(pipefd);
725
if (ret == -1){
726
perror("pipe");
727
exitstatus = EXIT_FAILURE;
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
969
if(ret == -1){
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
728
972
goto fallback;
729
973
}
974
/* Ask OS to automatic close the pipe on exec */
730
975
ret = set_cloexec_flag(pipefd[0]);
731
976
if(ret < 0){
732
perror("set_cloexec_flag");
733
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
734
979
goto fallback;
735
980
}
736
981
ret = set_cloexec_flag(pipefd[1]);
737
982
if(ret < 0){
738
perror("set_cloexec_flag");
739
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
740
985
goto fallback;
741
986
}
742
987
/* Block SIGCHLD until process is safely in process list */
743
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
988
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
&sigchld_action.sa_mask,
990
NULL));
744
991
if(ret < 0){
745
perror("sigprocmask");
746
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
747
994
goto fallback;
748
995
}
749
// Starting a new process to be watched
750
pid_t pid = fork();
996
/* Starting a new process to be watched */
997
pid_t pid;
998
do {
999
pid = fork();
1000
} while(pid == -1 and errno == EINTR);
751
1001
if(pid == -1){
752
perror("fork");
753
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
754
1004
goto fallback;
755
1005
}
756
1006
if(pid == 0){
757
1007
/* this is the child process */
758
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
759
1009
if(ret < 0){
760
perror("sigaction");
761
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
762
1012
}
763
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
764
1014
if(ret < 0){
765
perror("sigprocmask");
766
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
767
1017
}
768
1018
769
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
770
1020
if(ret == -1){
771
perror("dup2");
772
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
773
1023
}
774
1024
775
1025
if(dirfd(dir) < 0){
779
1029
}
780
1030
if(p->environ[0] == NULL){
781
1031
if(execv(filename, p->argv) < 0){
782
perror("execv");
783
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
784
1034
}
785
1035
} else {
786
1036
if(execve(filename, p->argv, p->environ) < 0){
787
perror("execve");
788
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
789
1039
}
790
1040
}
791
1041
/* no return */
792
1042
}
793
/* parent process */
1043
/* Parent process */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
794
1046
free(filename);
795
close(pipefd[1]); /* close unused write end of pipe */
796
process *new_process = malloc(sizeof(process));
797
if (new_process == NULL){
798
perror("malloc");
799
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1047
plugin *new_plugin = getplugin(dirst->d_name);
1048
if(new_plugin == NULL){
1049
error(0, errno, "getplugin");
1050
ret = (int)(TEMP_FAILURE_RETRY
1051
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1052
NULL)));
800
1053
if(ret < 0){
801
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
802
1055
}
803
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
804
1057
goto fallback;
805
1058
}
806
1059
807
*new_process = (struct process){ .pid = pid,
808
.fd = pipefd[0],
809
.next = process_list };
810
// List handling
811
process_list = new_process;
1060
new_plugin->pid = pid;
1061
new_plugin->fd = pipefd[0];
1062
812
1063
/* Unblock SIGCHLD so signal handler can be run if this process
813
1064
has already completed */
814
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1065
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1066
&sigchld_action.sa_mask,
1067
NULL));
815
1068
if(ret < 0){
816
perror("sigprocmask");
817
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
818
1071
goto fallback;
819
1072
}
820
1073
821
FD_SET(new_process->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
822
1076
823
if (maxfd < new_process->fd){
824
maxfd = new_process->fd;
1077
if(maxfd < new_plugin->fd){
1078
maxfd = new_plugin->fd;
825
1079
}
826
827
1080
}
828
829
free_plugin_list(plugin_list);
830
plugin_list = NULL;
831
1081
832
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
833
1083
dir = NULL;
834
835
if (process_list == NULL){
836
fprintf(stderr, "No plugin processes started. Incorrect plugin"
837
" directory?\n");
838
process_list = NULL;
1084
free_plugin(getplugin(NULL));
1085
1086
for(plugin *p = plugin_list; p != NULL; p = p->next){
1087
if(p->pid != 0){
1088
break;
1089
}
1090
if(p->next == NULL){
1091
fprintf(stderr, "No plugin processes started. Incorrect plugin"
1092
" directory?\n");
1093
free_plugin_list();
1094
}
839
1095
}
840
while(process_list){
1096
1097
/* Main loop while running plugins exist */
1098
while(plugin_list){
841
1099
fd_set rfds = rfds_all;
842
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
843
if (select_ret == -1){
844
perror("select");
845
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
846
1104
goto fallback;
847
1105
}
848
1106
/* OK, now either a process completed, or something can be read
849
1107
from one of them */
850
for(process *proc = process_list; proc ; proc = proc->next){
1108
for(plugin *proc = plugin_list; proc != NULL;){
851
1109
/* Is this process completely done? */
852
if(proc->eof and proc->completed){
1110
if(proc->completed and proc->eof){
853
1111
/* Only accept the plugin output if it exited cleanly */
854
1112
if(not WIFEXITED(proc->status)
855
1113
or WEXITSTATUS(proc->status) != 0){
856
1114
/* Bad exit by plugin */
1115
857
1116
if(debug){
858
1117
if(WIFEXITED(proc->status)){
859
fprintf(stderr, "Plugin %u exited with status %d\n",
860
(unsigned int) (proc->pid),
1118
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1119
" status %d\n", proc->name,
1120
(intmax_t) (proc->pid),
861
1121
WEXITSTATUS(proc->status));
862
} else if(WIFSIGNALED(proc->status)) {
863
fprintf(stderr, "Plugin %u killed by signal %d\n",
864
(unsigned int) (proc->pid),
865
WTERMSIG(proc->status));
1122
} else if(WIFSIGNALED(proc->status)){
1123
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1124
" signal %d: %s\n", proc->name,
1125
(intmax_t) (proc->pid),
1126
WTERMSIG(proc->status),
1127
strsignal(WTERMSIG(proc->status)));
866
1128
} else if(WCOREDUMP(proc->status)){
867
fprintf(stderr, "Plugin %d dumped core\n",
868
(unsigned int) (proc->pid));
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
869
1131
}
870
1132
}
1133
871
1134
/* Remove the plugin */
872
FD_CLR(proc->fd, &rfds_all);
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1137
873
1138
/* Block signal while modifying process_list */
874
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1139
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1140
(SIG_BLOCK,
1141
&sigchld_action.sa_mask,
1142
NULL));
875
1143
if(ret < 0){
876
perror("sigprocmask");
877
exitstatus = EXIT_FAILURE;
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
878
1146
goto fallback;
879
1147
}
880
/* Delete this process entry from the list */
881
if(process_list == proc){
882
/* First one - simple */
883
process_list = proc->next;
884
} else {
885
/* Second one or later */
886
for(process *p = process_list; p != NULL; p = p->next){
887
if(p->next == proc){
888
p->next = proc->next;
889
break;
890
}
891
}
892
}
1148
1149
plugin *next_plugin = proc->next;
1150
free_plugin(proc);
1151
proc = next_plugin;
1152
893
1153
/* We are done modifying process list, so unblock signal */
894
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
895
NULL);
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
896
1157
if(ret < 0){
897
perror("sigprocmask");
898
}
899
free(proc->buffer);
900
free(proc);
901
/* We deleted this process from the list, so we can't go
902
proc->next. Therefore, start over from the beginning of
903
the process list */
904
break;
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
1160
goto fallback;
1161
}
1162
1163
if(plugin_list == NULL){
1164
break;
1165
}
1166
1167
continue;
905
1168
}
1169
906
1170
/* This process exited nicely, so print its buffer */
907
1171
908
1172
bool bret = print_out_password(proc->buffer,
909
1173
proc->buffer_length);
910
1174
if(not bret){
911
perror("print_out_password");
912
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
913
1177
}
914
1178
goto fallback;
915
1179
}
1180
916
1181
/* This process has not completed. Does it have any output? */
917
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1182
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1183
warning from
1184
-Wconversion */
918
1185
/* This process had nothing to say at this time */
1186
proc = proc->next;
919
1187
continue;
920
1188
}
921
1189
/* Before reading, make the process' data buffer large enough */
922
1190
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
923
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
924
1192
+ (size_t) BUFFER_SIZE);
925
if (proc->buffer == NULL){
926
perror("malloc");
927
exitstatus = EXIT_FAILURE;
1193
if(proc->buffer == NULL){
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
928
1196
goto fallback;
929
1197
}
930
1198
proc->buffer_size += BUFFER_SIZE;
931
1199
}
932
1200
/* Read from the process */
933
ret = read(proc->fd, proc->buffer + proc->buffer_length,
934
BUFFER_SIZE);
935
if(ret < 0){
1201
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1202
proc->buffer
1203
+ proc->buffer_length,
1204
BUFFER_SIZE));
1205
if(sret < 0){
936
1206
/* Read error from this process; ignore the error */
1207
proc = proc->next;
937
1208
continue;
938
1209
}
939
if(ret == 0){
1210
if(sret == 0){
940
1211
/* got EOF */
941
1212
proc->eof = true;
942
1213
} else {
943
proc->buffer_length += (size_t) ret;
1214
proc->buffer_length += (size_t) sret;
944
1215
}
945
1216
}
946
1217
}
947
948
1218
1219
949
1220
fallback:
950
1221
951
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
952
1224
/* Fallback if all plugins failed, none are found or an error
953
1225
occured */
954
1226
bool bret;
955
1227
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
956
1228
char *passwordbuffer = getpass("Password: ");
957
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
1229
size_t len = strlen(passwordbuffer);
1230
/* Strip trailing newline */
1231
if(len > 0 and passwordbuffer[len-1] == '\n'){
1232
passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1233
len--;
1234
}
1235
bret = print_out_password(passwordbuffer, len);
958
1236
if(not bret){
959
perror("print_out_password");
960
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
961
1239
}
962
1240
}
963
1241
964
1242
/* Restore old signal handler */
965
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
966
1244
if(ret == -1){
967
perror("sigaction");
968
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
969
1247
}
970
1248
971
1249
if(custom_argv != NULL){
972
1250
for(char **arg = custom_argv+1; *arg != NULL; arg++){
973
1251
free(*arg);
974
1252
}
975
1253
free(custom_argv);
976
1254
}
977
free_plugin_list(plugin_list);
978
1255
979
1256
if(dir != NULL){
980
1257
closedir(dir);
981
1258
}
982
1259
983
/* Free the process list and kill the processes */
984
for(process *next; process_list != NULL; process_list = next){
985
next = process_list->next;
986
close(process_list->fd);
987
ret = kill(process_list->pid, SIGTERM);
988
if(ret == -1 and errno != ESRCH){
989
/* set-uid proccesses migth not get closed */
990
perror("kill");
1260
/* Kill the processes */
1261
for(plugin *p = plugin_list; p != NULL; p = p->next){
1262
if(p->pid != 0){
1263
close(p->fd);
1264
ret = kill(p->pid, SIGTERM);
1265
if(ret == -1 and errno != ESRCH){
1266
/* Set-uid proccesses might not get closed */
1267
error(0, errno, "kill");
1268
}
991
1269
}
992
free(process_list->buffer);
993
free(process_list);
994
1270
}
995
1271
996
1272
/* Wait for any remaining child processes to terminate */
997
do{
1273
do {
998
1274
ret = wait(NULL);
999
1275
} while(ret >= 0);
1000
1276
if(errno != ECHILD){
1001
perror("wait");
1277
error(0, errno, "wait");
1002
1278
}
1003
1279
1280
free_plugin_list();
1281
1004
1282
free(plugindir);
1005
1283
free(argfile);
1006
1284
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0