/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-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

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

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

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

Show diffs side-by-side

added added

removed removed

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