/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugbasedclient.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8 -*- */
2
 
/*
3
 
 * Mandos plugin runner - Run Mandos plugins
4
 
 *
5
 
 * Copyright © 2008,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
14
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 
 * General Public License for more details.
17
 
 * 
18
 
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
21
 
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
23
 
 */
24
 
 
25
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf() */
27
 
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
29
 
                                   EXIT_SUCCESS, realloc() */
30
 
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
38
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS() */
42
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
43
 
#include <iso646.h>             /* and, or, not */
44
 
#include <dirent.h>             /* DIR, struct dirent, opendir(),
45
 
                                   readdir(), closedir(), dirfd() */
46
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
47
 
                                   fcntl(), setuid(), setgid(),
48
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
49
 
                                   access(), pipe(), fork(), close()
50
 
                                   dup2(), STDOUT_FILENO, _exit(),
51
 
                                   execv(), write(), read(),
52
 
                                   close() */
53
 
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
54
 
                                   FD_CLOEXEC */
55
 
#include <string.h>             /* strsep, strlen(), asprintf() */
56
 
#include <errno.h>              /* errno */
57
 
#include <argp.h>               /* struct argp_option, struct
58
 
                                   argp_state, struct argp,
59
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
60
 
                                   ARGP_KEY_END, ARGP_KEY_ARG,
61
 
                                   error_t */
62
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
63
 
                                   sigaddset(), sigaction(),
64
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
65
 
                                   SIG_UNBLOCK, kill() */
66
 
#include <errno.h>              /* errno, EBADF */
67
 
 
68
 
#define BUFFER_SIZE 256
69
 
 
70
 
#define PDIR "/lib/mandos/plugins.d"
71
 
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
72
 
 
73
 
const char *argp_program_version = "plugin-runner " VERSION;
74
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
75
 
 
76
 
typedef struct plugin{
77
 
  char *name;                   /* can be NULL or any plugin name */
78
 
  char **argv;
79
 
  int argc;
80
 
  char **environ;
81
 
  int envc;
82
 
  bool disabled;
83
 
 
84
 
  /* Variables used for running processes*/
 
1
#include <stdio.h>      /* popen, fileno */
 
2
#include <iso646.h>     /* and, or, not */
 
3
#include <sys/types.h>  /* DIR, opendir, stat, struct stat, waitpid,
 
4
                           WIFEXITED, WEXITSTATUS, wait */
 
5
#include <sys/wait.h>   /* wait */
 
6
#include <dirent.h>     /* DIR, opendir */
 
7
#include <sys/stat.h>   /* stat, struct stat */
 
8
#include <unistd.h>     /* stat, struct stat, chdir */
 
9
#include <stdlib.h>     /* EXIT_FAILURE */
 
10
#include <sys/select.h> /* fd_set, select, FD_ZERO, FD_SET, FD_ISSET */
 
11
#include <string.h>     /* strlen, strcpy, strcat */
 
12
#include <stdbool.h>    /* true */
 
13
#include <sys/wait.h>   /* waitpid, WIFEXITED, WEXITSTATUS */
 
14
#include <errno.h>      /* errno */
 
15
 
 
16
struct process;
 
17
 
 
18
typedef struct process{
85
19
  pid_t pid;
86
20
  int fd;
87
21
  char *buffer;
88
 
  size_t buffer_size;
89
 
  size_t buffer_length;
90
 
  bool eof;
91
 
  volatile bool completed;
92
 
  volatile int status;
93
 
  struct plugin *next;
94
 
} plugin;
95
 
 
96
 
static plugin *plugin_list = NULL;
97
 
 
98
 
/* Gets an existing plugin based on name,
99
 
   or if none is found, creates a new one */
100
 
static plugin *getplugin(char *name){
101
 
  /* Check for exiting plugin with that name */
102
 
  for (plugin *p = plugin_list; p != NULL; p = p->next){
103
 
    if ((p->name == name)
104
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
105
 
      return p;
106
 
    }
107
 
  }
108
 
  /* Create a new plugin */
109
 
  plugin *new_plugin = malloc(sizeof(plugin));
110
 
  if (new_plugin == NULL){
111
 
    return NULL;
112
 
  }
113
 
  char *copy_name = NULL;
114
 
  if(name != NULL){
115
 
    copy_name = strdup(name);
116
 
    if(copy_name == NULL){
117
 
      return NULL;
118
 
    }
119
 
  }
120
 
  
121
 
  *new_plugin = (plugin) { .name = copy_name,
122
 
                           .argc = 1,
123
 
                           .disabled = false,
124
 
                           .next = plugin_list };
125
 
  
126
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
127
 
  if (new_plugin->argv == NULL){
128
 
    free(copy_name);
129
 
    free(new_plugin);
130
 
    return NULL;
131
 
  }
132
 
  new_plugin->argv[0] = copy_name;
133
 
  new_plugin->argv[1] = NULL;
134
 
  
135
 
  new_plugin->environ = malloc(sizeof(char *));
136
 
  if(new_plugin->environ == NULL){
137
 
    free(copy_name);
138
 
    free(new_plugin->argv);
139
 
    free(new_plugin);
140
 
    return NULL;
141
 
  }
142
 
  new_plugin->environ[0] = NULL;
143
 
  
144
 
  /* Append the new plugin to the list */
145
 
  plugin_list = new_plugin;
146
 
  return new_plugin;
147
 
}
148
 
 
149
 
/* Helper function for add_argument and add_environment */
150
 
static bool add_to_char_array(const char *new, char ***array,
151
 
                              int *len){
152
 
  /* Resize the pointed-to array to hold one more pointer */
153
 
  *array = realloc(*array, sizeof(char *)
154
 
                   * (size_t) ((*len) + 2));
155
 
  /* Malloc check */
156
 
  if(*array == NULL){
157
 
    return false;
158
 
  }
159
 
  /* Make a copy of the new string */
160
 
  char *copy = strdup(new);
161
 
  if(copy == NULL){
162
 
    return false;
163
 
  }
164
 
  /* Insert the copy */
165
 
  (*array)[*len] = copy;
166
 
  (*len)++;
167
 
  /* Add a new terminating NULL pointer to the last element */
168
 
  (*array)[*len] = NULL;
169
 
  return true;
170
 
}
171
 
 
172
 
/* Add to a plugin's argument vector */
173
 
static bool add_argument(plugin *p, const char *arg){
174
 
  if(p == NULL){
175
 
    return false;
176
 
  }
177
 
  return add_to_char_array(arg, &(p->argv), &(p->argc));
178
 
}
179
 
 
180
 
/* Add to a plugin's environment */
181
 
static bool add_environment(plugin *p, const char *def, bool replace){
182
 
  if(p == NULL){
183
 
    return false;
184
 
  }
185
 
  /* namelen = length of name of environment variable */
186
 
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
187
 
  /* Search for this environment variable */
188
 
  for(char **e = p->environ; *e != NULL; e++){
189
 
    if(strncmp(*e, def, namelen + 1) == 0){
190
 
      /* It already exists */
191
 
      if(replace){
192
 
        char *new = realloc(*e, strlen(def) + 1);
193
 
        if(new == NULL){
194
 
          return false;
195
 
        }
196
 
        *e = new;
197
 
        strcpy(*e, def);
198
 
      }
199
 
      return true;
200
 
    }
201
 
  }
202
 
  return add_to_char_array(def, &(p->environ), &(p->envc));
203
 
}
204
 
 
205
 
/*
206
 
 * Based on the example in the GNU LibC manual chapter 13.13 "File
207
 
 * Descriptor Flags".
208
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
209
 
 */
210
 
static int set_cloexec_flag(int fd){
211
 
  int ret = fcntl(fd, F_GETFD, 0);
212
 
  /* If reading the flags failed, return error indication now. */
213
 
  if(ret < 0){
214
 
    return ret;
215
 
  }
216
 
  /* Store modified flag word in the descriptor. */
217
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
218
 
}
219
 
 
220
 
 
221
 
/* Mark processes as completed when they exit, and save their exit
222
 
   status. */
223
 
static void handle_sigchld(__attribute__((unused)) int sig){
224
 
  while(true){
225
 
    plugin *proc = plugin_list;
226
 
    int status;
227
 
    pid_t pid = waitpid(-1, &status, WNOHANG);
228
 
    if(pid == 0){
229
 
      /* Only still running child processes */
230
 
      break;
231
 
    }
232
 
    if(pid == -1){
233
 
      if (errno != ECHILD){
234
 
        perror("waitpid");
235
 
      }
236
 
      /* No child processes */
237
 
      break;
238
 
    }
239
 
    
240
 
    /* A child exited, find it in process_list */
241
 
    while(proc != NULL and proc->pid != pid){
242
 
      proc = proc->next;
243
 
    }
244
 
    if(proc == NULL){
245
 
      /* Process not found in process list */
246
 
      continue;
247
 
    }
248
 
    proc->status = status;
249
 
    proc->completed = true;
250
 
  }
251
 
}
252
 
 
253
 
/* Prints out a password to stdout */
254
 
static bool print_out_password(const char *buffer, size_t length){
255
 
  ssize_t ret;
256
 
  for(size_t written = 0; written < length; written += (size_t)ret){
257
 
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
258
 
                                   length - written));
259
 
    if(ret < 0){
260
 
      return false;
261
 
    }
262
 
  }
263
 
  return true;
264
 
}
265
 
 
266
 
/* Removes and free a plugin from the plugin list */
267
 
static void free_plugin(plugin *plugin_node){
268
 
  
269
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
270
 
    free(*arg);
271
 
  }
272
 
  free(plugin_node->argv);
273
 
  for(char **env = plugin_node->environ; *env != NULL; env++){
274
 
    free(*env);
275
 
  }
276
 
  free(plugin_node->environ);
277
 
  free(plugin_node->buffer);
278
 
 
279
 
  /* Removes the plugin from the singly-linked list */
280
 
  if(plugin_node == plugin_list){
281
 
    /* First one - simple */
282
 
    plugin_list = plugin_list->next;
283
 
  } else {
284
 
    /* Second one or later */
285
 
    for(plugin *p = plugin_list; p != NULL; p = p->next){
286
 
      if(p->next == plugin_node){
287
 
        p->next = plugin_node->next;
288
 
        break;
289
 
      }
290
 
    }
291
 
  }
292
 
  
293
 
  free(plugin_node);
294
 
}
295
 
 
296
 
static void free_plugin_list(void){
297
 
  while(plugin_list != NULL){
298
 
    free_plugin(plugin_list);
299
 
  }
300
 
}
 
22
  int buffer_size;
 
23
  int buffer_length;
 
24
  struct process *next;
 
25
} process;
 
26
 
 
27
#define BUFFER_SIZE 256
301
28
 
302
29
int main(int argc, char *argv[]){
303
 
  char *plugindir = NULL;
304
 
  char *argfile = NULL;
305
 
  FILE *conffp;
306
 
  size_t d_name_len;
307
 
  DIR *dir = NULL;
 
30
  char plugindir[] = "plugins.d";
 
31
  size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
 
32
  DIR *dir;
308
33
  struct dirent *dirst;
309
34
  struct stat st;
310
 
  fd_set rfds_all;
 
35
  fd_set rfds_orig;
311
36
  int ret, maxfd = 0;
312
 
  ssize_t sret;
313
 
  uid_t uid = 65534;
314
 
  gid_t gid = 65534;
315
 
  bool debug = false;
316
 
  int exitstatus = EXIT_SUCCESS;
317
 
  struct sigaction old_sigchld_action;
318
 
  struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
319
 
                                      .sa_flags = SA_NOCLDSTOP };
320
 
  char **custom_argv = NULL;
321
 
  int custom_argc = 0;
322
 
  
323
 
  /* Establish a signal handler */
324
 
  sigemptyset(&sigchld_action.sa_mask);
325
 
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
326
 
  if(ret == -1){
327
 
    perror("sigaddset");
328
 
    exitstatus = EXIT_FAILURE;
329
 
    goto fallback;
330
 
  }
331
 
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
332
 
  if(ret == -1){
333
 
    perror("sigaction");
334
 
    exitstatus = EXIT_FAILURE;
335
 
    goto fallback;
336
 
  }
337
 
  
338
 
  /* The options we understand. */
339
 
  struct argp_option options[] = {
340
 
    { .name = "global-options", .key = 'g',
341
 
      .arg = "OPTION[,OPTION[,...]]",
342
 
      .doc = "Options passed to all plugins" },
343
 
    { .name = "global-env", .key = 'G',
344
 
      .arg = "VAR=value",
345
 
      .doc = "Environment variable passed to all plugins" },
346
 
    { .name = "options-for", .key = 'o',
347
 
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
348
 
      .doc = "Options passed only to specified plugin" },
349
 
    { .name = "env-for", .key = 'E',
350
 
      .arg = "PLUGIN:ENV=value",
351
 
      .doc = "Environment variable passed to specified plugin" },
352
 
    { .name = "disable", .key = 'd',
353
 
      .arg = "PLUGIN",
354
 
      .doc = "Disable a specific plugin", .group = 1 },
355
 
    { .name = "enable", .key = 'e',
356
 
      .arg = "PLUGIN",
357
 
      .doc = "Enable a specific plugin", .group = 1 },
358
 
    { .name = "plugin-dir", .key = 128,
359
 
      .arg = "DIRECTORY",
360
 
      .doc = "Specify a different plugin directory", .group = 2 },
361
 
    { .name = "config-file", .key = 129,
362
 
      .arg = "FILE",
363
 
      .doc = "Specify a different configuration file", .group = 2 },
364
 
    { .name = "userid", .key = 130,
365
 
      .arg = "ID", .flags = 0,
366
 
      .doc = "User ID the plugins will run as", .group = 3 },
367
 
    { .name = "groupid", .key = 131,
368
 
      .arg = "ID", .flags = 0,
369
 
      .doc = "Group ID the plugins will run as", .group = 3 },
370
 
    { .name = "debug", .key = 132,
371
 
      .doc = "Debug mode", .group = 4 },
372
 
    { .name = NULL }
373
 
  };
374
 
  
375
 
  error_t parse_opt (int key, char *arg, __attribute__((unused))
376
 
                     struct argp_state *state) {
377
 
    switch (key) {
378
 
    case 'g':                   /* --global-options */
379
 
      if (arg != NULL){
380
 
        char *p;
381
 
        while((p = strsep(&arg, ",")) != NULL){
382
 
          if(p[0] == '\0'){
383
 
            continue;
384
 
          }
385
 
          if(not add_argument(getplugin(NULL), p)){
386
 
            perror("add_argument");
387
 
            return ARGP_ERR_UNKNOWN;
388
 
          }
389
 
        }
390
 
      }
391
 
      break;
392
 
    case 'G':                   /* --global-env */
393
 
      if(arg == NULL){
394
 
        break;
395
 
      }
396
 
      if(not add_environment(getplugin(NULL), arg, true)){
397
 
        perror("add_environment");
398
 
      }
399
 
      break;
400
 
    case 'o':                   /* --options-for */
401
 
      if (arg != NULL){
402
 
        char *p_name = strsep(&arg, ":");
403
 
        if(p_name[0] == '\0' or arg == NULL){
404
 
          break;
405
 
        }
406
 
        char *opt = strsep(&arg, ":");
407
 
        if(opt[0] == '\0' or opt == NULL){
408
 
          break;
409
 
        }
410
 
        char *p;
411
 
        while((p = strsep(&opt, ",")) != NULL){
412
 
          if(p[0] == '\0'){
413
 
            continue;
414
 
          }
415
 
          if(not add_argument(getplugin(p_name), p)){
416
 
            perror("add_argument");
417
 
            return ARGP_ERR_UNKNOWN;
418
 
          }
419
 
        }
420
 
      }
421
 
      break;
422
 
    case 'E':                   /* --env-for */
423
 
      if(arg == NULL){
424
 
        break;
425
 
      }
426
 
      {
427
 
        char *envdef = strchr(arg, ':');
428
 
        if(envdef == NULL){
429
 
          break;
430
 
        }
431
 
        *envdef = '\0';
432
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
433
 
          perror("add_environment");
434
 
        }
435
 
      }
436
 
      break;
437
 
    case 'd':                   /* --disable */
438
 
      if (arg != NULL){
439
 
        plugin *p = getplugin(arg);
440
 
        if(p == NULL){
441
 
          return ARGP_ERR_UNKNOWN;
442
 
        }
443
 
        p->disabled = true;
444
 
      }
445
 
      break;
446
 
    case 'e':                   /* --enable */
447
 
      if (arg != NULL){
448
 
        plugin *p = getplugin(arg);
449
 
        if(p == NULL){
450
 
          return ARGP_ERR_UNKNOWN;
451
 
        }
452
 
        p->disabled = false;
453
 
      }
454
 
      break;
455
 
    case 128:                   /* --plugin-dir */
456
 
      free(plugindir);
457
 
      plugindir = strdup(arg);
458
 
      if(plugindir == NULL){
459
 
        perror("strdup");
460
 
      }      
461
 
      break;
462
 
    case 129:                   /* --config-file */
463
 
      /* This is already done by parse_opt_config_file() */
464
 
      break;
465
 
    case 130:                   /* --userid */
466
 
      uid = (uid_t)strtol(arg, NULL, 10);
467
 
      break;
468
 
    case 131:                   /* --groupid */
469
 
      gid = (gid_t)strtol(arg, NULL, 10);
470
 
      break;
471
 
    case 132:                   /* --debug */
472
 
      debug = true;
473
 
      break;
474
 
    case ARGP_KEY_ARG:
475
 
      /* Cryptsetup always passes an argument, which is an empty
476
 
         string if "none" was specified in /etc/crypttab.  So if
477
 
         argument was empty, we ignore it silently. */
478
 
      if(arg[0] != '\0'){
479
 
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
480
 
      }
481
 
      break;
482
 
    case ARGP_KEY_END:
483
 
      break;
484
 
    default:
485
 
      return ARGP_ERR_UNKNOWN;
486
 
    }
487
 
    return 0;
488
 
  }
489
 
  
490
 
  /* This option parser is the same as parse_opt() above, except it
491
 
     ignores everything but the --config-file option. */
492
 
  error_t parse_opt_config_file (int key, char *arg,
493
 
                                 __attribute__((unused))
494
 
                                 struct argp_state *state) {
495
 
    switch (key) {
496
 
    case 'g':                   /* --global-options */
497
 
    case 'G':                   /* --global-env */
498
 
    case 'o':                   /* --options-for */
499
 
    case 'E':                   /* --env-for */
500
 
    case 'd':                   /* --disable */
501
 
    case 'e':                   /* --enable */
502
 
    case 128:                   /* --plugin-dir */
503
 
      break;
504
 
    case 129:                   /* --config-file */
505
 
      free(argfile);
506
 
      argfile = strdup(arg);
507
 
      if(argfile == NULL){
508
 
        perror("strdup");
509
 
      }
510
 
      break;      
511
 
    case 130:                   /* --userid */
512
 
    case 131:                   /* --groupid */
513
 
    case 132:                   /* --debug */
514
 
    case ARGP_KEY_ARG:
515
 
    case ARGP_KEY_END:
516
 
      break;
517
 
    default:
518
 
      return ARGP_ERR_UNKNOWN;
519
 
    }
520
 
    return 0;
521
 
  }
522
 
  
523
 
  struct argp argp = { .options = options,
524
 
                       .parser = parse_opt_config_file,
525
 
                       .args_doc = "",
526
 
                       .doc = "Mandos plugin runner -- Run plugins" };
527
 
  
528
 
  /* Parse using the parse_opt_config_file in order to get the custom
529
 
     config file location, if any. */
530
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
531
 
  if (ret == ARGP_ERR_UNKNOWN){
532
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
533
 
    exitstatus = EXIT_FAILURE;
534
 
    goto fallback;
535
 
  }
536
 
  
537
 
  /* Reset to the normal argument parser */
538
 
  argp.parser = parse_opt;
539
 
  
540
 
  /* Open the configfile if available */
541
 
  if (argfile == NULL){
542
 
    conffp = fopen(AFILE, "r");
543
 
  } else {
544
 
    conffp = fopen(argfile, "r");
545
 
  }  
546
 
  if(conffp != NULL){
547
 
    char *org_line = NULL;
548
 
    char *p, *arg, *new_arg, *line;
549
 
    size_t size = 0;
550
 
    const char whitespace_delims[] = " \r\t\f\v\n";
551
 
    const char comment_delim[] = "#";
552
 
 
553
 
    custom_argc = 1;
554
 
    custom_argv = malloc(sizeof(char*) * 2);
555
 
    if(custom_argv == NULL){
556
 
      perror("malloc");
557
 
      exitstatus = EXIT_FAILURE;
558
 
      goto fallback;
559
 
    }
560
 
    custom_argv[0] = argv[0];
561
 
    custom_argv[1] = NULL;
562
 
 
563
 
    /* for each line in the config file, strip whitespace and ignore
564
 
       commented text */
565
 
    while(true){
566
 
      sret = getline(&org_line, &size, conffp);
567
 
      if(sret == -1){
568
 
        break;
569
 
      }
570
 
 
571
 
      line = org_line;
572
 
      arg = strsep(&line, comment_delim);
573
 
      while((p = strsep(&arg, whitespace_delims)) != NULL){
574
 
        if(p[0] == '\0'){
575
 
          continue;
576
 
        }
577
 
        new_arg = strdup(p);
578
 
        if(new_arg == NULL){
579
 
          perror("strdup");
580
 
          exitstatus = EXIT_FAILURE;
581
 
          free(org_line);
582
 
          goto fallback;
583
 
        }
584
 
        
585
 
        custom_argc += 1;
586
 
        custom_argv = realloc(custom_argv, sizeof(char *)
587
 
                              * ((unsigned int) custom_argc + 1));
588
 
        if(custom_argv == NULL){
589
 
          perror("realloc");
590
 
          exitstatus = EXIT_FAILURE;
591
 
          free(org_line);
592
 
          goto fallback;
593
 
        }
594
 
        custom_argv[custom_argc-1] = new_arg;
595
 
        custom_argv[custom_argc] = NULL;        
596
 
      }
597
 
    }
598
 
    free(org_line);
599
 
  } else {
600
 
    /* Check for harmful errors and go to fallback. Other errors might
601
 
       not affect opening plugins */
602
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
603
 
      perror("fopen");
604
 
      exitstatus = EXIT_FAILURE;
605
 
      goto fallback;
606
 
    }
607
 
  }
608
 
  /* If there was any arguments from configuration file,
609
 
     pass them to parser as command arguments */
610
 
  if(custom_argv != NULL){
611
 
    ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
612
 
                      0, NULL);
613
 
    if (ret == ARGP_ERR_UNKNOWN){
614
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
615
 
      exitstatus = EXIT_FAILURE;
616
 
      goto fallback;
617
 
    }
618
 
  }
619
 
  
620
 
  /* Parse actual command line arguments, to let them override the
621
 
     config file */
622
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
623
 
  if (ret == ARGP_ERR_UNKNOWN){
624
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
625
 
    exitstatus = EXIT_FAILURE;
626
 
    goto fallback;
627
 
  }
628
 
  
629
 
  if(debug){
630
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
631
 
      fprintf(stderr, "Plugin: %s has %d arguments\n",
632
 
              p->name ? p->name : "Global", p->argc - 1);
633
 
      for(char **a = p->argv; *a != NULL; a++){
634
 
        fprintf(stderr, "\tArg: %s\n", *a);
635
 
      }
636
 
      fprintf(stderr, "...and %u environment variables\n", p->envc);
637
 
      for(char **a = p->environ; *a != NULL; a++){
638
 
        fprintf(stderr, "\t%s\n", *a);
639
 
      }
640
 
    }
641
 
  }
642
 
  
643
 
  /* Strip permissions down to nobody */
644
 
  ret = setuid(uid);
645
 
  if (ret == -1){
646
 
    perror("setuid");
647
 
  }  
648
 
  setgid(gid);
649
 
  if (ret == -1){
650
 
    perror("setgid");
651
 
  }
652
 
  
653
 
  if (plugindir == NULL){
654
 
    dir = opendir(PDIR);
655
 
  } else {
656
 
    dir = opendir(plugindir);
657
 
  }
658
 
  
 
37
  process *process_list = NULL;
 
38
  
 
39
  dir = opendir(plugindir);
 
40
 
659
41
  if(dir == NULL){
660
 
    perror("Could not open plugin dir");
661
 
    exitstatus = EXIT_FAILURE;
662
 
    goto fallback;
663
 
  }
664
 
  
665
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
666
 
  {
667
 
    int dir_fd = dirfd(dir);
668
 
    if(dir_fd >= 0){
669
 
      ret = set_cloexec_flag(dir_fd);
670
 
      if(ret < 0){
671
 
        perror("set_cloexec_flag");
672
 
        exitstatus = EXIT_FAILURE;
673
 
        goto fallback;
674
 
      }
675
 
    }
676
 
  }
677
 
  
678
 
  FD_ZERO(&rfds_all);
679
 
  
680
 
  /* Read and execute any executable in the plugin directory*/
 
42
    fprintf(stderr, "Can not open directory\n");
 
43
    return EXIT_FAILURE;
 
44
  }
 
45
  
 
46
  FD_ZERO(&rfds_orig);
 
47
  
681
48
  while(true){
682
49
    dirst = readdir(dir);
683
50
    
684
 
    /* All directory entries have been processed */
 
51
    // All directory entries have been processed
685
52
    if(dirst == NULL){
686
 
      if (errno == EBADF){
687
 
        perror("readdir");
688
 
        exitstatus = EXIT_FAILURE;
689
 
        goto fallback;
690
 
      }
691
53
      break;
692
54
    }
693
55
    
694
56
    d_name_len = strlen(dirst->d_name);
695
57
    
696
 
    /* Ignore dotfiles, backup files and other junk */
697
 
    {
698
 
      bool bad_name = false;
699
 
      
700
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
701
 
      
702
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
703
 
                                           ".dpkg-old",
704
 
                                           ".dpkg-bak",
705
 
                                           ".dpkg-divert", NULL };
706
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
707
 
        size_t pre_len = strlen(*pre);
708
 
        if((d_name_len >= pre_len)
709
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
710
 
          if(debug){
711
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
712
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
713
 
          }
714
 
          bad_name = true;
715
 
          break;
716
 
        }
717
 
      }
718
 
      if(bad_name){
719
 
        continue;
720
 
      }
721
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
722
 
        size_t suf_len = strlen(*suf);
723
 
        if((d_name_len >= suf_len)
724
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
725
 
                == 0)){
726
 
          if(debug){
727
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
728
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
729
 
          }
730
 
          bad_name = true;
731
 
          break;
732
 
        }
733
 
      }
734
 
      
735
 
      if(bad_name){
736
 
        continue;
737
 
      }
738
 
    }
739
 
 
740
 
    char *filename;
741
 
    if(plugindir == NULL){
742
 
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
743
 
    } else {
744
 
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
745
 
    }
746
 
    if(ret < 0){
747
 
      perror("asprintf");
748
 
      continue;
749
 
    }
750
 
    
751
 
    ret = stat(filename, &st);
752
 
    if (ret == -1){
753
 
      perror("stat");
754
 
      free(filename);
755
 
      continue;
756
 
    }
757
 
 
758
 
    /* Ignore non-executable files */
759
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
760
 
      if(debug){
761
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
762
 
                " with bad type or mode\n", filename);
763
 
      }
764
 
      free(filename);
765
 
      continue;
766
 
    }
767
 
    
768
 
    plugin *p = getplugin(dirst->d_name);
769
 
    if(p == NULL){
770
 
      perror("getplugin");
771
 
      free(filename);
772
 
      continue;
773
 
    }
774
 
    if(p->disabled){
775
 
      if(debug){
776
 
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
777
 
                dirst->d_name);
778
 
      }
779
 
      free(filename);
780
 
      continue;
781
 
    }
782
 
    {
783
 
      /* Add global arguments to argument list for this plugin */
784
 
      plugin *g = getplugin(NULL);
785
 
      if(g != NULL){
786
 
        for(char **a = g->argv + 1; *a != NULL; a++){
787
 
          if(not add_argument(p, *a)){
788
 
            perror("add_argument");
789
 
          }
790
 
        }
791
 
        /* Add global environment variables */
792
 
        for(char **e = g->environ; *e != NULL; e++){
793
 
          if(not add_environment(p, *e, false)){
794
 
            perror("add_environment");
795
 
          }
796
 
        }
797
 
      }
798
 
    }
799
 
    /* If this plugin has any environment variables, we will call
800
 
       using execve and need to duplicate the environment from this
801
 
       process, too. */
802
 
    if(p->environ[0] != NULL){
803
 
      for(char **e = environ; *e != NULL; e++){
804
 
        if(not add_environment(p, *e, false)){
805
 
          perror("add_environment");
806
 
        }
807
 
      }
808
 
    }
809
 
    
810
 
    int pipefd[2];
811
 
    ret = pipe(pipefd);
812
 
    if (ret == -1){
813
 
      perror("pipe");
814
 
      exitstatus = EXIT_FAILURE;
815
 
      goto fallback;
816
 
    }
817
 
    /* Ask OS to automatic close the pipe on exec */
818
 
    ret = set_cloexec_flag(pipefd[0]);
819
 
    if(ret < 0){
820
 
      perror("set_cloexec_flag");
821
 
      exitstatus = EXIT_FAILURE;
822
 
      goto fallback;
823
 
    }
824
 
    ret = set_cloexec_flag(pipefd[1]);
825
 
    if(ret < 0){
826
 
      perror("set_cloexec_flag");
827
 
      exitstatus = EXIT_FAILURE;
828
 
      goto fallback;
829
 
    }
830
 
    /* Block SIGCHLD until process is safely in process list */
831
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
832
 
    if(ret < 0){
833
 
      perror("sigprocmask");
834
 
      exitstatus = EXIT_FAILURE;
835
 
      goto fallback;
836
 
    }
837
 
    /* Starting a new process to be watched */
838
 
    pid_t pid = fork();
839
 
    if(pid == -1){
840
 
      perror("fork");
841
 
      exitstatus = EXIT_FAILURE;
842
 
      goto fallback;
843
 
    }
844
 
    if(pid == 0){
845
 
      /* this is the child process */
846
 
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
847
 
      if(ret < 0){
848
 
        perror("sigaction");
849
 
        _exit(EXIT_FAILURE);
850
 
      }
851
 
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
852
 
      if(ret < 0){
853
 
        perror("sigprocmask");
854
 
        _exit(EXIT_FAILURE);
855
 
      }
856
 
      
857
 
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
858
 
      if(ret == -1){
859
 
        perror("dup2");
860
 
        _exit(EXIT_FAILURE);
861
 
      }
862
 
      
863
 
      if(dirfd(dir) < 0){
864
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
865
 
           above and must now close it manually here. */
 
58
    // Ignore dotfiles and backup files
 
59
    if (dirst->d_name[0] == '.'
 
60
        or dirst->d_name[d_name_len - 1] == '~'){
 
61
      continue;
 
62
    }
 
63
    
 
64
    char *filename = malloc(d_name_len + plugindir_len + 1);
 
65
    strcpy(filename, plugindir);
 
66
    strcat(filename, "/");
 
67
    strcat(filename, dirst->d_name);    
 
68
    
 
69
    stat(filename, &st);
 
70
 
 
71
    if (S_ISREG(st.st_mode) and (access(filename, X_OK) == 0)){
 
72
      // Starting a new process to be watched
 
73
      process *new_process = malloc(sizeof(process));
 
74
      int pipefd[2];
 
75
      pipe(pipefd);
 
76
      new_process->pid = fork();
 
77
      if(new_process->pid == 0){
 
78
        /* this is the child process */
866
79
        closedir(dir);
867
 
      }
868
 
      if(p->environ[0] == NULL){
869
 
        if(execv(filename, p->argv) < 0){
870
 
          perror("execv");
871
 
          _exit(EXIT_FAILURE);
872
 
        }
873
 
      } else {
874
 
        if(execve(filename, p->argv, p->environ) < 0){
875
 
          perror("execve");
876
 
          _exit(EXIT_FAILURE);
877
 
        }
878
 
      }
879
 
      /* no return */
880
 
    }
881
 
    /* Parent process */
882
 
    close(pipefd[1]);           /* Close unused write end of pipe */
883
 
    free(filename);
884
 
    plugin *new_plugin = getplugin(dirst->d_name);
885
 
    if (new_plugin == NULL){
886
 
      perror("getplugin");
887
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
888
 
      if(ret < 0){
889
 
        perror("sigprocmask");
890
 
      }
891
 
      exitstatus = EXIT_FAILURE;
892
 
      goto fallback;
893
 
    }
894
 
    
895
 
    new_plugin->pid = pid;
896
 
    new_plugin->fd = pipefd[0];
897
 
    
898
 
    /* Unblock SIGCHLD so signal handler can be run if this process
899
 
       has already completed */
900
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
901
 
    if(ret < 0){
902
 
      perror("sigprocmask");
903
 
      exitstatus = EXIT_FAILURE;
904
 
      goto fallback;
905
 
    }
906
 
    
907
 
    FD_SET(new_plugin->fd, &rfds_all);
908
 
    
909
 
    if (maxfd < new_plugin->fd){
910
 
      maxfd = new_plugin->fd;
 
80
        close(pipefd[0]);       /* close unused read end of pipe */
 
81
        dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
 
82
        /* create a new modified argument list */
 
83
        char **new_argv = malloc(sizeof(char *) * argc + 1);
 
84
        new_argv[0] = filename;
 
85
        for(int i = 1; i < argc; i++){
 
86
          new_argv[i] = argv[i];
 
87
        }
 
88
        new_argv[argc] = NULL;
 
89
        if(execv(filename, new_argv) < 0){
 
90
          perror(argv[0]);
 
91
          close(pipefd[1]);
 
92
          exit(EXIT_FAILURE);
 
93
        }
 
94
        /* no return */
 
95
      }
 
96
      close(pipefd[1]);         /* close unused write end of pipe */
 
97
      new_process->fd = pipefd[0];
 
98
      new_process->buffer = malloc(BUFFER_SIZE);
 
99
      if (new_process->buffer == NULL){
 
100
        perror(argv[0]);
 
101
        goto end;
 
102
      }
 
103
      new_process->buffer_size = BUFFER_SIZE;
 
104
      new_process->buffer_length = 0;
 
105
      FD_SET(new_process->fd, &rfds_orig);
 
106
      
 
107
      if (maxfd < new_process->fd){
 
108
        maxfd = new_process->fd;
 
109
      }
 
110
      
 
111
      //List handling
 
112
      new_process->next = process_list;
 
113
      process_list = new_process;
911
114
    }
912
115
  }
913
116
  
914
117
  closedir(dir);
915
 
  dir = NULL;
916
 
  
917
 
  for(plugin *p = plugin_list; p != NULL; p = p->next){
918
 
    if(p->pid != 0){
 
118
  
 
119
  if (process_list != NULL){
 
120
    while(true){
 
121
      fd_set rfds = rfds_orig;
 
122
      int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
 
123
      if (select_ret == -1){
 
124
        perror(argv[0]);
 
125
        goto end;
 
126
      }else{    
 
127
        for(process *process_itr = process_list; process_itr != NULL;
 
128
            process_itr = process_itr->next){
 
129
          if(FD_ISSET(process_itr->fd, &rfds)){
 
130
            if(process_itr->buffer_length + BUFFER_SIZE
 
131
               > process_itr->buffer_size){
 
132
                process_itr->buffer = realloc(process_itr->buffer,
 
133
                                              process_itr->buffer_size
 
134
                                              + BUFFER_SIZE);
 
135
                if (process_itr->buffer == NULL){
 
136
                  perror(argv[0]);
 
137
                  goto end;
 
138
                }
 
139
                process_itr->buffer_size += BUFFER_SIZE;
 
140
            }
 
141
            ret = read(process_itr->fd, process_itr->buffer
 
142
                       + process_itr->buffer_length, BUFFER_SIZE);
 
143
            process_itr->buffer_length+=ret;
 
144
            if(ret == 0){
 
145
              /* got EOF */
 
146
              /* wait for process exit */
 
147
              int status;
 
148
              waitpid(process_itr->pid, &status, 0);
 
149
              if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
 
150
                write(STDOUT_FILENO, process_itr->buffer,
 
151
                      process_itr->buffer_length);
 
152
                goto end;
 
153
              } else {
 
154
                FD_CLR(process_itr->fd, &rfds_orig);
 
155
              }
 
156
            }
 
157
          }
 
158
        }
 
159
      }
 
160
    }
 
161
  }
 
162
  
 
163
 end:
 
164
  for(process *process_itr = process_list; process_itr != NULL;
 
165
      process_itr = process_itr->next){
 
166
    close(process_itr->fd);
 
167
    kill(process_itr->pid, SIGTERM);
 
168
    free(process_itr->buffer);
 
169
  }
 
170
  
 
171
  while(true){
 
172
    int status;
 
173
    ret = wait(&status);
 
174
    if (ret == -1){
 
175
      if(errno != ECHILD){
 
176
        perror("wait");
 
177
      }
919
178
      break;
920
179
    }
921
 
    if(p->next == NULL){
922
 
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
923
 
              " directory?\n");
924
 
      free_plugin_list();
925
 
    }
926
 
  }
927
 
  
928
 
  /* Main loop while running plugins exist */
929
 
  while(plugin_list){
930
 
    fd_set rfds = rfds_all;
931
 
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
932
 
    if (select_ret == -1){
933
 
      perror("select");
934
 
      exitstatus = EXIT_FAILURE;
935
 
      goto fallback;
936
 
    }
937
 
    /* OK, now either a process completed, or something can be read
938
 
       from one of them */
939
 
    for(plugin *proc = plugin_list; proc != NULL;){
940
 
      /* Is this process completely done? */
941
 
      if(proc->eof and proc->completed){
942
 
        /* Only accept the plugin output if it exited cleanly */
943
 
        if(not WIFEXITED(proc->status)
944
 
           or WEXITSTATUS(proc->status) != 0){
945
 
          /* Bad exit by plugin */
946
 
 
947
 
          if(debug){
948
 
            if(WIFEXITED(proc->status)){
949
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
950
 
                      (unsigned int) (proc->pid),
951
 
                      WEXITSTATUS(proc->status));
952
 
            } else if(WIFSIGNALED(proc->status)) {
953
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
954
 
                      (unsigned int) (proc->pid),
955
 
                      WTERMSIG(proc->status));
956
 
            } else if(WCOREDUMP(proc->status)){
957
 
              fprintf(stderr, "Plugin %d dumped core\n",
958
 
                      (unsigned int) (proc->pid));
959
 
            }
960
 
          }
961
 
          
962
 
          /* Remove the plugin */
963
 
          FD_CLR(proc->fd, &rfds_all);
964
 
 
965
 
          /* Block signal while modifying process_list */
966
 
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
967
 
          if(ret < 0){
968
 
            perror("sigprocmask");
969
 
            exitstatus = EXIT_FAILURE;
970
 
            goto fallback;
971
 
          }
972
 
          
973
 
          plugin *next_plugin = proc->next;
974
 
          free_plugin(proc);
975
 
          proc = next_plugin;
976
 
          
977
 
          /* We are done modifying process list, so unblock signal */
978
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
979
 
                             NULL);
980
 
          if(ret < 0){
981
 
            perror("sigprocmask");
982
 
            exitstatus = EXIT_FAILURE;
983
 
            goto fallback;
984
 
          }
985
 
          
986
 
          if(plugin_list == NULL){
987
 
            break;
988
 
          }
989
 
          
990
 
          continue;
991
 
        }
992
 
        
993
 
        /* This process exited nicely, so print its buffer */
994
 
        
995
 
        bool bret = print_out_password(proc->buffer,
996
 
                                       proc->buffer_length);
997
 
        if(not bret){
998
 
          perror("print_out_password");
999
 
          exitstatus = EXIT_FAILURE;
1000
 
        }
1001
 
        goto fallback;
1002
 
      }
1003
 
      
1004
 
      /* This process has not completed.  Does it have any output? */
1005
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1006
 
        /* This process had nothing to say at this time */
1007
 
        proc = proc->next;
1008
 
        continue;
1009
 
      }
1010
 
      /* Before reading, make the process' data buffer large enough */
1011
 
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1012
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1013
 
                               + (size_t) BUFFER_SIZE);
1014
 
        if (proc->buffer == NULL){
1015
 
          perror("malloc");
1016
 
          exitstatus = EXIT_FAILURE;
1017
 
          goto fallback;
1018
 
        }
1019
 
        proc->buffer_size += BUFFER_SIZE;
1020
 
      }
1021
 
      /* Read from the process */
1022
 
      sret = read(proc->fd, proc->buffer + proc->buffer_length,
1023
 
                  BUFFER_SIZE);
1024
 
      if(sret < 0){
1025
 
        /* Read error from this process; ignore the error */
1026
 
        proc = proc->next;
1027
 
        continue;
1028
 
      }
1029
 
      if(sret == 0){
1030
 
        /* got EOF */
1031
 
        proc->eof = true;
1032
 
      } else {
1033
 
        proc->buffer_length += (size_t) sret;
1034
 
      }
1035
 
    }
1036
 
  }
1037
 
 
1038
 
 
1039
 
 fallback:
1040
 
  
1041
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1042
 
    /* Fallback if all plugins failed, none are found or an error
1043
 
       occured */
1044
 
    bool bret;
1045
 
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
1046
 
    char *passwordbuffer = getpass("Password: ");
1047
 
    size_t len = strlen(passwordbuffer);
1048
 
    /* Strip trailing newline */
1049
 
    if(len > 0 and passwordbuffer[len-1] == '\n'){
1050
 
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1051
 
      len--;
1052
 
    }
1053
 
    bret = print_out_password(passwordbuffer, len);
1054
 
    if(not bret){
1055
 
      perror("print_out_password");
1056
 
      exitstatus = EXIT_FAILURE;
1057
 
    }
1058
 
  }
1059
 
  
1060
 
  /* Restore old signal handler */
1061
 
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1062
 
  if(ret == -1){
1063
 
    perror("sigaction");
1064
 
    exitstatus = EXIT_FAILURE;
1065
 
  }
1066
 
  
1067
 
  if(custom_argv != NULL){
1068
 
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
1069
 
      free(*arg);
1070
 
    }
1071
 
    free(custom_argv);
1072
 
  }
1073
 
  
1074
 
  if(dir != NULL){
1075
 
    closedir(dir);
1076
 
  }
1077
 
  
1078
 
  /* Kill the processes */
1079
 
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1080
 
    if(p->pid != 0){
1081
 
      close(p->fd);
1082
 
      ret = kill(p->pid, SIGTERM);
1083
 
      if(ret == -1 and errno != ESRCH){
1084
 
        /* Set-uid proccesses might not get closed */
1085
 
        perror("kill");
1086
 
      }
1087
 
    }
1088
 
  }
1089
 
  
1090
 
  /* Wait for any remaining child processes to terminate */
1091
 
  do{
1092
 
    ret = wait(NULL);
1093
 
  } while(ret >= 0);
1094
 
  if(errno != ECHILD){
1095
 
    perror("wait");
1096
 
  }
1097
 
  
1098
 
  free_plugin_list();
1099
 
  
1100
 
  free(plugindir);
1101
 
  free(argfile);
1102
 
  
1103
 
  return exitstatus;
 
180
  }  
 
181
  return EXIT_SUCCESS;
1104
182
}