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