/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2015-01-25 00:02:51 UTC
  • Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.

Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).

Show diffs side-by-side

added added

removed removed

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