/mandos/release

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

« back to all changes in this revision

Viewing changes to plugbasedclient.c

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

Show diffs side-by-side

added added

removed removed

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