To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« 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 renamed:
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- 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 an 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
179
163
}
180
164
181
165
/* Add to a plugin's environment */
182
static bool add_environment(plugin *p, const char *def, bool replace){
166
static bool add_environment(plugin *p, const char *def){
183
167
if(p == NULL){
184
168
return false;
185
169
}
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) + 1);
194
if(new == NULL){
195
return false;
196
}
197
*e = new;
198
strcpy(*e, def);
199
}
200
return true;
201
}
202
}
203
170
return add_to_char_array(def, &(p->environ), &(p->envc));
204
171
}
205
172
173
206
174
/*
207
175
* Based on the example in the GNU LibC manual chapter 13.13 "File
208
176
* Descriptor Flags".
219
187
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
220
188
}
221
189
190
process *process_list = NULL;
222
191
223
/* Mark processes as completed when they exit, and save their exit
192
/* Mark a process as completed when it exits, and save its exit
224
193
status. */
225
194
void handle_sigchld(__attribute__((unused)) int sig){
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
}
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;
253
211
}
254
212
255
/* Prints out a password to stdout */
256
213
bool print_out_password(const char *buffer, size_t length){
257
214
ssize_t ret;
215
if(length>0 and buffer[length-1] == '\n'){
216
length--;
217
}
258
218
for(size_t written = 0; written < length; written += (size_t)ret){
259
219
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
260
220
length - written));
265
225
return true;
266
226
}
267
227
268
/* Removes and free a plugin from the plugin list */
269
static void free_plugin(plugin *plugin_node){
270
271
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
272
free(*arg);
273
}
274
free(plugin_node->argv);
275
for(char **env = plugin_node->environ; *env != NULL; env++){
276
free(*env);
277
}
278
free(plugin_node->environ);
279
free(plugin_node->buffer);
280
281
/* Removes the plugin from the singly-linked list */
282
if(plugin_node == plugin_list){
283
/* First one - simple */
284
plugin_list = plugin_list->next;
285
} else {
286
/* Second one or later */
287
for(plugin *p = plugin_list; p != NULL; p = p->next){
288
if(p->next == plugin_node){
289
p->next = plugin_node->next;
290
break;
291
}
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;
292
234
}
293
}
294
295
free(plugin_node);
296
}
297
298
static void free_plugin_list(void){
299
while(plugin_list != NULL){
300
free_plugin(plugin_list);
301
}
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;
302
247
}
303
248
304
249
int main(int argc, char *argv[]){
305
char *plugindir = NULL;
306
char *argfile = NULL;
250
const char *plugindir = "/lib/mandos/plugins.d";
251
const char *argfile = ARGFILE;
307
252
FILE *conffp;
308
253
size_t d_name_len;
309
254
DIR *dir = NULL;
324
269
/* Establish a signal handler */
325
270
sigemptyset(&sigchld_action.sa_mask);
326
271
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
327
if(ret == -1){
272
if(ret < 0){
328
273
perror("sigaddset");
329
exitstatus = EXIT_FAILURE;
330
goto fallback;
274
exit(EXIT_FAILURE);
331
275
}
332
276
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
333
if(ret == -1){
277
if(ret < 0){
334
278
perror("sigaction");
335
exitstatus = EXIT_FAILURE;
336
goto fallback;
279
exit(EXIT_FAILURE);
337
280
}
338
281
339
282
/* The options we understand. */
341
284
{ .name = "global-options", .key = 'g',
342
285
.arg = "OPTION[,OPTION[,...]]",
343
286
.doc = "Options passed to all plugins" },
344
{ .name = "global-env", .key = 'G',
287
{ .name = "global-envs", .key = 'e',
345
288
.arg = "VAR=value",
346
289
.doc = "Environment variable passed to all plugins" },
347
290
{ .name = "options-for", .key = 'o',
348
291
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
349
292
.doc = "Options passed only to specified plugin" },
350
{ .name = "env-for", .key = 'E',
293
{ .name = "envs-for", .key = 'f',
351
294
.arg = "PLUGIN:ENV=value",
352
295
.doc = "Environment variable passed to specified plugin" },
353
296
{ .name = "disable", .key = 'd',
354
297
.arg = "PLUGIN",
355
298
.doc = "Disable a specific plugin", .group = 1 },
356
{ .name = "enable", .key = 'e',
357
.arg = "PLUGIN",
358
.doc = "Enable a specific plugin", .group = 1 },
359
299
{ .name = "plugin-dir", .key = 128,
360
300
.arg = "DIRECTORY",
361
301
.doc = "Specify a different plugin directory", .group = 2 },
362
{ .name = "config-file", .key = 129,
363
.arg = "FILE",
364
.doc = "Specify a different configuration file", .group = 2 },
365
{ .name = "userid", .key = 130,
366
.arg = "ID", .flags = 0,
367
.doc = "User ID the plugins will run as", .group = 3 },
368
{ .name = "groupid", .key = 131,
369
.arg = "ID", .flags = 0,
370
.doc = "Group ID the plugins will run as", .group = 3 },
371
{ .name = "debug", .key = 132,
372
.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 },
373
310
{ .name = NULL }
374
311
};
375
312
376
error_t parse_opt (int key, char *arg, __attribute__((unused))
377
struct argp_state *state) {
313
error_t parse_opt (int key, char *arg, struct argp_state *state) {
314
/* Get the INPUT argument from `argp_parse', which we know is a
315
pointer to our plugin list pointer. */
316
plugin **plugins = state->input;
378
317
switch (key) {
379
case 'g': /* --global-options */
318
case 'g':
380
319
if (arg != NULL){
381
320
char *p;
382
321
while((p = strsep(&arg, ",")) != NULL){
383
322
if(p[0] == '\0'){
384
323
continue;
385
324
}
386
if(not add_argument(getplugin(NULL), p)){
325
if(not add_argument(getplugin(NULL, plugins), p)){
387
326
perror("add_argument");
388
327
return ARGP_ERR_UNKNOWN;
389
328
}
390
329
}
391
330
}
392
331
break;
393
case 'G': /* --global-env */
332
case 'e':
394
333
if(arg == NULL){
395
334
break;
396
335
}
399
338
if(envdef == NULL){
400
339
break;
401
340
}
402
if(not add_environment(getplugin(NULL), envdef, true)){
341
if(not add_environment(getplugin(NULL, plugins), envdef)){
403
342
perror("add_environment");
404
343
}
405
344
}
406
345
break;
407
case 'o': /* --options-for */
346
case 'o':
408
347
if (arg != NULL){
409
348
char *p_name = strsep(&arg, ":");
410
if(p_name[0] == '\0' or arg == NULL){
349
if(p_name[0] == '\0'){
411
350
break;
412
351
}
413
352
char *opt = strsep(&arg, ":");
414
if(opt[0] == '\0' or opt == NULL){
353
if(opt[0] == '\0'){
415
354
break;
416
355
}
417
char *p;
418
while((p = strsep(&opt, ",")) != NULL){
419
if(p[0] == '\0'){
420
continue;
421
}
422
if(not add_argument(getplugin(p_name), p)){
423
perror("add_argument");
424
return ARGP_ERR_UNKNOWN;
356
if(opt != NULL){
357
char *p;
358
while((p = strsep(&opt, ",")) != NULL){
359
if(p[0] == '\0'){
360
continue;
361
}
362
if(not add_argument(getplugin(p_name, plugins), p)){
363
perror("add_argument");
364
return ARGP_ERR_UNKNOWN;
365
}
425
366
}
426
367
}
427
368
}
428
369
break;
429
case 'E': /* --env-for */
370
case 'f':
430
371
if(arg == NULL){
431
372
break;
432
373
}
440
381
break;
441
382
}
442
383
envdef++;
443
if(not add_environment(getplugin(p_name), envdef, true)){
384
if(not add_environment(getplugin(p_name, plugins), envdef)){
444
385
perror("add_environment");
445
386
}
446
387
}
447
388
break;
448
case 'd': /* --disable */
389
case 'd':
449
390
if (arg != NULL){
450
plugin *p = getplugin(arg);
391
plugin *p = getplugin(arg, plugins);
451
392
if(p == NULL){
452
393
return ARGP_ERR_UNKNOWN;
453
394
}
454
395
p->disabled = true;
455
396
}
456
397
break;
457
case 'e': /* --enable */
458
if (arg != NULL){
459
plugin *p = getplugin(arg);
460
if(p == NULL){
461
return ARGP_ERR_UNKNOWN;
462
}
463
p->disabled = false;
464
}
465
break;
466
case 128: /* --plugin-dir */
467
plugindir = strdup(arg);
468
if(plugindir == NULL){
469
perror("strdup");
470
}
471
break;
472
case 129: /* --config-file */
473
/* This is already done by parse_opt_config_file() */
474
break;
475
case 130: /* --userid */
398
case 128:
399
plugindir = arg;
400
break;
401
case 129:
476
402
uid = (uid_t)strtol(arg, NULL, 10);
477
403
break;
478
case 131: /* --groupid */
404
case 130:
479
405
gid = (gid_t)strtol(arg, NULL, 10);
480
406
break;
481
case 132: /* --debug */
407
case 131:
482
408
debug = true;
483
409
break;
484
410
case ARGP_KEY_ARG:
492
418
return 0;
493
419
}
494
420
495
/* This option parser is the same as parse_opt() above, except it
496
ignores everything but the --config-file option. */
497
error_t parse_opt_config_file (int key, char *arg,
498
__attribute__((unused))
499
struct argp_state *state) {
500
switch (key) {
501
case 'g': /* --global-options */
502
case 'G': /* --global-env */
503
case 'o': /* --options-for */
504
case 'E': /* --env-for */
505
case 'd': /* --disable */
506
case 'e': /* --enable */
507
case 128: /* --plugin-dir */
508
break;
509
case 129: /* --config-file */
510
argfile = strdup(arg);
511
if(argfile == NULL){
512
perror("strdup");
513
}
514
break;
515
case 130: /* --userid */
516
case 131: /* --groupid */
517
case 132: /* --debug */
518
case ARGP_KEY_ARG:
519
case ARGP_KEY_END:
520
break;
521
default:
522
return ARGP_ERR_UNKNOWN;
523
}
524
return 0;
525
}
421
plugin *plugin_list = NULL;
526
422
527
struct argp argp = { .options = options,
528
.parser = parse_opt_config_file,
529
.args_doc = "",
423
struct argp argp = { .options = options, .parser = parse_opt,
424
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
530
425
.doc = "Mandos plugin runner -- Run plugins" };
531
426
532
/* Parse using the parse_opt_config_file in order to get the custom
533
config file location, if any. */
534
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
427
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
535
428
if (ret == ARGP_ERR_UNKNOWN){
536
429
fprintf(stderr, "Unknown error while parsing arguments\n");
537
430
exitstatus = EXIT_FAILURE;
538
goto fallback;
431
goto end;
539
432
}
540
541
/* Reset to the normal argument parser */
542
argp.parser = parse_opt;
543
544
/* Open the configfile if available */
545
if (argfile == NULL){
546
conffp = fopen(AFILE, "r");
547
} else {
548
conffp = fopen(argfile, "r");
549
}
433
434
conffp = fopen(argfile, "r");
550
435
if(conffp != NULL){
551
436
char *org_line = NULL;
552
char *p, *arg, *new_arg, *line;
553
437
size_t size = 0;
554
438
ssize_t sret;
439
char *p, *arg, *new_arg, *line;
555
440
const char whitespace_delims[] = " \r\t\f\v\n";
556
441
const char comment_delim[] = "#";
557
442
558
custom_argc = 1;
559
custom_argv = malloc(sizeof(char*) * 2);
560
if(custom_argv == NULL){
561
perror("malloc");
562
exitstatus = EXIT_FAILURE;
563
goto fallback;
564
}
565
custom_argv[0] = argv[0];
566
custom_argv[1] = NULL;
567
568
/* for each line in the config file, strip whitespace and ignore
569
commented text */
570
443
while(true){
571
444
sret = getline(&org_line, &size, conffp);
572
445
if(sret == -1){
580
453
continue;
581
454
}
582
455
new_arg = strdup(p);
583
if(new_arg == NULL){
584
perror("strdup");
585
exitstatus = EXIT_FAILURE;
586
free(org_line);
587
goto fallback;
588
}
589
590
custom_argc += 1;
591
custom_argv = realloc(custom_argv, sizeof(char *)
592
* ((unsigned int) custom_argc + 1));
593
if(custom_argv == NULL){
594
perror("realloc");
595
exitstatus = EXIT_FAILURE;
596
free(org_line);
597
goto fallback;
598
}
599
custom_argv[custom_argc-1] = new_arg;
600
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
}
601
462
}
602
463
}
603
464
free(org_line);
604
} else {
465
} else{
605
466
/* Check for harmful errors and go to fallback. Other errors might
606
467
not affect opening plugins */
607
468
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
608
469
perror("fopen");
609
470
exitstatus = EXIT_FAILURE;
610
goto fallback;
471
goto end;
611
472
}
612
473
}
613
/* If there was any arguments from configuration file,
614
pass them to parser as command arguments */
474
615
475
if(custom_argv != NULL){
616
ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
617
0, NULL);
476
custom_argv[0] = argv[0];
477
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
618
478
if (ret == ARGP_ERR_UNKNOWN){
619
479
fprintf(stderr, "Unknown error while parsing arguments\n");
620
480
exitstatus = EXIT_FAILURE;
621
goto fallback;
481
goto end;
622
482
}
623
483
}
624
484
625
/* Parse actual command line arguments, to let them override the
626
config file */
627
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
628
if (ret == ARGP_ERR_UNKNOWN){
629
fprintf(stderr, "Unknown error while parsing arguments\n");
630
exitstatus = EXIT_FAILURE;
631
goto fallback;
632
}
633
634
485
if(debug){
635
486
for(plugin *p = plugin_list; p != NULL; p=p->next){
636
487
fprintf(stderr, "Plugin: %s has %d arguments\n",
645
496
}
646
497
}
647
498
648
/* Strip permissions down to nobody */
649
499
ret = setuid(uid);
650
500
if (ret == -1){
651
501
perror("setuid");
652
}
502
}
503
653
504
setgid(gid);
654
505
if (ret == -1){
655
506
perror("setgid");
656
507
}
657
508
658
if (plugindir == NULL){
659
dir = opendir(PDIR);
660
} else {
661
dir = opendir(plugindir);
662
}
663
509
dir = opendir(plugindir);
664
510
if(dir == NULL){
665
511
perror("Could not open plugin dir");
666
512
exitstatus = EXIT_FAILURE;
667
goto fallback;
513
goto end;
668
514
}
669
515
670
516
/* Set the FD_CLOEXEC flag on the directory, if possible */
675
521
if(ret < 0){
676
522
perror("set_cloexec_flag");
677
523
exitstatus = EXIT_FAILURE;
678
goto fallback;
524
goto end;
679
525
}
680
526
}
681
527
}
682
528
683
529
FD_ZERO(&rfds_all);
684
530
685
/* Read and execute any executable in the plugin directory*/
686
531
while(true){
687
532
dirst = readdir(dir);
688
533
689
/* All directory entries have been processed */
534
// All directory entries have been processed
690
535
if(dirst == NULL){
691
536
if (errno == EBADF){
692
537
perror("readdir");
693
538
exitstatus = EXIT_FAILURE;
694
goto fallback;
539
goto end;
695
540
}
696
541
break;
697
542
}
698
543
699
544
d_name_len = strlen(dirst->d_name);
700
545
701
/* Ignore dotfiles, backup files and other junk */
546
// Ignore dotfiles, backup files and other junk
702
547
{
703
548
bool bad_name = false;
704
549
719
564
break;
720
565
}
721
566
}
567
722
568
if(bad_name){
723
569
continue;
724
570
}
571
725
572
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
726
573
size_t suf_len = strlen(*suf);
727
574
if((d_name_len >= suf_len)
742
589
}
743
590
744
591
char *filename;
745
if(plugindir == NULL){
746
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
747
} else {
748
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
749
}
592
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
750
593
if(ret < 0){
751
594
perror("asprintf");
752
595
continue;
758
601
free(filename);
759
602
continue;
760
603
}
761
762
/* Ignore non-executable files */
604
763
605
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
764
606
if(debug){
765
607
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
768
610
free(filename);
769
611
continue;
770
612
}
771
772
plugin *p = getplugin(dirst->d_name);
613
plugin *p = getplugin(dirst->d_name, &plugin_list);
773
614
if(p == NULL){
774
615
perror("getplugin");
775
616
free(filename);
785
626
}
786
627
{
787
628
/* Add global arguments to argument list for this plugin */
788
plugin *g = getplugin(NULL);
629
plugin *g = getplugin(NULL, &plugin_list);
789
630
if(g != NULL){
790
631
for(char **a = g->argv + 1; *a != NULL; a++){
791
632
if(not add_argument(p, *a)){
794
635
}
795
636
/* Add global environment variables */
796
637
for(char **e = g->environ; *e != NULL; e++){
797
if(not add_environment(p, *e, false)){
638
if(not add_environment(p, *e)){
798
639
perror("add_environment");
799
640
}
800
641
}
805
646
process, too. */
806
647
if(p->environ[0] != NULL){
807
648
for(char **e = environ; *e != NULL; e++){
808
if(not add_environment(p, *e, false)){
649
char *copy = strdup(*e);
650
if(copy == NULL){
651
perror("strdup");
652
continue;
653
}
654
if(not add_environment(p, copy)){
809
655
perror("add_environment");
810
656
}
811
657
}
812
658
}
813
659
814
int pipefd[2];
660
int pipefd[2];
815
661
ret = pipe(pipefd);
816
662
if (ret == -1){
817
663
perror("pipe");
818
664
exitstatus = EXIT_FAILURE;
819
goto fallback;
665
goto end;
820
666
}
821
/* Ask OS to automatic close the pipe on exec */
822
667
ret = set_cloexec_flag(pipefd[0]);
823
668
if(ret < 0){
824
669
perror("set_cloexec_flag");
825
670
exitstatus = EXIT_FAILURE;
826
goto fallback;
671
goto end;
827
672
}
828
673
ret = set_cloexec_flag(pipefd[1]);
829
674
if(ret < 0){
830
675
perror("set_cloexec_flag");
831
676
exitstatus = EXIT_FAILURE;
832
goto fallback;
677
goto end;
833
678
}
834
679
/* Block SIGCHLD until process is safely in process list */
835
680
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
836
681
if(ret < 0){
837
682
perror("sigprocmask");
838
683
exitstatus = EXIT_FAILURE;
839
goto fallback;
684
goto end;
840
685
}
841
/* Starting a new process to be watched */
686
// Starting a new process to be watched
842
687
pid_t pid = fork();
843
688
if(pid == -1){
844
689
perror("fork");
845
690
exitstatus = EXIT_FAILURE;
846
goto fallback;
691
goto end;
847
692
}
848
693
if(pid == 0){
849
694
/* this is the child process */
882
727
}
883
728
/* no return */
884
729
}
885
/* Parent process */
886
close(pipefd[1]); /* Close unused write end of pipe */
730
/* parent process */
887
731
free(filename);
888
plugin *new_plugin = getplugin(dirst->d_name);
889
if (new_plugin == NULL){
890
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");
891
736
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
892
737
if(ret < 0){
893
perror("sigprocmask");
738
perror("sigprocmask");
894
739
}
895
740
exitstatus = EXIT_FAILURE;
896
goto fallback;
741
goto end;
897
742
}
898
743
899
new_plugin->pid = pid;
900
new_plugin->fd = pipefd[0];
901
744
*new_process = (struct process){ .pid = pid,
745
.fd = pipefd[0],
746
.next = process_list };
747
// List handling
748
process_list = new_process;
902
749
/* Unblock SIGCHLD so signal handler can be run if this process
903
750
has already completed */
904
751
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
905
752
if(ret < 0){
906
753
perror("sigprocmask");
907
754
exitstatus = EXIT_FAILURE;
908
goto fallback;
909
}
910
911
FD_SET(new_plugin->fd, &rfds_all);
912
913
if (maxfd < new_plugin->fd){
914
maxfd = new_plugin->fd;
915
}
916
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);
917
776
}
918
777
919
778
closedir(dir);
920
779
dir = NULL;
921
922
for(plugin *p = plugin_list; p != NULL; p = p->next){
923
if(p->pid != 0){
924
break;
925
}
926
if(p->next == NULL){
927
fprintf(stderr, "No plugin processes started. Incorrect plugin"
928
" directory?\n");
929
free_plugin_list();
930
}
780
781
if (process_list == NULL){
782
fprintf(stderr, "No plugin processes started. Incorrect plugin"
783
" directory?\n");
784
process_list = NULL;
931
785
}
932
933
/* Main loop while running plugins exist */
934
while(plugin_list){
786
while(process_list){
935
787
fd_set rfds = rfds_all;
936
788
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
937
789
if (select_ret == -1){
938
790
perror("select");
939
791
exitstatus = EXIT_FAILURE;
940
goto fallback;
792
goto end;
941
793
}
942
794
/* OK, now either a process completed, or something can be read
943
795
from one of them */
944
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
796
for(process *proc = process_list; proc ; proc = proc->next){
945
797
/* Is this process completely done? */
946
798
if(proc->eof and proc->completed){
947
799
/* Only accept the plugin output if it exited cleanly */
948
800
if(not WIFEXITED(proc->status)
949
801
or WEXITSTATUS(proc->status) != 0){
950
802
/* Bad exit by plugin */
951
952
803
if(debug){
953
804
if(WIFEXITED(proc->status)){
954
805
fprintf(stderr, "Plugin %u exited with status %d\n",
963
814
(unsigned int) (proc->pid));
964
815
}
965
816
}
966
967
817
/* Remove the plugin */
968
818
FD_CLR(proc->fd, &rfds_all);
969
970
819
/* Block signal while modifying process_list */
971
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
820
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
972
821
if(ret < 0){
973
822
perror("sigprocmask");
974
823
exitstatus = EXIT_FAILURE;
975
goto fallback;
976
}
977
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
}
978
839
/* We are done modifying process list, so unblock signal */
979
840
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
980
841
NULL);
981
842
if(ret < 0){
982
843
perror("sigprocmask");
983
exitstatus = EXIT_FAILURE;
984
goto fallback;
985
}
986
987
if(plugin_list == NULL){
988
break;
989
}
990
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;
991
851
}
992
993
852
/* This process exited nicely, so print its buffer */
994
853
995
bool bret = print_out_password(proc->buffer,
996
proc->buffer_length);
854
bool bret = print_out_password(proc->buffer, proc->buffer_length);
997
855
if(not bret){
998
856
perror("print_out_password");
999
857
exitstatus = EXIT_FAILURE;
1000
858
}
1001
goto fallback;
859
goto end;
1002
860
}
1003
1004
861
/* This process has not completed. Does it have any output? */
1005
862
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1006
863
/* This process had nothing to say at this time */
1013
870
if (proc->buffer == NULL){
1014
871
perror("malloc");
1015
872
exitstatus = EXIT_FAILURE;
1016
goto fallback;
873
goto end;
1017
874
}
1018
875
proc->buffer_size += BUFFER_SIZE;
1019
876
}
1034
891
}
1035
892
1036
893
1037
fallback:
894
end:
1038
895
1039
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1040
/* Fallback if all plugins failed, none are found or an error
1041
occured */
896
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
897
/* Fallback if all plugins failed, none are found or an error occured */
1042
898
bool bret;
1043
899
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
1044
900
char *passwordbuffer = getpass("Password: ");
1045
size_t len = strlen(passwordbuffer);
1046
/* Strip trailing newline */
1047
if(len > 0 and passwordbuffer[len-1] == '\n'){
1048
passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1049
len--;
1050
}
1051
bret = print_out_password(passwordbuffer, len);
901
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
1052
902
if(not bret){
1053
903
perror("print_out_password");
1054
904
exitstatus = EXIT_FAILURE;
905
goto end;
1055
906
}
1056
907
}
1057
908
1058
909
/* Restore old signal handler */
1059
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1060
if(ret == -1){
1061
perror("sigaction");
1062
exitstatus = EXIT_FAILURE;
1063
}
1064
1065
if(custom_argv != NULL){
1066
for(char **arg = custom_argv+1; *arg != NULL; arg++){
1067
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
}
1068
922
}
1069
free(custom_argv);
923
free(plugin_list->environ);
924
free(plugin_list);
1070
925
}
1071
926
1072
927
if(dir != NULL){
1074
929
}
1075
930
1076
931
/* Free the process list and kill the processes */
1077
for(plugin *p = plugin_list; p != NULL; p = p->next){
1078
if(p->pid != 0){
1079
close(p->fd);
1080
ret = kill(p->pid, SIGTERM);
1081
if(ret == -1 and errno != ESRCH){
1082
/* Set-uid proccesses might not get closed */
1083
perror("kill");
1084
}
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");
1085
939
}
940
free(process_list->buffer);
941
free(process_list);
1086
942
}
1087
943
1088
944
/* Wait for any remaining child processes to terminate */
1092
948
if(errno != ECHILD){
1093
949
perror("wait");
1094
950
}
1095
1096
free_plugin_list();
1097
1098
free(plugindir);
1099
free(argfile);
1100
951
1101
952
return exitstatus;
1102
953
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0