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 78
- compare with another revision
- download diff
- download tarball
- view history from revision 78
- Committer: Teddy Hogeborn
- Date: 2008-08-16 03:29:08 UTC
- Revision ID: teddy@fukt.bsnet.se-20080816032908-ihw7c05r2mnyk389
Add feature to specify custom environment variables for plugins.
* plugin-runner.c (plugin): New members "environ" and "envc" to
contain possible custom environment.
(getplugin): Return NULL on failure instead of doing exit(); all
callers changed.
(add_to_char_array): New helper function for "add_argument" and
"add_environment".
(addargument): Renamed to "add_argument". Return bool. Call
"add_to_char_array" to actually do things.
(add_environment): New; analogous to "add_argument".
(addcustomargument): Renamed to "add_to_argv" to avoid confusion
with "add_argument".
(main): New options "--global-envs" and "--envs-for" to specify
custom environment for plugins. Print environment for
plugins in debug mode. Use asprintf instead of strcpy and
strcat. Use execve() for plugins with custom environments.
Free environment for plugin when freeing plugin list.
* plugin-runner.c (plugin): New members "environ" and "envc" to
contain possible custom environment.
(getplugin): Return NULL on failure instead of doing exit(); all
callers changed.
(add_to_char_array): New helper function for "add_argument" and
"add_environment".
(addargument): Renamed to "add_argument". Return bool. Call
"add_to_char_array" to actually do things.
(add_environment): New; analogous to "add_argument".
(addcustomargument): Renamed to "add_to_argv" to avoid confusion
with "add_argument".
(main): New options "--global-envs" and "--envs-for" to specify
custom environment for plugins. Print environment for
plugins in debug mode. Use asprintf instead of strcpy and
strcat. Use execve() for plugins with custom environments.
Free environment for plugin when freeing plugin list.
- files added:
- network-protocol.txt
- files removed:
- .bzrignore
- files modified:
- Makefile
added
removed
plugin-runner.c
56
56
#include <argp.h> /* struct argp_option, struct
57
57
argp_state, struct argp,
58
58
argp_parse(), ARGP_ERR_UNKNOWN,
59
ARGP_KEY_END, ARGP_KEY_ARG,
60
error_t */
59
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
60
#include <signal.h> /* struct sigaction, sigemptyset(),
62
61
sigaddset(), sigaction(),
63
62
sigprocmask(), SIG_BLOCK, SIGCHLD,
65
64
#include <errno.h> /* errno, EBADF */
66
65
67
66
#define BUFFER_SIZE 256
68
69
#define PDIR "/lib/mandos/plugins.d"
70
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
71
68
72
69
const char *argp_program_version = "plugin-runner 1.0";
73
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
74
71
75
struct plugin;
72
struct process;
73
74
typedef struct process{
75
pid_t pid;
76
int fd;
77
char *buffer;
78
size_t buffer_size;
79
size_t buffer_length;
80
bool eof;
81
bool completed;
82
int status;
83
struct process *next;
84
} process;
76
85
77
86
typedef struct plugin{
78
87
char *name; /* can be NULL or any plugin name */
81
90
char **environ;
82
91
int envc;
83
92
bool disabled;
84
85
/* Variables used for running processes*/
86
pid_t pid;
87
int fd;
88
char *buffer;
89
size_t buffer_size;
90
size_t buffer_length;
91
bool eof;
92
volatile bool completed;
93
volatile int status;
94
93
struct plugin *next;
95
94
} plugin;
96
95
97
static plugin *plugin_list = NULL;
98
99
/* Gets a existing plugin based on name,
100
or if none is found, creates a new one */
101
static plugin *getplugin(char *name){
102
/* Check for exiting plugin with that name */
103
for (plugin *p = plugin_list; p != NULL; p = p->next){
96
static plugin *getplugin(char *name, plugin **plugin_list){
97
for (plugin *p = *plugin_list; p != NULL; p = p->next){
104
98
if ((p->name == name)
105
99
or (p->name and name and (strcmp(p->name, name) == 0))){
106
100
return p;
111
105
if (new_plugin == NULL){
112
106
return NULL;
113
107
}
114
char *copy_name = NULL;
115
if(name != NULL){
116
copy_name = strdup(name);
117
if(copy_name == NULL){
118
return NULL;
119
}
120
}
121
122
*new_plugin = (plugin) { .name = copy_name,
108
*new_plugin = (plugin) { .name = name,
123
109
.argc = 1,
110
.envc = 0,
124
111
.disabled = false,
125
.next = plugin_list };
112
.next = *plugin_list };
126
113
127
114
new_plugin->argv = malloc(sizeof(char *) * 2);
128
115
if (new_plugin->argv == NULL){
129
free(copy_name);
130
116
free(new_plugin);
131
117
return NULL;
132
118
}
133
new_plugin->argv[0] = copy_name;
119
new_plugin->argv[0] = name;
134
120
new_plugin->argv[1] = NULL;
135
121
136
122
new_plugin->environ = malloc(sizeof(char *));
137
123
if(new_plugin->environ == NULL){
138
free(copy_name);
139
124
free(new_plugin->argv);
140
125
free(new_plugin);
141
126
return NULL;
142
127
}
143
128
new_plugin->environ[0] = NULL;
144
145
129
/* Append the new plugin to the list */
146
plugin_list = new_plugin;
130
*plugin_list = new_plugin;
147
131
return new_plugin;
148
132
}
149
133
186
170
return add_to_char_array(def, &(p->environ), &(p->envc));
187
171
}
188
172
173
189
174
/*
190
175
* Based on the example in the GNU LibC manual chapter 13.13 "File
191
176
* Descriptor Flags".
202
187
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
203
188
}
204
189
190
process *process_list = NULL;
205
191
206
/* Mark processes as completed when they exit, and save their exit
192
/* Mark a process as completed when it exits, and save its exit
207
193
status. */
208
194
void handle_sigchld(__attribute__((unused)) int sig){
209
while(true){
210
plugin *proc = plugin_list;
211
int status;
212
pid_t pid = waitpid(-1, &status, WNOHANG);
213
if(pid == 0){
214
/* Only still running child processes */
215
break;
216
}
217
if(pid == -1){
218
if (errno != ECHILD){
219
perror("waitpid");
220
}
221
/* No child processes */
222
break;
223
}
224
225
/* A child exited, find it in process_list */
226
while(proc != NULL and proc->pid != pid){
227
proc = proc->next;
228
}
229
if(proc == NULL){
230
/* Process not found in process list */
231
continue;
232
}
233
proc->status = status;
234
proc->completed = true;
235
}
195
process *proc = process_list;
196
int status;
197
pid_t pid = wait(&status);
198
if(pid == -1){
199
perror("wait");
200
return;
201
}
202
while(proc != NULL and proc->pid != pid){
203
proc = proc->next;
204
}
205
if(proc == NULL){
206
/* Process not found in process list */
207
return;
208
}
209
proc->status = status;
210
proc->completed = true;
236
211
}
237
212
238
/* Prints out a password to stdout */
239
213
bool print_out_password(const char *buffer, size_t length){
240
214
ssize_t ret;
241
215
if(length>0 and buffer[length-1] == '\n'){
251
225
return true;
252
226
}
253
227
254
/* Removes and free a plugin from the plugin list */
255
static void free_plugin(plugin *plugin_node){
256
257
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
258
free(*arg);
259
}
260
free(plugin_node->argv);
261
for(char **env = plugin_node->environ; *env != NULL; env++){
262
free(*env);
263
}
264
free(plugin_node->environ);
265
free(plugin_node->buffer);
266
267
/* Removes the plugin from the singly-linked list */
268
if(plugin_node == plugin_list){
269
/* First one - simple */
270
plugin_list = plugin_list->next;
271
} else {
272
/* Second one or later */
273
for(plugin *p = plugin_list; p != NULL; p = p->next){
274
if(p->next == plugin_node){
275
p->next = plugin_node->next;
276
break;
277
}
228
char **add_to_argv(char **argv, int *argc, char *arg){
229
if (argv == NULL){
230
*argc = 1;
231
argv = malloc(sizeof(char*) * 2);
232
if(argv == NULL){
233
return NULL;
278
234
}
279
}
280
281
free(plugin_node);
282
}
283
284
static void free_plugin_list(void){
285
while(plugin_list != NULL){
286
free_plugin(plugin_list);
287
}
235
argv[0] = NULL; /* Will be set to argv[0] in main before parsing */
236
argv[1] = NULL;
237
}
238
*argc += 1;
239
argv = realloc(argv, sizeof(char *)
240
* ((unsigned int) *argc + 1));
241
if(argv == NULL){
242
return NULL;
243
}
244
argv[*argc-1] = arg;
245
argv[*argc] = NULL;
246
return argv;
288
247
}
289
248
290
249
int main(int argc, char *argv[]){
291
char *plugindir = NULL;
292
char *argfile = NULL;
250
const char *plugindir = "/lib/mandos/plugins.d";
251
const char *argfile = ARGFILE;
293
252
FILE *conffp;
294
253
size_t d_name_len;
295
254
DIR *dir = NULL;
310
269
/* Establish a signal handler */
311
270
sigemptyset(&sigchld_action.sa_mask);
312
271
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
313
if(ret == -1){
272
if(ret < 0){
314
273
perror("sigaddset");
315
exitstatus = EXIT_FAILURE;
316
goto fallback;
274
exit(EXIT_FAILURE);
317
275
}
318
276
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
319
if(ret == -1){
277
if(ret < 0){
320
278
perror("sigaction");
321
exitstatus = EXIT_FAILURE;
322
goto fallback;
279
exit(EXIT_FAILURE);
323
280
}
324
281
325
282
/* The options we understand. */
342
299
{ .name = "plugin-dir", .key = 128,
343
300
.arg = "DIRECTORY",
344
301
.doc = "Specify a different plugin directory", .group = 2 },
345
{ .name = "config-file", .key = 129,
346
.arg = "FILE",
347
.doc = "Specify a different configuration file", .group = 2 },
348
{ .name = "userid", .key = 130,
349
.arg = "ID", .flags = 0,
350
.doc = "User ID the plugins will run as", .group = 3 },
351
{ .name = "groupid", .key = 131,
352
.arg = "ID", .flags = 0,
353
.doc = "Group ID the plugins will run as", .group = 3 },
354
{ .name = "debug", .key = 132,
355
.doc = "Debug mode", .group = 4 },
302
{ .name = "userid", .key = 129,
303
.arg = "ID", .flags = 0,
304
.doc = "User ID the plugins will run as", .group = 2 },
305
{ .name = "groupid", .key = 130,
306
.arg = "ID", .flags = 0,
307
.doc = "Group ID the plugins will run as", .group = 2 },
308
{ .name = "debug", .key = 131,
309
.doc = "Debug mode", .group = 3 },
356
310
{ .name = NULL }
357
311
};
358
312
359
error_t parse_opt (int key, char *arg, __attribute__((unused))
360
struct argp_state *state) {
313
error_t parse_opt (int key, char *arg, struct argp_state *state) {
361
314
/* Get the INPUT argument from `argp_parse', which we know is a
362
315
pointer to our plugin list pointer. */
316
plugin **plugins = state->input;
363
317
switch (key) {
364
case 'g': /* --global-options */
318
case 'g':
365
319
if (arg != NULL){
366
320
char *p;
367
321
while((p = strsep(&arg, ",")) != NULL){
368
322
if(p[0] == '\0'){
369
323
continue;
370
324
}
371
if(not add_argument(getplugin(NULL), p)){
325
if(not add_argument(getplugin(NULL, plugins), p)){
372
326
perror("add_argument");
373
327
return ARGP_ERR_UNKNOWN;
374
328
}
375
329
}
376
330
}
377
331
break;
378
case 'e': /* --global-envs */
332
case 'e':
379
333
if(arg == NULL){
380
334
break;
381
335
}
384
338
if(envdef == NULL){
385
339
break;
386
340
}
387
if(not add_environment(getplugin(NULL), envdef)){
341
if(not add_environment(getplugin(NULL, plugins), envdef)){
388
342
perror("add_environment");
389
343
}
390
344
}
391
345
break;
392
case 'o': /* --options-for */
346
case 'o':
393
347
if (arg != NULL){
394
348
char *p_name = strsep(&arg, ":");
395
349
if(p_name[0] == '\0'){
405
359
if(p[0] == '\0'){
406
360
continue;
407
361
}
408
if(not add_argument(getplugin(p_name), p)){
362
if(not add_argument(getplugin(p_name, plugins), p)){
409
363
perror("add_argument");
410
364
return ARGP_ERR_UNKNOWN;
411
365
}
413
367
}
414
368
}
415
369
break;
416
case 'f': /* --envs-for */
370
case 'f':
417
371
if(arg == NULL){
418
372
break;
419
373
}
427
381
break;
428
382
}
429
383
envdef++;
430
if(not add_environment(getplugin(p_name), envdef)){
384
if(not add_environment(getplugin(p_name, plugins), envdef)){
431
385
perror("add_environment");
432
386
}
433
387
}
434
388
break;
435
case 'd': /* --disable */
389
case 'd':
436
390
if (arg != NULL){
437
plugin *p = getplugin(arg);
391
plugin *p = getplugin(arg, plugins);
438
392
if(p == NULL){
439
393
return ARGP_ERR_UNKNOWN;
440
394
}
441
395
p->disabled = true;
442
396
}
443
397
break;
444
case 128: /* --plugin-dir */
445
plugindir = strdup(arg);
446
if(plugindir == NULL){
447
perror("strdup");
448
}
398
case 128:
399
plugindir = arg;
449
400
break;
450
case 129: /* --config-file */
451
argfile = strdup(arg);
452
if(argfile == NULL){
453
perror("strdup");
454
}
455
break;
456
case 130: /* --userid */
401
case 129:
457
402
uid = (uid_t)strtol(arg, NULL, 10);
458
403
break;
459
case 131: /* --groupid */
404
case 130:
460
405
gid = (gid_t)strtol(arg, NULL, 10);
461
406
break;
462
case 132: /* --debug */
407
case 131:
463
408
debug = true;
464
409
break;
465
410
case ARGP_KEY_ARG:
473
418
return 0;
474
419
}
475
420
421
plugin *plugin_list = NULL;
422
476
423
struct argp argp = { .options = options, .parser = parse_opt,
477
424
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
478
425
.doc = "Mandos plugin runner -- Run plugins" };
479
426
480
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
427
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
481
428
if (ret == ARGP_ERR_UNKNOWN){
482
429
fprintf(stderr, "Unknown error while parsing arguments\n");
483
430
exitstatus = EXIT_FAILURE;
484
goto fallback;
431
goto end;
485
432
}
486
433
487
/* Opens the configfile if aviable */
488
if (argfile == NULL){
489
conffp = fopen(AFILE, "r");
490
} else {
491
conffp = fopen(argfile, "r");
492
}
434
conffp = fopen(argfile, "r");
493
435
if(conffp != NULL){
494
436
char *org_line = NULL;
495
char *p, *arg, *new_arg, *line;
496
437
size_t size = 0;
497
438
ssize_t sret;
439
char *p, *arg, *new_arg, *line;
498
440
const char whitespace_delims[] = " \r\t\f\v\n";
499
441
const char comment_delim[] = "#";
500
442
501
custom_argc = 1;
502
custom_argv = malloc(sizeof(char*) * 2);
503
if(custom_argv == NULL){
504
perror("malloc");
505
exitstatus = EXIT_FAILURE;
506
goto fallback;
507
}
508
custom_argv[0] = argv[0];
509
custom_argv[1] = NULL;
510
511
/* for each line in the config file, strip whitespace and ignore
512
commented text */
513
443
while(true){
514
444
sret = getline(&org_line, &size, conffp);
515
445
if(sret == -1){
523
453
continue;
524
454
}
525
455
new_arg = strdup(p);
526
if(new_arg == NULL){
527
perror("strdup");
528
exitstatus = EXIT_FAILURE;
529
free(org_line);
530
goto fallback;
531
}
532
533
custom_argc += 1;
534
custom_argv = realloc(custom_argv, sizeof(char *)
535
* ((unsigned int) custom_argc + 1));
536
if(custom_argv == NULL){
537
perror("realloc");
538
exitstatus = EXIT_FAILURE;
539
free(org_line);
540
goto fallback;
541
}
542
custom_argv[custom_argc-1] = new_arg;
543
custom_argv[custom_argc] = NULL;
456
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
457
if (custom_argv == NULL){
458
perror("add_to_argv");
459
exitstatus = EXIT_FAILURE;
460
goto end;
461
}
544
462
}
545
463
}
546
464
free(org_line);
550
468
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
551
469
perror("fopen");
552
470
exitstatus = EXIT_FAILURE;
553
goto fallback;
471
goto end;
554
472
}
555
473
}
556
/* If there was any arguments from configuration file,
557
pass them to parser as command arguments */
474
558
475
if(custom_argv != NULL){
559
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);
476
custom_argv[0] = argv[0];
477
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
560
478
if (ret == ARGP_ERR_UNKNOWN){
561
479
fprintf(stderr, "Unknown error while parsing arguments\n");
562
480
exitstatus = EXIT_FAILURE;
563
goto fallback;
481
goto end;
564
482
}
565
483
}
566
484
577
495
}
578
496
}
579
497
}
580
581
/* Strip permissions down to nobody */
498
582
499
ret = setuid(uid);
583
500
if (ret == -1){
584
501
perror("setuid");
585
}
502
}
503
586
504
setgid(gid);
587
505
if (ret == -1){
588
506
perror("setgid");
589
507
}
590
591
if (plugindir == NULL){
592
dir = opendir(PDIR);
593
} else {
594
dir = opendir(plugindir);
595
}
596
508
509
dir = opendir(plugindir);
597
510
if(dir == NULL){
598
511
perror("Could not open plugin dir");
599
512
exitstatus = EXIT_FAILURE;
600
goto fallback;
513
goto end;
601
514
}
602
515
603
516
/* Set the FD_CLOEXEC flag on the directory, if possible */
608
521
if(ret < 0){
609
522
perror("set_cloexec_flag");
610
523
exitstatus = EXIT_FAILURE;
611
goto fallback;
524
goto end;
612
525
}
613
526
}
614
527
}
615
528
616
529
FD_ZERO(&rfds_all);
617
618
/* Read and execute any executable in the plugin directory*/
530
619
531
while(true){
620
532
dirst = readdir(dir);
621
533
624
536
if (errno == EBADF){
625
537
perror("readdir");
626
538
exitstatus = EXIT_FAILURE;
627
goto fallback;
539
goto end;
628
540
}
629
541
break;
630
542
}
652
564
break;
653
565
}
654
566
}
567
655
568
if(bad_name){
656
569
continue;
657
570
}
571
658
572
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
659
573
size_t suf_len = strlen(*suf);
660
574
if((d_name_len >= suf_len)
687
601
free(filename);
688
602
continue;
689
603
}
690
691
/* Ignore non-executable files */
604
692
605
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
693
606
if(debug){
694
607
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
697
610
free(filename);
698
611
continue;
699
612
}
700
701
plugin *p = getplugin(dirst->d_name);
613
plugin *p = getplugin(dirst->d_name, &plugin_list);
702
614
if(p == NULL){
703
615
perror("getplugin");
704
616
free(filename);
714
626
}
715
627
{
716
628
/* Add global arguments to argument list for this plugin */
717
plugin *g = getplugin(NULL);
629
plugin *g = getplugin(NULL, &plugin_list);
718
630
if(g != NULL){
719
631
for(char **a = g->argv + 1; *a != NULL; a++){
720
632
if(not add_argument(p, *a)){
745
657
}
746
658
}
747
659
748
int pipefd[2];
660
int pipefd[2];
749
661
ret = pipe(pipefd);
750
662
if (ret == -1){
751
663
perror("pipe");
752
664
exitstatus = EXIT_FAILURE;
753
goto fallback;
665
goto end;
754
666
}
755
/* Ask OS to automatic close the pipe on exec */
756
667
ret = set_cloexec_flag(pipefd[0]);
757
668
if(ret < 0){
758
669
perror("set_cloexec_flag");
759
670
exitstatus = EXIT_FAILURE;
760
goto fallback;
671
goto end;
761
672
}
762
673
ret = set_cloexec_flag(pipefd[1]);
763
674
if(ret < 0){
764
675
perror("set_cloexec_flag");
765
676
exitstatus = EXIT_FAILURE;
766
goto fallback;
677
goto end;
767
678
}
768
679
/* Block SIGCHLD until process is safely in process list */
769
680
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
770
681
if(ret < 0){
771
682
perror("sigprocmask");
772
683
exitstatus = EXIT_FAILURE;
773
goto fallback;
684
goto end;
774
685
}
775
686
// Starting a new process to be watched
776
687
pid_t pid = fork();
777
688
if(pid == -1){
778
689
perror("fork");
779
690
exitstatus = EXIT_FAILURE;
780
goto fallback;
691
goto end;
781
692
}
782
693
if(pid == 0){
783
694
/* this is the child process */
816
727
}
817
728
/* no return */
818
729
}
819
/* Parent process */
820
close(pipefd[1]); /* Close unused write end of pipe */
730
/* parent process */
821
731
free(filename);
822
plugin *new_plugin = getplugin(dirst->d_name);
823
if (new_plugin == NULL){
824
perror("getplugin");
732
close(pipefd[1]); /* close unused write end of pipe */
733
process *new_process = malloc(sizeof(process));
734
if (new_process == NULL){
735
perror("malloc");
825
736
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
826
737
if(ret < 0){
827
perror("sigprocmask");
738
perror("sigprocmask");
828
739
}
829
740
exitstatus = EXIT_FAILURE;
830
goto fallback;
741
goto end;
831
742
}
832
743
833
new_plugin->pid = pid;
834
new_plugin->fd = pipefd[0];
835
744
*new_process = (struct process){ .pid = pid,
745
.fd = pipefd[0],
746
.next = process_list };
747
// List handling
748
process_list = new_process;
836
749
/* Unblock SIGCHLD so signal handler can be run if this process
837
750
has already completed */
838
751
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
839
752
if(ret < 0){
840
753
perror("sigprocmask");
841
754
exitstatus = EXIT_FAILURE;
842
goto fallback;
843
}
844
845
FD_SET(new_plugin->fd, &rfds_all);
846
847
if (maxfd < new_plugin->fd){
848
maxfd = new_plugin->fd;
849
}
850
755
goto end;
756
}
757
758
FD_SET(new_process->fd, &rfds_all);
759
760
if (maxfd < new_process->fd){
761
maxfd = new_process->fd;
762
}
763
764
}
765
766
/* Free the plugin list */
767
for(plugin *next; plugin_list != NULL; plugin_list = next){
768
next = plugin_list->next;
769
free(plugin_list->argv);
770
if(plugin_list->environ[0] != NULL){
771
for(char **e = plugin_list->environ; *e != NULL; e++){
772
free(*e);
773
}
774
}
775
free(plugin_list);
851
776
}
852
777
853
778
closedir(dir);
854
779
dir = NULL;
855
856
for(plugin *p = plugin_list; p != NULL; p = p->next){
857
if(p->pid != 0){
858
break;
859
}
860
if(p->next == NULL){
861
fprintf(stderr, "No plugin processes started. Incorrect plugin"
862
" directory?\n");
863
free_plugin_list();
864
}
780
781
if (process_list == NULL){
782
fprintf(stderr, "No plugin processes started. Incorrect plugin"
783
" directory?\n");
784
process_list = NULL;
865
785
}
866
867
/* Main loop while running plugins exist */
868
while(plugin_list){
786
while(process_list){
869
787
fd_set rfds = rfds_all;
870
788
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
871
789
if (select_ret == -1){
872
790
perror("select");
873
791
exitstatus = EXIT_FAILURE;
874
goto fallback;
792
goto end;
875
793
}
876
794
/* OK, now either a process completed, or something can be read
877
795
from one of them */
878
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
796
for(process *proc = process_list; proc ; proc = proc->next){
879
797
/* Is this process completely done? */
880
798
if(proc->eof and proc->completed){
881
799
/* Only accept the plugin output if it exited cleanly */
882
800
if(not WIFEXITED(proc->status)
883
801
or WEXITSTATUS(proc->status) != 0){
884
802
/* Bad exit by plugin */
885
886
803
if(debug){
887
804
if(WIFEXITED(proc->status)){
888
805
fprintf(stderr, "Plugin %u exited with status %d\n",
897
814
(unsigned int) (proc->pid));
898
815
}
899
816
}
900
901
817
/* Remove the plugin */
902
818
FD_CLR(proc->fd, &rfds_all);
903
904
819
/* Block signal while modifying process_list */
905
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
820
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
906
821
if(ret < 0){
907
822
perror("sigprocmask");
908
823
exitstatus = EXIT_FAILURE;
909
goto fallback;
910
}
911
free_plugin(proc);
824
goto end;
825
}
826
/* Delete this process entry from the list */
827
if(process_list == proc){
828
/* First one - simple */
829
process_list = proc->next;
830
} else {
831
/* Second one or later */
832
for(process *p = process_list; p != NULL; p = p->next){
833
if(p->next == proc){
834
p->next = proc->next;
835
break;
836
}
837
}
838
}
912
839
/* We are done modifying process list, so unblock signal */
913
840
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
914
841
NULL);
915
842
if(ret < 0){
916
843
perror("sigprocmask");
917
exitstatus = EXIT_FAILURE;
918
goto fallback;
919
}
920
921
if(plugin_list == NULL){
922
break;
923
}
924
continue;
844
}
845
free(proc->buffer);
846
free(proc);
847
/* We deleted this process from the list, so we can't go
848
proc->next. Therefore, start over from the beginning of
849
the process list */
850
break;
925
851
}
926
927
852
/* This process exited nicely, so print its buffer */
928
853
929
bool bret = print_out_password(proc->buffer,
930
proc->buffer_length);
854
bool bret = print_out_password(proc->buffer, proc->buffer_length);
931
855
if(not bret){
932
856
perror("print_out_password");
933
857
exitstatus = EXIT_FAILURE;
934
858
}
935
goto fallback;
859
goto end;
936
860
}
937
938
861
/* This process has not completed. Does it have any output? */
939
862
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
940
863
/* This process had nothing to say at this time */
947
870
if (proc->buffer == NULL){
948
871
perror("malloc");
949
872
exitstatus = EXIT_FAILURE;
950
goto fallback;
873
goto end;
951
874
}
952
875
proc->buffer_size += BUFFER_SIZE;
953
876
}
968
891
}
969
892
970
893
971
fallback:
894
end:
972
895
973
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
974
/* Fallback if all plugins failed, none are found or an error
975
occured */
896
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
897
/* Fallback if all plugins failed, none are found or an error occured */
976
898
bool bret;
977
899
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
978
900
char *passwordbuffer = getpass("Password: ");
980
902
if(not bret){
981
903
perror("print_out_password");
982
904
exitstatus = EXIT_FAILURE;
905
goto end;
983
906
}
984
907
}
985
908
986
909
/* Restore old signal handler */
987
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
988
if(ret == -1){
989
perror("sigaction");
990
exitstatus = EXIT_FAILURE;
991
}
992
993
if(custom_argv != NULL){
994
for(char **arg = custom_argv+1; *arg != NULL; arg++){
995
free(*arg);
910
sigaction(SIGCHLD, &old_sigchld_action, NULL);
911
912
free(custom_argv);
913
914
/* Free the plugin list */
915
for(plugin *next; plugin_list != NULL; plugin_list = next){
916
next = plugin_list->next;
917
free(plugin_list->argv);
918
if(plugin_list->environ[0] != NULL){
919
for(char **e = plugin_list->environ; *e != NULL; e++){
920
free(*e);
921
}
996
922
}
997
free(custom_argv);
923
free(plugin_list->environ);
924
free(plugin_list);
998
925
}
999
926
1000
927
if(dir != NULL){
1002
929
}
1003
930
1004
931
/* Free the process list and kill the processes */
1005
for(plugin *p = plugin_list; p != NULL; p = p->next){
1006
if(p->pid != 0){
1007
close(p->fd);
1008
ret = kill(p->pid, SIGTERM);
1009
if(ret == -1 and errno != ESRCH){
1010
/* Set-uid proccesses might not get closed */
1011
perror("kill");
1012
}
932
for(process *next; process_list != NULL; process_list = next){
933
next = process_list->next;
934
close(process_list->fd);
935
ret = kill(process_list->pid, SIGTERM);
936
if(ret == -1 and errno != ESRCH){
937
/* set-uid proccesses migth not get closed */
938
perror("kill");
1013
939
}
940
free(process_list->buffer);
941
free(process_list);
1014
942
}
1015
943
1016
944
/* Wait for any remaining child processes to terminate */
1020
948
if(errno != ECHILD){
1021
949
perror("wait");
1022
950
}
1023
1024
free_plugin_list();
1025
1026
free(plugindir);
1027
free(argfile);
1028
951
1029
952
return exitstatus;
1030
953
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0