/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

Added optional parameters certdir, certkey and certfile that can be iven at start in the command line.

Show diffs side-by-side

added added

removed removed

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