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