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:
- DBUS-API
- debian/source
- network-hooks.d
- files removed:
- debian/mandos-client.config
- 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>";
81
const char *argp_program_version = "plugin-runner " VERSION;
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
74
83
75
84
typedef struct plugin{
76
85
char *name; /* can be NULL or any plugin name */
79
88
char **environ;
80
89
int envc;
81
90
bool disabled;
82
91
83
92
/* Variables used for running processes*/
84
93
pid_t pid;
85
94
int fd;
87
96
size_t buffer_size;
88
97
size_t buffer_length;
89
98
bool eof;
90
volatile bool completed;
91
volatile int status;
99
volatile sig_atomic_t completed;
100
int status;
92
101
struct plugin *next;
93
102
} plugin;
94
103
97
106
/* Gets an existing plugin based on name,
98
107
or if none is found, creates a new one */
99
108
static plugin *getplugin(char *name){
100
/* Check for exiting plugin with that name */
101
for (plugin *p = plugin_list; p != NULL; p = p->next){
102
if ((p->name == name)
103
or (p->name and name and (strcmp(p->name, name) == 0))){
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))){
104
113
return p;
105
114
}
106
115
}
107
116
/* Create a new plugin */
108
plugin *new_plugin = malloc(sizeof(plugin));
109
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){
110
122
return NULL;
111
123
}
112
124
char *copy_name = NULL;
113
125
if(name != NULL){
114
copy_name = strdup(name);
126
do {
127
copy_name = strdup(name);
128
} while(copy_name == NULL and errno == EINTR);
115
129
if(copy_name == NULL){
130
int e = errno;
131
free(new_plugin);
132
errno = e;
116
133
return NULL;
117
134
}
118
135
}
119
136
120
*new_plugin = (plugin) { .name = copy_name,
121
.argc = 1,
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
154
134
new_plugin->environ = malloc(sizeof(char *));
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;
146
171
}
147
172
148
173
/* Helper function for add_argument and add_environment */
174
__attribute__((nonnull))
149
175
static bool add_to_char_array(const char *new, char ***array,
150
176
int *len){
151
177
/* Resize the pointed-to array to hold one more pointer */
152
*array = realloc(*array, sizeof(char *)
153
* (size_t) ((*len) + 2));
178
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} while(*array == NULL and errno == EINTR);
154
182
/* Malloc check */
155
183
if(*array == NULL){
156
184
return false;
157
185
}
158
186
/* Make a copy of the new string */
159
char *copy = strdup(new);
187
char *copy;
188
do {
189
copy = strdup(new);
190
} while(copy == NULL and errno == EINTR);
160
191
if(copy == NULL){
161
192
return false;
162
193
}
169
200
}
170
201
171
202
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
172
204
static bool add_argument(plugin *p, const char *arg){
173
205
if(p == NULL){
174
206
return false;
177
209
}
178
210
179
211
/* Add to a plugin's environment */
212
__attribute__((nonnull(2)))
180
213
static bool add_environment(plugin *p, const char *def, bool replace){
181
214
if(p == NULL){
182
215
return false;
188
221
if(strncmp(*e, def, namelen + 1) == 0){
189
222
/* It already exists */
190
223
if(replace){
191
char *new = realloc(*e, strlen(def) + 1);
224
char *new;
225
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
192
228
if(new == NULL){
193
229
return false;
194
230
}
204
240
/*
205
241
* Based on the example in the GNU LibC manual chapter 13.13 "File
206
242
* Descriptor Flags".
207
* *Note File Descriptor Flags:(libc)Descriptor Flags.
243
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
208
244
*/
209
245
static int set_cloexec_flag(int fd){
210
int ret = fcntl(fd, F_GETFD, 0);
246
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
211
247
/* If reading the flags failed, return error indication now. */
212
248
if(ret < 0){
213
249
return ret;
214
250
}
215
251
/* Store modified flag word in the descriptor. */
216
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
252
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
ret | FD_CLOEXEC));
217
254
}
218
255
219
256
220
257
/* Mark processes as completed when they exit, and save their exit
221
258
status. */
222
259
static void handle_sigchld(__attribute__((unused)) int sig){
260
int old_errno = errno;
223
261
while(true){
224
262
plugin *proc = plugin_list;
225
263
int status;
229
267
break;
230
268
}
231
269
if(pid == -1){
232
if (errno != ECHILD){
233
perror("waitpid");
270
if(errno == ECHILD){
271
/* No child processes */
272
break;
234
273
}
235
/* No child processes */
236
break;
274
error(0, errno, "waitpid");
237
275
}
238
276
239
277
/* A child exited, find it in process_list */
245
283
continue;
246
284
}
247
285
proc->status = status;
248
proc->completed = true;
286
proc->completed = 1;
249
287
}
288
errno = old_errno;
250
289
}
251
290
252
291
/* Prints out a password to stdout */
292
__attribute__((nonnull))
253
293
static bool print_out_password(const char *buffer, size_t length){
254
294
ssize_t ret;
255
295
for(size_t written = 0; written < length; written += (size_t)ret){
263
303
}
264
304
265
305
/* Removes and free a plugin from the plugin list */
306
__attribute__((nonnull))
266
307
static void free_plugin(plugin *plugin_node){
267
308
268
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
274
315
}
275
316
free(plugin_node->environ);
276
317
free(plugin_node->buffer);
277
318
278
319
/* Removes the plugin from the singly-linked list */
279
320
if(plugin_node == plugin_list){
280
321
/* First one - simple */
308
349
struct stat st;
309
350
fd_set rfds_all;
310
351
int ret, maxfd = 0;
352
ssize_t sret;
311
353
uid_t uid = 65534;
312
354
gid_t gid = 65534;
313
355
bool debug = false;
322
364
sigemptyset(&sigchld_action.sa_mask);
323
365
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
324
366
if(ret == -1){
325
perror("sigaddset");
326
exitstatus = EXIT_FAILURE;
367
error(0, errno, "sigaddset");
368
exitstatus = EX_OSERR;
327
369
goto fallback;
328
370
}
329
371
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
330
372
if(ret == -1){
331
perror("sigaction");
332
exitstatus = EXIT_FAILURE;
373
error(0, errno, "sigaction");
374
exitstatus = EX_OSERR;
333
375
goto fallback;
334
376
}
335
377
367
409
.doc = "Group ID the plugins will run as", .group = 3 },
368
410
{ .name = "debug", .key = 132,
369
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 },
370
421
{ .name = NULL }
371
422
};
372
423
373
error_t parse_opt (int key, char *arg, __attribute__((unused))
374
struct argp_state *state) {
375
switch (key) {
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;
376
430
case 'g': /* --global-options */
377
if (arg != NULL){
378
char *p;
379
while((p = strsep(&arg, ",")) != NULL){
380
if(p[0] == '\0'){
381
continue;
382
}
383
if(not add_argument(getplugin(NULL), p)){
384
perror("add_argument");
385
return ARGP_ERR_UNKNOWN;
431
{
432
char *plugin_option;
433
while((plugin_option = strsep(&arg, ",")) != NULL){
434
if(not add_argument(getplugin(NULL), plugin_option)){
435
break;
386
436
}
387
437
}
388
438
}
389
439
break;
390
440
case 'G': /* --global-env */
391
if(arg == NULL){
392
break;
393
}
394
if(not add_environment(getplugin(NULL), arg, true)){
395
perror("add_environment");
396
}
441
add_environment(getplugin(NULL), arg, true);
397
442
break;
398
443
case 'o': /* --options-for */
399
if (arg != NULL){
400
char *p_name = strsep(&arg, ":");
401
if(p_name[0] == '\0' or arg == NULL){
402
break;
403
}
404
char *opt = strsep(&arg, ":");
405
if(opt[0] == '\0' or opt == NULL){
406
break;
407
}
408
char *p;
409
while((p = strsep(&opt, ",")) != NULL){
410
if(p[0] == '\0'){
411
continue;
412
}
413
if(not add_argument(getplugin(p_name), p)){
414
perror("add_argument");
415
return ARGP_ERR_UNKNOWN;
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;
416
462
}
417
463
}
418
464
}
419
465
break;
420
466
case 'E': /* --env-for */
421
if(arg == NULL){
422
break;
423
}
424
467
{
425
468
char *envdef = strchr(arg, ':');
426
469
if(envdef == NULL){
470
argp_error(state, "No colon in \"%s\"", arg);
471
errno = EINVAL;
427
472
break;
428
473
}
429
474
*envdef = '\0';
430
if(not add_environment(getplugin(arg), envdef+1, true)){
431
perror("add_environment");
475
envdef++;
476
if(arg[0] == '\0'){
477
argp_error(state, "Empty plugin name");
478
errno = EINVAL;
479
break;
432
480
}
481
add_environment(getplugin(arg), envdef, true);
433
482
}
434
483
break;
435
484
case 'd': /* --disable */
436
if (arg != NULL){
485
{
437
486
plugin *p = getplugin(arg);
438
if(p == NULL){
439
return ARGP_ERR_UNKNOWN;
487
if(p != NULL){
488
p->disabled = true;
440
489
}
441
p->disabled = true;
442
490
}
443
491
break;
444
492
case 'e': /* --enable */
445
if (arg != NULL){
493
{
446
494
plugin *p = getplugin(arg);
447
if(p == NULL){
448
return ARGP_ERR_UNKNOWN;
495
if(p != NULL){
496
p->disabled = false;
449
497
}
450
p->disabled = false;
451
498
}
452
499
break;
453
500
case 128: /* --plugin-dir */
454
501
free(plugindir);
455
502
plugindir = strdup(arg);
456
if(plugindir == NULL){
457
perror("strdup");
458
}
459
503
break;
460
504
case 129: /* --config-file */
461
505
/* This is already done by parse_opt_config_file() */
462
506
break;
463
507
case 130: /* --userid */
464
uid = (uid_t)strtol(arg, NULL, 10);
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;
465
516
break;
466
517
case 131: /* --groupid */
467
gid = (gid_t)strtol(arg, NULL, 10);
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;
468
526
break;
469
527
case 132: /* --debug */
470
528
debug = true;
471
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
*/
472
548
case ARGP_KEY_ARG:
473
549
/* Cryptsetup always passes an argument, which is an empty
474
550
string if "none" was specified in /etc/crypttab. So if
475
551
argument was empty, we ignore it silently. */
476
if(arg[0] != '\0'){
477
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
552
if(arg[0] == '\0'){
553
break;
478
554
}
479
break;
480
case ARGP_KEY_END:
481
break;
482
555
default:
483
556
return ARGP_ERR_UNKNOWN;
484
557
}
485
return 0;
558
return errno; /* Set to 0 at start */
486
559
}
487
560
488
561
/* This option parser is the same as parse_opt() above, except it
489
562
ignores everything but the --config-file option. */
490
error_t parse_opt_config_file (int key, char *arg,
491
__attribute__((unused))
492
struct argp_state *state) {
493
switch (key) {
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){
494
568
case 'g': /* --global-options */
495
569
case 'G': /* --global-env */
496
570
case 'o': /* --options-for */
502
576
case 129: /* --config-file */
503
577
free(argfile);
504
578
argfile = strdup(arg);
505
if(argfile == NULL){
506
perror("strdup");
507
}
508
break;
579
break;
509
580
case 130: /* --userid */
510
581
case 131: /* --groupid */
511
582
case 132: /* --debug */
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
512
586
case ARGP_KEY_ARG:
513
case ARGP_KEY_END:
514
587
break;
515
588
default:
516
589
return ARGP_ERR_UNKNOWN;
517
590
}
518
return 0;
591
return errno;
519
592
}
520
593
521
594
struct argp argp = { .options = options,
523
596
.args_doc = "",
524
597
.doc = "Mandos plugin runner -- Run plugins" };
525
598
526
/* Parse using the parse_opt_config_file in order to get the custom
599
/* Parse using parse_opt_config_file() in order to get the custom
527
600
config file location, if any. */
528
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
529
if (ret == ARGP_ERR_UNKNOWN){
530
fprintf(stderr, "Unknown error while parsing arguments\n");
531
exitstatus = EXIT_FAILURE;
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;
532
615
goto fallback;
533
616
}
534
617
536
619
argp.parser = parse_opt;
537
620
538
621
/* Open the configfile if available */
539
if (argfile == NULL){
622
if(argfile == NULL){
540
623
conffp = fopen(AFILE, "r");
541
624
} else {
542
625
conffp = fopen(argfile, "r");
543
}
626
}
544
627
if(conffp != NULL){
545
628
char *org_line = NULL;
546
629
char *p, *arg, *new_arg, *line;
547
630
size_t size = 0;
548
ssize_t sret;
549
631
const char whitespace_delims[] = " \r\t\f\v\n";
550
632
const char comment_delim[] = "#";
551
633
552
634
custom_argc = 1;
553
635
custom_argv = malloc(sizeof(char*) * 2);
554
636
if(custom_argv == NULL){
555
perror("malloc");
556
exitstatus = EXIT_FAILURE;
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
557
639
goto fallback;
558
640
}
559
641
custom_argv[0] = argv[0];
560
642
custom_argv[1] = NULL;
561
643
562
644
/* for each line in the config file, strip whitespace and ignore
563
645
commented text */
564
646
while(true){
566
648
if(sret == -1){
567
649
break;
568
650
}
569
651
570
652
line = org_line;
571
653
arg = strsep(&line, comment_delim);
572
654
while((p = strsep(&arg, whitespace_delims)) != NULL){
575
657
}
576
658
new_arg = strdup(p);
577
659
if(new_arg == NULL){
578
perror("strdup");
579
exitstatus = EXIT_FAILURE;
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
580
662
free(org_line);
581
663
goto fallback;
582
664
}
585
667
custom_argv = realloc(custom_argv, sizeof(char *)
586
668
* ((unsigned int) custom_argc + 1));
587
669
if(custom_argv == NULL){
588
perror("realloc");
589
exitstatus = EXIT_FAILURE;
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
590
672
free(org_line);
591
673
goto fallback;
592
674
}
593
675
custom_argv[custom_argc-1] = new_arg;
594
custom_argv[custom_argc] = NULL;
676
custom_argv[custom_argc] = NULL;
595
677
}
596
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
}
597
687
free(org_line);
598
688
} else {
599
689
/* Check for harmful errors and go to fallback. Other errors might
600
690
not affect opening plugins */
601
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
602
perror("fopen");
603
exitstatus = EXIT_FAILURE;
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
604
694
goto fallback;
605
695
}
606
696
}
607
/* If there was any arguments from configuration file,
608
pass them to parser as command arguments */
697
/* If there were any arguments from the configuration file, pass
698
them to parser as command line arguments */
609
699
if(custom_argv != NULL){
610
ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
611
0, NULL);
612
if (ret == ARGP_ERR_UNKNOWN){
613
fprintf(stderr, "Unknown error while parsing arguments\n");
614
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;
615
714
goto fallback;
616
715
}
617
716
}
618
717
619
718
/* Parse actual command line arguments, to let them override the
620
719
config file */
621
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
622
if (ret == ARGP_ERR_UNKNOWN){
623
fprintf(stderr, "Unknown error while parsing arguments\n");
624
exitstatus = EXIT_FAILURE;
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;
625
734
goto fallback;
626
735
}
627
736
632
741
for(char **a = p->argv; *a != NULL; a++){
633
742
fprintf(stderr, "\tArg: %s\n", *a);
634
743
}
635
fprintf(stderr, "...and %u environment variables\n", p->envc);
744
fprintf(stderr, "...and %d environment variables\n", p->envc);
636
745
for(char **a = p->environ; *a != NULL; a++){
637
746
fprintf(stderr, "\t%s\n", *a);
638
747
}
639
748
}
640
749
}
641
750
642
/* Strip permissions down to nobody */
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
}
643
778
ret = setuid(uid);
644
if (ret == -1){
645
perror("setuid");
646
}
647
setgid(gid);
648
if (ret == -1){
649
perror("setgid");
650
}
651
652
if (plugindir == NULL){
653
dir = opendir(PDIR);
654
} else {
655
dir = opendir(plugindir);
656
}
657
658
if(dir == NULL){
659
perror("Could not open plugin dir");
660
exitstatus = EXIT_FAILURE;
661
goto fallback;
662
}
663
664
/* 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 */
665
784
{
666
int dir_fd = dirfd(dir);
667
if(dir_fd >= 0){
668
ret = set_cloexec_flag(dir_fd);
669
if(ret < 0){
670
perror("set_cloexec_flag");
671
exitstatus = EXIT_FAILURE;
672
goto fallback;
673
}
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;
674
826
}
675
827
}
676
828
678
830
679
831
/* Read and execute any executable in the plugin directory*/
680
832
while(true){
681
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
682
836
683
837
/* All directory entries have been processed */
684
838
if(dirst == NULL){
685
if (errno == EBADF){
686
perror("readdir");
687
exitstatus = EXIT_FAILURE;
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
688
842
goto fallback;
689
843
}
690
844
break;
700
854
701
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
702
856
".dpkg-old",
857
".dpkg-bak",
703
858
".dpkg-divert", NULL };
704
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
705
860
size_t pre_len = strlen(*pre);
719
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
720
875
size_t suf_len = strlen(*suf);
721
876
if((d_name_len >= suf_len)
722
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
723
878
== 0)){
724
879
if(debug){
725
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
734
889
continue;
735
890
}
736
891
}
737
892
738
893
char *filename;
739
894
if(plugindir == NULL){
740
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
895
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
dirst->d_name));
741
897
} else {
742
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
898
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
plugindir,
900
dirst->d_name));
743
901
}
744
902
if(ret < 0){
745
perror("asprintf");
903
error(0, errno, "asprintf");
746
904
continue;
747
905
}
748
906
749
ret = stat(filename, &st);
750
if (ret == -1){
751
perror("stat");
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
908
if(ret == -1){
909
error(0, errno, "stat");
752
910
free(filename);
753
911
continue;
754
912
}
755
913
756
914
/* Ignore non-executable files */
757
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
915
if(not S_ISREG(st.st_mode)
916
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
758
917
if(debug){
759
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
760
919
" with bad type or mode\n", filename);
765
924
766
925
plugin *p = getplugin(dirst->d_name);
767
926
if(p == NULL){
768
perror("getplugin");
927
error(0, errno, "getplugin");
769
928
free(filename);
770
929
continue;
771
930
}
783
942
if(g != NULL){
784
943
for(char **a = g->argv + 1; *a != NULL; a++){
785
944
if(not add_argument(p, *a)){
786
perror("add_argument");
945
error(0, errno, "add_argument");
787
946
}
788
947
}
789
948
/* Add global environment variables */
790
949
for(char **e = g->environ; *e != NULL; e++){
791
950
if(not add_environment(p, *e, false)){
792
perror("add_environment");
951
error(0, errno, "add_environment");
793
952
}
794
953
}
795
954
}
800
959
if(p->environ[0] != NULL){
801
960
for(char **e = environ; *e != NULL; e++){
802
961
if(not add_environment(p, *e, false)){
803
perror("add_environment");
962
error(0, errno, "add_environment");
804
963
}
805
964
}
806
965
}
807
966
808
967
int pipefd[2];
809
ret = pipe(pipefd);
810
if (ret == -1){
811
perror("pipe");
812
exitstatus = EXIT_FAILURE;
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
969
if(ret == -1){
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
813
972
goto fallback;
814
973
}
815
974
/* Ask OS to automatic close the pipe on exec */
816
975
ret = set_cloexec_flag(pipefd[0]);
817
976
if(ret < 0){
818
perror("set_cloexec_flag");
819
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
820
979
goto fallback;
821
980
}
822
981
ret = set_cloexec_flag(pipefd[1]);
823
982
if(ret < 0){
824
perror("set_cloexec_flag");
825
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
826
985
goto fallback;
827
986
}
828
987
/* Block SIGCHLD until process is safely in process list */
829
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));
830
991
if(ret < 0){
831
perror("sigprocmask");
832
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
833
994
goto fallback;
834
995
}
835
996
/* Starting a new process to be watched */
836
pid_t pid = fork();
997
pid_t pid;
998
do {
999
pid = fork();
1000
} while(pid == -1 and errno == EINTR);
837
1001
if(pid == -1){
838
perror("fork");
839
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
840
1004
goto fallback;
841
1005
}
842
1006
if(pid == 0){
843
1007
/* this is the child process */
844
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
845
1009
if(ret < 0){
846
perror("sigaction");
847
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
848
1012
}
849
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
850
1014
if(ret < 0){
851
perror("sigprocmask");
852
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
853
1017
}
854
1018
855
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
856
1020
if(ret == -1){
857
perror("dup2");
858
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
859
1023
}
860
1024
861
1025
if(dirfd(dir) < 0){
865
1029
}
866
1030
if(p->environ[0] == NULL){
867
1031
if(execv(filename, p->argv) < 0){
868
perror("execv");
869
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
870
1034
}
871
1035
} else {
872
1036
if(execve(filename, p->argv, p->environ) < 0){
873
perror("execve");
874
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
875
1039
}
876
1040
}
877
1041
/* no return */
878
1042
}
879
1043
/* Parent process */
880
close(pipefd[1]); /* Close unused write end of pipe */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
881
1046
free(filename);
882
1047
plugin *new_plugin = getplugin(dirst->d_name);
883
if (new_plugin == NULL){
884
perror("getplugin");
885
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
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)));
886
1053
if(ret < 0){
887
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
888
1055
}
889
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
890
1057
goto fallback;
891
1058
}
892
1059
895
1062
896
1063
/* Unblock SIGCHLD so signal handler can be run if this process
897
1064
has already completed */
898
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));
899
1068
if(ret < 0){
900
perror("sigprocmask");
901
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
902
1071
goto fallback;
903
1072
}
904
1073
905
FD_SET(new_plugin->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
906
1076
907
if (maxfd < new_plugin->fd){
1077
if(maxfd < new_plugin->fd){
908
1078
maxfd = new_plugin->fd;
909
1079
}
910
911
1080
}
912
1081
913
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
914
1083
dir = NULL;
915
1084
free_plugin(getplugin(NULL));
1085
916
1086
for(plugin *p = plugin_list; p != NULL; p = p->next){
917
1087
if(p->pid != 0){
918
1088
break;
923
1093
free_plugin_list();
924
1094
}
925
1095
}
926
1096
927
1097
/* Main loop while running plugins exist */
928
1098
while(plugin_list){
929
1099
fd_set rfds = rfds_all;
930
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
931
if (select_ret == -1){
932
perror("select");
933
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
934
1104
goto fallback;
935
1105
}
936
1106
/* OK, now either a process completed, or something can be read
937
1107
from one of them */
938
1108
for(plugin *proc = plugin_list; proc != NULL;){
939
1109
/* Is this process completely done? */
940
if(proc->eof and proc->completed){
1110
if(proc->completed and proc->eof){
941
1111
/* Only accept the plugin output if it exited cleanly */
942
1112
if(not WIFEXITED(proc->status)
943
1113
or WEXITSTATUS(proc->status) != 0){
944
1114
/* Bad exit by plugin */
945
1115
946
1116
if(debug){
947
1117
if(WIFEXITED(proc->status)){
948
fprintf(stderr, "Plugin %u exited with status %d\n",
949
(unsigned int) (proc->pid),
1118
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1119
" status %d\n", proc->name,
1120
(intmax_t) (proc->pid),
950
1121
WEXITSTATUS(proc->status));
951
} else if(WIFSIGNALED(proc->status)) {
952
fprintf(stderr, "Plugin %u killed by signal %d\n",
953
(unsigned int) (proc->pid),
954
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)));
955
1128
} else if(WCOREDUMP(proc->status)){
956
fprintf(stderr, "Plugin %d dumped core\n",
957
(unsigned int) (proc->pid));
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
958
1131
}
959
1132
}
960
1133
961
1134
/* Remove the plugin */
962
FD_CLR(proc->fd, &rfds_all);
963
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1137
964
1138
/* Block signal while modifying process_list */
965
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
966
if(ret < 0){
967
perror("sigprocmask");
968
exitstatus = EXIT_FAILURE;
969
goto fallback;
970
}
971
972
/* We are done modifying process list, so unblock signal */
973
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
974
NULL);
975
if(ret < 0){
976
perror("sigprocmask");
977
exitstatus = EXIT_FAILURE;
978
goto fallback;
979
}
980
981
if(plugin_list == NULL){
982
break;
1139
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1140
(SIG_BLOCK,
1141
&sigchld_action.sa_mask,
1142
NULL));
1143
if(ret < 0){
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
1146
goto fallback;
983
1147
}
984
1148
985
1149
plugin *next_plugin = proc->next;
986
1150
free_plugin(proc);
987
1151
proc = next_plugin;
1152
1153
/* We are done modifying process list, so unblock signal */
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
1157
if(ret < 0){
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
1160
goto fallback;
1161
}
1162
1163
if(plugin_list == NULL){
1164
break;
1165
}
1166
988
1167
continue;
989
1168
}
990
1169
991
1170
/* This process exited nicely, so print its buffer */
992
1171
993
1172
bool bret = print_out_password(proc->buffer,
994
1173
proc->buffer_length);
995
1174
if(not bret){
996
perror("print_out_password");
997
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
998
1177
}
999
1178
goto fallback;
1000
1179
}
1001
1180
1002
1181
/* This process has not completed. Does it have any output? */
1003
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 */
1004
1185
/* This process had nothing to say at this time */
1005
1186
proc = proc->next;
1006
1187
continue;
1009
1190
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1010
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
1011
1192
+ (size_t) BUFFER_SIZE);
1012
if (proc->buffer == NULL){
1013
perror("malloc");
1014
exitstatus = EXIT_FAILURE;
1193
if(proc->buffer == NULL){
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
1015
1196
goto fallback;
1016
1197
}
1017
1198
proc->buffer_size += BUFFER_SIZE;
1018
1199
}
1019
1200
/* Read from the process */
1020
ret = read(proc->fd, proc->buffer + proc->buffer_length,
1021
BUFFER_SIZE);
1022
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){
1023
1206
/* Read error from this process; ignore the error */
1024
1207
proc = proc->next;
1025
1208
continue;
1026
1209
}
1027
if(ret == 0){
1210
if(sret == 0){
1028
1211
/* got EOF */
1029
1212
proc->eof = true;
1030
1213
} else {
1031
proc->buffer_length += (size_t) ret;
1214
proc->buffer_length += (size_t) sret;
1032
1215
}
1033
1216
}
1034
1217
}
1035
1036
1218
1219
1037
1220
fallback:
1038
1221
1039
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
1040
1224
/* Fallback if all plugins failed, none are found or an error
1041
1225
occured */
1042
1226
bool bret;
1050
1234
}
1051
1235
bret = print_out_password(passwordbuffer, len);
1052
1236
if(not bret){
1053
perror("print_out_password");
1054
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
1055
1239
}
1056
1240
}
1057
1241
1058
1242
/* Restore old signal handler */
1059
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1060
1244
if(ret == -1){
1061
perror("sigaction");
1062
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
1063
1247
}
1064
1248
1065
1249
if(custom_argv != NULL){
1066
1250
for(char **arg = custom_argv+1; *arg != NULL; arg++){
1067
1251
free(*arg);
1073
1257
closedir(dir);
1074
1258
}
1075
1259
1076
/* Free the process list and kill the processes */
1260
/* Kill the processes */
1077
1261
for(plugin *p = plugin_list; p != NULL; p = p->next){
1078
1262
if(p->pid != 0){
1079
1263
close(p->fd);
1080
1264
ret = kill(p->pid, SIGTERM);
1081
1265
if(ret == -1 and errno != ESRCH){
1082
1266
/* Set-uid proccesses might not get closed */
1083
perror("kill");
1267
error(0, errno, "kill");
1084
1268
}
1085
1269
}
1086
1270
}
1087
1271
1088
1272
/* Wait for any remaining child processes to terminate */
1089
do{
1273
do {
1090
1274
ret = wait(NULL);
1091
1275
} while(ret >= 0);
1092
1276
if(errno != ECHILD){
1093
perror("wait");
1277
error(0, errno, "wait");
1094
1278
}
1095
1279
1096
1280
free_plugin_list();
1097
1281
1098
1282
free(plugindir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0