/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: 2019-08-05 21:14:05 UTC
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

Show diffs side-by-side

added added

removed removed

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