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 263
- compare with another revision
- download diff
- download tarball
- view history from revision 263
- Committer: Teddy Hogeborn
- Date: 2009-01-12 22:02:33 UTC
- Revision ID: teddy@fukt.bsnet.se-20090112220233-lawxo4uvyzb38u1f
* README (The Plugin System): Removed redundant text about options and
files for the plugins, this is now
documented in the manuals for the
plugins.
* plugins.d/mandos-client.c (main): Remove comment which was copied
from another program by mistake.
Use "sscanf" instead of "strtol"
to parse numbers; this uses the
correct type instead of casting.
Don't report errors when removing
temporary directory if directory
is already gone.
files for the plugins, this is now
documented in the manuals for the
plugins.
* plugins.d/mandos-client.c (main): Remove comment which was copied
from another program by mistake.
Use "sscanf" instead of "strtol"
to parse numbers; this uses the
correct type instead of casting.
Don't report errors when removing
temporary directory if directory
is already gone.
- files removed:
- debian/watch
- files renamed:
- mandos-ctl => mandos-list
- files modified:
- INSTALL
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
*
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
28
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
29
29
EXIT_SUCCESS, realloc() */
30
30
#include <stdbool.h> /* bool, true, false */
31
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() */
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 */
72
67
73
68
#define BUFFER_SIZE 256
74
69
85
80
char **environ;
86
81
int envc;
87
82
bool disabled;
88
83
89
84
/* Variables used for running processes*/
90
85
pid_t pid;
91
86
int fd;
93
88
size_t buffer_size;
94
89
size_t buffer_length;
95
90
bool eof;
96
volatile sig_atomic_t completed;
97
int status;
91
volatile bool completed;
92
volatile int status;
98
93
struct plugin *next;
99
94
} plugin;
100
95
103
98
/* Gets an existing plugin based on name,
104
99
or if none is found, creates a new one */
105
100
static plugin *getplugin(char *name){
106
/* Check for existing plugin with that name */
107
for(plugin *p = plugin_list; p != NULL; p = p->next){
108
if((p->name == name)
109
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))){
110
105
return p;
111
106
}
112
107
}
113
108
/* Create a new plugin */
114
plugin *new_plugin = NULL;
115
do {
116
new_plugin = malloc(sizeof(plugin));
117
} while(new_plugin == NULL and errno == EINTR);
118
if(new_plugin == NULL){
109
plugin *new_plugin = malloc(sizeof(plugin));
110
if (new_plugin == NULL){
119
111
return NULL;
120
112
}
121
113
char *copy_name = NULL;
122
114
if(name != NULL){
123
do {
124
copy_name = strdup(name);
125
} while(copy_name == NULL and errno == EINTR);
115
copy_name = strdup(name);
126
116
if(copy_name == NULL){
127
int e = errno;
128
free(new_plugin);
129
errno = e;
130
117
return NULL;
131
118
}
132
119
}
133
120
134
*new_plugin = (plugin){ .name = copy_name,
135
.argc = 1,
136
.disabled = false,
137
.next = plugin_list };
121
*new_plugin = (plugin) { .name = copy_name,
122
.argc = 1,
123
.disabled = false,
124
.next = plugin_list };
138
125
139
do {
140
new_plugin->argv = malloc(sizeof(char *) * 2);
141
} while(new_plugin->argv == NULL and errno == EINTR);
142
if(new_plugin->argv == NULL){
143
int e = errno;
126
new_plugin->argv = malloc(sizeof(char *) * 2);
127
if (new_plugin->argv == NULL){
144
128
free(copy_name);
145
129
free(new_plugin);
146
errno = e;
147
130
return NULL;
148
131
}
149
132
new_plugin->argv[0] = copy_name;
150
133
new_plugin->argv[1] = NULL;
151
134
152
do {
153
new_plugin->environ = malloc(sizeof(char *));
154
} while(new_plugin->environ == NULL and errno == EINTR);
135
new_plugin->environ = malloc(sizeof(char *));
155
136
if(new_plugin->environ == NULL){
156
int e = errno;
157
137
free(copy_name);
158
138
free(new_plugin->argv);
159
139
free(new_plugin);
160
errno = e;
161
140
return NULL;
162
141
}
163
142
new_plugin->environ[0] = NULL;
171
150
static bool add_to_char_array(const char *new, char ***array,
172
151
int *len){
173
152
/* Resize the pointed-to array to hold one more pointer */
174
do {
175
*array = realloc(*array, sizeof(char *)
176
* (size_t) ((*len) + 2));
177
} while(*array == NULL and errno == EINTR);
153
*array = realloc(*array, sizeof(char *)
154
* (size_t) ((*len) + 2));
178
155
/* Malloc check */
179
156
if(*array == NULL){
180
157
return false;
181
158
}
182
159
/* Make a copy of the new string */
183
char *copy;
184
do {
185
copy = strdup(new);
186
} while(copy == NULL and errno == EINTR);
160
char *copy = strdup(new);
187
161
if(copy == NULL){
188
162
return false;
189
163
}
215
189
if(strncmp(*e, def, namelen + 1) == 0){
216
190
/* It already exists */
217
191
if(replace){
218
char *new;
219
do {
220
new = realloc(*e, strlen(def) + 1);
221
} while(new == NULL and errno == EINTR);
192
char *new = realloc(*e, strlen(def) + 1);
222
193
if(new == NULL){
223
194
return false;
224
195
}
234
205
/*
235
206
* Based on the example in the GNU LibC manual chapter 13.13 "File
236
207
* Descriptor Flags".
237
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
208
* *Note File Descriptor Flags:(libc)Descriptor Flags.
238
209
*/
239
210
static int set_cloexec_flag(int fd){
240
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
211
int ret = fcntl(fd, F_GETFD, 0);
241
212
/* If reading the flags failed, return error indication now. */
242
213
if(ret < 0){
243
214
return ret;
244
215
}
245
216
/* Store modified flag word in the descriptor. */
246
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
247
ret | FD_CLOEXEC));
217
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
248
218
}
249
219
250
220
251
221
/* Mark processes as completed when they exit, and save their exit
252
222
status. */
253
223
static void handle_sigchld(__attribute__((unused)) int sig){
254
int old_errno = errno;
255
224
while(true){
256
225
plugin *proc = plugin_list;
257
226
int status;
261
230
break;
262
231
}
263
232
if(pid == -1){
264
if(errno == ECHILD){
265
/* No child processes */
266
break;
233
if (errno != ECHILD){
234
perror("waitpid");
267
235
}
268
perror("waitpid");
236
/* No child processes */
237
break;
269
238
}
270
239
271
240
/* A child exited, find it in process_list */
277
246
continue;
278
247
}
279
248
proc->status = status;
280
proc->completed = 1;
249
proc->completed = true;
281
250
}
282
errno = old_errno;
283
251
}
284
252
285
253
/* Prints out a password to stdout */
307
275
}
308
276
free(plugin_node->environ);
309
277
free(plugin_node->buffer);
310
278
311
279
/* Removes the plugin from the singly-linked list */
312
280
if(plugin_node == plugin_list){
313
281
/* First one - simple */
401
369
.doc = "Group ID the plugins will run as", .group = 3 },
402
370
{ .name = "debug", .key = 132,
403
371
.doc = "Debug mode", .group = 4 },
404
/*
405
* These reproduce what we would get without ARGP_NO_HELP
406
*/
407
{ .name = "help", .key = '?',
408
.doc = "Give this help list", .group = -1 },
409
{ .name = "usage", .key = -3,
410
.doc = "Give a short usage message", .group = -1 },
411
{ .name = "version", .key = 'V',
412
.doc = "Print program version", .group = -1 },
413
372
{ .name = NULL }
414
373
};
415
374
416
error_t parse_opt(int key, char *arg, struct argp_state *state){
417
errno = 0;
418
switch(key){
419
char *tmp;
420
intmax_t tmpmax;
375
error_t parse_opt (int key, char *arg, __attribute__((unused))
376
struct argp_state *state) {
377
switch (key) {
421
378
case 'g': /* --global-options */
422
{
423
char *plugin_option;
424
while((plugin_option = strsep(&arg, ",")) != NULL){
425
if(not add_argument(getplugin(NULL), plugin_option)){
426
break;
379
if (arg != NULL){
380
char *p;
381
while((p = strsep(&arg, ",")) != NULL){
382
if(p[0] == '\0'){
383
continue;
384
}
385
if(not add_argument(getplugin(NULL), p)){
386
perror("add_argument");
387
return ARGP_ERR_UNKNOWN;
427
388
}
428
389
}
429
390
}
430
391
break;
431
392
case 'G': /* --global-env */
432
add_environment(getplugin(NULL), arg, true);
393
if(arg == NULL){
394
break;
395
}
396
if(not add_environment(getplugin(NULL), arg, true)){
397
perror("add_environment");
398
}
433
399
break;
434
400
case 'o': /* --options-for */
435
{
436
char *option_list = strchr(arg, ':');
437
if(option_list == NULL){
438
argp_error(state, "No colon in \"%s\"", arg);
439
errno = EINVAL;
440
break;
441
}
442
*option_list = '\0';
443
option_list++;
444
if(arg[0] == '\0'){
445
argp_error(state, "Empty plugin name");
446
errno = EINVAL;
447
break;
448
}
449
char *option;
450
while((option = strsep(&option_list, ",")) != NULL){
451
if(not add_argument(getplugin(arg), option)){
452
break;
401
if (arg != NULL){
402
char *p_name = strsep(&arg, ":");
403
if(p_name[0] == '\0' or arg == NULL){
404
break;
405
}
406
char *opt = strsep(&arg, ":");
407
if(opt[0] == '\0' or opt == NULL){
408
break;
409
}
410
char *p;
411
while((p = strsep(&opt, ",")) != NULL){
412
if(p[0] == '\0'){
413
continue;
414
}
415
if(not add_argument(getplugin(p_name), p)){
416
perror("add_argument");
417
return ARGP_ERR_UNKNOWN;
453
418
}
454
419
}
455
420
}
456
421
break;
457
422
case 'E': /* --env-for */
423
if(arg == NULL){
424
break;
425
}
458
426
{
459
427
char *envdef = strchr(arg, ':');
460
428
if(envdef == NULL){
461
argp_error(state, "No colon in \"%s\"", arg);
462
errno = EINVAL;
463
429
break;
464
430
}
465
431
*envdef = '\0';
466
envdef++;
467
if(arg[0] == '\0'){
468
argp_error(state, "Empty plugin name");
469
errno = EINVAL;
470
break;
432
if(not add_environment(getplugin(arg), envdef+1, true)){
433
perror("add_environment");
471
434
}
472
add_environment(getplugin(arg), envdef, true);
473
435
}
474
436
break;
475
437
case 'd': /* --disable */
476
{
438
if (arg != NULL){
477
439
plugin *p = getplugin(arg);
478
if(p != NULL){
479
p->disabled = true;
440
if(p == NULL){
441
return ARGP_ERR_UNKNOWN;
480
442
}
443
p->disabled = true;
481
444
}
482
445
break;
483
446
case 'e': /* --enable */
484
{
447
if (arg != NULL){
485
448
plugin *p = getplugin(arg);
486
if(p != NULL){
487
p->disabled = false;
449
if(p == NULL){
450
return ARGP_ERR_UNKNOWN;
488
451
}
452
p->disabled = false;
489
453
}
490
454
break;
491
455
case 128: /* --plugin-dir */
492
456
free(plugindir);
493
457
plugindir = strdup(arg);
458
if(plugindir == NULL){
459
perror("strdup");
460
}
494
461
break;
495
462
case 129: /* --config-file */
496
463
/* This is already done by parse_opt_config_file() */
497
464
break;
498
465
case 130: /* --userid */
499
tmpmax = strtoimax(arg, &tmp, 10);
500
if(errno != 0 or tmp == arg or *tmp != '\0'
501
or tmpmax != (uid_t)tmpmax){
502
argp_error(state, "Bad user ID number: \"%s\", using %"
503
PRIdMAX, arg, (intmax_t)uid);
504
break;
505
}
506
uid = (uid_t)tmpmax;
466
uid = (uid_t)strtol(arg, NULL, 10);
507
467
break;
508
468
case 131: /* --groupid */
509
tmpmax = strtoimax(arg, &tmp, 10);
510
if(errno != 0 or tmp == arg or *tmp != '\0'
511
or tmpmax != (gid_t)tmpmax){
512
argp_error(state, "Bad group ID number: \"%s\", using %"
513
PRIdMAX, arg, (intmax_t)gid);
514
break;
515
}
516
gid = (gid_t)tmpmax;
469
gid = (gid_t)strtol(arg, NULL, 10);
517
470
break;
518
471
case 132: /* --debug */
519
472
debug = true;
520
473
break;
521
/*
522
* These reproduce what we would get without ARGP_NO_HELP
523
*/
524
case '?': /* --help */
525
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
526
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
527
case -3: /* --usage */
528
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
argp_state_help(state, state->out_stream,
530
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
531
case 'V': /* --version */
532
fprintf(state->out_stream, "%s\n", argp_program_version);
533
exit(EXIT_SUCCESS);
534
break;
535
/*
536
* When adding more options before this line, remember to also add a
537
* "case" to the "parse_opt_config_file" function below.
538
*/
539
474
case ARGP_KEY_ARG:
540
475
/* Cryptsetup always passes an argument, which is an empty
541
476
string if "none" was specified in /etc/crypttab. So if
542
477
argument was empty, we ignore it silently. */
543
if(arg[0] == '\0'){
544
break;
478
if(arg[0] != '\0'){
479
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
545
480
}
481
break;
482
case ARGP_KEY_END:
483
break;
546
484
default:
547
485
return ARGP_ERR_UNKNOWN;
548
486
}
549
return errno; /* Set to 0 at start */
487
return 0;
550
488
}
551
489
552
490
/* This option parser is the same as parse_opt() above, except it
553
491
ignores everything but the --config-file option. */
554
error_t parse_opt_config_file(int key, char *arg,
555
__attribute__((unused))
556
struct argp_state *state){
557
errno = 0;
558
switch(key){
492
error_t parse_opt_config_file (int key, char *arg,
493
__attribute__((unused))
494
struct argp_state *state) {
495
switch (key) {
559
496
case 'g': /* --global-options */
560
497
case 'G': /* --global-env */
561
498
case 'o': /* --options-for */
567
504
case 129: /* --config-file */
568
505
free(argfile);
569
506
argfile = strdup(arg);
570
break;
507
if(argfile == NULL){
508
perror("strdup");
509
}
510
break;
571
511
case 130: /* --userid */
572
512
case 131: /* --groupid */
573
513
case 132: /* --debug */
574
case '?': /* --help */
575
case -3: /* --usage */
576
case 'V': /* --version */
577
514
case ARGP_KEY_ARG:
515
case ARGP_KEY_END:
578
516
break;
579
517
default:
580
518
return ARGP_ERR_UNKNOWN;
581
519
}
582
return errno;
520
return 0;
583
521
}
584
522
585
523
struct argp argp = { .options = options,
587
525
.args_doc = "",
588
526
.doc = "Mandos plugin runner -- Run plugins" };
589
527
590
/* Parse using parse_opt_config_file() in order to get the custom
528
/* Parse using the parse_opt_config_file in order to get the custom
591
529
config file location, if any. */
592
ret = argp_parse(&argp, argc, argv,
593
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
594
NULL, NULL);
595
switch(ret){
596
case 0:
597
break;
598
case ENOMEM:
599
default:
600
errno = ret;
601
perror("argp_parse");
602
exitstatus = EX_OSERR;
603
goto fallback;
604
case EINVAL:
605
exitstatus = EX_USAGE;
530
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
531
if (ret == ARGP_ERR_UNKNOWN){
532
fprintf(stderr, "Unknown error while parsing arguments\n");
533
exitstatus = EXIT_FAILURE;
606
534
goto fallback;
607
535
}
608
536
610
538
argp.parser = parse_opt;
611
539
612
540
/* Open the configfile if available */
613
if(argfile == NULL){
541
if (argfile == NULL){
614
542
conffp = fopen(AFILE, "r");
615
543
} else {
616
544
conffp = fopen(argfile, "r");
617
}
545
}
618
546
if(conffp != NULL){
619
547
char *org_line = NULL;
620
548
char *p, *arg, *new_arg, *line;
621
549
size_t size = 0;
622
550
const char whitespace_delims[] = " \r\t\f\v\n";
623
551
const char comment_delim[] = "#";
624
552
625
553
custom_argc = 1;
626
554
custom_argv = malloc(sizeof(char*) * 2);
627
555
if(custom_argv == NULL){
631
559
}
632
560
custom_argv[0] = argv[0];
633
561
custom_argv[1] = NULL;
634
562
635
563
/* for each line in the config file, strip whitespace and ignore
636
564
commented text */
637
565
while(true){
639
567
if(sret == -1){
640
568
break;
641
569
}
642
570
643
571
line = org_line;
644
572
arg = strsep(&line, comment_delim);
645
573
while((p = strsep(&arg, whitespace_delims)) != NULL){
664
592
goto fallback;
665
593
}
666
594
custom_argv[custom_argc-1] = new_arg;
667
custom_argv[custom_argc] = NULL;
595
custom_argv[custom_argc] = NULL;
668
596
}
669
597
}
670
do {
671
ret = fclose(conffp);
672
} while(ret == EOF and errno == EINTR);
673
if(ret == EOF){
674
perror("fclose");
675
exitstatus = EXIT_FAILURE;
676
goto fallback;
677
}
678
598
free(org_line);
679
599
} else {
680
600
/* Check for harmful errors and go to fallback. Other errors might
681
601
not affect opening plugins */
682
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
602
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
683
603
perror("fopen");
684
604
exitstatus = EXIT_FAILURE;
685
605
goto fallback;
686
606
}
687
607
}
688
/* If there were any arguments from the configuration file, pass
689
them to parser as command line arguments */
608
/* If there was any arguments from configuration file,
609
pass them to parser as command arguments */
690
610
if(custom_argv != NULL){
691
ret = argp_parse(&argp, custom_argc, custom_argv,
692
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
693
NULL, NULL);
694
switch(ret){
695
case 0:
696
break;
697
case ENOMEM:
698
default:
699
errno = ret;
700
perror("argp_parse");
701
exitstatus = EX_OSERR;
702
goto fallback;
703
case EINVAL:
704
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;
705
616
goto fallback;
706
617
}
707
618
}
708
619
709
620
/* Parse actual command line arguments, to let them override the
710
621
config file */
711
ret = argp_parse(&argp, argc, argv,
712
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
713
NULL, NULL);
714
switch(ret){
715
case 0:
716
break;
717
case ENOMEM:
718
default:
719
errno = ret;
720
perror("argp_parse");
721
exitstatus = EX_OSERR;
722
goto fallback;
723
case EINVAL:
724
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;
725
626
goto fallback;
726
627
}
727
628
732
633
for(char **a = p->argv; *a != NULL; a++){
733
634
fprintf(stderr, "\tArg: %s\n", *a);
734
635
}
735
fprintf(stderr, "...and %d environment variables\n", p->envc);
636
fprintf(stderr, "...and %u environment variables\n", p->envc);
736
637
for(char **a = p->environ; *a != NULL; a++){
737
638
fprintf(stderr, "\t%s\n", *a);
738
639
}
740
641
}
741
642
742
643
/* Strip permissions down to nobody */
644
ret = setuid(uid);
645
if (ret == -1){
646
perror("setuid");
647
}
743
648
setgid(gid);
744
if(ret == -1){
649
if (ret == -1){
745
650
perror("setgid");
746
651
}
747
ret = setuid(uid);
748
if(ret == -1){
749
perror("setuid");
750
}
751
752
/* Open plugin directory with close_on_exec flag */
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 */
753
666
{
754
int dir_fd = -1;
755
if(plugindir == NULL){
756
dir_fd = open(PDIR, O_RDONLY |
757
#ifdef O_CLOEXEC
758
O_CLOEXEC
759
#else /* not O_CLOEXEC */
760
0
761
#endif /* not O_CLOEXEC */
762
);
763
} else {
764
dir_fd = open(plugindir, O_RDONLY |
765
#ifdef O_CLOEXEC
766
O_CLOEXEC
767
#else /* not O_CLOEXEC */
768
0
769
#endif /* not O_CLOEXEC */
770
);
771
}
772
if(dir_fd == -1){
773
perror("Could not open plugin dir");
774
exitstatus = EXIT_FAILURE;
775
goto fallback;
776
}
777
778
#ifndef O_CLOEXEC
779
/* Set the FD_CLOEXEC flag on the directory */
780
ret = set_cloexec_flag(dir_fd);
781
if(ret < 0){
782
perror("set_cloexec_flag");
783
TEMP_FAILURE_RETRY(close(dir_fd));
784
exitstatus = EXIT_FAILURE;
785
goto fallback;
786
}
787
#endif /* O_CLOEXEC */
788
789
dir = fdopendir(dir_fd);
790
if(dir == NULL){
791
perror("Could not open plugin dir");
792
TEMP_FAILURE_RETRY(close(dir_fd));
793
exitstatus = EXIT_FAILURE;
794
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
}
795
675
}
796
676
}
797
677
799
679
800
680
/* Read and execute any executable in the plugin directory*/
801
681
while(true){
802
do {
803
dirst = readdir(dir);
804
} while(dirst == NULL and errno == EINTR);
682
dirst = readdir(dir);
805
683
806
684
/* All directory entries have been processed */
807
685
if(dirst == NULL){
808
if(errno == EBADF){
686
if (errno == EBADF){
809
687
perror("readdir");
810
688
exitstatus = EXIT_FAILURE;
811
689
goto fallback;
858
736
continue;
859
737
}
860
738
}
861
739
862
740
char *filename;
863
741
if(plugindir == NULL){
864
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
865
dirst->d_name));
742
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
866
743
} else {
867
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
868
plugindir,
869
dirst->d_name));
744
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
870
745
}
871
746
if(ret < 0){
872
747
perror("asprintf");
873
748
continue;
874
749
}
875
750
876
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
877
if(ret == -1){
751
ret = stat(filename, &st);
752
if (ret == -1){
878
753
perror("stat");
879
754
free(filename);
880
755
continue;
881
756
}
882
757
883
758
/* Ignore non-executable files */
884
if(not S_ISREG(st.st_mode)
885
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
759
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
886
760
if(debug){
887
761
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
888
762
" with bad type or mode\n", filename);
934
808
}
935
809
936
810
int pipefd[2];
937
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
938
if(ret == -1){
811
ret = pipe(pipefd);
812
if (ret == -1){
939
813
perror("pipe");
940
814
exitstatus = EXIT_FAILURE;
941
815
goto fallback;
954
828
goto fallback;
955
829
}
956
830
/* Block SIGCHLD until process is safely in process list */
957
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
958
&sigchld_action.sa_mask,
959
NULL));
831
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
960
832
if(ret < 0){
961
833
perror("sigprocmask");
962
834
exitstatus = EXIT_FAILURE;
963
835
goto fallback;
964
836
}
965
837
/* Starting a new process to be watched */
966
pid_t pid;
967
do {
968
pid = fork();
969
} while(pid == -1 and errno == EINTR);
838
pid_t pid = fork();
970
839
if(pid == -1){
971
840
perror("fork");
972
841
exitstatus = EXIT_FAILURE;
1010
879
/* no return */
1011
880
}
1012
881
/* Parent process */
1013
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1014
pipe */
882
close(pipefd[1]); /* Close unused write end of pipe */
1015
883
free(filename);
1016
884
plugin *new_plugin = getplugin(dirst->d_name);
1017
if(new_plugin == NULL){
885
if (new_plugin == NULL){
1018
886
perror("getplugin");
1019
ret = (int)(TEMP_FAILURE_RETRY
1020
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1021
NULL)));
887
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1022
888
if(ret < 0){
1023
889
perror("sigprocmask");
1024
890
}
1031
897
1032
898
/* Unblock SIGCHLD so signal handler can be run if this process
1033
899
has already completed */
1034
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1035
&sigchld_action.sa_mask,
1036
NULL));
900
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1037
901
if(ret < 0){
1038
902
perror("sigprocmask");
1039
903
exitstatus = EXIT_FAILURE;
1040
904
goto fallback;
1041
905
}
1042
906
1043
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1044
-Wconversion */
907
FD_SET(new_plugin->fd, &rfds_all);
1045
908
1046
if(maxfd < new_plugin->fd){
909
if (maxfd < new_plugin->fd){
1047
910
maxfd = new_plugin->fd;
1048
911
}
1049
912
}
1050
913
1051
TEMP_FAILURE_RETRY(closedir(dir));
914
closedir(dir);
1052
915
dir = NULL;
1053
free_plugin(getplugin(NULL));
1054
916
1055
917
for(plugin *p = plugin_list; p != NULL; p = p->next){
1056
918
if(p->pid != 0){
1067
929
while(plugin_list){
1068
930
fd_set rfds = rfds_all;
1069
931
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1070
if(select_ret == -1 and errno != EINTR){
932
if (select_ret == -1){
1071
933
perror("select");
1072
934
exitstatus = EXIT_FAILURE;
1073
935
goto fallback;
1076
938
from one of them */
1077
939
for(plugin *proc = plugin_list; proc != NULL;){
1078
940
/* Is this process completely done? */
1079
if(proc->completed and proc->eof){
941
if(proc->eof and proc->completed){
1080
942
/* Only accept the plugin output if it exited cleanly */
1081
943
if(not WIFEXITED(proc->status)
1082
944
or WEXITSTATUS(proc->status) != 0){
1083
945
/* Bad exit by plugin */
1084
946
1085
947
if(debug){
1086
948
if(WIFEXITED(proc->status)){
1087
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1088
" status %d\n", proc->name,
1089
(intmax_t) (proc->pid),
949
fprintf(stderr, "Plugin %u exited with status %d\n",
950
(unsigned int) (proc->pid),
1090
951
WEXITSTATUS(proc->status));
1091
} else if(WIFSIGNALED(proc->status)){
1092
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1093
" signal %d: %s\n", proc->name,
1094
(intmax_t) (proc->pid),
1095
WTERMSIG(proc->status),
1096
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));
1097
956
} else if(WCOREDUMP(proc->status)){
1098
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1099
" core\n", proc->name, (intmax_t) (proc->pid));
957
fprintf(stderr, "Plugin %d dumped core\n",
958
(unsigned int) (proc->pid));
1100
959
}
1101
960
}
1102
961
1103
962
/* Remove the plugin */
1104
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1105
-Wconversion */
1106
963
FD_CLR(proc->fd, &rfds_all);
964
1107
965
/* Block signal while modifying process_list */
1108
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1109
(SIG_BLOCK,
1110
&sigchld_action.sa_mask,
1111
NULL));
966
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1112
967
if(ret < 0){
1113
968
perror("sigprocmask");
1114
969
exitstatus = EXIT_FAILURE;
1120
975
proc = next_plugin;
1121
976
1122
977
/* We are done modifying process list, so unblock signal */
1123
ret = (int)(TEMP_FAILURE_RETRY
1124
(sigprocmask(SIG_UNBLOCK,
1125
&sigchld_action.sa_mask, NULL)));
978
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
979
NULL);
1126
980
if(ret < 0){
1127
981
perror("sigprocmask");
1128
982
exitstatus = EXIT_FAILURE;
1148
1002
}
1149
1003
1150
1004
/* This process has not completed. Does it have any output? */
1151
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1152
warning from
1153
-Wconversion */
1005
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1154
1006
/* This process had nothing to say at this time */
1155
1007
proc = proc->next;
1156
1008
continue;
1159
1011
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1160
1012
proc->buffer = realloc(proc->buffer, proc->buffer_size
1161
1013
+ (size_t) BUFFER_SIZE);
1162
if(proc->buffer == NULL){
1014
if (proc->buffer == NULL){
1163
1015
perror("malloc");
1164
1016
exitstatus = EXIT_FAILURE;
1165
1017
goto fallback;
1167
1019
proc->buffer_size += BUFFER_SIZE;
1168
1020
}
1169
1021
/* Read from the process */
1170
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1171
proc->buffer
1172
+ proc->buffer_length,
1173
BUFFER_SIZE));
1022
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1023
BUFFER_SIZE);
1174
1024
if(sret < 0){
1175
1025
/* Read error from this process; ignore the error */
1176
1026
proc = proc->next;
1184
1034
}
1185
1035
}
1186
1036
}
1187
1188
1037
1038
1189
1039
fallback:
1190
1040
1191
1041
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1238
1088
}
1239
1089
1240
1090
/* Wait for any remaining child processes to terminate */
1241
do {
1091
do{
1242
1092
ret = wait(NULL);
1243
1093
} while(ret >= 0);
1244
1094
if(errno != ECHILD){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0