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 101
- compare with another revision
- download diff
- download tarball
- view history from revision 101
- Committer: Teddy Hogeborn
- Date: 2008-08-24 23:18:18 UTC
- Revision ID: teddy@fukt.bsnet.se-20080824231818-4cgr5zekodg4s0dl
* initramfs-tools-hook: Added "--enable-dsa2" and "--trust-model
always" options to gpg.
always" options to gpg.
- files added:
- initramfs-tools-script
- files removed:
- network-protocol.txt
- files renamed:
- mandos-client.c => plugin-runner.c
- mandos-client.xml => plugin-runner.xml
- files modified:
- Makefile
added
removed
plugin-runner.c
21
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
22
*/
23
23
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
26
26
#include <stddef.h> /* size_t, NULL */
27
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
28
EXIT_SUCCESS, realloc() */
51
51
close() */
52
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
53
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), strcpy(),
55
strcat() */
54
#include <string.h> /* strsep, strlen(), asprintf() */
56
55
#include <errno.h> /* errno */
57
56
#include <argp.h> /* struct argp_option, struct
58
57
argp_state, struct argp,
65
64
#include <errno.h> /* errno, EBADF */
66
65
67
66
#define BUFFER_SIZE 256
68
#define CONFFILE "/conf/conf.d/mandos/client.conf"
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
69
68
70
const char *argp_program_version = "mandos-client 1.0";
69
const char *argp_program_version = "plugin-runner 1.0";
71
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
72
71
73
72
struct process;
88
87
char *name; /* can be NULL or any plugin name */
89
88
char **argv;
90
89
int argc;
90
char **environ;
91
int envc;
91
92
bool disabled;
92
93
struct plugin *next;
93
94
} plugin;
102
103
/* Create a new plugin */
103
104
plugin *new_plugin = malloc(sizeof(plugin));
104
105
if (new_plugin == NULL){
105
perror("malloc");
106
exit(EXIT_FAILURE);
107
}
108
new_plugin->name = name;
106
return NULL;
107
}
108
char *copy_name = NULL;
109
if(name != NULL){
110
copy_name = strdup(name);
111
if(copy_name == NULL){
112
return NULL;
113
}
114
}
115
116
*new_plugin = (plugin) { .name = copy_name,
117
.argc = 1,
118
.envc = 0,
119
.disabled = false,
120
.next = *plugin_list };
121
109
122
new_plugin->argv = malloc(sizeof(char *) * 2);
110
123
if (new_plugin->argv == NULL){
111
perror("malloc");
112
exit(EXIT_FAILURE);
124
free(copy_name);
125
free(new_plugin);
126
return NULL;
113
127
}
114
new_plugin->argv[0] = name;
128
new_plugin->argv[0] = copy_name;
115
129
new_plugin->argv[1] = NULL;
116
new_plugin->argc = 1;
117
new_plugin->disabled = false;
118
new_plugin->next = *plugin_list;
130
131
new_plugin->environ = malloc(sizeof(char *));
132
if(new_plugin->environ == NULL){
133
free(copy_name);
134
free(new_plugin->argv);
135
free(new_plugin);
136
return NULL;
137
}
138
new_plugin->environ[0] = NULL;
119
139
/* Append the new plugin to the list */
120
140
*plugin_list = new_plugin;
121
141
return new_plugin;
122
142
}
123
143
124
static void addargument(plugin *p, char *arg){
125
p->argv[p->argc] = arg;
126
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
127
if (p->argv == NULL){
128
perror("malloc");
129
exit(EXIT_FAILURE);
130
}
131
p->argc++;
132
p->argv[p->argc] = NULL;
133
}
144
/* Helper function for add_argument and add_environment */
145
static bool add_to_char_array(const char *new, char ***array,
146
int *len){
147
/* Resize the pointed-to array to hold one more pointer */
148
*array = realloc(*array, sizeof(char *)
149
* (size_t) ((*len) + 2));
150
/* Malloc check */
151
if(*array == NULL){
152
return false;
153
}
154
/* Make a copy of the new string */
155
char *copy = strdup(new);
156
if(copy == NULL){
157
return false;
158
}
159
/* Insert the copy */
160
(*array)[*len] = copy;
161
(*len)++;
162
/* Add a new terminating NULL pointer to the last element */
163
(*array)[*len] = NULL;
164
return true;
165
}
166
167
/* Add to a plugin's argument vector */
168
static bool add_argument(plugin *p, const char *arg){
169
if(p == NULL){
170
return false;
171
}
172
return add_to_char_array(arg, &(p->argv), &(p->argc));
173
}
174
175
/* Add to a plugin's environment */
176
static bool add_environment(plugin *p, const char *def){
177
if(p == NULL){
178
return false;
179
}
180
return add_to_char_array(def, &(p->environ), &(p->envc));
181
}
182
134
183
135
184
/*
136
185
* Based on the example in the GNU LibC manual chapter 13.13 "File
186
235
return true;
187
236
}
188
237
189
char ** addcustomargument(char **argv, int *argc, char *arg){
190
238
char **add_to_argv(char **argv, int *argc, char *arg){
191
239
if (argv == NULL){
192
240
*argc = 1;
193
241
argv = malloc(sizeof(char*) * 2);
204
252
return NULL;
205
253
}
206
254
argv[*argc-1] = arg;
207
argv[*argc] = NULL;
255
argv[*argc] = NULL;
208
256
return argv;
209
257
}
210
258
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);
271
}
272
}
273
211
274
int main(int argc, char *argv[]){
212
const char *plugindir = "/conf/conf.d/mandos/plugins.d";
213
const char *conffile = CONFFILE;
275
const char *plugindir = "/lib/mandos/plugins.d";
276
const char *argfile = ARGFILE;
214
277
FILE *conffp;
215
278
size_t d_name_len;
216
279
DIR *dir = NULL;
231
294
/* Establish a signal handler */
232
295
sigemptyset(&sigchld_action.sa_mask);
233
296
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
234
if(ret < 0){
297
if(ret == -1){
235
298
perror("sigaddset");
236
exit(EXIT_FAILURE);
299
exitstatus = EXIT_FAILURE;
300
goto fallback;
237
301
}
238
302
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
239
if(ret < 0){
303
if(ret == -1){
240
304
perror("sigaction");
241
exit(EXIT_FAILURE);
305
exitstatus = EXIT_FAILURE;
306
goto fallback;
242
307
}
243
308
244
309
/* The options we understand. */
246
311
{ .name = "global-options", .key = 'g',
247
312
.arg = "OPTION[,OPTION[,...]]",
248
313
.doc = "Options passed to all plugins" },
314
{ .name = "global-envs", .key = 'e',
315
.arg = "VAR=value",
316
.doc = "Environment variable passed to all plugins" },
249
317
{ .name = "options-for", .key = 'o',
250
318
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
251
319
.doc = "Options passed only to specified plugin" },
320
{ .name = "envs-for", .key = 'f',
321
.arg = "PLUGIN:ENV=value",
322
.doc = "Environment variable passed to specified plugin" },
252
323
{ .name = "disable", .key = 'd',
253
324
.arg = "PLUGIN",
254
325
.doc = "Disable a specific plugin", .group = 1 },
278
349
if(p[0] == '\0'){
279
350
continue;
280
351
}
281
addargument(getplugin(NULL, plugins), p);
352
if(not add_argument(getplugin(NULL, plugins), p)){
353
perror("add_argument");
354
return ARGP_ERR_UNKNOWN;
355
}
356
}
357
}
358
break;
359
case 'e':
360
if(arg == NULL){
361
break;
362
}
363
{
364
char *envdef = strdup(arg);
365
if(envdef == NULL){
366
break;
367
}
368
if(not add_environment(getplugin(NULL, plugins), envdef)){
369
perror("add_environment");
282
370
}
283
371
}
284
372
break;
285
373
case 'o':
286
374
if (arg != NULL){
287
char *name = strsep(&arg, ":");
288
if(name[0] == '\0'){
375
char *p_name = strsep(&arg, ":");
376
if(p_name[0] == '\0'){
289
377
break;
290
378
}
291
379
char *opt = strsep(&arg, ":");
298
386
if(p[0] == '\0'){
299
387
continue;
300
388
}
301
addargument(getplugin(name, plugins), p);
389
if(not add_argument(getplugin(p_name, plugins), p)){
390
perror("add_argument");
391
return ARGP_ERR_UNKNOWN;
392
}
302
393
}
303
394
}
304
395
}
305
396
break;
397
case 'f':
398
if(arg == NULL){
399
break;
400
}
401
{
402
char *envdef = strchr(arg, ':');
403
if(envdef == NULL){
404
break;
405
}
406
char *p_name = strndup(arg, (size_t) (envdef-arg));
407
if(p_name == NULL){
408
break;
409
}
410
envdef++;
411
if(not add_environment(getplugin(p_name, plugins), envdef)){
412
perror("add_environment");
413
}
414
}
415
break;
306
416
case 'd':
307
417
if (arg != NULL){
308
getplugin(arg, plugins)->disabled = true;
418
plugin *p = getplugin(arg, plugins);
419
if(p == NULL){
420
return ARGP_ERR_UNKNOWN;
421
}
422
p->disabled = true;
309
423
}
310
424
break;
311
425
case 128:
321
435
debug = true;
322
436
break;
323
437
case ARGP_KEY_ARG:
324
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
438
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
325
439
break;
326
440
case ARGP_KEY_END:
327
441
break;
341
455
if (ret == ARGP_ERR_UNKNOWN){
342
456
fprintf(stderr, "Unknown error while parsing arguments\n");
343
457
exitstatus = EXIT_FAILURE;
344
goto end;
458
goto fallback;
345
459
}
346
460
347
conffp = fopen(conffile, "r");
461
conffp = fopen(argfile, "r");
348
462
if(conffp != NULL){
349
463
char *org_line = NULL;
464
char *p, *arg, *new_arg, *line;
350
465
size_t size = 0;
351
466
ssize_t sret;
352
char *p, *arg, *new_arg, *line;
353
467
const char whitespace_delims[] = " \r\t\f\v\n";
354
468
const char comment_delim[] = "#";
355
469
366
480
continue;
367
481
}
368
482
new_arg = strdup(p);
369
custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
483
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
370
484
if (custom_argv == NULL){
371
perror("addcustomargument");
485
perror("add_to_argv");
372
486
exitstatus = EXIT_FAILURE;
373
goto end;
487
goto fallback;
374
488
}
375
489
}
376
490
}
377
491
free(org_line);
378
492
} else{
379
/* check for harmfull errors */
493
/* Check for harmful errors and go to fallback. Other errors might
494
not affect opening plugins */
380
495
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
381
496
perror("fopen");
382
497
exitstatus = EXIT_FAILURE;
383
goto end;
498
goto fallback;
384
499
}
385
500
}
386
501
390
505
if (ret == ARGP_ERR_UNKNOWN){
391
506
fprintf(stderr, "Unknown error while parsing arguments\n");
392
507
exitstatus = EXIT_FAILURE;
393
goto end;
508
goto fallback;
394
509
}
395
510
}
396
511
401
516
for(char **a = p->argv; *a != NULL; a++){
402
517
fprintf(stderr, "\tArg: %s\n", *a);
403
518
}
519
fprintf(stderr, "...and %u environment variables\n", p->envc);
520
for(char **a = p->environ; *a != NULL; a++){
521
fprintf(stderr, "\t%s\n", *a);
522
}
404
523
}
405
524
}
406
525
418
537
if(dir == NULL){
419
538
perror("Could not open plugin dir");
420
539
exitstatus = EXIT_FAILURE;
421
goto end;
540
goto fallback;
422
541
}
423
542
424
543
/* Set the FD_CLOEXEC flag on the directory, if possible */
429
548
if(ret < 0){
430
549
perror("set_cloexec_flag");
431
550
exitstatus = EXIT_FAILURE;
432
goto end;
551
goto fallback;
433
552
}
434
553
}
435
554
}
444
563
if (errno == EBADF){
445
564
perror("readdir");
446
565
exitstatus = EXIT_FAILURE;
447
goto end;
566
goto fallback;
448
567
}
449
568
break;
450
569
}
495
614
continue;
496
615
}
497
616
}
498
499
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
500
if (filename == NULL){
501
perror("malloc");
617
618
char *filename;
619
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
620
if(ret < 0){
621
perror("asprintf");
502
622
continue;
503
623
}
504
strcpy(filename, plugindir); /* Spurious warning */
505
strcat(filename, "/"); /* Spurious warning */
506
strcat(filename, dirst->d_name); /* Spurious warning */
507
624
508
625
ret = stat(filename, &st);
509
626
if (ret == -1){
520
637
free(filename);
521
638
continue;
522
639
}
523
if(getplugin(dirst->d_name, &plugin_list)->disabled){
640
plugin *p = getplugin(dirst->d_name, &plugin_list);
641
if(p == NULL){
642
perror("getplugin");
643
free(filename);
644
continue;
645
}
646
if(p->disabled){
524
647
if(debug){
525
648
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
526
649
dirst->d_name);
528
651
free(filename);
529
652
continue;
530
653
}
531
plugin *p = getplugin(dirst->d_name, &plugin_list);
532
654
{
533
655
/* Add global arguments to argument list for this plugin */
534
656
plugin *g = getplugin(NULL, &plugin_list);
535
for(char **a = g->argv + 1; *a != NULL; a++){
536
addargument(p, *a);
537
}
538
}
539
int pipefd[2];
657
if(g != NULL){
658
for(char **a = g->argv + 1; *a != NULL; a++){
659
if(not add_argument(p, *a)){
660
perror("add_argument");
661
}
662
}
663
/* Add global environment variables */
664
for(char **e = g->environ; *e != NULL; e++){
665
if(not add_environment(p, *e)){
666
perror("add_environment");
667
}
668
}
669
}
670
}
671
/* If this plugin has any environment variables, we will call
672
using execve and need to duplicate the environment from this
673
process, too. */
674
if(p->environ[0] != NULL){
675
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)){
682
perror("add_environment");
683
}
684
}
685
}
686
687
int pipefd[2];
540
688
ret = pipe(pipefd);
541
689
if (ret == -1){
542
690
perror("pipe");
543
691
exitstatus = EXIT_FAILURE;
544
goto end;
692
goto fallback;
545
693
}
546
694
ret = set_cloexec_flag(pipefd[0]);
547
695
if(ret < 0){
548
696
perror("set_cloexec_flag");
549
697
exitstatus = EXIT_FAILURE;
550
goto end;
698
goto fallback;
551
699
}
552
700
ret = set_cloexec_flag(pipefd[1]);
553
701
if(ret < 0){
554
702
perror("set_cloexec_flag");
555
703
exitstatus = EXIT_FAILURE;
556
goto end;
704
goto fallback;
557
705
}
558
706
/* Block SIGCHLD until process is safely in process list */
559
707
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
560
708
if(ret < 0){
561
709
perror("sigprocmask");
562
710
exitstatus = EXIT_FAILURE;
563
goto end;
711
goto fallback;
564
712
}
565
713
// Starting a new process to be watched
566
714
pid_t pid = fork();
567
715
if(pid == -1){
568
716
perror("fork");
569
717
exitstatus = EXIT_FAILURE;
570
goto end;
718
goto fallback;
571
719
}
572
720
if(pid == 0){
573
721
/* this is the child process */
593
741
above and must now close it manually here. */
594
742
closedir(dir);
595
743
}
596
if(execv(filename, p->argv) < 0){
597
perror("execv");
598
_exit(EXIT_FAILURE);
744
if(p->environ[0] == NULL){
745
if(execv(filename, p->argv) < 0){
746
perror("execv");
747
_exit(EXIT_FAILURE);
748
}
749
} else {
750
if(execve(filename, p->argv, p->environ) < 0){
751
perror("execve");
752
_exit(EXIT_FAILURE);
753
}
599
754
}
600
755
/* no return */
601
756
}
610
765
perror("sigprocmask");
611
766
}
612
767
exitstatus = EXIT_FAILURE;
613
goto end;
768
goto fallback;
614
769
}
615
770
616
771
*new_process = (struct process){ .pid = pid,
624
779
if(ret < 0){
625
780
perror("sigprocmask");
626
781
exitstatus = EXIT_FAILURE;
627
goto end;
782
goto fallback;
628
783
}
629
784
630
785
FD_SET(new_process->fd, &rfds_all);
635
790
636
791
}
637
792
638
/* Free the plugin list */
639
for(plugin *next; plugin_list != NULL; plugin_list = next){
640
next = plugin_list->next;
641
free(plugin_list->argv);
642
free(plugin_list);
643
}
793
free_plugin_list(plugin_list);
794
plugin_list = NULL;
644
795
645
796
closedir(dir);
646
797
dir = NULL;
656
807
if (select_ret == -1){
657
808
perror("select");
658
809
exitstatus = EXIT_FAILURE;
659
goto end;
810
goto fallback;
660
811
}
661
812
/* OK, now either a process completed, or something can be read
662
813
from one of them */
688
839
if(ret < 0){
689
840
perror("sigprocmask");
690
841
exitstatus = EXIT_FAILURE;
691
goto end;
842
goto fallback;
692
843
}
693
844
/* Delete this process entry from the list */
694
845
if(process_list == proc){
723
874
perror("print_out_password");
724
875
exitstatus = EXIT_FAILURE;
725
876
}
726
goto end;
877
goto fallback;
727
878
}
728
879
/* This process has not completed. Does it have any output? */
729
880
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
737
888
if (proc->buffer == NULL){
738
889
perror("malloc");
739
890
exitstatus = EXIT_FAILURE;
740
goto end;
891
goto fallback;
741
892
}
742
893
proc->buffer_size += BUFFER_SIZE;
743
894
}
758
909
}
759
910
760
911
761
end:
912
fallback:
762
913
763
914
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
764
915
/* Fallback if all plugins failed, none are found or an error occured */
769
920
if(not bret){
770
921
perror("print_out_password");
771
922
exitstatus = EXIT_FAILURE;
772
goto end;
773
923
}
774
924
}
775
925
776
926
/* Restore old signal handler */
777
sigaction(SIGCHLD, &old_sigchld_action, NULL);
778
779
free(custom_argv);
780
781
/* Free the plugin list */
782
for(plugin *next; plugin_list != NULL; plugin_list = next){
783
next = plugin_list->next;
784
free(plugin_list->argv);
785
free(plugin_list);
786
}
927
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
928
if(ret == -1){
929
perror("sigaction");
930
exitstatus = EXIT_FAILURE;
931
}
932
933
if(custom_argv != NULL){
934
for(char **arg = custom_argv; *arg != NULL; arg++){
935
free(*arg);
936
}
937
free(custom_argv);
938
}
939
free_plugin_list(plugin_list);
787
940
788
941
if(dir != NULL){
789
942
closedir(dir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0