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 24.1.81
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.81
- Committer: Björn Påhlsson
- Date: 2008-09-03 18:47:50 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 149.
- Revision ID: belorn@braxen-20080903184750-s0k0jrrq0lxiamwh
removed keyring pre-requirement for starting password-request.
Keys will now be imported in run-time to a run-time created keyring
Changed seckey and pubkey to be paths to private and public keys of the pgp encrypted password and gnutls authentication credentials.
Keys will now be imported in run-time to a run-time created keyring
Changed seckey and pubkey to be paths to private and public keys of the pgp encrypted password and gnutls authentication credentials.
- files added:
- .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, error_t */
59
ARGP_KEY_END, ARGP_KEY_ARG,
60
error_t */
60
61
#include <signal.h> /* struct sigaction, sigemptyset(),
61
62
sigaddset(), sigaction(),
62
63
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
65
#include <errno.h> /* errno, EBADF */
65
66
66
67
#define BUFFER_SIZE 256
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
69
#define PDIR "/lib/mandos/plugins.d"
70
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
71
69
72
const char *argp_program_version = "plugin-runner 1.0";
70
73
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
74
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;
75
struct plugin;
85
76
86
77
typedef struct plugin{
87
78
char *name; /* can be NULL or any plugin name */
90
81
char **environ;
91
82
int envc;
92
83
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;
93
94
struct plugin *next;
94
95
} plugin;
95
96
96
static plugin *getplugin(char *name, plugin **plugin_list){
97
for (plugin *p = *plugin_list; p != NULL; p = p->next){
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){
98
104
if ((p->name == name)
99
105
or (p->name and name and (strcmp(p->name, name) == 0))){
100
106
return p;
112
118
return NULL;
113
119
}
114
120
}
115
121
116
122
*new_plugin = (plugin) { .name = copy_name,
117
123
.argc = 1,
118
.envc = 0,
119
124
.disabled = false,
120
.next = *plugin_list };
125
.next = plugin_list };
121
126
122
127
new_plugin->argv = malloc(sizeof(char *) * 2);
123
128
if (new_plugin->argv == NULL){
127
132
}
128
133
new_plugin->argv[0] = copy_name;
129
134
new_plugin->argv[1] = NULL;
130
135
131
136
new_plugin->environ = malloc(sizeof(char *));
132
137
if(new_plugin->environ == NULL){
133
138
free(copy_name);
136
141
return NULL;
137
142
}
138
143
new_plugin->environ[0] = NULL;
144
139
145
/* Append the new plugin to the list */
140
*plugin_list = new_plugin;
146
plugin_list = new_plugin;
141
147
return new_plugin;
142
148
}
143
149
173
179
}
174
180
175
181
/* Add to a plugin's environment */
176
static bool add_environment(plugin *p, const char *def){
182
static bool add_environment(plugin *p, const char *def, bool replace){
177
183
if(p == NULL){
178
184
return false;
179
185
}
186
/* namelen = length of name of environment variable */
187
size_t namelen = (size_t)(strchrnul(def, '=') - def);
188
/* Search for this environment variable */
189
for(char **e = p->environ; *e != NULL; e++){
190
if(strncmp(*e, def, namelen+1) == 0){
191
/* It already exists */
192
if(replace){
193
char *new = realloc(*e, strlen(def));
194
if(new == NULL){
195
return false;
196
}
197
*e = new;
198
strcpy(*e, def);
199
}
200
return true;
201
}
202
}
180
203
return add_to_char_array(def, &(p->environ), &(p->envc));
181
204
}
182
205
183
184
206
/*
185
207
* Based on the example in the GNU LibC manual chapter 13.13 "File
186
208
* Descriptor Flags".
197
219
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
198
220
}
199
221
200
process *process_list = NULL;
201
222
202
/* Mark a process as completed when it exits, and save its exit
223
/* Mark processes as completed when they exit, and save their exit
203
224
status. */
204
225
void handle_sigchld(__attribute__((unused)) int sig){
205
process *proc = process_list;
206
int status;
207
pid_t pid = wait(&status);
208
if(pid == -1){
209
perror("wait");
210
return;
211
}
212
while(proc != NULL and proc->pid != pid){
213
proc = proc->next;
214
}
215
if(proc == NULL){
216
/* Process not found in process list */
217
return;
218
}
219
proc->status = status;
220
proc->completed = true;
226
while(true){
227
plugin *proc = plugin_list;
228
int status;
229
pid_t pid = waitpid(-1, &status, WNOHANG);
230
if(pid == 0){
231
/* Only still running child processes */
232
break;
233
}
234
if(pid == -1){
235
if (errno != ECHILD){
236
perror("waitpid");
237
}
238
/* No child processes */
239
break;
240
}
241
242
/* A child exited, find it in process_list */
243
while(proc != NULL and proc->pid != pid){
244
proc = proc->next;
245
}
246
if(proc == NULL){
247
/* Process not found in process list */
248
continue;
249
}
250
proc->status = status;
251
proc->completed = true;
252
}
221
253
}
222
254
255
/* Prints out a password to stdout */
223
256
bool print_out_password(const char *buffer, size_t length){
224
257
ssize_t ret;
225
258
if(length>0 and buffer[length-1] == '\n'){
235
268
return true;
236
269
}
237
270
238
char **add_to_argv(char **argv, int *argc, char *arg){
239
if (argv == NULL){
240
*argc = 1;
241
argv = malloc(sizeof(char*) * 2);
242
if(argv == NULL){
243
return NULL;
271
/* Removes and free a plugin from the plugin list */
272
static void free_plugin(plugin *plugin_node){
273
274
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
275
free(*arg);
276
}
277
free(plugin_node->argv);
278
for(char **env = plugin_node->environ; *env != NULL; env++){
279
free(*env);
280
}
281
free(plugin_node->environ);
282
free(plugin_node->buffer);
283
284
/* Removes the plugin from the singly-linked list */
285
if(plugin_node == plugin_list){
286
/* First one - simple */
287
plugin_list = plugin_list->next;
288
} else {
289
/* Second one or later */
290
for(plugin *p = plugin_list; p != NULL; p = p->next){
291
if(p->next == plugin_node){
292
p->next = plugin_node->next;
293
break;
294
}
244
295
}
245
argv[0] = NULL; /* Will be set to argv[0] in main before parsing */
246
argv[1] = NULL;
247
}
248
*argc += 1;
249
argv = realloc(argv, sizeof(char *)
250
* ((unsigned int) *argc + 1));
251
if(argv == NULL){
252
return NULL;
253
}
254
argv[*argc-1] = arg;
255
argv[*argc] = NULL;
256
return argv;
296
}
297
298
free(plugin_node);
257
299
}
258
300
259
static void free_plugin_list(plugin *plugin_list){
260
for(plugin *next; plugin_list != NULL; plugin_list = next){
261
next = plugin_list->next;
262
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
263
free(*arg);
264
}
265
free(plugin_list->argv);
266
for(char **env = plugin_list->environ; *env != NULL; env++){
267
free(*env);
268
}
269
free(plugin_list->environ);
270
free(plugin_list);
301
static void free_plugin_list(void){
302
while(plugin_list != NULL){
303
free_plugin(plugin_list);
271
304
}
272
305
}
273
306
274
307
int main(int argc, char *argv[]){
275
const char *plugindir = "/lib/mandos/plugins.d";
276
const char *argfile = ARGFILE;
308
char *plugindir = NULL;
309
char *argfile = NULL;
277
310
FILE *conffp;
278
311
size_t d_name_len;
279
312
DIR *dir = NULL;
311
344
{ .name = "global-options", .key = 'g',
312
345
.arg = "OPTION[,OPTION[,...]]",
313
346
.doc = "Options passed to all plugins" },
314
{ .name = "global-envs", .key = 'e',
347
{ .name = "global-env", .key = 'G',
315
348
.arg = "VAR=value",
316
349
.doc = "Environment variable passed to all plugins" },
317
350
{ .name = "options-for", .key = 'o',
318
351
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
319
352
.doc = "Options passed only to specified plugin" },
320
{ .name = "envs-for", .key = 'f',
353
{ .name = "env-for", .key = 'E',
321
354
.arg = "PLUGIN:ENV=value",
322
355
.doc = "Environment variable passed to specified plugin" },
323
356
{ .name = "disable", .key = 'd',
324
357
.arg = "PLUGIN",
325
358
.doc = "Disable a specific plugin", .group = 1 },
359
{ .name = "enable", .key = 'e',
360
.arg = "PLUGIN",
361
.doc = "Enable a specific plugin", .group = 1 },
326
362
{ .name = "plugin-dir", .key = 128,
327
363
.arg = "DIRECTORY",
328
364
.doc = "Specify a different plugin directory", .group = 2 },
329
{ .name = "userid", .key = 129,
330
.arg = "ID", .flags = 0,
331
.doc = "User ID the plugins will run as", .group = 2 },
332
{ .name = "groupid", .key = 130,
333
.arg = "ID", .flags = 0,
334
.doc = "Group ID the plugins will run as", .group = 2 },
335
{ .name = "debug", .key = 131,
336
.doc = "Debug mode", .group = 3 },
365
{ .name = "config-file", .key = 129,
366
.arg = "FILE",
367
.doc = "Specify a different configuration file", .group = 2 },
368
{ .name = "userid", .key = 130,
369
.arg = "ID", .flags = 0,
370
.doc = "User ID the plugins will run as", .group = 3 },
371
{ .name = "groupid", .key = 131,
372
.arg = "ID", .flags = 0,
373
.doc = "Group ID the plugins will run as", .group = 3 },
374
{ .name = "debug", .key = 132,
375
.doc = "Debug mode", .group = 4 },
337
376
{ .name = NULL }
338
377
};
339
378
340
error_t parse_opt (int key, char *arg, struct argp_state *state) {
341
/* Get the INPUT argument from `argp_parse', which we know is a
342
pointer to our plugin list pointer. */
343
plugin **plugins = state->input;
379
error_t parse_opt (int key, char *arg, __attribute__((unused))
380
struct argp_state *state) {
344
381
switch (key) {
345
case 'g':
382
case 'g': /* --global-options */
346
383
if (arg != NULL){
347
384
char *p;
348
385
while((p = strsep(&arg, ",")) != NULL){
349
386
if(p[0] == '\0'){
350
387
continue;
351
388
}
352
if(not add_argument(getplugin(NULL, plugins), p)){
389
if(not add_argument(getplugin(NULL), p)){
353
390
perror("add_argument");
354
391
return ARGP_ERR_UNKNOWN;
355
392
}
356
393
}
357
394
}
358
395
break;
359
case 'e':
396
case 'G': /* --global-env */
360
397
if(arg == NULL){
361
398
break;
362
399
}
365
402
if(envdef == NULL){
366
403
break;
367
404
}
368
if(not add_environment(getplugin(NULL, plugins), envdef)){
405
if(not add_environment(getplugin(NULL), envdef, true)){
369
406
perror("add_environment");
370
407
}
371
408
}
372
409
break;
373
case 'o':
410
case 'o': /* --options-for */
374
411
if (arg != NULL){
375
412
char *p_name = strsep(&arg, ":");
376
413
if(p_name[0] == '\0'){
386
423
if(p[0] == '\0'){
387
424
continue;
388
425
}
389
if(not add_argument(getplugin(p_name, plugins), p)){
426
if(not add_argument(getplugin(p_name), p)){
390
427
perror("add_argument");
391
428
return ARGP_ERR_UNKNOWN;
392
429
}
394
431
}
395
432
}
396
433
break;
397
case 'f':
434
case 'E': /* --env-for */
398
435
if(arg == NULL){
399
436
break;
400
437
}
408
445
break;
409
446
}
410
447
envdef++;
411
if(not add_environment(getplugin(p_name, plugins), envdef)){
448
if(not add_environment(getplugin(p_name), envdef, true)){
412
449
perror("add_environment");
413
450
}
414
451
}
415
452
break;
416
case 'd':
453
case 'd': /* --disable */
417
454
if (arg != NULL){
418
plugin *p = getplugin(arg, plugins);
455
plugin *p = getplugin(arg);
419
456
if(p == NULL){
420
457
return ARGP_ERR_UNKNOWN;
421
458
}
422
459
p->disabled = true;
423
460
}
424
461
break;
425
case 128:
426
plugindir = arg;
427
break;
428
case 129:
462
case 'e': /* --enable */
463
if (arg != NULL){
464
plugin *p = getplugin(arg);
465
if(p == NULL){
466
return ARGP_ERR_UNKNOWN;
467
}
468
p->disabled = false;
469
}
470
break;
471
case 128: /* --plugin-dir */
472
plugindir = strdup(arg);
473
if(plugindir == NULL){
474
perror("strdup");
475
}
476
break;
477
case 129: /* --config-file */
478
/* This is already done by parse_opt_config_file() */
479
break;
480
case 130: /* --userid */
429
481
uid = (uid_t)strtol(arg, NULL, 10);
430
482
break;
431
case 130:
483
case 131: /* --groupid */
432
484
gid = (gid_t)strtol(arg, NULL, 10);
433
485
break;
434
case 131:
486
case 132: /* --debug */
435
487
debug = true;
436
488
break;
437
489
case ARGP_KEY_ARG:
445
497
return 0;
446
498
}
447
499
448
plugin *plugin_list = NULL;
500
/* This option parser is the same as parse_opt() above, except it
501
ignores everything but the --config-file option. */
502
error_t parse_opt_config_file (int key, char *arg,
503
__attribute__((unused))
504
struct argp_state *state) {
505
switch (key) {
506
case 'g': /* --global-options */
507
case 'G': /* --global-env */
508
case 'o': /* --options-for */
509
case 'E': /* --env-for */
510
case 'd': /* --disable */
511
case 'e': /* --enable */
512
case 128: /* --plugin-dir */
513
break;
514
case 129: /* --config-file */
515
argfile = strdup(arg);
516
if(argfile == NULL){
517
perror("strdup");
518
}
519
break;
520
case 130: /* --userid */
521
case 131: /* --groupid */
522
case 132: /* --debug */
523
case ARGP_KEY_ARG:
524
case ARGP_KEY_END:
525
break;
526
default:
527
return ARGP_ERR_UNKNOWN;
528
}
529
return 0;
530
}
449
531
450
struct argp argp = { .options = options, .parser = parse_opt,
451
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
532
struct argp argp = { .options = options,
533
.parser = parse_opt_config_file,
534
.args_doc = "",
452
535
.doc = "Mandos plugin runner -- Run plugins" };
453
536
454
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
537
/* Parse using the parse_opt_config_file in order to get the custom
538
config file location, if any. */
539
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
455
540
if (ret == ARGP_ERR_UNKNOWN){
456
541
fprintf(stderr, "Unknown error while parsing arguments\n");
457
542
exitstatus = EXIT_FAILURE;
458
543
goto fallback;
459
544
}
460
461
conffp = fopen(argfile, "r");
545
546
/* Reset to the normal argument parser */
547
argp.parser = parse_opt;
548
549
/* Open the configfile if available */
550
if (argfile == NULL){
551
conffp = fopen(AFILE, "r");
552
} else {
553
conffp = fopen(argfile, "r");
554
}
462
555
if(conffp != NULL){
463
556
char *org_line = NULL;
464
557
char *p, *arg, *new_arg, *line;
467
560
const char whitespace_delims[] = " \r\t\f\v\n";
468
561
const char comment_delim[] = "#";
469
562
563
custom_argc = 1;
564
custom_argv = malloc(sizeof(char*) * 2);
565
if(custom_argv == NULL){
566
perror("malloc");
567
exitstatus = EXIT_FAILURE;
568
goto fallback;
569
}
570
custom_argv[0] = argv[0];
571
custom_argv[1] = NULL;
572
573
/* for each line in the config file, strip whitespace and ignore
574
commented text */
470
575
while(true){
471
576
sret = getline(&org_line, &size, conffp);
472
577
if(sret == -1){
480
585
continue;
481
586
}
482
587
new_arg = strdup(p);
483
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
484
if (custom_argv == NULL){
485
perror("add_to_argv");
486
exitstatus = EXIT_FAILURE;
487
goto fallback;
488
}
588
if(new_arg == NULL){
589
perror("strdup");
590
exitstatus = EXIT_FAILURE;
591
free(org_line);
592
goto fallback;
593
}
594
595
custom_argc += 1;
596
custom_argv = realloc(custom_argv, sizeof(char *)
597
* ((unsigned int) custom_argc + 1));
598
if(custom_argv == NULL){
599
perror("realloc");
600
exitstatus = EXIT_FAILURE;
601
free(org_line);
602
goto fallback;
603
}
604
custom_argv[custom_argc-1] = new_arg;
605
custom_argv[custom_argc] = NULL;
489
606
}
490
607
}
491
608
free(org_line);
492
} else{
609
} else {
493
610
/* Check for harmful errors and go to fallback. Other errors might
494
611
not affect opening plugins */
495
612
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
498
615
goto fallback;
499
616
}
500
617
}
501
618
/* If there was any arguments from configuration file,
619
pass them to parser as command arguments */
502
620
if(custom_argv != NULL){
503
custom_argv[0] = argv[0];
504
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
621
ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
622
0, NULL);
505
623
if (ret == ARGP_ERR_UNKNOWN){
506
624
fprintf(stderr, "Unknown error while parsing arguments\n");
507
625
exitstatus = EXIT_FAILURE;
509
627
}
510
628
}
511
629
630
/* Parse actual command line arguments, to let them override the
631
config file */
632
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
633
if (ret == ARGP_ERR_UNKNOWN){
634
fprintf(stderr, "Unknown error while parsing arguments\n");
635
exitstatus = EXIT_FAILURE;
636
goto fallback;
637
}
638
512
639
if(debug){
513
640
for(plugin *p = plugin_list; p != NULL; p=p->next){
514
641
fprintf(stderr, "Plugin: %s has %d arguments\n",
523
650
}
524
651
}
525
652
653
/* Strip permissions down to nobody */
526
654
ret = setuid(uid);
527
655
if (ret == -1){
528
656
perror("setuid");
529
}
530
657
}
531
658
setgid(gid);
532
659
if (ret == -1){
533
660
perror("setgid");
534
661
}
535
662
536
dir = opendir(plugindir);
663
if (plugindir == NULL){
664
dir = opendir(PDIR);
665
} else {
666
dir = opendir(plugindir);
667
}
668
537
669
if(dir == NULL){
538
670
perror("Could not open plugin dir");
539
671
exitstatus = EXIT_FAILURE;
555
687
556
688
FD_ZERO(&rfds_all);
557
689
690
/* Read and execute any executable in the plugin directory*/
558
691
while(true){
559
692
dirst = readdir(dir);
560
693
561
// All directory entries have been processed
694
/* All directory entries have been processed */
562
695
if(dirst == NULL){
563
696
if (errno == EBADF){
564
697
perror("readdir");
570
703
571
704
d_name_len = strlen(dirst->d_name);
572
705
573
// Ignore dotfiles, backup files and other junk
706
/* Ignore dotfiles, backup files and other junk */
574
707
{
575
708
bool bad_name = false;
576
709
591
724
break;
592
725
}
593
726
}
594
595
727
if(bad_name){
596
728
continue;
597
729
}
598
599
730
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
600
731
size_t suf_len = strlen(*suf);
601
732
if((d_name_len >= suf_len)
628
759
free(filename);
629
760
continue;
630
761
}
631
762
763
/* Ignore non-executable files */
632
764
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
633
765
if(debug){
634
766
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
637
769
free(filename);
638
770
continue;
639
771
}
640
plugin *p = getplugin(dirst->d_name, &plugin_list);
772
773
plugin *p = getplugin(dirst->d_name);
641
774
if(p == NULL){
642
775
perror("getplugin");
643
776
free(filename);
653
786
}
654
787
{
655
788
/* Add global arguments to argument list for this plugin */
656
plugin *g = getplugin(NULL, &plugin_list);
789
plugin *g = getplugin(NULL);
657
790
if(g != NULL){
658
791
for(char **a = g->argv + 1; *a != NULL; a++){
659
792
if(not add_argument(p, *a)){
662
795
}
663
796
/* Add global environment variables */
664
797
for(char **e = g->environ; *e != NULL; e++){
665
if(not add_environment(p, *e)){
798
if(not add_environment(p, *e, false)){
666
799
perror("add_environment");
667
800
}
668
801
}
673
806
process, too. */
674
807
if(p->environ[0] != NULL){
675
808
for(char **e = environ; *e != NULL; e++){
676
char *copy = strdup(*e);
677
if(copy == NULL){
678
perror("strdup");
679
continue;
680
}
681
if(not add_environment(p, copy)){
809
if(not add_environment(p, *e, false)){
682
810
perror("add_environment");
683
811
}
684
812
}
691
819
exitstatus = EXIT_FAILURE;
692
820
goto fallback;
693
821
}
822
/* Ask OS to automatic close the pipe on exec */
694
823
ret = set_cloexec_flag(pipefd[0]);
695
824
if(ret < 0){
696
825
perror("set_cloexec_flag");
710
839
exitstatus = EXIT_FAILURE;
711
840
goto fallback;
712
841
}
713
// Starting a new process to be watched
842
/* Starting a new process to be watched */
714
843
pid_t pid = fork();
715
844
if(pid == -1){
716
845
perror("fork");
754
883
}
755
884
/* no return */
756
885
}
757
/* parent process */
886
/* Parent process */
887
close(pipefd[1]); /* Close unused write end of pipe */
758
888
free(filename);
759
close(pipefd[1]); /* close unused write end of pipe */
760
process *new_process = malloc(sizeof(process));
761
if (new_process == NULL){
762
perror("malloc");
889
plugin *new_plugin = getplugin(dirst->d_name);
890
if (new_plugin == NULL){
891
perror("getplugin");
763
892
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
764
893
if(ret < 0){
765
perror("sigprocmask");
894
perror("sigprocmask");
766
895
}
767
896
exitstatus = EXIT_FAILURE;
768
897
goto fallback;
769
898
}
770
899
771
*new_process = (struct process){ .pid = pid,
772
.fd = pipefd[0],
773
.next = process_list };
774
// List handling
775
process_list = new_process;
900
new_plugin->pid = pid;
901
new_plugin->fd = pipefd[0];
902
776
903
/* Unblock SIGCHLD so signal handler can be run if this process
777
904
has already completed */
778
905
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
782
909
goto fallback;
783
910
}
784
911
785
FD_SET(new_process->fd, &rfds_all);
912
FD_SET(new_plugin->fd, &rfds_all);
786
913
787
if (maxfd < new_process->fd){
788
maxfd = new_process->fd;
914
if (maxfd < new_plugin->fd){
915
maxfd = new_plugin->fd;
789
916
}
790
917
791
918
}
792
919
793
free_plugin_list(plugin_list);
794
plugin_list = NULL;
795
796
920
closedir(dir);
797
921
dir = NULL;
798
799
if (process_list == NULL){
800
fprintf(stderr, "No plugin processes started. Incorrect plugin"
801
" directory?\n");
802
process_list = NULL;
922
923
for(plugin *p = plugin_list; p != NULL; p = p->next){
924
if(p->pid != 0){
925
break;
926
}
927
if(p->next == NULL){
928
fprintf(stderr, "No plugin processes started. Incorrect plugin"
929
" directory?\n");
930
free_plugin_list();
931
}
803
932
}
804
while(process_list){
933
934
/* Main loop while running plugins exist */
935
while(plugin_list){
805
936
fd_set rfds = rfds_all;
806
937
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
807
938
if (select_ret == -1){
811
942
}
812
943
/* OK, now either a process completed, or something can be read
813
944
from one of them */
814
for(process *proc = process_list; proc ; proc = proc->next){
945
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
815
946
/* Is this process completely done? */
816
947
if(proc->eof and proc->completed){
817
948
/* Only accept the plugin output if it exited cleanly */
818
949
if(not WIFEXITED(proc->status)
819
950
or WEXITSTATUS(proc->status) != 0){
820
951
/* Bad exit by plugin */
952
821
953
if(debug){
822
954
if(WIFEXITED(proc->status)){
823
955
fprintf(stderr, "Plugin %u exited with status %d\n",
832
964
(unsigned int) (proc->pid));
833
965
}
834
966
}
967
835
968
/* Remove the plugin */
836
969
FD_CLR(proc->fd, &rfds_all);
970
837
971
/* Block signal while modifying process_list */
838
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
972
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
839
973
if(ret < 0){
840
974
perror("sigprocmask");
841
975
exitstatus = EXIT_FAILURE;
842
976
goto fallback;
843
977
}
844
/* Delete this process entry from the list */
845
if(process_list == proc){
846
/* First one - simple */
847
process_list = proc->next;
848
} else {
849
/* Second one or later */
850
for(process *p = process_list; p != NULL; p = p->next){
851
if(p->next == proc){
852
p->next = proc->next;
853
break;
854
}
855
}
856
}
978
free_plugin(proc);
857
979
/* We are done modifying process list, so unblock signal */
858
980
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
859
981
NULL);
860
982
if(ret < 0){
861
983
perror("sigprocmask");
862
}
863
free(proc->buffer);
864
free(proc);
865
/* We deleted this process from the list, so we can't go
866
proc->next. Therefore, start over from the beginning of
867
the process list */
868
break;
984
exitstatus = EXIT_FAILURE;
985
goto fallback;
986
}
987
988
if(plugin_list == NULL){
989
break;
990
}
991
continue;
869
992
}
993
870
994
/* This process exited nicely, so print its buffer */
871
995
872
bool bret = print_out_password(proc->buffer, proc->buffer_length);
996
bool bret = print_out_password(proc->buffer,
997
proc->buffer_length);
873
998
if(not bret){
874
999
perror("print_out_password");
875
1000
exitstatus = EXIT_FAILURE;
876
1001
}
877
1002
goto fallback;
878
1003
}
1004
879
1005
/* This process has not completed. Does it have any output? */
880
1006
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
881
1007
/* This process had nothing to say at this time */
911
1037
912
1038
fallback:
913
1039
914
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
915
/* Fallback if all plugins failed, none are found or an error occured */
1040
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1041
/* Fallback if all plugins failed, none are found or an error
1042
occured */
916
1043
bool bret;
917
1044
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
918
1045
char *passwordbuffer = getpass("Password: ");
931
1058
}
932
1059
933
1060
if(custom_argv != NULL){
934
for(char **arg = custom_argv; *arg != NULL; arg++){
1061
for(char **arg = custom_argv+1; *arg != NULL; arg++){
935
1062
free(*arg);
936
1063
}
937
1064
free(custom_argv);
938
1065
}
939
free_plugin_list(plugin_list);
940
1066
941
1067
if(dir != NULL){
942
1068
closedir(dir);
943
1069
}
944
1070
945
1071
/* Free the process list and kill the processes */
946
for(process *next; process_list != NULL; process_list = next){
947
next = process_list->next;
948
close(process_list->fd);
949
ret = kill(process_list->pid, SIGTERM);
950
if(ret == -1 and errno != ESRCH){
951
/* set-uid proccesses migth not get closed */
952
perror("kill");
1072
for(plugin *p = plugin_list; p != NULL; p = p->next){
1073
if(p->pid != 0){
1074
close(p->fd);
1075
ret = kill(p->pid, SIGTERM);
1076
if(ret == -1 and errno != ESRCH){
1077
/* Set-uid proccesses might not get closed */
1078
perror("kill");
1079
}
953
1080
}
954
free(process_list->buffer);
955
free(process_list);
956
1081
}
957
1082
958
1083
/* Wait for any remaining child processes to terminate */
962
1087
if(errno != ECHILD){
963
1088
perror("wait");
964
1089
}
1090
1091
free_plugin_list();
1092
1093
free(plugindir);
1094
free(argfile);
965
1095
966
1096
return exitstatus;
967
1097
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0