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

  • Committer: Teddy Hogeborn
  • Date: 2015-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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