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 74
- compare with another revision
- download diff
- download tarball
- view history from revision 74
- Committer: Teddy Hogeborn
- Date: 2008-08-14 02:24:59 UTC
- Revision ID: teddy@fukt.bsnet.se-20080814022459-rq3jt4q409l3qbj3
* Makefile (PREFIX, CONFDIR): New.
* initramfs-tools-hook: Search for Mandos in /usr/local as well as in
/usr. Also copy plugin-runner. Also chmod
the config dir.
(DESTCONFDIR): Removed.
(MANDOSDIR): New.
(PLUGINDIR): Changed to "${MANDOSDIR}/plugins.d".
* initramfs-tools-script: New.
* mandos-client.c: Renamed to "plugin-runner.c". All references
changed.
(plugindir): Changed to "/lib/mandos/plugins.d".
* plugins.d/usplash: New.
* initramfs-tools-hook: Search for Mandos in /usr/local as well as in
/usr. Also copy plugin-runner. Also chmod
the config dir.
(DESTCONFDIR): Removed.
(MANDOSDIR): New.
(PLUGINDIR): Changed to "${MANDOSDIR}/plugins.d".
* initramfs-tools-script: New.
* mandos-client.c: Renamed to "plugin-runner.c". All references
changed.
(plugindir): Changed to "/lib/mandos/plugins.d".
* plugins.d/usplash: New.
- files added:
- network-protocol.txt
- files removed:
- COPYING
- 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(), getline(),
25
asprintf() */
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
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(), asprintf() */
54
#include <string.h> /* strtok, strlen(), strcpy(),
55
strcat() */
55
56
#include <errno.h> /* errno */
56
57
#include <argp.h> /* struct argp_option, struct
57
58
argp_state, struct argp,
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
68
69
69
const char *argp_program_version = "plugin-runner 1.0";
70
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
87
87
char *name; /* can be NULL or any plugin name */
88
88
char **argv;
89
89
int argc;
90
char **environ;
91
int envc;
92
90
bool disabled;
93
91
struct plugin *next;
94
92
} plugin;
103
101
/* Create a new plugin */
104
102
plugin *new_plugin = malloc(sizeof(plugin));
105
103
if (new_plugin == NULL){
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
104
perror("malloc");
105
exit(EXIT_FAILURE);
106
}
107
new_plugin->name = name;
122
108
new_plugin->argv = malloc(sizeof(char *) * 2);
123
109
if (new_plugin->argv == NULL){
124
free(copy_name);
125
free(new_plugin);
126
return NULL;
110
perror("malloc");
111
exit(EXIT_FAILURE);
127
112
}
128
new_plugin->argv[0] = copy_name;
113
new_plugin->argv[0] = name;
129
114
new_plugin->argv[1] = NULL;
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;
115
new_plugin->argc = 1;
116
new_plugin->disabled = false;
117
new_plugin->next = *plugin_list;
139
118
/* Append the new plugin to the list */
140
119
*plugin_list = new_plugin;
141
120
return new_plugin;
142
121
}
143
122
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
123
static void addargument(plugin *p, char *arg){
124
p->argv[p->argc] = arg;
125
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
126
if (p->argv == NULL){
127
perror("malloc");
128
exit(EXIT_FAILURE);
129
}
130
p->argc++;
131
p->argv[p->argc] = NULL;
132
}
183
133
184
134
/*
185
135
* Based on the example in the GNU LibC manual chapter 13.13 "File
199
149
200
150
process *process_list = NULL;
201
151
202
/* Mark processes as completed when it exits, and save its exit
152
/* Mark a process as completed when it exits, and save its exit
203
153
status. */
204
154
void handle_sigchld(__attribute__((unused)) int sig){
205
155
process *proc = process_list;
206
while(true){
207
int status;
208
pid_t pid = waitpid(-1, &status, WNOHANG);
209
if(pid == 0){
210
break;
211
}
212
if(pid == -1){
213
if (errno != ECHILD){
214
perror("waitpid");
215
}
216
return;
217
}
218
219
while(proc != NULL and proc->pid != pid){
220
proc = proc->next;
221
}
222
if(proc == NULL){
223
/* Process not found in process list */
224
continue;
225
}
226
proc->status = status;
227
proc->completed = true;
228
}
156
int status;
157
pid_t pid = wait(&status);
158
if(pid == -1){
159
perror("wait");
160
return;
161
}
162
while(proc != NULL and proc->pid != pid){
163
proc = proc->next;
164
}
165
if(proc == NULL){
166
/* Process not found in process list */
167
return;
168
}
169
proc->status = status;
170
proc->completed = true;
229
171
}
230
172
231
173
bool print_out_password(const char *buffer, size_t length){
243
185
return true;
244
186
}
245
187
246
char **add_to_argv(char **argv, int *argc, char *arg){
247
if (argv == NULL){
248
*argc = 1;
249
argv = malloc(sizeof(char*) * 2);
250
if(argv == NULL){
251
return NULL;
252
}
253
argv[0] = NULL; /* Will be set to argv[0] in main before parsing */
254
argv[1] = NULL;
255
}
256
*argc += 1;
257
argv = realloc(argv, sizeof(char *)
258
* ((unsigned int) *argc + 1));
259
if(argv == NULL){
260
return NULL;
261
}
262
argv[*argc-1] = arg;
263
argv[*argc] = NULL;
264
return argv;
265
}
266
267
static void free_plugin_list(plugin *plugin_list){
268
for(plugin *next; plugin_list != NULL; plugin_list = next){
269
next = plugin_list->next;
270
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
271
free(*arg);
272
}
273
free(plugin_list->argv);
274
for(char **env = plugin_list->environ; *env != NULL; env++){
275
free(*env);
276
}
277
free(plugin_list->environ);
278
free(plugin_list);
279
}
280
}
281
282
188
int main(int argc, char *argv[]){
283
189
const char *plugindir = "/lib/mandos/plugins.d";
284
const char *argfile = ARGFILE;
285
FILE *conffp;
286
190
size_t d_name_len;
287
191
DIR *dir = NULL;
288
192
struct dirent *dirst;
296
200
struct sigaction old_sigchld_action;
297
201
struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
298
202
.sa_flags = SA_NOCLDSTOP };
299
char **custom_argv = NULL;
300
int custom_argc = 0;
301
203
char *plus_options = NULL;
204
char **plus_argv = NULL;
205
302
206
/* Establish a signal handler */
303
207
sigemptyset(&sigchld_action.sa_mask);
304
208
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
305
if(ret == -1){
209
if(ret < 0){
306
210
perror("sigaddset");
307
exitstatus = EXIT_FAILURE;
308
goto fallback;
211
exit(EXIT_FAILURE);
309
212
}
310
213
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
311
if(ret == -1){
214
if(ret < 0){
312
215
perror("sigaction");
313
exitstatus = EXIT_FAILURE;
314
goto fallback;
216
exit(EXIT_FAILURE);
315
217
}
316
218
317
219
/* The options we understand. */
319
221
{ .name = "global-options", .key = 'g',
320
222
.arg = "OPTION[,OPTION[,...]]",
321
223
.doc = "Options passed to all plugins" },
322
{ .name = "global-envs", .key = 'e',
323
.arg = "VAR=value",
324
.doc = "Environment variable passed to all plugins" },
325
224
{ .name = "options-for", .key = 'o',
326
225
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
327
226
.doc = "Options passed only to specified plugin" },
328
{ .name = "envs-for", .key = 'f',
329
.arg = "PLUGIN:ENV=value",
330
.doc = "Environment variable passed to specified plugin" },
331
227
{ .name = "disable", .key = 'd',
332
228
.arg = "PLUGIN",
333
229
.doc = "Disable a specific plugin", .group = 1 },
352
248
switch (key) {
353
249
case 'g':
354
250
if (arg != NULL){
355
char *p;
356
while((p = strsep(&arg, ",")) != NULL){
357
if(p[0] == '\0'){
358
continue;
359
}
360
if(not add_argument(getplugin(NULL, plugins), p)){
361
perror("add_argument");
362
return ARGP_ERR_UNKNOWN;
363
}
364
}
365
}
366
break;
367
case 'e':
368
if(arg == NULL){
369
break;
370
}
371
{
372
char *envdef = strdup(arg);
373
if(envdef == NULL){
374
break;
375
}
376
if(not add_environment(getplugin(NULL, plugins), envdef)){
377
perror("add_environment");
378
}
251
char *p = strtok(arg, ",");
252
do{
253
addargument(getplugin(NULL, plugins), p);
254
p = strtok(NULL, ",");
255
} while (p != NULL);
379
256
}
380
257
break;
381
258
case 'o':
382
259
if (arg != NULL){
383
char *p_name = strsep(&arg, ":");
384
if(p_name[0] == '\0'){
385
break;
386
}
387
char *opt = strsep(&arg, ":");
388
if(opt[0] == '\0'){
389
break;
390
}
391
if(opt != NULL){
392
char *p;
393
while((p = strsep(&opt, ",")) != NULL){
394
if(p[0] == '\0'){
395
continue;
396
}
397
if(not add_argument(getplugin(p_name, plugins), p)){
398
perror("add_argument");
399
return ARGP_ERR_UNKNOWN;
400
}
401
}
402
}
403
}
404
break;
405
case 'f':
406
if(arg == NULL){
407
break;
408
}
409
{
410
char *envdef = strchr(arg, ':');
411
if(envdef == NULL){
412
break;
413
}
414
char *p_name = strndup(arg, (size_t) (envdef-arg));
415
if(p_name == NULL){
416
break;
417
}
418
envdef++;
419
if(not add_environment(getplugin(p_name, plugins), envdef)){
420
perror("add_environment");
260
char *name = strtok(arg, ":");
261
char *p = strtok(NULL, ":");
262
if(p != NULL){
263
p = strtok(p, ",");
264
do{
265
addargument(getplugin(name, plugins), p);
266
p = strtok(NULL, ",");
267
} while (p != NULL);
421
268
}
422
269
}
423
270
break;
424
271
case 'd':
425
272
if (arg != NULL){
426
plugin *p = getplugin(arg, plugins);
427
if(p == NULL){
428
return ARGP_ERR_UNKNOWN;
429
}
430
p->disabled = true;
273
getplugin(arg, plugins)->disabled = true;
431
274
}
432
275
break;
433
276
case 128:
443
286
debug = true;
444
287
break;
445
288
case ARGP_KEY_ARG:
446
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
289
if(plus_options != NULL or arg == NULL or arg[0] != '+'){
290
argp_usage (state);
291
}
292
plus_options = arg;
447
293
break;
448
294
case ARGP_KEY_END:
449
295
break;
463
309
if (ret == ARGP_ERR_UNKNOWN){
464
310
fprintf(stderr, "Unknown error while parsing arguments\n");
465
311
exitstatus = EXIT_FAILURE;
466
goto fallback;
312
goto end;
467
313
}
468
469
conffp = fopen(argfile, "r");
470
if(conffp != NULL){
471
char *org_line = NULL;
472
char *p, *arg, *new_arg, *line;
473
size_t size = 0;
474
ssize_t sret;
475
const char whitespace_delims[] = " \r\t\f\v\n";
476
const char comment_delim[] = "#";
477
478
while(true){
479
sret = getline(&org_line, &size, conffp);
480
if(sret == -1){
481
break;
482
}
483
484
line = org_line;
485
arg = strsep(&line, comment_delim);
486
while((p = strsep(&arg, whitespace_delims)) != NULL){
487
if(p[0] == '\0'){
488
continue;
489
}
490
new_arg = strdup(p);
491
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
492
if (custom_argv == NULL){
493
perror("add_to_argv");
494
exitstatus = EXIT_FAILURE;
495
goto fallback;
496
}
497
}
498
}
499
free(org_line);
500
} else{
501
/* Check for harmful errors and go to fallback. Other errors might
502
not affect opening plugins */
503
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
504
perror("fopen");
314
315
if(plus_options){
316
/* This is a mangled argument in the form of
317
"+--option+--other-option=parameter+--yet-another-option", etc */
318
/* Make new argc and argv vars, and call argp_parse() again. */
319
plus_options++; /* skip the first '+' character */
320
const char delims[] = "+";
321
char *arg;
322
int new_argc = 1;
323
plus_argv = malloc(sizeof(char*) * 2);
324
if(plus_argv == NULL){
325
perror("malloc");
505
326
exitstatus = EXIT_FAILURE;
506
goto fallback;
507
}
508
}
509
510
if(custom_argv != NULL){
511
custom_argv[0] = argv[0];
512
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
327
goto end;
328
}
329
plus_argv[0] = argv[0];
330
plus_argv[1] = NULL;
331
arg = strtok(plus_options, delims); /* Get first argument */
332
while(arg != NULL){
333
new_argc++;
334
plus_argv = realloc(plus_argv, sizeof(char *)
335
* ((unsigned int) new_argc + 1));
336
if(plus_argv == NULL){
337
perror("realloc");
338
exitstatus = EXIT_FAILURE;
339
goto end;
340
}
341
plus_argv[new_argc-1] = arg;
342
plus_argv[new_argc] = NULL;
343
arg = strtok(NULL, delims); /* Get next argument */
344
}
345
ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);
513
346
if (ret == ARGP_ERR_UNKNOWN){
514
347
fprintf(stderr, "Unknown error while parsing arguments\n");
515
348
exitstatus = EXIT_FAILURE;
516
goto fallback;
349
goto end;
517
350
}
518
351
}
519
352
524
357
for(char **a = p->argv; *a != NULL; a++){
525
358
fprintf(stderr, "\tArg: %s\n", *a);
526
359
}
527
fprintf(stderr, "...and %u environment variables\n", p->envc);
528
for(char **a = p->environ; *a != NULL; a++){
529
fprintf(stderr, "\t%s\n", *a);
530
}
531
360
}
532
361
}
533
362
545
374
if(dir == NULL){
546
375
perror("Could not open plugin dir");
547
376
exitstatus = EXIT_FAILURE;
548
goto fallback;
377
goto end;
549
378
}
550
379
551
380
/* Set the FD_CLOEXEC flag on the directory, if possible */
556
385
if(ret < 0){
557
386
perror("set_cloexec_flag");
558
387
exitstatus = EXIT_FAILURE;
559
goto fallback;
388
goto end;
560
389
}
561
390
}
562
391
}
571
400
if (errno == EBADF){
572
401
perror("readdir");
573
402
exitstatus = EXIT_FAILURE;
574
goto fallback;
403
goto end;
575
404
}
576
405
break;
577
406
}
622
451
continue;
623
452
}
624
453
}
625
626
char *filename;
627
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
628
if(ret < 0){
629
perror("asprintf");
454
455
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
456
if (filename == NULL){
457
perror("malloc");
630
458
continue;
631
459
}
460
strcpy(filename, plugindir); /* Spurious warning */
461
strcat(filename, "/"); /* Spurious warning */
462
strcat(filename, dirst->d_name); /* Spurious warning */
632
463
633
464
ret = stat(filename, &st);
634
465
if (ret == -1){
645
476
free(filename);
646
477
continue;
647
478
}
648
plugin *p = getplugin(dirst->d_name, &plugin_list);
649
if(p == NULL){
650
perror("getplugin");
651
free(filename);
652
continue;
653
}
654
if(p->disabled){
479
if(getplugin(dirst->d_name, &plugin_list)->disabled){
655
480
if(debug){
656
481
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
657
482
dirst->d_name);
659
484
free(filename);
660
485
continue;
661
486
}
487
plugin *p = getplugin(dirst->d_name, &plugin_list);
662
488
{
663
489
/* Add global arguments to argument list for this plugin */
664
490
plugin *g = getplugin(NULL, &plugin_list);
665
if(g != NULL){
666
for(char **a = g->argv + 1; *a != NULL; a++){
667
if(not add_argument(p, *a)){
668
perror("add_argument");
669
}
670
}
671
/* Add global environment variables */
672
for(char **e = g->environ; *e != NULL; e++){
673
if(not add_environment(p, *e)){
674
perror("add_environment");
675
}
676
}
677
}
678
}
679
/* If this plugin has any environment variables, we will call
680
using execve and need to duplicate the environment from this
681
process, too. */
682
if(p->environ[0] != NULL){
683
for(char **e = environ; *e != NULL; e++){
684
char *copy = strdup(*e);
685
if(copy == NULL){
686
perror("strdup");
687
continue;
688
}
689
if(not add_environment(p, copy)){
690
perror("add_environment");
691
}
692
}
693
}
694
695
int pipefd[2];
491
for(char **a = g->argv + 1; *a != NULL; a++){
492
addargument(p, *a);
493
}
494
}
495
int pipefd[2];
696
496
ret = pipe(pipefd);
697
497
if (ret == -1){
698
498
perror("pipe");
699
499
exitstatus = EXIT_FAILURE;
700
goto fallback;
500
goto end;
701
501
}
702
502
ret = set_cloexec_flag(pipefd[0]);
703
503
if(ret < 0){
704
504
perror("set_cloexec_flag");
705
505
exitstatus = EXIT_FAILURE;
706
goto fallback;
506
goto end;
707
507
}
708
508
ret = set_cloexec_flag(pipefd[1]);
709
509
if(ret < 0){
710
510
perror("set_cloexec_flag");
711
511
exitstatus = EXIT_FAILURE;
712
goto fallback;
512
goto end;
713
513
}
714
514
/* Block SIGCHLD until process is safely in process list */
715
515
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
716
516
if(ret < 0){
717
517
perror("sigprocmask");
718
518
exitstatus = EXIT_FAILURE;
719
goto fallback;
519
goto end;
720
520
}
721
521
// Starting a new process to be watched
722
522
pid_t pid = fork();
723
523
if(pid == -1){
724
524
perror("fork");
725
525
exitstatus = EXIT_FAILURE;
726
goto fallback;
526
goto end;
727
527
}
728
528
if(pid == 0){
729
529
/* this is the child process */
749
549
above and must now close it manually here. */
750
550
closedir(dir);
751
551
}
752
if(p->environ[0] == NULL){
753
if(execv(filename, p->argv) < 0){
754
perror("execv");
755
_exit(EXIT_FAILURE);
756
}
757
} else {
758
if(execve(filename, p->argv, p->environ) < 0){
759
perror("execve");
760
_exit(EXIT_FAILURE);
761
}
552
if(execv(filename, p->argv) < 0){
553
perror("execv");
554
_exit(EXIT_FAILURE);
762
555
}
763
556
/* no return */
764
557
}
773
566
perror("sigprocmask");
774
567
}
775
568
exitstatus = EXIT_FAILURE;
776
goto fallback;
569
goto end;
777
570
}
778
571
779
572
*new_process = (struct process){ .pid = pid,
787
580
if(ret < 0){
788
581
perror("sigprocmask");
789
582
exitstatus = EXIT_FAILURE;
790
goto fallback;
583
goto end;
791
584
}
792
585
793
586
FD_SET(new_process->fd, &rfds_all);
798
591
799
592
}
800
593
801
free_plugin_list(plugin_list);
802
plugin_list = NULL;
594
/* Free the plugin list */
595
for(plugin *next; plugin_list != NULL; plugin_list = next){
596
next = plugin_list->next;
597
free(plugin_list->argv);
598
free(plugin_list);
599
}
803
600
804
601
closedir(dir);
805
602
dir = NULL;
815
612
if (select_ret == -1){
816
613
perror("select");
817
614
exitstatus = EXIT_FAILURE;
818
goto fallback;
615
goto end;
819
616
}
820
617
/* OK, now either a process completed, or something can be read
821
618
from one of them */
847
644
if(ret < 0){
848
645
perror("sigprocmask");
849
646
exitstatus = EXIT_FAILURE;
850
goto fallback;
647
goto end;
851
648
}
852
649
/* Delete this process entry from the list */
853
650
if(process_list == proc){
882
679
perror("print_out_password");
883
680
exitstatus = EXIT_FAILURE;
884
681
}
885
goto fallback;
682
goto end;
886
683
}
887
684
/* This process has not completed. Does it have any output? */
888
685
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
896
693
if (proc->buffer == NULL){
897
694
perror("malloc");
898
695
exitstatus = EXIT_FAILURE;
899
goto fallback;
696
goto end;
900
697
}
901
698
proc->buffer_size += BUFFER_SIZE;
902
699
}
917
714
}
918
715
919
716
920
fallback:
717
end:
921
718
922
719
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
923
720
/* Fallback if all plugins failed, none are found or an error occured */
928
725
if(not bret){
929
726
perror("print_out_password");
930
727
exitstatus = EXIT_FAILURE;
728
goto end;
931
729
}
932
730
}
933
731
934
732
/* Restore old signal handler */
935
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
936
if(ret == -1){
937
perror("sigaction");
938
exitstatus = EXIT_FAILURE;
939
}
940
941
if(custom_argv != NULL){
942
for(char **arg = custom_argv; *arg != NULL; arg++){
943
free(*arg);
944
}
945
free(custom_argv);
946
}
947
free_plugin_list(plugin_list);
733
sigaction(SIGCHLD, &old_sigchld_action, NULL);
734
735
free(plus_argv);
736
737
/* Free the plugin list */
738
for(plugin *next; plugin_list != NULL; plugin_list = next){
739
next = plugin_list->next;
740
free(plugin_list->argv);
741
free(plugin_list);
742
}
948
743
949
744
if(dir != NULL){
950
745
closedir(dir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0