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