/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 plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2015-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2008,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
19
19
 * along with this program.  If not, see
20
20
 * <http://www.gnu.org/licenses/>.
21
21
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
22
 * Contact the authors at <mandos@recompile.se>.
23
23
 */
24
24
 
25
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
                                   O_CLOEXEC, pipe2() */
27
27
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
29
 
                                   EXIT_SUCCESS, realloc() */
 
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
 
29
                                   realloc() */
30
30
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
 
31
#include <stdio.h>              /* fileno(), fprintf(),
 
32
                                   stderr, STDOUT_FILENO, fclose() */
 
33
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
34
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
35
                                   pid_t, uid_t, gid_t, getuid(),
 
36
                                   getgid() */
38
37
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
38
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
39
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
40
                                   WEXITSTATUS(), WTERMSIG(),
42
41
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
44
43
#include <iso646.h>             /* and, or, not */
45
 
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
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() */
 
44
#include <dirent.h>             /* struct dirent, scandirat() */
 
45
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
 
46
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
 
47
                                   struct stat, fstat(), close(),
 
48
                                   setgid(), setuid(), S_ISREG(),
 
49
                                   faccessat() pipe2(), fork(),
 
50
                                   _exit(), dup2(), fexecve(), read()
 
51
                                */
54
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
 
55
#include <string.h>             /* strsep, strlen(), strsignal(),
 
56
                                   strcmp(), strncmp() */
58
57
#include <errno.h>              /* errno */
59
58
#include <argp.h>               /* struct argp_option, struct
60
59
                                   argp_state, struct argp,
68
67
                                */
69
68
#include <errno.h>              /* errno, EBADF */
70
69
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
 
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
72
#include <errno.h>              /* errno */
 
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
71
75
 
72
76
#define BUFFER_SIZE 256
73
77
 
75
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
76
80
 
77
81
const char *argp_program_version = "plugin-runner " VERSION;
78
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
79
83
 
80
84
typedef struct plugin{
81
85
  char *name;                   /* can be NULL or any plugin name */
101
105
 
102
106
/* Gets an existing plugin based on name,
103
107
   or if none is found, creates a new one */
 
108
__attribute__((warn_unused_result))
104
109
static plugin *getplugin(char *name){
105
 
  /* Check for exiting plugin with that name */
 
110
  /* Check for existing plugin with that name */
106
111
  for(plugin *p = plugin_list; p != NULL; p = p->next){
107
112
    if((p->name == name)
108
113
       or (p->name and name and (strcmp(p->name, name) == 0))){
123
128
      copy_name = strdup(name);
124
129
    } while(copy_name == NULL and errno == EINTR);
125
130
    if(copy_name == NULL){
 
131
      int e = errno;
126
132
      free(new_plugin);
 
133
      errno = e;
127
134
      return NULL;
128
135
    }
129
136
  }
137
144
    new_plugin->argv = malloc(sizeof(char *) * 2);
138
145
  } while(new_plugin->argv == NULL and errno == EINTR);
139
146
  if(new_plugin->argv == NULL){
 
147
    int e = errno;
140
148
    free(copy_name);
141
149
    free(new_plugin);
 
150
    errno = e;
142
151
    return NULL;
143
152
  }
144
153
  new_plugin->argv[0] = copy_name;
148
157
    new_plugin->environ = malloc(sizeof(char *));
149
158
  } while(new_plugin->environ == NULL and errno == EINTR);
150
159
  if(new_plugin->environ == NULL){
 
160
    int e = errno;
151
161
    free(copy_name);
152
162
    free(new_plugin->argv);
153
163
    free(new_plugin);
 
164
    errno = e;
154
165
    return NULL;
155
166
  }
156
167
  new_plugin->environ[0] = NULL;
161
172
}
162
173
 
163
174
/* Helper function for add_argument and add_environment */
 
175
__attribute__((nonnull, warn_unused_result))
164
176
static bool add_to_char_array(const char *new, char ***array,
165
177
                              int *len){
166
178
  /* Resize the pointed-to array to hold one more pointer */
 
179
  char **new_array = NULL;
167
180
  do {
168
 
    *array = realloc(*array, sizeof(char *)
169
 
                     * (size_t) ((*len) + 2));
170
 
  } while(*array == NULL and errno == EINTR);
 
181
    new_array = realloc(*array, sizeof(char *)
 
182
                        * (size_t) ((*len) + 2));
 
183
  } while(new_array == NULL and errno == EINTR);
171
184
  /* Malloc check */
172
 
  if(*array == NULL){
 
185
  if(new_array == NULL){
173
186
    return false;
174
187
  }
 
188
  *array = new_array;
175
189
  /* Make a copy of the new string */
176
190
  char *copy;
177
191
  do {
189
203
}
190
204
 
191
205
/* Add to a plugin's argument vector */
 
206
__attribute__((nonnull(2), warn_unused_result))
192
207
static bool add_argument(plugin *p, const char *arg){
193
208
  if(p == NULL){
194
209
    return false;
197
212
}
198
213
 
199
214
/* Add to a plugin's environment */
 
215
__attribute__((nonnull(2), warn_unused_result))
200
216
static bool add_environment(plugin *p, const char *def, bool replace){
201
217
  if(p == NULL){
202
218
    return false;
204
220
  /* namelen = length of name of environment variable */
205
221
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
206
222
  /* Search for this environment variable */
207
 
  for(char **e = p->environ; *e != NULL; e++){
208
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
223
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
224
    if(strncmp(*envdef, def, namelen + 1) == 0){
209
225
      /* It already exists */
210
226
      if(replace){
211
 
        char *new;
 
227
        char *new_envdef;
212
228
        do {
213
 
          new = realloc(*e, strlen(def) + 1);
214
 
        } while(new == NULL and errno == EINTR);
215
 
        if(new == NULL){
 
229
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
230
        } while(new_envdef == NULL and errno == EINTR);
 
231
        if(new_envdef == NULL){
216
232
          return false;
217
233
        }
218
 
        *e = new;
219
 
        strcpy(*e, def);
 
234
        *envdef = new_envdef;
 
235
        strcpy(*envdef, def);
220
236
      }
221
237
      return true;
222
238
    }
224
240
  return add_to_char_array(def, &(p->environ), &(p->envc));
225
241
}
226
242
 
 
243
#ifndef O_CLOEXEC
227
244
/*
228
245
 * Based on the example in the GNU LibC manual chapter 13.13 "File
229
246
 * Descriptor Flags".
230
247
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
231
248
 */
 
249
__attribute__((warn_unused_result))
232
250
static int set_cloexec_flag(int fd){
233
251
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
234
252
  /* If reading the flags failed, return error indication now. */
239
257
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
240
258
                                       ret | FD_CLOEXEC));
241
259
}
 
260
#endif  /* not O_CLOEXEC */
242
261
 
243
262
 
244
263
/* Mark processes as completed when they exit, and save their exit
258
277
        /* No child processes */
259
278
        break;
260
279
      }
261
 
      perror("waitpid");
 
280
      error(0, errno, "waitpid");
262
281
    }
263
282
    
264
283
    /* A child exited, find it in process_list */
276
295
}
277
296
 
278
297
/* Prints out a password to stdout */
 
298
__attribute__((nonnull, warn_unused_result))
279
299
static bool print_out_password(const char *buffer, size_t length){
280
300
  ssize_t ret;
281
301
  for(size_t written = 0; written < length; written += (size_t)ret){
289
309
}
290
310
 
291
311
/* Removes and free a plugin from the plugin list */
 
312
__attribute__((nonnull))
292
313
static void free_plugin(plugin *plugin_node){
293
314
  
294
315
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
328
349
  char *plugindir = NULL;
329
350
  char *argfile = NULL;
330
351
  FILE *conffp;
331
 
  size_t d_name_len;
332
 
  DIR *dir = NULL;
333
 
  struct dirent *dirst;
 
352
  struct dirent **direntries = NULL;
334
353
  struct stat st;
335
354
  fd_set rfds_all;
336
355
  int ret, maxfd = 0;
344
363
                                      .sa_flags = SA_NOCLDSTOP };
345
364
  char **custom_argv = NULL;
346
365
  int custom_argc = 0;
 
366
  int dir_fd = -1;
347
367
  
348
368
  /* Establish a signal handler */
349
369
  sigemptyset(&sigchld_action.sa_mask);
350
370
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
351
371
  if(ret == -1){
352
 
    perror("sigaddset");
353
 
    exitstatus = EXIT_FAILURE;
 
372
    error(0, errno, "sigaddset");
 
373
    exitstatus = EX_OSERR;
354
374
    goto fallback;
355
375
  }
356
376
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
357
377
  if(ret == -1){
358
 
    perror("sigaction");
359
 
    exitstatus = EXIT_FAILURE;
 
378
    error(0, errno, "sigaction");
 
379
    exitstatus = EX_OSERR;
360
380
    goto fallback;
361
381
  }
362
382
  
394
414
      .doc = "Group ID the plugins will run as", .group = 3 },
395
415
    { .name = "debug", .key = 132,
396
416
      .doc = "Debug mode", .group = 4 },
 
417
    /*
 
418
     * These reproduce what we would get without ARGP_NO_HELP
 
419
     */
 
420
    { .name = "help", .key = '?',
 
421
      .doc = "Give this help list", .group = -1 },
 
422
    { .name = "usage", .key = -3,
 
423
      .doc = "Give a short usage message", .group = -1 },
 
424
    { .name = "version", .key = 'V',
 
425
      .doc = "Print program version", .group = -1 },
397
426
    { .name = NULL }
398
427
  };
399
428
  
400
 
  error_t parse_opt(int key, char *arg, __attribute__((unused))
401
 
                    struct argp_state *state){
 
429
  __attribute__((nonnull(3)))
 
430
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
431
    errno = 0;
402
432
    switch(key){
403
433
      char *tmp;
404
 
      intmax_t tmpmax;
 
434
      intmax_t tmp_id;
405
435
    case 'g':                   /* --global-options */
406
 
      if(arg != NULL){
 
436
      {
407
437
        char *plugin_option;
408
438
        while((plugin_option = strsep(&arg, ",")) != NULL){
409
 
          if(plugin_option[0] == '\0'){
410
 
            continue;
411
 
          }
412
439
          if(not add_argument(getplugin(NULL), plugin_option)){
413
 
            perror("add_argument");
414
 
            return ARGP_ERR_UNKNOWN;
 
440
            break;
415
441
          }
416
442
        }
 
443
        errno = 0;
417
444
      }
418
445
      break;
419
446
    case 'G':                   /* --global-env */
420
 
      if(arg == NULL){
421
 
        break;
422
 
      }
423
 
      if(not add_environment(getplugin(NULL), arg, true)){
424
 
        perror("add_environment");
 
447
      if(add_environment(getplugin(NULL), arg, true)){
 
448
        errno = 0;
425
449
      }
426
450
      break;
427
451
    case 'o':                   /* --options-for */
428
 
      if(arg != NULL){
429
 
        char *plugin_name = strsep(&arg, ":");
430
 
        if(plugin_name[0] == '\0'){
431
 
          break;
432
 
        }
433
 
        char *plugin_option;
434
 
        while((plugin_option = strsep(&arg, ",")) != NULL){
435
 
          if(not add_argument(getplugin(plugin_name), plugin_option)){
436
 
            perror("add_argument");
437
 
            return ARGP_ERR_UNKNOWN;
 
452
      {
 
453
        char *option_list = strchr(arg, ':');
 
454
        if(option_list == NULL){
 
455
          argp_error(state, "No colon in \"%s\"", arg);
 
456
          errno = EINVAL;
 
457
          break;
 
458
        }
 
459
        *option_list = '\0';
 
460
        option_list++;
 
461
        if(arg[0] == '\0'){
 
462
          argp_error(state, "Empty plugin name");
 
463
          errno = EINVAL;
 
464
          break;
 
465
        }
 
466
        char *option;
 
467
        while((option = strsep(&option_list, ",")) != NULL){
 
468
          if(not add_argument(getplugin(arg), option)){
 
469
            break;
438
470
          }
439
471
        }
 
472
        errno = 0;
440
473
      }
441
474
      break;
442
475
    case 'E':                   /* --env-for */
443
 
      if(arg == NULL){
444
 
        break;
445
 
      }
446
476
      {
447
477
        char *envdef = strchr(arg, ':');
448
478
        if(envdef == NULL){
 
479
          argp_error(state, "No colon in \"%s\"", arg);
 
480
          errno = EINVAL;
449
481
          break;
450
482
        }
451
483
        *envdef = '\0';
452
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
453
 
          perror("add_environment");
 
484
        envdef++;
 
485
        if(arg[0] == '\0'){
 
486
          argp_error(state, "Empty plugin name");
 
487
          errno = EINVAL;
 
488
          break;
 
489
        }
 
490
        if(add_environment(getplugin(arg), envdef, true)){
 
491
          errno = 0;
454
492
        }
455
493
      }
456
494
      break;
457
495
    case 'd':                   /* --disable */
458
 
      if(arg != NULL){
 
496
      {
459
497
        plugin *p = getplugin(arg);
460
 
        if(p == NULL){
461
 
          return ARGP_ERR_UNKNOWN;
 
498
        if(p != NULL){
 
499
          p->disabled = true;
 
500
          errno = 0;
462
501
        }
463
 
        p->disabled = true;
464
502
      }
465
503
      break;
466
504
    case 'e':                   /* --enable */
467
 
      if(arg != NULL){
 
505
      {
468
506
        plugin *p = getplugin(arg);
469
 
        if(p == NULL){
470
 
          return ARGP_ERR_UNKNOWN;
 
507
        if(p != NULL){
 
508
          p->disabled = false;
 
509
          errno = 0;
471
510
        }
472
 
        p->disabled = false;
473
511
      }
474
512
      break;
475
513
    case 128:                   /* --plugin-dir */
476
514
      free(plugindir);
477
515
      plugindir = strdup(arg);
478
 
      if(plugindir == NULL){
479
 
        perror("strdup");
 
516
      if(plugindir != NULL){
 
517
        errno = 0;
480
518
      }
481
519
      break;
482
520
    case 129:                   /* --config-file */
483
521
      /* This is already done by parse_opt_config_file() */
484
522
      break;
485
523
    case 130:                   /* --userid */
486
 
      errno = 0;
487
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
524
      tmp_id = strtoimax(arg, &tmp, 10);
488
525
      if(errno != 0 or tmp == arg or *tmp != '\0'
489
 
         or tmpmax != (uid_t)tmpmax){
490
 
        fprintf(stderr, "Bad user ID number: \"%s\", using %"
491
 
                PRIdMAX "\n", arg, (intmax_t)uid);
492
 
      } else {
493
 
        uid = (uid_t)tmpmax;
 
526
         or tmp_id != (uid_t)tmp_id){
 
527
        argp_error(state, "Bad user ID number: \"%s\", using %"
 
528
                   PRIdMAX, arg, (intmax_t)uid);
 
529
        break;
494
530
      }
 
531
      uid = (uid_t)tmp_id;
 
532
      errno = 0;
495
533
      break;
496
534
    case 131:                   /* --groupid */
497
 
      errno = 0;
498
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
535
      tmp_id = strtoimax(arg, &tmp, 10);
499
536
      if(errno != 0 or tmp == arg or *tmp != '\0'
500
 
         or tmpmax != (gid_t)tmpmax){
501
 
        fprintf(stderr, "Bad group ID number: \"%s\", using %"
502
 
                PRIdMAX "\n", arg, (intmax_t)gid);
503
 
      } else {
504
 
        gid = (gid_t)tmpmax;
 
537
         or tmp_id != (gid_t)tmp_id){
 
538
        argp_error(state, "Bad group ID number: \"%s\", using %"
 
539
                   PRIdMAX, arg, (intmax_t)gid);
 
540
        break;
505
541
      }
 
542
      gid = (gid_t)tmp_id;
 
543
      errno = 0;
506
544
      break;
507
545
    case 132:                   /* --debug */
508
546
      debug = true;
509
547
      break;
 
548
      /*
 
549
       * These reproduce what we would get without ARGP_NO_HELP
 
550
       */
 
551
    case '?':                   /* --help */
 
552
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
553
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
554
    case -3:                    /* --usage */
 
555
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
556
      argp_state_help(state, state->out_stream,
 
557
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
558
    case 'V':                   /* --version */
 
559
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
560
      exit(EXIT_SUCCESS);
 
561
      break;
510
562
/*
511
563
 * When adding more options before this line, remember to also add a
512
564
 * "case" to the "parse_opt_config_file" function below.
515
567
      /* Cryptsetup always passes an argument, which is an empty
516
568
         string if "none" was specified in /etc/crypttab.  So if
517
569
         argument was empty, we ignore it silently. */
518
 
      if(arg[0] != '\0'){
519
 
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
570
      if(arg[0] == '\0'){
 
571
        break;
520
572
      }
521
 
      break;
522
 
    case ARGP_KEY_END:
523
 
      break;
524
573
    default:
525
574
      return ARGP_ERR_UNKNOWN;
526
575
    }
527
 
    return 0;
 
576
    return errno;               /* Set to 0 at start */
528
577
  }
529
578
  
530
579
  /* This option parser is the same as parse_opt() above, except it
532
581
  error_t parse_opt_config_file(int key, char *arg,
533
582
                                __attribute__((unused))
534
583
                                struct argp_state *state){
 
584
    errno = 0;
535
585
    switch(key){
536
586
    case 'g':                   /* --global-options */
537
587
    case 'G':                   /* --global-env */
544
594
    case 129:                   /* --config-file */
545
595
      free(argfile);
546
596
      argfile = strdup(arg);
547
 
      if(argfile == NULL){
548
 
        perror("strdup");
 
597
      if(argfile != NULL){
 
598
        errno = 0;
549
599
      }
550
600
      break;
551
601
    case 130:                   /* --userid */
552
602
    case 131:                   /* --groupid */
553
603
    case 132:                   /* --debug */
 
604
    case '?':                   /* --help */
 
605
    case -3:                    /* --usage */
 
606
    case 'V':                   /* --version */
554
607
    case ARGP_KEY_ARG:
555
 
    case ARGP_KEY_END:
556
608
      break;
557
609
    default:
558
610
      return ARGP_ERR_UNKNOWN;
559
611
    }
560
 
    return 0;
 
612
    return errno;
561
613
  }
562
614
  
563
615
  struct argp argp = { .options = options,
567
619
  
568
620
  /* Parse using parse_opt_config_file() in order to get the custom
569
621
     config file location, if any. */
570
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
571
 
  if(ret == ARGP_ERR_UNKNOWN){
572
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
573
 
    exitstatus = EXIT_FAILURE;
 
622
  ret = argp_parse(&argp, argc, argv,
 
623
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
624
                   NULL, NULL);
 
625
  switch(ret){
 
626
  case 0:
 
627
    break;
 
628
  case ENOMEM:
 
629
  default:
 
630
    errno = ret;
 
631
    error(0, errno, "argp_parse");
 
632
    exitstatus = EX_OSERR;
 
633
    goto fallback;
 
634
  case EINVAL:
 
635
    exitstatus = EX_USAGE;
574
636
    goto fallback;
575
637
  }
576
638
  
593
655
    custom_argc = 1;
594
656
    custom_argv = malloc(sizeof(char*) * 2);
595
657
    if(custom_argv == NULL){
596
 
      perror("malloc");
597
 
      exitstatus = EXIT_FAILURE;
 
658
      error(0, errno, "malloc");
 
659
      exitstatus = EX_OSERR;
598
660
      goto fallback;
599
661
    }
600
662
    custom_argv[0] = argv[0];
616
678
        }
617
679
        new_arg = strdup(p);
618
680
        if(new_arg == NULL){
619
 
          perror("strdup");
620
 
          exitstatus = EXIT_FAILURE;
 
681
          error(0, errno, "strdup");
 
682
          exitstatus = EX_OSERR;
621
683
          free(org_line);
622
684
          goto fallback;
623
685
        }
624
686
        
625
687
        custom_argc += 1;
626
 
        custom_argv = realloc(custom_argv, sizeof(char *)
627
 
                              * ((unsigned int) custom_argc + 1));
628
 
        if(custom_argv == NULL){
629
 
          perror("realloc");
630
 
          exitstatus = EXIT_FAILURE;
631
 
          free(org_line);
632
 
          goto fallback;
 
688
        {
 
689
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
690
                                    * ((unsigned int)
 
691
                                       custom_argc + 1));
 
692
          if(new_argv == NULL){
 
693
            error(0, errno, "realloc");
 
694
            exitstatus = EX_OSERR;
 
695
            free(new_arg);
 
696
            free(org_line);
 
697
            goto fallback;
 
698
          } else {
 
699
            custom_argv = new_argv;
 
700
          }
633
701
        }
634
702
        custom_argv[custom_argc-1] = new_arg;
635
703
        custom_argv[custom_argc] = NULL;
639
707
      ret = fclose(conffp);
640
708
    } while(ret == EOF and errno == EINTR);
641
709
    if(ret == EOF){
642
 
      perror("fclose");
643
 
      exitstatus = EXIT_FAILURE;
 
710
      error(0, errno, "fclose");
 
711
      exitstatus = EX_IOERR;
644
712
      goto fallback;
645
713
    }
646
714
    free(org_line);
648
716
    /* Check for harmful errors and go to fallback. Other errors might
649
717
       not affect opening plugins */
650
718
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
651
 
      perror("fopen");
652
 
      exitstatus = EXIT_FAILURE;
 
719
      error(0, errno, "fopen");
 
720
      exitstatus = EX_OSERR;
653
721
      goto fallback;
654
722
    }
655
723
  }
656
 
  /* If there was any arguments from configuration file,
657
 
     pass them to parser as command arguments */
 
724
  /* If there were any arguments from the configuration file, pass
 
725
     them to parser as command line arguments */
658
726
  if(custom_argv != NULL){
659
 
    ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
660
 
                     0, NULL);
661
 
    if(ret == ARGP_ERR_UNKNOWN){
662
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
663
 
      exitstatus = EXIT_FAILURE;
 
727
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
728
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
729
                     NULL, NULL);
 
730
    switch(ret){
 
731
    case 0:
 
732
      break;
 
733
    case ENOMEM:
 
734
    default:
 
735
      errno = ret;
 
736
      error(0, errno, "argp_parse");
 
737
      exitstatus = EX_OSERR;
 
738
      goto fallback;
 
739
    case EINVAL:
 
740
      exitstatus = EX_CONFIG;
664
741
      goto fallback;
665
742
    }
666
743
  }
667
744
  
668
745
  /* Parse actual command line arguments, to let them override the
669
746
     config file */
670
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
671
 
  if(ret == ARGP_ERR_UNKNOWN){
672
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
673
 
    exitstatus = EXIT_FAILURE;
 
747
  ret = argp_parse(&argp, argc, argv,
 
748
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
749
                   NULL, NULL);
 
750
  switch(ret){
 
751
  case 0:
 
752
    break;
 
753
  case ENOMEM:
 
754
  default:
 
755
    errno = ret;
 
756
    error(0, errno, "argp_parse");
 
757
    exitstatus = EX_OSERR;
 
758
    goto fallback;
 
759
  case EINVAL:
 
760
    exitstatus = EX_USAGE;
674
761
    goto fallback;
675
762
  }
676
763
  
688
775
    }
689
776
  }
690
777
  
691
 
  /* Strip permissions down to nobody */
692
 
  setgid(gid);
 
778
  if(getuid() == 0){
 
779
    /* Work around Debian bug #633582:
 
780
       <http://bugs.debian.org/633582> */
 
781
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
782
    if(plugindir_fd == -1){
 
783
      if(errno != ENOENT){
 
784
        error(0, errno, "open(\"" PDIR "\")");
 
785
      }
 
786
    } else {
 
787
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
788
      if(ret == -1){
 
789
        error(0, errno, "fstat");
 
790
      } else {
 
791
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
792
          ret = fchown(plugindir_fd, uid, gid);
 
793
          if(ret == -1){
 
794
            error(0, errno, "fchown");
 
795
          }
 
796
        }
 
797
      }
 
798
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
799
    }
 
800
  }
 
801
  
 
802
  /* Lower permissions */
 
803
  ret = setgid(gid);
693
804
  if(ret == -1){
694
 
    perror("setgid");
 
805
    error(0, errno, "setgid");
695
806
  }
696
807
  ret = setuid(uid);
697
808
  if(ret == -1){
698
 
    perror("setuid");
 
809
    error(0, errno, "setuid");
699
810
  }
700
811
  
701
812
  /* Open plugin directory with close_on_exec flag */
702
813
  {
703
 
    int dir_fd = -1;
704
 
    if(plugindir == NULL){
705
 
      dir_fd = open(PDIR, O_RDONLY |
706
 
#ifdef O_CLOEXEC
707
 
                    O_CLOEXEC
708
 
#else  /* not O_CLOEXEC */
709
 
                    0
710
 
#endif  /* not O_CLOEXEC */
711
 
                    );
712
 
    } else {
713
 
      dir_fd = open(plugindir, O_RDONLY |
714
 
#ifdef O_CLOEXEC
715
 
                    O_CLOEXEC
716
 
#else  /* not O_CLOEXEC */
717
 
                    0
718
 
#endif  /* not O_CLOEXEC */
719
 
                    );
720
 
    }
 
814
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
815
#ifdef O_CLOEXEC
 
816
                  O_CLOEXEC
 
817
#else  /* not O_CLOEXEC */
 
818
                  0
 
819
#endif  /* not O_CLOEXEC */
 
820
                  );
721
821
    if(dir_fd == -1){
722
 
      perror("Could not open plugin dir");
723
 
      exitstatus = EXIT_FAILURE;
 
822
      error(0, errno, "Could not open plugin dir");
 
823
      exitstatus = EX_UNAVAILABLE;
724
824
      goto fallback;
725
825
    }
726
826
    
728
828
  /* Set the FD_CLOEXEC flag on the directory */
729
829
    ret = set_cloexec_flag(dir_fd);
730
830
    if(ret < 0){
731
 
      perror("set_cloexec_flag");
732
 
      TEMP_FAILURE_RETRY(close(dir_fd));
733
 
      exitstatus = EXIT_FAILURE;
 
831
      error(0, errno, "set_cloexec_flag");
 
832
      exitstatus = EX_OSERR;
734
833
      goto fallback;
735
834
    }
736
835
#endif  /* O_CLOEXEC */
737
 
    
738
 
    dir = fdopendir(dir_fd);
739
 
    if(dir == NULL){
740
 
      perror("Could not open plugin dir");
741
 
      TEMP_FAILURE_RETRY(close(dir_fd));
742
 
      exitstatus = EXIT_FAILURE;
743
 
      goto fallback;
 
836
  }
 
837
  
 
838
  int good_name(const struct dirent * const dirent){
 
839
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
840
                                      "*.dpkg-old", "*.dpkg-bak",
 
841
                                      "*.dpkg-divert", NULL };
 
842
#ifdef __GNUC__
 
843
#pragma GCC diagnostic push
 
844
#pragma GCC diagnostic ignored "-Wcast-qual"
 
845
#endif
 
846
    for(const char **pat = (const char **)patterns;
 
847
        *pat != NULL; pat++){
 
848
#ifdef __GNUC__
 
849
#pragma GCC diagnostic pop
 
850
#endif
 
851
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
852
         != FNM_NOMATCH){
 
853
        if(debug){
 
854
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
855
                    " matching pattern %s\n", dirent->d_name, *pat);
 
856
        }
 
857
        return 0;
 
858
      }
744
859
    }
 
860
    return 1;
 
861
  }
 
862
  
 
863
#ifdef __GLIBC__
 
864
#if __GLIBC_PREREQ(2, 15)
 
865
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
866
                             alphasort);
 
867
#else  /* not __GLIBC_PREREQ(2, 15) */
 
868
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
869
                           &direntries, good_name, alphasort);
 
870
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
871
#else   /* not __GLIBC__ */
 
872
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
873
                           &direntries, good_name, alphasort);
 
874
#endif  /* not __GLIBC__ */
 
875
  if(numplugins == -1){
 
876
    error(0, errno, "Could not scan plugin dir");
 
877
    direntries = NULL;
 
878
    exitstatus = EX_OSERR;
 
879
    goto fallback;
745
880
  }
746
881
  
747
882
  FD_ZERO(&rfds_all);
748
883
  
749
884
  /* Read and execute any executable in the plugin directory*/
750
 
  while(true){
751
 
    do {
752
 
      dirst = readdir(dir);
753
 
    } while(dirst == NULL and errno == EINTR);
754
 
    
755
 
    /* All directory entries have been processed */
756
 
    if(dirst == NULL){
757
 
      if(errno == EBADF){
758
 
        perror("readdir");
759
 
        exitstatus = EXIT_FAILURE;
760
 
        goto fallback;
761
 
      }
762
 
      break;
763
 
    }
764
 
    
765
 
    d_name_len = strlen(dirst->d_name);
766
 
    
767
 
    /* Ignore dotfiles, backup files and other junk */
768
 
    {
769
 
      bool bad_name = false;
770
 
      
771
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
772
 
      
773
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
774
 
                                           ".dpkg-old",
775
 
                                           ".dpkg-bak",
776
 
                                           ".dpkg-divert", NULL };
777
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
778
 
        size_t pre_len = strlen(*pre);
779
 
        if((d_name_len >= pre_len)
780
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
781
 
          if(debug){
782
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
783
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
784
 
          }
785
 
          bad_name = true;
786
 
          break;
787
 
        }
788
 
      }
789
 
      if(bad_name){
790
 
        continue;
791
 
      }
792
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
793
 
        size_t suf_len = strlen(*suf);
794
 
        if((d_name_len >= suf_len)
795
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
796
 
                == 0)){
797
 
          if(debug){
798
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
799
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
800
 
          }
801
 
          bad_name = true;
802
 
          break;
803
 
        }
804
 
      }
805
 
      
806
 
      if(bad_name){
807
 
        continue;
808
 
      }
809
 
    }
810
 
    
811
 
    char *filename;
812
 
    if(plugindir == NULL){
813
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
814
 
                                             dirst->d_name));
815
 
    } else {
816
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
817
 
                                             plugindir,
818
 
                                             dirst->d_name));
819
 
    }
820
 
    if(ret < 0){
821
 
      perror("asprintf");
 
885
  for(int i = 0; i < numplugins; i++){
 
886
    
 
887
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
888
    if(plugin_fd == -1){
 
889
      error(0, errno, "Could not open plugin");
 
890
      free(direntries[i]);
822
891
      continue;
823
892
    }
824
 
    
825
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
893
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
826
894
    if(ret == -1){
827
 
      perror("stat");
828
 
      free(filename);
 
895
      error(0, errno, "stat");
 
896
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
897
      free(direntries[i]);
829
898
      continue;
830
899
    }
831
900
    
832
901
    /* Ignore non-executable files */
833
902
    if(not S_ISREG(st.st_mode)
834
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
903
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
904
                                        X_OK, 0)) != 0)){
835
905
      if(debug){
836
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
837
 
                " with bad type or mode\n", filename);
 
906
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
907
                " with bad type or mode\n",
 
908
                plugindir != NULL ? plugindir : PDIR,
 
909
                direntries[i]->d_name);
838
910
      }
839
 
      free(filename);
 
911
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
912
      free(direntries[i]);
840
913
      continue;
841
914
    }
842
915
    
843
 
    plugin *p = getplugin(dirst->d_name);
 
916
    plugin *p = getplugin(direntries[i]->d_name);
844
917
    if(p == NULL){
845
 
      perror("getplugin");
846
 
      free(filename);
 
918
      error(0, errno, "getplugin");
 
919
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
920
      free(direntries[i]);
847
921
      continue;
848
922
    }
849
923
    if(p->disabled){
850
924
      if(debug){
851
925
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
852
 
                dirst->d_name);
 
926
                direntries[i]->d_name);
853
927
      }
854
 
      free(filename);
 
928
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
929
      free(direntries[i]);
855
930
      continue;
856
931
    }
857
932
    {
860
935
      if(g != NULL){
861
936
        for(char **a = g->argv + 1; *a != NULL; a++){
862
937
          if(not add_argument(p, *a)){
863
 
            perror("add_argument");
 
938
            error(0, errno, "add_argument");
864
939
          }
865
940
        }
866
941
        /* Add global environment variables */
867
942
        for(char **e = g->environ; *e != NULL; e++){
868
943
          if(not add_environment(p, *e, false)){
869
 
            perror("add_environment");
 
944
            error(0, errno, "add_environment");
870
945
          }
871
946
        }
872
947
      }
873
948
    }
874
 
    /* If this plugin has any environment variables, we will call
875
 
       using execve and need to duplicate the environment from this
876
 
       process, too. */
 
949
    /* If this plugin has any environment variables, we need to
 
950
       duplicate the environment from this process, too. */
877
951
    if(p->environ[0] != NULL){
878
952
      for(char **e = environ; *e != NULL; e++){
879
953
        if(not add_environment(p, *e, false)){
880
 
          perror("add_environment");
 
954
          error(0, errno, "add_environment");
881
955
        }
882
956
      }
883
957
    }
884
958
    
885
959
    int pipefd[2];
 
960
#ifndef O_CLOEXEC
886
961
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
962
#else  /* O_CLOEXEC */
 
963
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
964
#endif  /* O_CLOEXEC */
887
965
    if(ret == -1){
888
 
      perror("pipe");
889
 
      exitstatus = EXIT_FAILURE;
890
 
      goto fallback;
891
 
    }
 
966
      error(0, errno, "pipe");
 
967
      exitstatus = EX_OSERR;
 
968
      free(direntries[i]);
 
969
      goto fallback;
 
970
    }
 
971
    if(pipefd[0] >= FD_SETSIZE){
 
972
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
973
              FD_SETSIZE);
 
974
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
975
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
976
      exitstatus = EX_OSERR;
 
977
      free(direntries[i]);
 
978
      goto fallback;
 
979
    }
 
980
#ifndef O_CLOEXEC
892
981
    /* Ask OS to automatic close the pipe on exec */
893
982
    ret = set_cloexec_flag(pipefd[0]);
894
983
    if(ret < 0){
895
 
      perror("set_cloexec_flag");
896
 
      exitstatus = EXIT_FAILURE;
 
984
      error(0, errno, "set_cloexec_flag");
 
985
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
986
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
987
      exitstatus = EX_OSERR;
 
988
      free(direntries[i]);
897
989
      goto fallback;
898
990
    }
899
991
    ret = set_cloexec_flag(pipefd[1]);
900
992
    if(ret < 0){
901
 
      perror("set_cloexec_flag");
902
 
      exitstatus = EXIT_FAILURE;
 
993
      error(0, errno, "set_cloexec_flag");
 
994
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
995
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
996
      exitstatus = EX_OSERR;
 
997
      free(direntries[i]);
903
998
      goto fallback;
904
999
    }
 
1000
#endif  /* not O_CLOEXEC */
905
1001
    /* Block SIGCHLD until process is safely in process list */
906
1002
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
907
1003
                                              &sigchld_action.sa_mask,
908
1004
                                              NULL));
909
1005
    if(ret < 0){
910
 
      perror("sigprocmask");
911
 
      exitstatus = EXIT_FAILURE;
 
1006
      error(0, errno, "sigprocmask");
 
1007
      exitstatus = EX_OSERR;
 
1008
      free(direntries[i]);
912
1009
      goto fallback;
913
1010
    }
914
1011
    /* Starting a new process to be watched */
917
1014
      pid = fork();
918
1015
    } while(pid == -1 and errno == EINTR);
919
1016
    if(pid == -1){
920
 
      perror("fork");
921
 
      exitstatus = EXIT_FAILURE;
 
1017
      error(0, errno, "fork");
 
1018
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1019
                                     &sigchld_action.sa_mask, NULL));
 
1020
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
1021
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1022
      exitstatus = EX_OSERR;
 
1023
      free(direntries[i]);
922
1024
      goto fallback;
923
1025
    }
924
1026
    if(pid == 0){
925
1027
      /* this is the child process */
926
1028
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
927
1029
      if(ret < 0){
928
 
        perror("sigaction");
929
 
        _exit(EXIT_FAILURE);
 
1030
        error(0, errno, "sigaction");
 
1031
        _exit(EX_OSERR);
930
1032
      }
931
1033
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
932
1034
      if(ret < 0){
933
 
        perror("sigprocmask");
934
 
        _exit(EXIT_FAILURE);
 
1035
        error(0, errno, "sigprocmask");
 
1036
        _exit(EX_OSERR);
935
1037
      }
936
1038
      
937
1039
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
938
1040
      if(ret == -1){
939
 
        perror("dup2");
940
 
        _exit(EXIT_FAILURE);
 
1041
        error(0, errno, "dup2");
 
1042
        _exit(EX_OSERR);
941
1043
      }
942
1044
      
943
 
      if(dirfd(dir) < 0){
944
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
945
 
           above and must now close it manually here. */
946
 
        closedir(dir);
947
 
      }
948
 
      if(p->environ[0] == NULL){
949
 
        if(execv(filename, p->argv) < 0){
950
 
          perror("execv");
951
 
          _exit(EXIT_FAILURE);
952
 
        }
953
 
      } else {
954
 
        if(execve(filename, p->argv, p->environ) < 0){
955
 
          perror("execve");
956
 
          _exit(EXIT_FAILURE);
957
 
        }
 
1045
      if(fexecve(plugin_fd, p->argv,
 
1046
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1047
        error(0, errno, "fexecve for %s/%s",
 
1048
              plugindir != NULL ? plugindir : PDIR,
 
1049
              direntries[i]->d_name);
 
1050
        _exit(EX_OSERR);
958
1051
      }
959
1052
      /* no return */
960
1053
    }
961
1054
    /* Parent process */
962
1055
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
963
1056
                                             pipe */
964
 
    free(filename);
965
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1057
    TEMP_FAILURE_RETRY(close(plugin_fd));
 
1058
    plugin *new_plugin = getplugin(direntries[i]->d_name);
966
1059
    if(new_plugin == NULL){
967
 
      perror("getplugin");
 
1060
      error(0, errno, "getplugin");
968
1061
      ret = (int)(TEMP_FAILURE_RETRY
969
1062
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
970
1063
                               NULL)));
971
1064
      if(ret < 0){
972
 
        perror("sigprocmask");
 
1065
        error(0, errno, "sigprocmask");
973
1066
      }
974
 
      exitstatus = EXIT_FAILURE;
 
1067
      exitstatus = EX_OSERR;
 
1068
      free(direntries[i]);
975
1069
      goto fallback;
976
1070
    }
 
1071
    free(direntries[i]);
977
1072
    
978
1073
    new_plugin->pid = pid;
979
1074
    new_plugin->fd = pipefd[0];
984
1079
                                              &sigchld_action.sa_mask,
985
1080
                                              NULL));
986
1081
    if(ret < 0){
987
 
      perror("sigprocmask");
988
 
      exitstatus = EXIT_FAILURE;
 
1082
      error(0, errno, "sigprocmask");
 
1083
      exitstatus = EX_OSERR;
989
1084
      goto fallback;
990
1085
    }
991
1086
    
 
1087
#if defined (__GNUC__) and defined (__GLIBC__)
 
1088
#if not __GLIBC_PREREQ(2, 16)
 
1089
#pragma GCC diagnostic push
 
1090
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1091
#endif
 
1092
#endif
992
1093
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
993
 
                                          -Wconversion */
 
1094
                                          -Wconversion in GNU libc
 
1095
                                          before 2.16 */
 
1096
#if defined (__GNUC__) and defined (__GLIBC__)
 
1097
#if not __GLIBC_PREREQ(2, 16)
 
1098
#pragma GCC diagnostic pop
 
1099
#endif
 
1100
#endif
994
1101
    
995
1102
    if(maxfd < new_plugin->fd){
996
1103
      maxfd = new_plugin->fd;
997
1104
    }
998
1105
  }
999
1106
  
1000
 
  TEMP_FAILURE_RETRY(closedir(dir));
1001
 
  dir = NULL;
 
1107
  free(direntries);
 
1108
  direntries = NULL;
 
1109
  TEMP_FAILURE_RETRY(close(dir_fd));
 
1110
  dir_fd = -1;
1002
1111
  free_plugin(getplugin(NULL));
1003
1112
  
1004
1113
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1017
1126
    fd_set rfds = rfds_all;
1018
1127
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1019
1128
    if(select_ret == -1 and errno != EINTR){
1020
 
      perror("select");
1021
 
      exitstatus = EXIT_FAILURE;
 
1129
      error(0, errno, "select");
 
1130
      exitstatus = EX_OSERR;
1022
1131
      goto fallback;
1023
1132
    }
1024
1133
    /* OK, now either a process completed, or something can be read
1050
1159
          }
1051
1160
          
1052
1161
          /* Remove the plugin */
 
1162
#if defined (__GNUC__) and defined (__GLIBC__)
 
1163
#if not __GLIBC_PREREQ(2, 16)
 
1164
#pragma GCC diagnostic push
 
1165
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1166
#endif
 
1167
#endif
1053
1168
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1054
 
                                          -Wconversion */
 
1169
                                          -Wconversion in GNU libc
 
1170
                                          before 2.16 */
 
1171
#if defined (__GNUC__) and defined (__GLIBC__)
 
1172
#if not __GLIBC_PREREQ(2, 16)
 
1173
#pragma GCC diagnostic pop
 
1174
#endif
 
1175
#endif
1055
1176
          
1056
1177
          /* Block signal while modifying process_list */
1057
1178
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1059
1180
                                         &sigchld_action.sa_mask,
1060
1181
                                         NULL));
1061
1182
          if(ret < 0){
1062
 
            perror("sigprocmask");
1063
 
            exitstatus = EXIT_FAILURE;
 
1183
            error(0, errno, "sigprocmask");
 
1184
            exitstatus = EX_OSERR;
1064
1185
            goto fallback;
1065
1186
          }
1066
1187
          
1073
1194
                      (sigprocmask(SIG_UNBLOCK,
1074
1195
                                   &sigchld_action.sa_mask, NULL)));
1075
1196
          if(ret < 0){
1076
 
            perror("sigprocmask");
1077
 
            exitstatus = EXIT_FAILURE;
 
1197
            error(0, errno, "sigprocmask");
 
1198
            exitstatus = EX_OSERR;
1078
1199
            goto fallback;
1079
1200
          }
1080
1201
          
1090
1211
        bool bret = print_out_password(proc->buffer,
1091
1212
                                       proc->buffer_length);
1092
1213
        if(not bret){
1093
 
          perror("print_out_password");
1094
 
          exitstatus = EXIT_FAILURE;
 
1214
          error(0, errno, "print_out_password");
 
1215
          exitstatus = EX_IOERR;
1095
1216
        }
1096
1217
        goto fallback;
1097
1218
      }
1098
1219
      
1099
1220
      /* This process has not completed.  Does it have any output? */
 
1221
#if defined (__GNUC__) and defined (__GLIBC__)
 
1222
#if not __GLIBC_PREREQ(2, 16)
 
1223
#pragma GCC diagnostic push
 
1224
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1225
#endif
 
1226
#endif
1100
1227
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1101
1228
                                                         warning from
1102
 
                                                         -Wconversion */
 
1229
                                                         -Wconversion
 
1230
                                                         in GNU libc
 
1231
                                                         before
 
1232
                                                         2.16 */
 
1233
#if defined (__GNUC__) and defined (__GLIBC__)
 
1234
#if not __GLIBC_PREREQ(2, 16)
 
1235
#pragma GCC diagnostic pop
 
1236
#endif
 
1237
#endif
1103
1238
        /* This process had nothing to say at this time */
1104
1239
        proc = proc->next;
1105
1240
        continue;
1106
1241
      }
1107
1242
      /* Before reading, make the process' data buffer large enough */
1108
1243
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1109
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1110
 
                               + (size_t) BUFFER_SIZE);
1111
 
        if(proc->buffer == NULL){
1112
 
          perror("malloc");
1113
 
          exitstatus = EXIT_FAILURE;
 
1244
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1245
                                   + (size_t) BUFFER_SIZE);
 
1246
        if(new_buffer == NULL){
 
1247
          error(0, errno, "malloc");
 
1248
          exitstatus = EX_OSERR;
1114
1249
          goto fallback;
1115
1250
        }
 
1251
        proc->buffer = new_buffer;
1116
1252
        proc->buffer_size += BUFFER_SIZE;
1117
1253
      }
1118
1254
      /* Read from the process */
1137
1273
  
1138
1274
 fallback:
1139
1275
  
1140
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1276
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1277
                             and exitstatus != EX_OK)){
1141
1278
    /* Fallback if all plugins failed, none are found or an error
1142
1279
       occured */
1143
1280
    bool bret;
1151
1288
    }
1152
1289
    bret = print_out_password(passwordbuffer, len);
1153
1290
    if(not bret){
1154
 
      perror("print_out_password");
1155
 
      exitstatus = EXIT_FAILURE;
 
1291
      error(0, errno, "print_out_password");
 
1292
      exitstatus = EX_IOERR;
1156
1293
    }
1157
1294
  }
1158
1295
  
1159
1296
  /* Restore old signal handler */
1160
1297
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1161
1298
  if(ret == -1){
1162
 
    perror("sigaction");
1163
 
    exitstatus = EXIT_FAILURE;
 
1299
    error(0, errno, "sigaction");
 
1300
    exitstatus = EX_OSERR;
1164
1301
  }
1165
1302
  
1166
1303
  if(custom_argv != NULL){
1170
1307
    free(custom_argv);
1171
1308
  }
1172
1309
  
1173
 
  if(dir != NULL){
1174
 
    closedir(dir);
 
1310
  free(direntries);
 
1311
  
 
1312
  if(dir_fd != -1){
 
1313
    TEMP_FAILURE_RETRY(close(dir_fd));
1175
1314
  }
1176
1315
  
1177
1316
  /* Kill the processes */
1181
1320
      ret = kill(p->pid, SIGTERM);
1182
1321
      if(ret == -1 and errno != ESRCH){
1183
1322
        /* Set-uid proccesses might not get closed */
1184
 
        perror("kill");
 
1323
        error(0, errno, "kill");
1185
1324
      }
1186
1325
    }
1187
1326
  }
1191
1330
    ret = wait(NULL);
1192
1331
  } while(ret >= 0);
1193
1332
  if(errno != ECHILD){
1194
 
    perror("wait");
 
1333
    error(0, errno, "wait");
1195
1334
  }
1196
1335
  
1197
1336
  free_plugin_list();