/mandos/release

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2024-09-09 01:36:41 UTC
  • mto: This revision was merged to the branch mainline in revision 410.
  • Revision ID: teddy@recompile.se-20240909013641-6zu6kx2f7meu134k
Make all required directories when installing

When installing into a normal system, one can assume that target
directories, such as /usr/bin, already exists.  But when installing
into a subdirectory for the purpose of creating a package, one cannot
assume that all directories already exist.  Therefore, when
installing, we must not check if any directories exist, and must
instead always create any directories we want to install into.

* Makefile (confdir/mandos.conf, confdir/clients.conf, install-html):
  Use the "-D" option to "install" instead of creating the directory
  separately.
  (install-server): Move creation of $(CONFDIR) down to before it is
  needed.  Don't check if the $(TMPFILES) or $(SYSUSERS) directories
  exist; instead create them by using the "-D" option to "install".
  Create the $(PREFIX)/sbin directory.  Always use
  "--target-directory" if possible; i.e. if the file name is the same.
  Create the $(DBUSPOLICYDIR) and $(DESTDIR)/etc/init.d directories by
  using the "-D" option to "install".  Don't check if the $(SYSTEMD)
  directory exists; instead create it by using the "-D" option to
  "install".  Create the $(DESTDIR)/etc/default and $(MANDIR)/man8
  directories by using the "-D" option to "install".  Create the
  $(MANDIR)/man5 directories explicitly.
  (install-client-nokey): Remove unnecessary creation of the
  $(CONFDIR) directory.  Don't check if the $(SYSUSERS) directory
  exists; instead create it by using the "-D" option to "install".
  Move the "--directory" argument to be the first argument, for
  clarity.  Create the $(PREFIX)/sbin directory.  Use the "-D"
  argument to "install" when installing
  $(INITRAMFSTOOLS)/hooks/mandos,
  $(INITRAMFSTOOLS)/conf.d/mandos-conf,
  $(INITRAMFSTOOLS)/conf-hooks.d/zz-mandos,
  $(INITRAMFSTOOLS)/scripts/init-premount/mandos,
  $(INITRAMFSTOOLS)/scripts/local-premount/mandos,
  $(DRACUTMODULE)/ask-password-mandos.path, and
  $(DRACUTMODULE)/dracut-module/ask-password-mandos.service.  Create
  the $(MANDIR)/man8 directory.

Reported-By: Erich Eckner <erich@eckner.net>
Thanks: Erich Eckner <erich@eckner.net> for analysis

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-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2022 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
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
27
                                   getline(), asprintf(), O_CLOEXEC,
 
28
                                   scandirat(), pipe2() */
 
29
#include <argp.h>               /* argp_program_version,
 
30
                                   argp_program_bug_address,
 
31
                                   struct argp_option,
 
32
                                   struct argp_state, argp_error(),
 
33
                                   ARGP_NO_EXIT, argp_state_help,
 
34
                                   ARGP_HELP_STD_HELP,
 
35
                                   ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
 
36
                                   ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
 
37
                                   struct argp, argp_parse(),
 
38
                                   ARGP_IN_ORDER, ARGP_NO_HELP */
 
39
#include <stdbool.h>            /* bool, false, true */
 
40
#include <sys/types.h>          /* pid_t, sig_atomic_t, uid_t, gid_t,
 
41
                                   getuid(), setgid(), setuid() */
27
42
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
29
 
                                   EXIT_SUCCESS, realloc() */
30
 
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
38
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
44
 
#include <iso646.h>             /* and, or, not */
45
 
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
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() */
 
43
#include <iso646.h>             /* or, and, not */
 
44
#include <string.h>             /* strcmp(), strdup(), strchrnul(),
 
45
                                   strncmp(), strlen(), strcpy(),
 
46
                                   strsep(), strchr(), strsignal() */
 
47
#include <stdlib.h>             /* malloc(), free(), reallocarray(),
 
48
                                   realloc(), EXIT_SUCCESS */
 
49
#include <errno.h>              /* errno, EINTR, ENOMEM, ECHILD,
 
50
                                   error_t, EINVAL, EMFILE, ENFILE,
 
51
                                   ENOENT, ESRCH */
 
52
#include <stdint.h>             /* SIZE_MAX */
 
53
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
54
                                   getline(), asprintf(), O_CLOEXEC,
 
55
                                   scandirat(), pipe2() */
 
56
#include <unistd.h>             /* TEMP_FAILURE_RETRY(), ssize_t,
 
57
                                   write(), STDOUT_FILENO, uid_t,
 
58
                                   gid_t, getuid(), fchown(), close(),
 
59
                                   symlink(), setgid(), setuid(),
 
60
                                   faccessat(), X_OK, pipe(), pipe2(),
 
61
                                   fork(), _exit(), dup2(), fexecve(),
 
62
                                   read(), getpass() */
54
63
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal() */
58
 
#include <errno.h>              /* errno */
59
 
#include <argp.h>               /* struct argp_option, struct
60
 
                                   argp_state, struct argp,
61
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
62
 
                                   ARGP_KEY_END, ARGP_KEY_ARG,
63
 
                                   error_t */
64
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
65
 
                                   sigaddset(), sigaction(),
66
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
67
 
                                   SIG_UNBLOCK, kill(), sig_atomic_t
68
 
                                */
69
 
#include <errno.h>              /* errno, EBADF */
70
 
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
71
 
#include <sysexits.h>           /* EX_OSERR, EX_USAGE */
 
64
                                   FD_CLOEXEC, open(), O_RDONLY,
 
65
                                   O_CLOEXEC, openat() */
 
66
#include <sys/wait.h>           /* waitpid(), WNOHANG, WIFEXITED(),
 
67
                                   WEXITSTATUS(), WIFSIGNALED(),
 
68
                                   WTERMSIG(), wait() */
 
69
#include <error.h>              /* error() */
 
70
#include <stdio.h>              /* FILE, fprintf(), fopen(),
 
71
                                   getline(), fclose(), EOF,
 
72
                                   asprintf(), stderr */
 
73
#include <dirent.h>             /* struct dirent, scandirat(),
 
74
                                   alphasort() */
 
75
#include <sys/stat.h>           /* struct stat, fstat(), S_ISDIR(),
 
76
                                   lstat(), S_ISREG() */
 
77
#include <sys/select.h>         /* fd_set, FD_ZERO(), FD_SETSIZE,
 
78
                                   FD_SET(), select(), FD_CLR(),
 
79
                                   FD_ISSET() */
 
80
#include <signal.h>             /* struct sigaction, SA_NOCLDSTOP,
 
81
                                   sigemptyset(), sigaddset(),
 
82
                                   SIGCHLD, sigprocmask(), SIG_BLOCK,
 
83
                                   SIG_UNBLOCK, kill(), SIGTERM */
 
84
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
 
85
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
86
#include <inttypes.h>           /* intmax_t, strtoimax(), PRIdMAX */
 
87
#include <fnmatch.h>            /* fnmatch(), FNM_FILE_NAME,
 
88
                                   FNM_PERIOD, FNM_NOMATCH */
72
89
 
73
90
#define BUFFER_SIZE 256
74
91
 
75
92
#define PDIR "/lib/mandos/plugins.d"
 
93
#define PHDIR "/lib/mandos/plugin-helpers"
76
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
77
95
 
78
96
const char *argp_program_version = "plugin-runner " VERSION;
79
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
80
98
 
81
99
typedef struct plugin{
82
100
  char *name;                   /* can be NULL or any plugin name */
102
120
 
103
121
/* Gets an existing plugin based on name,
104
122
   or if none is found, creates a new one */
 
123
__attribute__((warn_unused_result))
105
124
static plugin *getplugin(char *name){
106
125
  /* Check for existing plugin with that name */
107
126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
168
187
}
169
188
 
170
189
/* Helper function for add_argument and add_environment */
 
190
__attribute__((nonnull, warn_unused_result))
171
191
static bool add_to_char_array(const char *new, char ***array,
172
192
                              int *len){
173
193
  /* Resize the pointed-to array to hold one more pointer */
 
194
  char **new_array = NULL;
174
195
  do {
175
 
    *array = realloc(*array, sizeof(char *)
176
 
                     * (size_t) ((*len) + 2));
177
 
  } while(*array == NULL and errno == EINTR);
 
196
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
197
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
198
                             sizeof(char *));
 
199
#else
 
200
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
201
      /* overflow */
 
202
      new_array = NULL;
 
203
      errno = ENOMEM;
 
204
    } else {
 
205
      new_array = realloc(*array, (size_t)((*len) + 2)
 
206
                          * sizeof(char *));
 
207
    }
 
208
#endif
 
209
  } while(new_array == NULL and errno == EINTR);
178
210
  /* Malloc check */
179
 
  if(*array == NULL){
 
211
  if(new_array == NULL){
180
212
    return false;
181
213
  }
 
214
  *array = new_array;
182
215
  /* Make a copy of the new string */
183
216
  char *copy;
184
217
  do {
196
229
}
197
230
 
198
231
/* Add to a plugin's argument vector */
 
232
__attribute__((nonnull(2), warn_unused_result))
199
233
static bool add_argument(plugin *p, const char *arg){
200
234
  if(p == NULL){
201
235
    return false;
204
238
}
205
239
 
206
240
/* Add to a plugin's environment */
 
241
__attribute__((nonnull(2), warn_unused_result))
207
242
static bool add_environment(plugin *p, const char *def, bool replace){
208
243
  if(p == NULL){
209
244
    return false;
211
246
  /* namelen = length of name of environment variable */
212
247
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
213
248
  /* Search for this environment variable */
214
 
  for(char **e = p->environ; *e != NULL; e++){
215
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
249
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
250
    if(strncmp(*envdef, def, namelen + 1) == 0){
216
251
      /* It already exists */
217
252
      if(replace){
218
 
        char *new;
 
253
        char *new_envdef;
219
254
        do {
220
 
          new = realloc(*e, strlen(def) + 1);
221
 
        } while(new == NULL and errno == EINTR);
222
 
        if(new == NULL){
 
255
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
256
        } while(new_envdef == NULL and errno == EINTR);
 
257
        if(new_envdef == NULL){
223
258
          return false;
224
259
        }
225
 
        *e = new;
226
 
        strcpy(*e, def);
 
260
        *envdef = new_envdef;
 
261
        strcpy(*envdef, def);
227
262
      }
228
263
      return true;
229
264
    }
231
266
  return add_to_char_array(def, &(p->environ), &(p->envc));
232
267
}
233
268
 
 
269
#ifndef O_CLOEXEC
234
270
/*
235
271
 * Based on the example in the GNU LibC manual chapter 13.13 "File
236
272
 * Descriptor Flags".
237
273
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
238
274
 */
 
275
__attribute__((warn_unused_result))
239
276
static int set_cloexec_flag(int fd){
240
277
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
241
278
  /* If reading the flags failed, return error indication now. */
246
283
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
247
284
                                       ret | FD_CLOEXEC));
248
285
}
 
286
#endif  /* not O_CLOEXEC */
249
287
 
250
288
 
251
289
/* Mark processes as completed when they exit, and save their exit
265
303
        /* No child processes */
266
304
        break;
267
305
      }
268
 
      perror("waitpid");
 
306
      error(0, errno, "waitpid");
269
307
    }
270
308
    
271
309
    /* A child exited, find it in process_list */
283
321
}
284
322
 
285
323
/* Prints out a password to stdout */
 
324
__attribute__((nonnull, warn_unused_result))
286
325
static bool print_out_password(const char *buffer, size_t length){
287
326
  ssize_t ret;
288
327
  for(size_t written = 0; written < length; written += (size_t)ret){
296
335
}
297
336
 
298
337
/* Removes and free a plugin from the plugin list */
 
338
__attribute__((nonnull))
299
339
static void free_plugin(plugin *plugin_node){
300
340
  
301
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
302
342
    free(*arg);
303
343
  }
 
344
  free(plugin_node->name);
304
345
  free(plugin_node->argv);
305
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
306
347
    free(*env);
333
374
 
334
375
int main(int argc, char *argv[]){
335
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
336
378
  char *argfile = NULL;
337
379
  FILE *conffp;
338
 
  size_t d_name_len;
339
 
  DIR *dir = NULL;
340
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
341
381
  struct stat st;
342
382
  fd_set rfds_all;
343
383
  int ret, maxfd = 0;
351
391
                                      .sa_flags = SA_NOCLDSTOP };
352
392
  char **custom_argv = NULL;
353
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
354
395
  
355
396
  /* Establish a signal handler */
356
397
  sigemptyset(&sigchld_action.sa_mask);
357
398
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
358
399
  if(ret == -1){
359
 
    perror("sigaddset");
360
 
    exitstatus = EXIT_FAILURE;
 
400
    error(0, errno, "sigaddset");
 
401
    exitstatus = EX_OSERR;
361
402
    goto fallback;
362
403
  }
363
404
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
364
405
  if(ret == -1){
365
 
    perror("sigaction");
366
 
    exitstatus = EXIT_FAILURE;
 
406
    error(0, errno, "sigaction");
 
407
    exitstatus = EX_OSERR;
367
408
    goto fallback;
368
409
  }
369
410
  
401
442
      .doc = "Group ID the plugins will run as", .group = 3 },
402
443
    { .name = "debug", .key = 132,
403
444
      .doc = "Debug mode", .group = 4 },
 
445
    { .name = "plugin-helper-dir", .key = 133,
 
446
      .arg = "DIRECTORY",
 
447
      .doc = "Specify a different plugin helper directory",
 
448
      .group = 2 },
404
449
    /*
405
450
     * These reproduce what we would get without ARGP_NO_HELP
406
451
     */
413
458
    { .name = NULL }
414
459
  };
415
460
  
 
461
  __attribute__((nonnull(3)))
416
462
  error_t parse_opt(int key, char *arg, struct argp_state *state){
417
463
    errno = 0;
418
464
    switch(key){
419
465
      char *tmp;
420
 
      intmax_t tmpmax;
 
466
      intmax_t tmp_id;
421
467
    case 'g':                   /* --global-options */
422
468
      {
423
469
        char *plugin_option;
426
472
            break;
427
473
          }
428
474
        }
 
475
        errno = 0;
429
476
      }
430
477
      break;
431
478
    case 'G':                   /* --global-env */
432
 
      add_environment(getplugin(NULL), arg, true);
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
 
481
      }
433
482
      break;
434
483
    case 'o':                   /* --options-for */
435
484
      {
452
501
            break;
453
502
          }
454
503
        }
 
504
        errno = 0;
455
505
      }
456
506
      break;
457
507
    case 'E':                   /* --env-for */
469
519
          errno = EINVAL;
470
520
          break;
471
521
        }
472
 
        add_environment(getplugin(arg), envdef, true);
 
522
        if(add_environment(getplugin(arg), envdef, true)){
 
523
          errno = 0;
 
524
        }
473
525
      }
474
526
      break;
475
527
    case 'd':                   /* --disable */
477
529
        plugin *p = getplugin(arg);
478
530
        if(p != NULL){
479
531
          p->disabled = true;
 
532
          errno = 0;
480
533
        }
481
534
      }
482
535
      break;
485
538
        plugin *p = getplugin(arg);
486
539
        if(p != NULL){
487
540
          p->disabled = false;
 
541
          errno = 0;
488
542
        }
489
543
      }
490
544
      break;
491
545
    case 128:                   /* --plugin-dir */
492
546
      free(plugindir);
493
547
      plugindir = strdup(arg);
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
494
551
      break;
495
552
    case 129:                   /* --config-file */
496
553
      /* This is already done by parse_opt_config_file() */
497
554
      break;
498
555
    case 130:                   /* --userid */
499
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
556
      tmp_id = strtoimax(arg, &tmp, 10);
500
557
      if(errno != 0 or tmp == arg or *tmp != '\0'
501
 
         or tmpmax != (uid_t)tmpmax){
 
558
         or tmp_id != (uid_t)tmp_id){
502
559
        argp_error(state, "Bad user ID number: \"%s\", using %"
503
560
                   PRIdMAX, arg, (intmax_t)uid);
504
561
        break;
505
562
      }
506
 
      uid = (uid_t)tmpmax;
 
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
507
565
      break;
508
566
    case 131:                   /* --groupid */
509
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
567
      tmp_id = strtoimax(arg, &tmp, 10);
510
568
      if(errno != 0 or tmp == arg or *tmp != '\0'
511
 
         or tmpmax != (gid_t)tmpmax){
 
569
         or tmp_id != (gid_t)tmp_id){
512
570
        argp_error(state, "Bad group ID number: \"%s\", using %"
513
571
                   PRIdMAX, arg, (intmax_t)gid);
514
572
        break;
515
573
      }
516
 
      gid = (gid_t)tmpmax;
 
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
517
576
      break;
518
577
    case 132:                   /* --debug */
519
578
      debug = true;
520
579
      break;
 
580
    case 133:                   /* --plugin-helper-dir */
 
581
      free(pluginhelperdir);
 
582
      pluginhelperdir = strdup(arg);
 
583
      if(pluginhelperdir != NULL){
 
584
        errno = 0;
 
585
      }
 
586
      break;
521
587
      /*
522
588
       * These reproduce what we would get without ARGP_NO_HELP
523
589
       */
524
590
    case '?':                   /* --help */
525
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
526
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
527
594
    case -3:                    /* --usage */
528
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
596
      argp_state_help(state, state->out_stream,
530
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
531
599
    case 'V':                   /* --version */
532
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
533
601
      exit(EXIT_SUCCESS);
543
611
      if(arg[0] == '\0'){
544
612
        break;
545
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
546
619
    default:
547
620
      return ARGP_ERR_UNKNOWN;
548
621
    }
567
640
    case 129:                   /* --config-file */
568
641
      free(argfile);
569
642
      argfile = strdup(arg);
 
643
      if(argfile != NULL){
 
644
        errno = 0;
 
645
      }
570
646
      break;
571
647
    case 130:                   /* --userid */
572
648
    case 131:                   /* --groupid */
573
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
574
651
    case '?':                   /* --help */
575
652
    case -3:                    /* --usage */
576
653
    case 'V':                   /* --version */
598
675
  case ENOMEM:
599
676
  default:
600
677
    errno = ret;
601
 
    perror("argp_parse");
 
678
    error(0, errno, "argp_parse");
602
679
    exitstatus = EX_OSERR;
603
680
    goto fallback;
604
681
  case EINVAL:
625
702
    custom_argc = 1;
626
703
    custom_argv = malloc(sizeof(char*) * 2);
627
704
    if(custom_argv == NULL){
628
 
      perror("malloc");
629
 
      exitstatus = EXIT_FAILURE;
 
705
      error(0, errno, "malloc");
 
706
      exitstatus = EX_OSERR;
630
707
      goto fallback;
631
708
    }
632
709
    custom_argv[0] = argv[0];
648
725
        }
649
726
        new_arg = strdup(p);
650
727
        if(new_arg == NULL){
651
 
          perror("strdup");
652
 
          exitstatus = EXIT_FAILURE;
 
728
          error(0, errno, "strdup");
 
729
          exitstatus = EX_OSERR;
653
730
          free(org_line);
654
731
          goto fallback;
655
732
        }
656
733
        
657
734
        custom_argc += 1;
658
 
        custom_argv = realloc(custom_argv, sizeof(char *)
659
 
                              * ((unsigned int) custom_argc + 1));
660
 
        if(custom_argv == NULL){
661
 
          perror("realloc");
662
 
          exitstatus = EXIT_FAILURE;
663
 
          free(org_line);
664
 
          goto fallback;
 
735
        {
 
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
737
          char **new_argv = reallocarray(custom_argv,
 
738
                                         (size_t)custom_argc + 1,
 
739
                                         sizeof(char *));
 
740
#else
 
741
          char **new_argv = NULL;
 
742
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
743
            /* overflow */
 
744
            errno = ENOMEM;
 
745
          } else {
 
746
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
747
                               * sizeof(char *));
 
748
          }
 
749
#endif
 
750
          if(new_argv == NULL){
 
751
            error(0, errno, "reallocarray");
 
752
            exitstatus = EX_OSERR;
 
753
            free(new_arg);
 
754
            free(org_line);
 
755
            goto fallback;
 
756
          } else {
 
757
            custom_argv = new_argv;
 
758
          }
665
759
        }
666
760
        custom_argv[custom_argc-1] = new_arg;
667
761
        custom_argv[custom_argc] = NULL;
671
765
      ret = fclose(conffp);
672
766
    } while(ret == EOF and errno == EINTR);
673
767
    if(ret == EOF){
674
 
      perror("fclose");
675
 
      exitstatus = EXIT_FAILURE;
 
768
      error(0, errno, "fclose");
 
769
      exitstatus = EX_IOERR;
676
770
      goto fallback;
677
771
    }
678
772
    free(org_line);
680
774
    /* Check for harmful errors and go to fallback. Other errors might
681
775
       not affect opening plugins */
682
776
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
683
 
      perror("fopen");
684
 
      exitstatus = EXIT_FAILURE;
 
777
      error(0, errno, "fopen");
 
778
      exitstatus = EX_OSERR;
685
779
      goto fallback;
686
780
    }
687
781
  }
697
791
    case ENOMEM:
698
792
    default:
699
793
      errno = ret;
700
 
      perror("argp_parse");
 
794
      error(0, errno, "argp_parse");
701
795
      exitstatus = EX_OSERR;
702
796
      goto fallback;
703
797
    case EINVAL:
717
811
  case ENOMEM:
718
812
  default:
719
813
    errno = ret;
720
 
    perror("argp_parse");
 
814
    error(0, errno, "argp_parse");
721
815
    exitstatus = EX_OSERR;
722
816
    goto fallback;
723
817
  case EINVAL:
725
819
    goto fallback;
726
820
  }
727
821
  
 
822
  {
 
823
    char *pluginhelperenv;
 
824
    bool bret = true;
 
825
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
826
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
827
    if(ret != -1){
 
828
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
829
    }
 
830
    if(ret == -1 or not bret){
 
831
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
832
            " environment variable to \"%s\" for all plugins\n",
 
833
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
834
    }
 
835
    if(ret != -1){
 
836
      free(pluginhelperenv);
 
837
    }
 
838
  }
 
839
  
728
840
  if(debug){
729
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
841
    for(plugin *p = plugin_list; p != NULL; p = p->next){
730
842
      fprintf(stderr, "Plugin: %s has %d arguments\n",
731
843
              p->name ? p->name : "Global", p->argc - 1);
732
844
      for(char **a = p->argv; *a != NULL; a++){
739
851
    }
740
852
  }
741
853
  
742
 
  /* Strip permissions down to nobody */
743
 
  setgid(gid);
 
854
  if(getuid() == 0){
 
855
    /* Work around Debian bug #633582:
 
856
       <https://bugs.debian.org/633582> */
 
857
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
858
    if(plugindir_fd == -1){
 
859
      if(errno != ENOENT){
 
860
        error(0, errno, "open(\"" PDIR "\")");
 
861
      }
 
862
    } else {
 
863
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
864
      if(ret == -1){
 
865
        error(0, errno, "fstat");
 
866
      } else {
 
867
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
868
          ret = fchown(plugindir_fd, uid, gid);
 
869
          if(ret == -1){
 
870
            error(0, errno, "fchown");
 
871
          }
 
872
        }
 
873
      }
 
874
      close(plugindir_fd);
 
875
    }
 
876
 
 
877
    /* Work around Debian bug #981302
 
878
       <https://bugs.debian.org/981302> */
 
879
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
880
      ret = symlink("/proc/self/fd", "/dev/fd");
 
881
      if(ret == -1){
 
882
        error(0, errno, "Failed to create /dev/fd symlink");
 
883
      }
 
884
    }
 
885
  }
 
886
  
 
887
  /* Lower permissions */
 
888
  ret = setgid(gid);
744
889
  if(ret == -1){
745
 
    perror("setgid");
 
890
    error(0, errno, "setgid");
746
891
  }
747
892
  ret = setuid(uid);
748
893
  if(ret == -1){
749
 
    perror("setuid");
 
894
    error(0, errno, "setuid");
750
895
  }
751
896
  
752
897
  /* Open plugin directory with close_on_exec flag */
753
898
  {
754
 
    int dir_fd = -1;
755
 
    if(plugindir == NULL){
756
 
      dir_fd = open(PDIR, O_RDONLY |
757
 
#ifdef O_CLOEXEC
758
 
                    O_CLOEXEC
759
 
#else  /* not O_CLOEXEC */
760
 
                    0
761
 
#endif  /* not O_CLOEXEC */
762
 
                    );
763
 
    } else {
764
 
      dir_fd = open(plugindir, O_RDONLY |
765
 
#ifdef O_CLOEXEC
766
 
                    O_CLOEXEC
767
 
#else  /* not O_CLOEXEC */
768
 
                    0
769
 
#endif  /* not O_CLOEXEC */
770
 
                    );
771
 
    }
 
899
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
900
#ifdef O_CLOEXEC
 
901
                  O_CLOEXEC
 
902
#else  /* not O_CLOEXEC */
 
903
                  0
 
904
#endif  /* not O_CLOEXEC */
 
905
                  );
772
906
    if(dir_fd == -1){
773
 
      perror("Could not open plugin dir");
774
 
      exitstatus = EXIT_FAILURE;
 
907
      error(0, errno, "Could not open plugin dir");
 
908
      exitstatus = EX_UNAVAILABLE;
775
909
      goto fallback;
776
910
    }
777
911
    
779
913
  /* Set the FD_CLOEXEC flag on the directory */
780
914
    ret = set_cloexec_flag(dir_fd);
781
915
    if(ret < 0){
782
 
      perror("set_cloexec_flag");
783
 
      TEMP_FAILURE_RETRY(close(dir_fd));
784
 
      exitstatus = EXIT_FAILURE;
 
916
      error(0, errno, "set_cloexec_flag");
 
917
      exitstatus = EX_OSERR;
785
918
      goto fallback;
786
919
    }
787
920
#endif  /* O_CLOEXEC */
788
 
    
789
 
    dir = fdopendir(dir_fd);
790
 
    if(dir == NULL){
791
 
      perror("Could not open plugin dir");
792
 
      TEMP_FAILURE_RETRY(close(dir_fd));
793
 
      exitstatus = EXIT_FAILURE;
794
 
      goto fallback;
 
921
  }
 
922
  
 
923
  int good_name(const struct dirent * const dirent){
 
924
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
925
                                      "*.dpkg-old", "*.dpkg-bak",
 
926
                                      "*.dpkg-divert", NULL };
 
927
#ifdef __GNUC__
 
928
#pragma GCC diagnostic push
 
929
#pragma GCC diagnostic ignored "-Wcast-qual"
 
930
#endif
 
931
    for(const char **pat = (const char **)patterns;
 
932
        *pat != NULL; pat++){
 
933
#ifdef __GNUC__
 
934
#pragma GCC diagnostic pop
 
935
#endif
 
936
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
937
         != FNM_NOMATCH){
 
938
        if(debug){
 
939
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
940
                    " matching pattern %s\n", dirent->d_name, *pat);
 
941
        }
 
942
        return 0;
 
943
      }
795
944
    }
 
945
    return 1;
 
946
  }
 
947
  
 
948
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
949
                             alphasort);
 
950
  if(numplugins == -1){
 
951
    error(0, errno, "Could not scan plugin dir");
 
952
    direntries = NULL;
 
953
    exitstatus = EX_OSERR;
 
954
    goto fallback;
796
955
  }
797
956
  
798
957
  FD_ZERO(&rfds_all);
799
958
  
800
959
  /* Read and execute any executable in the plugin directory*/
801
 
  while(true){
802
 
    do {
803
 
      dirst = readdir(dir);
804
 
    } while(dirst == NULL and errno == EINTR);
805
 
    
806
 
    /* All directory entries have been processed */
807
 
    if(dirst == NULL){
808
 
      if(errno == EBADF){
809
 
        perror("readdir");
810
 
        exitstatus = EXIT_FAILURE;
811
 
        goto fallback;
812
 
      }
813
 
      break;
814
 
    }
815
 
    
816
 
    d_name_len = strlen(dirst->d_name);
817
 
    
818
 
    /* Ignore dotfiles, backup files and other junk */
819
 
    {
820
 
      bool bad_name = false;
821
 
      
822
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
823
 
      
824
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
825
 
                                           ".dpkg-old",
826
 
                                           ".dpkg-bak",
827
 
                                           ".dpkg-divert", NULL };
828
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
829
 
        size_t pre_len = strlen(*pre);
830
 
        if((d_name_len >= pre_len)
831
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
832
 
          if(debug){
833
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
834
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
835
 
          }
836
 
          bad_name = true;
837
 
          break;
838
 
        }
839
 
      }
840
 
      if(bad_name){
841
 
        continue;
842
 
      }
843
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
844
 
        size_t suf_len = strlen(*suf);
845
 
        if((d_name_len >= suf_len)
846
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
847
 
                == 0)){
848
 
          if(debug){
849
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
850
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
851
 
          }
852
 
          bad_name = true;
853
 
          break;
854
 
        }
855
 
      }
856
 
      
857
 
      if(bad_name){
858
 
        continue;
859
 
      }
860
 
    }
861
 
    
862
 
    char *filename;
863
 
    if(plugindir == NULL){
864
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
865
 
                                             dirst->d_name));
866
 
    } else {
867
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
868
 
                                             plugindir,
869
 
                                             dirst->d_name));
870
 
    }
871
 
    if(ret < 0){
872
 
      perror("asprintf");
 
960
  for(int i = 0; i < numplugins; i++){
 
961
    
 
962
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
963
    if(plugin_fd == -1){
 
964
      error(0, errno, "Could not open plugin");
 
965
      free(direntries[i]);
873
966
      continue;
874
967
    }
875
 
    
876
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
968
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
877
969
    if(ret == -1){
878
 
      perror("stat");
879
 
      free(filename);
 
970
      error(0, errno, "stat");
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
880
973
      continue;
881
974
    }
882
975
    
883
976
    /* Ignore non-executable files */
884
977
    if(not S_ISREG(st.st_mode)
885
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
978
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
979
                                        X_OK, 0)) != 0)){
886
980
      if(debug){
887
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
888
 
                " with bad type or mode\n", filename);
 
981
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
982
                " with bad type or mode\n",
 
983
                plugindir != NULL ? plugindir : PDIR,
 
984
                direntries[i]->d_name);
889
985
      }
890
 
      free(filename);
 
986
      close(plugin_fd);
 
987
      free(direntries[i]);
891
988
      continue;
892
989
    }
893
990
    
894
 
    plugin *p = getplugin(dirst->d_name);
 
991
    plugin *p = getplugin(direntries[i]->d_name);
895
992
    if(p == NULL){
896
 
      perror("getplugin");
897
 
      free(filename);
 
993
      error(0, errno, "getplugin");
 
994
      close(plugin_fd);
 
995
      free(direntries[i]);
898
996
      continue;
899
997
    }
900
998
    if(p->disabled){
901
999
      if(debug){
902
1000
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
903
 
                dirst->d_name);
 
1001
                direntries[i]->d_name);
904
1002
      }
905
 
      free(filename);
 
1003
      close(plugin_fd);
 
1004
      free(direntries[i]);
906
1005
      continue;
907
1006
    }
908
1007
    {
911
1010
      if(g != NULL){
912
1011
        for(char **a = g->argv + 1; *a != NULL; a++){
913
1012
          if(not add_argument(p, *a)){
914
 
            perror("add_argument");
 
1013
            error(0, errno, "add_argument");
915
1014
          }
916
1015
        }
917
1016
        /* Add global environment variables */
918
1017
        for(char **e = g->environ; *e != NULL; e++){
919
1018
          if(not add_environment(p, *e, false)){
920
 
            perror("add_environment");
 
1019
            error(0, errno, "add_environment");
921
1020
          }
922
1021
        }
923
1022
      }
924
1023
    }
925
 
    /* If this plugin has any environment variables, we will call
926
 
       using execve and need to duplicate the environment from this
927
 
       process, too. */
 
1024
    /* If this plugin has any environment variables, we need to
 
1025
       duplicate the environment from this process, too. */
928
1026
    if(p->environ[0] != NULL){
929
1027
      for(char **e = environ; *e != NULL; e++){
930
1028
        if(not add_environment(p, *e, false)){
931
 
          perror("add_environment");
 
1029
          error(0, errno, "add_environment");
932
1030
        }
933
1031
      }
934
1032
    }
935
1033
    
936
1034
    int pipefd[2];
 
1035
#ifndef O_CLOEXEC
937
1036
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1037
#else  /* O_CLOEXEC */
 
1038
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1039
#endif  /* O_CLOEXEC */
938
1040
    if(ret == -1){
939
 
      perror("pipe");
940
 
      exitstatus = EXIT_FAILURE;
941
 
      goto fallback;
942
 
    }
 
1041
      error(0, errno, "pipe");
 
1042
      exitstatus = EX_OSERR;
 
1043
      free(direntries[i]);
 
1044
      goto fallback;
 
1045
    }
 
1046
    if(pipefd[0] >= FD_SETSIZE){
 
1047
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1048
              FD_SETSIZE);
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
 
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
 
1053
      goto fallback;
 
1054
    }
 
1055
#ifndef O_CLOEXEC
943
1056
    /* Ask OS to automatic close the pipe on exec */
944
1057
    ret = set_cloexec_flag(pipefd[0]);
945
1058
    if(ret < 0){
946
 
      perror("set_cloexec_flag");
947
 
      exitstatus = EXIT_FAILURE;
 
1059
      error(0, errno, "set_cloexec_flag");
 
1060
      close(pipefd[0]);
 
1061
      close(pipefd[1]);
 
1062
      exitstatus = EX_OSERR;
 
1063
      free(direntries[i]);
948
1064
      goto fallback;
949
1065
    }
950
1066
    ret = set_cloexec_flag(pipefd[1]);
951
1067
    if(ret < 0){
952
 
      perror("set_cloexec_flag");
953
 
      exitstatus = EXIT_FAILURE;
 
1068
      error(0, errno, "set_cloexec_flag");
 
1069
      close(pipefd[0]);
 
1070
      close(pipefd[1]);
 
1071
      exitstatus = EX_OSERR;
 
1072
      free(direntries[i]);
954
1073
      goto fallback;
955
1074
    }
 
1075
#endif  /* not O_CLOEXEC */
956
1076
    /* Block SIGCHLD until process is safely in process list */
957
1077
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
958
1078
                                              &sigchld_action.sa_mask,
959
1079
                                              NULL));
960
1080
    if(ret < 0){
961
 
      perror("sigprocmask");
962
 
      exitstatus = EXIT_FAILURE;
 
1081
      error(0, errno, "sigprocmask");
 
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
963
1084
      goto fallback;
964
1085
    }
965
1086
    /* Starting a new process to be watched */
968
1089
      pid = fork();
969
1090
    } while(pid == -1 and errno == EINTR);
970
1091
    if(pid == -1){
971
 
      perror("fork");
972
 
      exitstatus = EXIT_FAILURE;
 
1092
      error(0, errno, "fork");
 
1093
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1094
                                     &sigchld_action.sa_mask, NULL));
 
1095
      close(pipefd[0]);
 
1096
      close(pipefd[1]);
 
1097
      exitstatus = EX_OSERR;
 
1098
      free(direntries[i]);
973
1099
      goto fallback;
974
1100
    }
975
1101
    if(pid == 0){
976
1102
      /* this is the child process */
977
1103
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
978
1104
      if(ret < 0){
979
 
        perror("sigaction");
980
 
        _exit(EXIT_FAILURE);
 
1105
        error(0, errno, "sigaction");
 
1106
        _exit(EX_OSERR);
981
1107
      }
982
1108
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
983
1109
      if(ret < 0){
984
 
        perror("sigprocmask");
985
 
        _exit(EXIT_FAILURE);
 
1110
        error(0, errno, "sigprocmask");
 
1111
        _exit(EX_OSERR);
986
1112
      }
987
1113
      
988
1114
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
989
1115
      if(ret == -1){
990
 
        perror("dup2");
991
 
        _exit(EXIT_FAILURE);
 
1116
        error(0, errno, "dup2");
 
1117
        _exit(EX_OSERR);
992
1118
      }
993
1119
      
994
 
      if(dirfd(dir) < 0){
995
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
996
 
           above and must now close it manually here. */
997
 
        closedir(dir);
998
 
      }
999
 
      if(p->environ[0] == NULL){
1000
 
        if(execv(filename, p->argv) < 0){
1001
 
          perror("execv");
1002
 
          _exit(EXIT_FAILURE);
1003
 
        }
1004
 
      } else {
1005
 
        if(execve(filename, p->argv, p->environ) < 0){
1006
 
          perror("execve");
1007
 
          _exit(EXIT_FAILURE);
1008
 
        }
 
1120
      if(fexecve(plugin_fd, p->argv,
 
1121
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1122
        error(0, errno, "fexecve for %s/%s",
 
1123
              plugindir != NULL ? plugindir : PDIR,
 
1124
              direntries[i]->d_name);
 
1125
        _exit(EX_OSERR);
1009
1126
      }
1010
1127
      /* no return */
1011
1128
    }
1012
1129
    /* Parent process */
1013
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1014
 
                                             pipe */
1015
 
    free(filename);
1016
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1130
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1131
    close(plugin_fd);
 
1132
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1017
1133
    if(new_plugin == NULL){
1018
 
      perror("getplugin");
 
1134
      error(0, errno, "getplugin");
1019
1135
      ret = (int)(TEMP_FAILURE_RETRY
1020
1136
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1021
1137
                               NULL)));
1022
1138
      if(ret < 0){
1023
 
        perror("sigprocmask");
 
1139
        error(0, errno, "sigprocmask");
1024
1140
      }
1025
 
      exitstatus = EXIT_FAILURE;
 
1141
      exitstatus = EX_OSERR;
 
1142
      free(direntries[i]);
1026
1143
      goto fallback;
1027
1144
    }
 
1145
    free(direntries[i]);
1028
1146
    
1029
1147
    new_plugin->pid = pid;
1030
1148
    new_plugin->fd = pipefd[0];
1031
 
    
 
1149
 
 
1150
    if(debug){
 
1151
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1152
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1153
    }
 
1154
 
1032
1155
    /* Unblock SIGCHLD so signal handler can be run if this process
1033
1156
       has already completed */
1034
1157
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1035
1158
                                              &sigchld_action.sa_mask,
1036
1159
                                              NULL));
1037
1160
    if(ret < 0){
1038
 
      perror("sigprocmask");
1039
 
      exitstatus = EXIT_FAILURE;
 
1161
      error(0, errno, "sigprocmask");
 
1162
      exitstatus = EX_OSERR;
1040
1163
      goto fallback;
1041
1164
    }
1042
1165
    
1043
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1044
 
                                          -Wconversion */
 
1166
    FD_SET(new_plugin->fd, &rfds_all);
1045
1167
    
1046
1168
    if(maxfd < new_plugin->fd){
1047
1169
      maxfd = new_plugin->fd;
1048
1170
    }
1049
1171
  }
1050
1172
  
1051
 
  TEMP_FAILURE_RETRY(closedir(dir));
1052
 
  dir = NULL;
 
1173
  free(direntries);
 
1174
  direntries = NULL;
 
1175
  close(dir_fd);
 
1176
  dir_fd = -1;
1053
1177
  free_plugin(getplugin(NULL));
1054
1178
  
1055
1179
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1068
1192
    fd_set rfds = rfds_all;
1069
1193
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1070
1194
    if(select_ret == -1 and errno != EINTR){
1071
 
      perror("select");
1072
 
      exitstatus = EXIT_FAILURE;
 
1195
      error(0, errno, "select");
 
1196
      exitstatus = EX_OSERR;
1073
1197
      goto fallback;
1074
1198
    }
1075
1199
    /* OK, now either a process completed, or something can be read
1094
1218
                      (intmax_t) (proc->pid),
1095
1219
                      WTERMSIG(proc->status),
1096
1220
                      strsignal(WTERMSIG(proc->status)));
1097
 
            } else if(WCOREDUMP(proc->status)){
1098
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1099
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1100
1221
            }
1101
1222
          }
1102
1223
          
1103
1224
          /* Remove the plugin */
1104
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1105
 
                                          -Wconversion */
 
1225
          FD_CLR(proc->fd, &rfds_all);
1106
1226
          
1107
1227
          /* Block signal while modifying process_list */
1108
1228
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1110
1230
                                         &sigchld_action.sa_mask,
1111
1231
                                         NULL));
1112
1232
          if(ret < 0){
1113
 
            perror("sigprocmask");
1114
 
            exitstatus = EXIT_FAILURE;
 
1233
            error(0, errno, "sigprocmask");
 
1234
            exitstatus = EX_OSERR;
1115
1235
            goto fallback;
1116
1236
          }
1117
1237
          
1124
1244
                      (sigprocmask(SIG_UNBLOCK,
1125
1245
                                   &sigchld_action.sa_mask, NULL)));
1126
1246
          if(ret < 0){
1127
 
            perror("sigprocmask");
1128
 
            exitstatus = EXIT_FAILURE;
 
1247
            error(0, errno, "sigprocmask");
 
1248
            exitstatus = EX_OSERR;
1129
1249
            goto fallback;
1130
1250
          }
1131
1251
          
1141
1261
        bool bret = print_out_password(proc->buffer,
1142
1262
                                       proc->buffer_length);
1143
1263
        if(not bret){
1144
 
          perror("print_out_password");
1145
 
          exitstatus = EXIT_FAILURE;
 
1264
          error(0, errno, "print_out_password");
 
1265
          exitstatus = EX_IOERR;
1146
1266
        }
1147
1267
        goto fallback;
1148
1268
      }
1149
1269
      
1150
1270
      /* This process has not completed.  Does it have any output? */
1151
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1152
 
                                                         warning from
1153
 
                                                         -Wconversion */
 
1271
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1154
1272
        /* This process had nothing to say at this time */
1155
1273
        proc = proc->next;
1156
1274
        continue;
1157
1275
      }
1158
1276
      /* Before reading, make the process' data buffer large enough */
1159
1277
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1160
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1161
 
                               + (size_t) BUFFER_SIZE);
1162
 
        if(proc->buffer == NULL){
1163
 
          perror("malloc");
1164
 
          exitstatus = EXIT_FAILURE;
 
1278
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1279
                                   + (size_t) BUFFER_SIZE);
 
1280
        if(new_buffer == NULL){
 
1281
          error(0, errno, "malloc");
 
1282
          exitstatus = EX_OSERR;
1165
1283
          goto fallback;
1166
1284
        }
 
1285
        proc->buffer = new_buffer;
1167
1286
        proc->buffer_size += BUFFER_SIZE;
1168
1287
      }
1169
1288
      /* Read from the process */
1188
1307
  
1189
1308
 fallback:
1190
1309
  
1191
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1310
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1311
                             and exitstatus != EX_OK)){
1192
1312
    /* Fallback if all plugins failed, none are found or an error
1193
1313
       occured */
1194
1314
    bool bret;
1202
1322
    }
1203
1323
    bret = print_out_password(passwordbuffer, len);
1204
1324
    if(not bret){
1205
 
      perror("print_out_password");
1206
 
      exitstatus = EXIT_FAILURE;
 
1325
      error(0, errno, "print_out_password");
 
1326
      exitstatus = EX_IOERR;
1207
1327
    }
1208
1328
  }
1209
1329
  
1210
1330
  /* Restore old signal handler */
1211
1331
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1212
1332
  if(ret == -1){
1213
 
    perror("sigaction");
1214
 
    exitstatus = EXIT_FAILURE;
 
1333
    error(0, errno, "sigaction");
 
1334
    exitstatus = EX_OSERR;
1215
1335
  }
1216
1336
  
1217
1337
  if(custom_argv != NULL){
1221
1341
    free(custom_argv);
1222
1342
  }
1223
1343
  
1224
 
  if(dir != NULL){
1225
 
    closedir(dir);
 
1344
  free(direntries);
 
1345
  
 
1346
  if(dir_fd != -1){
 
1347
    close(dir_fd);
1226
1348
  }
1227
1349
  
1228
1350
  /* Kill the processes */
1232
1354
      ret = kill(p->pid, SIGTERM);
1233
1355
      if(ret == -1 and errno != ESRCH){
1234
1356
        /* Set-uid proccesses might not get closed */
1235
 
        perror("kill");
 
1357
        error(0, errno, "kill");
1236
1358
      }
1237
1359
    }
1238
1360
  }
1242
1364
    ret = wait(NULL);
1243
1365
  } while(ret >= 0);
1244
1366
  if(errno != ECHILD){
1245
 
    perror("wait");
 
1367
    error(0, errno, "wait");
1246
1368
  }
1247
1369
  
1248
1370
  free_plugin_list();
1249
1371
  
1250
1372
  free(plugindir);
 
1373
  free(pluginhelperdir);
1251
1374
  free(argfile);
1252
1375
  
1253
1376
  return exitstatus;