/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: 2016-03-17 20:40:55 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 341.
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

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