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