/mandos/trunk

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

* plugin-runner.c (handle_sigchld): Loop until all exited children
                                    have been wait()ed for.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
68
 
69
 
const char *argp_program_version = "mandos-client 1.0";
 
69
const char *argp_program_version = "plugin-runner 1.0";
70
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
71
 
72
72
struct process;
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;
90
92
  bool disabled;
91
93
  struct plugin *next;
92
94
} plugin;
101
103
  /* Create a new plugin */
102
104
  plugin *new_plugin = malloc(sizeof(plugin));
103
105
  if (new_plugin == NULL){
104
 
    perror("malloc");
105
 
    exit(EXIT_FAILURE);
106
 
  }
107
 
  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
  
108
122
  new_plugin->argv = malloc(sizeof(char *) * 2);
109
123
  if (new_plugin->argv == NULL){
110
 
    perror("malloc");
111
 
    exit(EXIT_FAILURE);
 
124
    free(copy_name);
 
125
    free(new_plugin);
 
126
    return NULL;
112
127
  }
113
 
  new_plugin->argv[0] = name;
 
128
  new_plugin->argv[0] = copy_name;
114
129
  new_plugin->argv[1] = NULL;
115
 
  new_plugin->argc = 1;
116
 
  new_plugin->disabled = false;
117
 
  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;
118
139
  /* Append the new plugin to the list */
119
140
  *plugin_list = new_plugin;
120
141
  return new_plugin;
121
142
}
122
143
 
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
 
}
 
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
 
133
183
 
134
184
/*
135
185
 * Based on the example in the GNU LibC manual chapter 13.13 "File
149
199
 
150
200
process *process_list = NULL;
151
201
 
152
 
/* Mark a process as completed when it exits, and save its exit
 
202
/* Mark processes as completed when it exits, and save its exit
153
203
   status. */
154
204
void handle_sigchld(__attribute__((unused)) int sig){
155
205
  process *proc = process_list;
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;
 
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
  }
171
229
}
172
230
 
173
231
bool print_out_password(const char *buffer, size_t length){
185
243
  return true;
186
244
}
187
245
 
 
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
 
188
282
int main(int argc, char *argv[]){
189
 
  const char *plugindir = "/conf/conf.d/mandos/plugins.d";
 
283
  const char *plugindir = "/lib/mandos/plugins.d";
 
284
  const char *argfile = ARGFILE;
 
285
  FILE *conffp;
190
286
  size_t d_name_len;
191
287
  DIR *dir = NULL;
192
288
  struct dirent *dirst;
200
296
  struct sigaction old_sigchld_action;
201
297
  struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
202
298
                                      .sa_flags = SA_NOCLDSTOP };
203
 
  char *plus_options = NULL;
204
 
  char **plus_argv = NULL;
205
 
 
 
299
  char **custom_argv = NULL;
 
300
  int custom_argc = 0;
 
301
  
206
302
  /* Establish a signal handler */
207
303
  sigemptyset(&sigchld_action.sa_mask);
208
304
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
209
 
  if(ret < 0){
 
305
  if(ret == -1){
210
306
    perror("sigaddset");
211
 
    exit(EXIT_FAILURE);
 
307
    exitstatus = EXIT_FAILURE;
 
308
    goto fallback;
212
309
  }
213
310
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
214
 
  if(ret < 0){
 
311
  if(ret == -1){
215
312
    perror("sigaction");
216
 
    exit(EXIT_FAILURE);
 
313
    exitstatus = EXIT_FAILURE;
 
314
    goto fallback;
217
315
  }
218
316
  
219
317
  /* The options we understand. */
221
319
    { .name = "global-options", .key = 'g',
222
320
      .arg = "OPTION[,OPTION[,...]]",
223
321
      .doc = "Options passed to all plugins" },
 
322
    { .name = "global-envs", .key = 'e',
 
323
      .arg = "VAR=value",
 
324
      .doc = "Environment variable passed to all plugins" },
224
325
    { .name = "options-for", .key = 'o',
225
326
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
226
327
      .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" },
227
331
    { .name = "disable", .key = 'd',
228
332
      .arg = "PLUGIN",
229
333
      .doc = "Disable a specific plugin", .group = 1 },
250
354
      if (arg != NULL){
251
355
        char *p;
252
356
        while((p = strsep(&arg, ",")) != NULL){
253
 
          if(strcmp(p, "") == 0){
 
357
          if(p[0] == '\0'){
254
358
            continue;
255
359
          }
256
 
          addargument(getplugin(NULL, plugins), p);
 
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");
257
378
        }
258
379
      }
259
380
      break;
260
381
    case 'o':
261
382
      if (arg != NULL){
262
 
        char *name = strsep(&arg, ":");
263
 
        if(strcmp(name, "") == 0){
 
383
        char *p_name = strsep(&arg, ":");
 
384
        if(p_name[0] == '\0'){
264
385
          break;
265
386
        }
266
387
        char *opt = strsep(&arg, ":");
267
 
        if(strcmp(opt, "") == 0){
 
388
        if(opt[0] == '\0'){
268
389
          break;
269
390
        }
270
391
        if(opt != NULL){
271
392
          char *p;
272
393
          while((p = strsep(&opt, ",")) != NULL){
273
 
            if(strcmp(p, "") == 0){
 
394
            if(p[0] == '\0'){
274
395
              continue;
275
396
            }
276
 
            addargument(getplugin(name, plugins), p);
 
397
            if(not add_argument(getplugin(p_name, plugins), p)){
 
398
              perror("add_argument");
 
399
              return ARGP_ERR_UNKNOWN;
 
400
            }
277
401
          }
278
402
        }
279
403
      }
280
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");
 
421
        }
 
422
      }
 
423
      break;
281
424
    case 'd':
282
425
      if (arg != NULL){
283
 
        getplugin(arg, plugins)->disabled = true;
 
426
        plugin *p = getplugin(arg, plugins);
 
427
        if(p == NULL){
 
428
          return ARGP_ERR_UNKNOWN;
 
429
        }
 
430
        p->disabled = true;
284
431
      }
285
432
      break;
286
433
    case 128:
296
443
      debug = true;
297
444
      break;
298
445
    case ARGP_KEY_ARG:
299
 
      if(plus_options != NULL or arg == NULL or arg[0] != '+'){
300
 
        argp_usage (state);
301
 
      }
302
 
      plus_options = arg;
 
446
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
303
447
      break;
304
448
    case ARGP_KEY_END:
305
449
      break;
319
463
  if (ret == ARGP_ERR_UNKNOWN){
320
464
    fprintf(stderr, "Unknown error while parsing arguments\n");
321
465
    exitstatus = EXIT_FAILURE;
322
 
    goto end;
 
466
    goto fallback;
323
467
  }
324
 
  
325
 
  if(plus_options){
326
 
    /* This is a mangled argument in the form of
327
 
     "+--option+--other-option=parameter+--yet-another-option", etc */
328
 
    /* Make new argc and argv vars, and call argp_parse() again. */
329
 
    plus_options++;             /* skip the first '+' character */
330
 
    const char delims[] = "+";
331
 
    char *arg;
332
 
    int new_argc = 1;
333
 
    plus_argv = malloc(sizeof(char*) * 2);
334
 
    if(plus_argv == NULL){
335
 
      perror("malloc");
 
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");
336
505
      exitstatus = EXIT_FAILURE;
337
 
      goto end;
338
 
    }
339
 
    plus_argv[0] = argv[0];
340
 
    plus_argv[1] = NULL;
341
 
 
342
 
    while((arg = strsep(&plus_options, delims)) != NULL){
343
 
      new_argc++;
344
 
      plus_argv = realloc(plus_argv, sizeof(char *)
345
 
                         * ((unsigned int) new_argc + 1));
346
 
      if(plus_argv == NULL){
347
 
        perror("realloc");
348
 
        exitstatus = EXIT_FAILURE;
349
 
        goto end;
350
 
      }
351
 
      plus_argv[new_argc-1] = arg;
352
 
      plus_argv[new_argc] = NULL;
353
 
    }
354
 
 
355
 
    ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);
 
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);
356
513
    if (ret == ARGP_ERR_UNKNOWN){
357
514
      fprintf(stderr, "Unknown error while parsing arguments\n");
358
515
      exitstatus = EXIT_FAILURE;
359
 
      goto end;
 
516
      goto fallback;
360
517
    }
361
518
  }
362
519
  
367
524
      for(char **a = p->argv; *a != NULL; a++){
368
525
        fprintf(stderr, "\tArg: %s\n", *a);
369
526
      }
 
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
      }
370
531
    }
371
532
  }
372
533
  
384
545
  if(dir == NULL){
385
546
    perror("Could not open plugin dir");
386
547
    exitstatus = EXIT_FAILURE;
387
 
    goto end;
 
548
    goto fallback;
388
549
  }
389
550
  
390
551
  /* Set the FD_CLOEXEC flag on the directory, if possible */
395
556
      if(ret < 0){
396
557
        perror("set_cloexec_flag");
397
558
        exitstatus = EXIT_FAILURE;
398
 
        goto end;
 
559
        goto fallback;
399
560
      }
400
561
    }
401
562
  }
410
571
      if (errno == EBADF){
411
572
        perror("readdir");
412
573
        exitstatus = EXIT_FAILURE;
413
 
        goto end;
 
574
        goto fallback;
414
575
      }
415
576
      break;
416
577
    }
461
622
        continue;
462
623
      }
463
624
    }
464
 
    
465
 
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
466
 
    if (filename == NULL){
467
 
      perror("malloc");
 
625
 
 
626
    char *filename;
 
627
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
 
628
    if(ret < 0){
 
629
      perror("asprintf");
468
630
      continue;
469
631
    }
470
 
    strcpy(filename, plugindir); /* Spurious warning */
471
 
    strcat(filename, "/");      /* Spurious warning */
472
 
    strcat(filename, dirst->d_name); /* Spurious warning */
473
632
    
474
633
    ret = stat(filename, &st);
475
634
    if (ret == -1){
486
645
      free(filename);
487
646
      continue;
488
647
    }
489
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
 
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){
490
655
      if(debug){
491
656
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
492
657
                dirst->d_name);
494
659
      free(filename);
495
660
      continue;
496
661
    }
497
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
498
662
    {
499
663
      /* Add global arguments to argument list for this plugin */
500
664
      plugin *g = getplugin(NULL, &plugin_list);
501
 
      for(char **a = g->argv + 1; *a != NULL; a++){
502
 
        addargument(p, *a);
503
 
      }
504
 
    }
505
 
    int pipefd[2]; 
 
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];
506
696
    ret = pipe(pipefd);
507
697
    if (ret == -1){
508
698
      perror("pipe");
509
699
      exitstatus = EXIT_FAILURE;
510
 
      goto end;
 
700
      goto fallback;
511
701
    }
512
702
    ret = set_cloexec_flag(pipefd[0]);
513
703
    if(ret < 0){
514
704
      perror("set_cloexec_flag");
515
705
      exitstatus = EXIT_FAILURE;
516
 
      goto end;
 
706
      goto fallback;
517
707
    }
518
708
    ret = set_cloexec_flag(pipefd[1]);
519
709
    if(ret < 0){
520
710
      perror("set_cloexec_flag");
521
711
      exitstatus = EXIT_FAILURE;
522
 
      goto end;
 
712
      goto fallback;
523
713
    }
524
714
    /* Block SIGCHLD until process is safely in process list */
525
715
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
526
716
    if(ret < 0){
527
717
      perror("sigprocmask");
528
718
      exitstatus = EXIT_FAILURE;
529
 
      goto end;
 
719
      goto fallback;
530
720
    }
531
721
    // Starting a new process to be watched
532
722
    pid_t pid = fork();
533
723
    if(pid == -1){
534
724
      perror("fork");
535
725
      exitstatus = EXIT_FAILURE;
536
 
      goto end;
 
726
      goto fallback;
537
727
    }
538
728
    if(pid == 0){
539
729
      /* this is the child process */
559
749
           above and must now close it manually here. */
560
750
        closedir(dir);
561
751
      }
562
 
      if(execv(filename, p->argv) < 0){
563
 
        perror("execv");
564
 
        _exit(EXIT_FAILURE);
 
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
        }
565
762
      }
566
763
      /* no return */
567
764
    }
576
773
        perror("sigprocmask");
577
774
      }
578
775
      exitstatus = EXIT_FAILURE;
579
 
      goto end;
 
776
      goto fallback;
580
777
    }
581
778
    
582
779
    *new_process = (struct process){ .pid = pid,
590
787
    if(ret < 0){
591
788
      perror("sigprocmask");
592
789
      exitstatus = EXIT_FAILURE;
593
 
      goto end;
 
790
      goto fallback;
594
791
    }
595
792
    
596
793
    FD_SET(new_process->fd, &rfds_all);
601
798
    
602
799
  }
603
800
  
604
 
  /* Free the plugin list */
605
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
606
 
    next = plugin_list->next;
607
 
    free(plugin_list->argv);
608
 
    free(plugin_list);
609
 
  }
 
801
  free_plugin_list(plugin_list);
 
802
  plugin_list = NULL;
610
803
  
611
804
  closedir(dir);
612
805
  dir = NULL;
622
815
    if (select_ret == -1){
623
816
      perror("select");
624
817
      exitstatus = EXIT_FAILURE;
625
 
      goto end;
 
818
      goto fallback;
626
819
    }
627
820
    /* OK, now either a process completed, or something can be read
628
821
       from one of them */
654
847
          if(ret < 0){
655
848
            perror("sigprocmask");
656
849
            exitstatus = EXIT_FAILURE;
657
 
            goto end;
 
850
            goto fallback;
658
851
          }
659
852
          /* Delete this process entry from the list */
660
853
          if(process_list == proc){
689
882
          perror("print_out_password");
690
883
          exitstatus = EXIT_FAILURE;
691
884
        }
692
 
        goto end;
 
885
        goto fallback;
693
886
      }
694
887
      /* This process has not completed.  Does it have any output? */
695
888
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
703
896
        if (proc->buffer == NULL){
704
897
          perror("malloc");
705
898
          exitstatus = EXIT_FAILURE;
706
 
          goto end;
 
899
          goto fallback;
707
900
        }
708
901
        proc->buffer_size += BUFFER_SIZE;
709
902
      }
724
917
  }
725
918
 
726
919
 
727
 
 end:
 
920
 fallback:
728
921
  
729
922
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
730
923
    /* Fallback if all plugins failed, none are found or an error occured */
735
928
    if(not bret){
736
929
      perror("print_out_password");
737
930
      exitstatus = EXIT_FAILURE;
738
 
      goto end;
739
931
    }
740
932
  }
741
933
  
742
934
  /* Restore old signal handler */
743
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
744
 
  
745
 
  free(plus_argv);
746
 
  
747
 
  /* Free the plugin list */
748
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
749
 
    next = plugin_list->next;
750
 
    free(plugin_list->argv);
751
 
    free(plugin_list);
752
 
  }
 
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);
753
948
  
754
949
  if(dir != NULL){
755
950
    closedir(dir);