/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 at recompile
  • Date: 2020-04-05 21:30:59 UTC
  • mto: This revision was merged to the branch mainline in revision 398.
  • Revision ID: teddy@recompile.se-20200405213059-fb2a61ckqynrmatk
Fix file descriptor leak in mandos-client

When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.)  The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.

This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route.  If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.

Fix this by eliminating the file descriptor leak in the client.

* plugins.d/mandos-client.c (add_delete_local_route): Do
  close(devnull) also in parent process, also if fork() fails, and on
  any failure in child process.

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(), reallocarray(), realloc(),
 
30
                                   EXIT_SUCCESS, exit() */
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
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
183
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
184
                             sizeof(char *));
 
185
#else
 
186
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
187
      /* overflow */
 
188
      new_array = NULL;
 
189
      errno = ENOMEM;
 
190
    } else {
 
191
      new_array = realloc(*array, (size_t)((*len) + 2)
 
192
                          * sizeof(char *));
 
193
    }
 
194
#endif
 
195
  } while(new_array == NULL and errno == EINTR);
171
196
  /* Malloc check */
172
 
  if(*array == NULL){
 
197
  if(new_array == NULL){
173
198
    return false;
174
199
  }
 
200
  *array = new_array;
175
201
  /* Make a copy of the new string */
176
202
  char *copy;
177
203
  do {
189
215
}
190
216
 
191
217
/* Add to a plugin's argument vector */
 
218
__attribute__((nonnull(2), warn_unused_result))
192
219
static bool add_argument(plugin *p, const char *arg){
193
220
  if(p == NULL){
194
221
    return false;
197
224
}
198
225
 
199
226
/* Add to a plugin's environment */
 
227
__attribute__((nonnull(2), warn_unused_result))
200
228
static bool add_environment(plugin *p, const char *def, bool replace){
201
229
  if(p == NULL){
202
230
    return false;
204
232
  /* namelen = length of name of environment variable */
205
233
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
206
234
  /* Search for this environment variable */
207
 
  for(char **e = p->environ; *e != NULL; e++){
208
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
235
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
236
    if(strncmp(*envdef, def, namelen + 1) == 0){
209
237
      /* It already exists */
210
238
      if(replace){
211
 
        char *new;
 
239
        char *new_envdef;
212
240
        do {
213
 
          new = realloc(*e, strlen(def) + 1);
214
 
        } while(new == NULL and errno == EINTR);
215
 
        if(new == NULL){
 
241
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
242
        } while(new_envdef == NULL and errno == EINTR);
 
243
        if(new_envdef == NULL){
216
244
          return false;
217
245
        }
218
 
        *e = new;
219
 
        strcpy(*e, def);
 
246
        *envdef = new_envdef;
 
247
        strcpy(*envdef, def);
220
248
      }
221
249
      return true;
222
250
    }
224
252
  return add_to_char_array(def, &(p->environ), &(p->envc));
225
253
}
226
254
 
 
255
#ifndef O_CLOEXEC
227
256
/*
228
257
 * Based on the example in the GNU LibC manual chapter 13.13 "File
229
258
 * Descriptor Flags".
230
259
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
231
260
 */
 
261
__attribute__((warn_unused_result))
232
262
static int set_cloexec_flag(int fd){
233
263
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
234
264
  /* If reading the flags failed, return error indication now. */
239
269
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
240
270
                                       ret | FD_CLOEXEC));
241
271
}
 
272
#endif  /* not O_CLOEXEC */
242
273
 
243
274
 
244
275
/* Mark processes as completed when they exit, and save their exit
258
289
        /* No child processes */
259
290
        break;
260
291
      }
261
 
      perror("waitpid");
 
292
      error(0, errno, "waitpid");
262
293
    }
263
294
    
264
295
    /* A child exited, find it in process_list */
276
307
}
277
308
 
278
309
/* Prints out a password to stdout */
 
310
__attribute__((nonnull, warn_unused_result))
279
311
static bool print_out_password(const char *buffer, size_t length){
280
312
  ssize_t ret;
281
313
  for(size_t written = 0; written < length; written += (size_t)ret){
289
321
}
290
322
 
291
323
/* Removes and free a plugin from the plugin list */
 
324
__attribute__((nonnull))
292
325
static void free_plugin(plugin *plugin_node){
293
326
  
294
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
327
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
295
328
    free(*arg);
296
329
  }
 
330
  free(plugin_node->name);
297
331
  free(plugin_node->argv);
298
332
  for(char **env = plugin_node->environ; *env != NULL; env++){
299
333
    free(*env);
326
360
 
327
361
int main(int argc, char *argv[]){
328
362
  char *plugindir = NULL;
 
363
  char *pluginhelperdir = NULL;
329
364
  char *argfile = NULL;
330
365
  FILE *conffp;
331
 
  size_t d_name_len;
332
 
  DIR *dir = NULL;
333
 
  struct dirent *dirst;
 
366
  struct dirent **direntries = NULL;
334
367
  struct stat st;
335
368
  fd_set rfds_all;
336
369
  int ret, maxfd = 0;
344
377
                                      .sa_flags = SA_NOCLDSTOP };
345
378
  char **custom_argv = NULL;
346
379
  int custom_argc = 0;
 
380
  int dir_fd = -1;
347
381
  
348
382
  /* Establish a signal handler */
349
383
  sigemptyset(&sigchld_action.sa_mask);
350
384
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
351
385
  if(ret == -1){
352
 
    perror("sigaddset");
353
 
    exitstatus = EXIT_FAILURE;
 
386
    error(0, errno, "sigaddset");
 
387
    exitstatus = EX_OSERR;
354
388
    goto fallback;
355
389
  }
356
390
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
357
391
  if(ret == -1){
358
 
    perror("sigaction");
359
 
    exitstatus = EXIT_FAILURE;
 
392
    error(0, errno, "sigaction");
 
393
    exitstatus = EX_OSERR;
360
394
    goto fallback;
361
395
  }
362
396
  
394
428
      .doc = "Group ID the plugins will run as", .group = 3 },
395
429
    { .name = "debug", .key = 132,
396
430
      .doc = "Debug mode", .group = 4 },
 
431
    { .name = "plugin-helper-dir", .key = 133,
 
432
      .arg = "DIRECTORY",
 
433
      .doc = "Specify a different plugin helper directory",
 
434
      .group = 2 },
 
435
    /*
 
436
     * These reproduce what we would get without ARGP_NO_HELP
 
437
     */
 
438
    { .name = "help", .key = '?',
 
439
      .doc = "Give this help list", .group = -1 },
 
440
    { .name = "usage", .key = -3,
 
441
      .doc = "Give a short usage message", .group = -1 },
 
442
    { .name = "version", .key = 'V',
 
443
      .doc = "Print program version", .group = -1 },
397
444
    { .name = NULL }
398
445
  };
399
446
  
400
 
  error_t parse_opt(int key, char *arg, __attribute__((unused))
401
 
                    struct argp_state *state){
 
447
  __attribute__((nonnull(3)))
 
448
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
449
    errno = 0;
402
450
    switch(key){
403
451
      char *tmp;
404
 
      intmax_t tmpmax;
 
452
      intmax_t tmp_id;
405
453
    case 'g':                   /* --global-options */
406
 
      if(arg != NULL){
 
454
      {
407
455
        char *plugin_option;
408
456
        while((plugin_option = strsep(&arg, ",")) != NULL){
409
 
          if(plugin_option[0] == '\0'){
410
 
            continue;
411
 
          }
412
457
          if(not add_argument(getplugin(NULL), plugin_option)){
413
 
            perror("add_argument");
414
 
            return ARGP_ERR_UNKNOWN;
 
458
            break;
415
459
          }
416
460
        }
 
461
        errno = 0;
417
462
      }
418
463
      break;
419
464
    case 'G':                   /* --global-env */
420
 
      if(arg == NULL){
421
 
        break;
422
 
      }
423
 
      if(not add_environment(getplugin(NULL), arg, true)){
424
 
        perror("add_environment");
 
465
      if(add_environment(getplugin(NULL), arg, true)){
 
466
        errno = 0;
425
467
      }
426
468
      break;
427
469
    case 'o':                   /* --options-for */
428
 
      if(arg != NULL){
429
 
        char *plugin_name = strsep(&arg, ":");
430
 
        if(plugin_name[0] == '\0'){
431
 
          break;
432
 
        }
433
 
        char *plugin_option;
434
 
        while((plugin_option = strsep(&arg, ",")) != NULL){
435
 
          if(not add_argument(getplugin(plugin_name), plugin_option)){
436
 
            perror("add_argument");
437
 
            return ARGP_ERR_UNKNOWN;
 
470
      {
 
471
        char *option_list = strchr(arg, ':');
 
472
        if(option_list == NULL){
 
473
          argp_error(state, "No colon in \"%s\"", arg);
 
474
          errno = EINVAL;
 
475
          break;
 
476
        }
 
477
        *option_list = '\0';
 
478
        option_list++;
 
479
        if(arg[0] == '\0'){
 
480
          argp_error(state, "Empty plugin name");
 
481
          errno = EINVAL;
 
482
          break;
 
483
        }
 
484
        char *option;
 
485
        while((option = strsep(&option_list, ",")) != NULL){
 
486
          if(not add_argument(getplugin(arg), option)){
 
487
            break;
438
488
          }
439
489
        }
 
490
        errno = 0;
440
491
      }
441
492
      break;
442
493
    case 'E':                   /* --env-for */
443
 
      if(arg == NULL){
444
 
        break;
445
 
      }
446
494
      {
447
495
        char *envdef = strchr(arg, ':');
448
496
        if(envdef == NULL){
 
497
          argp_error(state, "No colon in \"%s\"", arg);
 
498
          errno = EINVAL;
449
499
          break;
450
500
        }
451
501
        *envdef = '\0';
452
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
453
 
          perror("add_environment");
 
502
        envdef++;
 
503
        if(arg[0] == '\0'){
 
504
          argp_error(state, "Empty plugin name");
 
505
          errno = EINVAL;
 
506
          break;
 
507
        }
 
508
        if(add_environment(getplugin(arg), envdef, true)){
 
509
          errno = 0;
454
510
        }
455
511
      }
456
512
      break;
457
513
    case 'd':                   /* --disable */
458
 
      if(arg != NULL){
 
514
      {
459
515
        plugin *p = getplugin(arg);
460
 
        if(p == NULL){
461
 
          return ARGP_ERR_UNKNOWN;
 
516
        if(p != NULL){
 
517
          p->disabled = true;
 
518
          errno = 0;
462
519
        }
463
 
        p->disabled = true;
464
520
      }
465
521
      break;
466
522
    case 'e':                   /* --enable */
467
 
      if(arg != NULL){
 
523
      {
468
524
        plugin *p = getplugin(arg);
469
 
        if(p == NULL){
470
 
          return ARGP_ERR_UNKNOWN;
 
525
        if(p != NULL){
 
526
          p->disabled = false;
 
527
          errno = 0;
471
528
        }
472
 
        p->disabled = false;
473
529
      }
474
530
      break;
475
531
    case 128:                   /* --plugin-dir */
476
532
      free(plugindir);
477
533
      plugindir = strdup(arg);
478
 
      if(plugindir == NULL){
479
 
        perror("strdup");
 
534
      if(plugindir != NULL){
 
535
        errno = 0;
480
536
      }
481
537
      break;
482
538
    case 129:                   /* --config-file */
483
539
      /* This is already done by parse_opt_config_file() */
484
540
      break;
485
541
    case 130:                   /* --userid */
486
 
      errno = 0;
487
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
542
      tmp_id = strtoimax(arg, &tmp, 10);
488
543
      if(errno != 0 or tmp == arg or *tmp != '\0'
489
 
         or tmpmax != (uid_t)tmpmax){
490
 
        fprintf(stderr, "Bad user ID number: \"%s\", using %"
491
 
                PRIdMAX "\n", arg, (intmax_t)uid);
492
 
      } else {
493
 
        uid = (uid_t)tmpmax;
 
544
         or tmp_id != (uid_t)tmp_id){
 
545
        argp_error(state, "Bad user ID number: \"%s\", using %"
 
546
                   PRIdMAX, arg, (intmax_t)uid);
 
547
        break;
494
548
      }
 
549
      uid = (uid_t)tmp_id;
 
550
      errno = 0;
495
551
      break;
496
552
    case 131:                   /* --groupid */
497
 
      errno = 0;
498
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
553
      tmp_id = strtoimax(arg, &tmp, 10);
499
554
      if(errno != 0 or tmp == arg or *tmp != '\0'
500
 
         or tmpmax != (gid_t)tmpmax){
501
 
        fprintf(stderr, "Bad group ID number: \"%s\", using %"
502
 
                PRIdMAX "\n", arg, (intmax_t)gid);
503
 
      } else {
504
 
        gid = (gid_t)tmpmax;
 
555
         or tmp_id != (gid_t)tmp_id){
 
556
        argp_error(state, "Bad group ID number: \"%s\", using %"
 
557
                   PRIdMAX, arg, (intmax_t)gid);
 
558
        break;
505
559
      }
 
560
      gid = (gid_t)tmp_id;
 
561
      errno = 0;
506
562
      break;
507
563
    case 132:                   /* --debug */
508
564
      debug = true;
509
565
      break;
 
566
    case 133:                   /* --plugin-helper-dir */
 
567
      free(pluginhelperdir);
 
568
      pluginhelperdir = strdup(arg);
 
569
      if(pluginhelperdir != NULL){
 
570
        errno = 0;
 
571
      }
 
572
      break;
 
573
      /*
 
574
       * These reproduce what we would get without ARGP_NO_HELP
 
575
       */
 
576
    case '?':                   /* --help */
 
577
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
578
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
579
      __builtin_unreachable();
 
580
    case -3:                    /* --usage */
 
581
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
582
      argp_state_help(state, state->out_stream,
 
583
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
584
      __builtin_unreachable();
 
585
    case 'V':                   /* --version */
 
586
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
587
      exit(EXIT_SUCCESS);
 
588
      break;
510
589
/*
511
590
 * When adding more options before this line, remember to also add a
512
591
 * "case" to the "parse_opt_config_file" function below.
515
594
      /* Cryptsetup always passes an argument, which is an empty
516
595
         string if "none" was specified in /etc/crypttab.  So if
517
596
         argument was empty, we ignore it silently. */
518
 
      if(arg[0] != '\0'){
519
 
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
597
      if(arg[0] == '\0'){
 
598
        break;
520
599
      }
521
 
      break;
522
 
    case ARGP_KEY_END:
523
 
      break;
 
600
#if __GNUC__ >= 7
 
601
      __attribute__((fallthrough));
 
602
#else
 
603
          /* FALLTHROUGH */
 
604
#endif
524
605
    default:
525
606
      return ARGP_ERR_UNKNOWN;
526
607
    }
527
 
    return 0;
 
608
    return errno;               /* Set to 0 at start */
528
609
  }
529
610
  
530
611
  /* This option parser is the same as parse_opt() above, except it
532
613
  error_t parse_opt_config_file(int key, char *arg,
533
614
                                __attribute__((unused))
534
615
                                struct argp_state *state){
 
616
    errno = 0;
535
617
    switch(key){
536
618
    case 'g':                   /* --global-options */
537
619
    case 'G':                   /* --global-env */
544
626
    case 129:                   /* --config-file */
545
627
      free(argfile);
546
628
      argfile = strdup(arg);
547
 
      if(argfile == NULL){
548
 
        perror("strdup");
 
629
      if(argfile != NULL){
 
630
        errno = 0;
549
631
      }
550
632
      break;
551
633
    case 130:                   /* --userid */
552
634
    case 131:                   /* --groupid */
553
635
    case 132:                   /* --debug */
 
636
    case 133:                   /* --plugin-helper-dir */
 
637
    case '?':                   /* --help */
 
638
    case -3:                    /* --usage */
 
639
    case 'V':                   /* --version */
554
640
    case ARGP_KEY_ARG:
555
 
    case ARGP_KEY_END:
556
641
      break;
557
642
    default:
558
643
      return ARGP_ERR_UNKNOWN;
559
644
    }
560
 
    return 0;
 
645
    return errno;
561
646
  }
562
647
  
563
648
  struct argp argp = { .options = options,
567
652
  
568
653
  /* Parse using parse_opt_config_file() in order to get the custom
569
654
     config file location, if any. */
570
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
571
 
  if(ret == ARGP_ERR_UNKNOWN){
572
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
573
 
    exitstatus = EXIT_FAILURE;
 
655
  ret = argp_parse(&argp, argc, argv,
 
656
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
657
                   NULL, NULL);
 
658
  switch(ret){
 
659
  case 0:
 
660
    break;
 
661
  case ENOMEM:
 
662
  default:
 
663
    errno = ret;
 
664
    error(0, errno, "argp_parse");
 
665
    exitstatus = EX_OSERR;
 
666
    goto fallback;
 
667
  case EINVAL:
 
668
    exitstatus = EX_USAGE;
574
669
    goto fallback;
575
670
  }
576
671
  
593
688
    custom_argc = 1;
594
689
    custom_argv = malloc(sizeof(char*) * 2);
595
690
    if(custom_argv == NULL){
596
 
      perror("malloc");
597
 
      exitstatus = EXIT_FAILURE;
 
691
      error(0, errno, "malloc");
 
692
      exitstatus = EX_OSERR;
598
693
      goto fallback;
599
694
    }
600
695
    custom_argv[0] = argv[0];
616
711
        }
617
712
        new_arg = strdup(p);
618
713
        if(new_arg == NULL){
619
 
          perror("strdup");
620
 
          exitstatus = EXIT_FAILURE;
 
714
          error(0, errno, "strdup");
 
715
          exitstatus = EX_OSERR;
621
716
          free(org_line);
622
717
          goto fallback;
623
718
        }
624
719
        
625
720
        custom_argc += 1;
626
 
        custom_argv = realloc(custom_argv, sizeof(char *)
627
 
                              * ((unsigned int) custom_argc + 1));
628
 
        if(custom_argv == NULL){
629
 
          perror("realloc");
630
 
          exitstatus = EXIT_FAILURE;
631
 
          free(org_line);
632
 
          goto fallback;
 
721
        {
 
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
723
          char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
 
724
                                         sizeof(char *));
 
725
#else
 
726
          char **new_argv = NULL;
 
727
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
728
            /* overflow */
 
729
            errno = ENOMEM;
 
730
          } else {
 
731
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
732
                               * sizeof(char *));
 
733
          }
 
734
#endif
 
735
          if(new_argv == NULL){
 
736
            error(0, errno, "reallocarray");
 
737
            exitstatus = EX_OSERR;
 
738
            free(new_arg);
 
739
            free(org_line);
 
740
            goto fallback;
 
741
          } else {
 
742
            custom_argv = new_argv;
 
743
          }
633
744
        }
634
745
        custom_argv[custom_argc-1] = new_arg;
635
746
        custom_argv[custom_argc] = NULL;
639
750
      ret = fclose(conffp);
640
751
    } while(ret == EOF and errno == EINTR);
641
752
    if(ret == EOF){
642
 
      perror("fclose");
643
 
      exitstatus = EXIT_FAILURE;
 
753
      error(0, errno, "fclose");
 
754
      exitstatus = EX_IOERR;
644
755
      goto fallback;
645
756
    }
646
757
    free(org_line);
648
759
    /* Check for harmful errors and go to fallback. Other errors might
649
760
       not affect opening plugins */
650
761
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
651
 
      perror("fopen");
652
 
      exitstatus = EXIT_FAILURE;
 
762
      error(0, errno, "fopen");
 
763
      exitstatus = EX_OSERR;
653
764
      goto fallback;
654
765
    }
655
766
  }
656
 
  /* If there was any arguments from configuration file,
657
 
     pass them to parser as command arguments */
 
767
  /* If there were any arguments from the configuration file, pass
 
768
     them to parser as command line arguments */
658
769
  if(custom_argv != NULL){
659
 
    ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
660
 
                     0, NULL);
661
 
    if(ret == ARGP_ERR_UNKNOWN){
662
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
663
 
      exitstatus = EXIT_FAILURE;
 
770
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
771
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
772
                     NULL, NULL);
 
773
    switch(ret){
 
774
    case 0:
 
775
      break;
 
776
    case ENOMEM:
 
777
    default:
 
778
      errno = ret;
 
779
      error(0, errno, "argp_parse");
 
780
      exitstatus = EX_OSERR;
 
781
      goto fallback;
 
782
    case EINVAL:
 
783
      exitstatus = EX_CONFIG;
664
784
      goto fallback;
665
785
    }
666
786
  }
667
787
  
668
788
  /* Parse actual command line arguments, to let them override the
669
789
     config file */
670
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
671
 
  if(ret == ARGP_ERR_UNKNOWN){
672
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
673
 
    exitstatus = EXIT_FAILURE;
674
 
    goto fallback;
 
790
  ret = argp_parse(&argp, argc, argv,
 
791
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
792
                   NULL, NULL);
 
793
  switch(ret){
 
794
  case 0:
 
795
    break;
 
796
  case ENOMEM:
 
797
  default:
 
798
    errno = ret;
 
799
    error(0, errno, "argp_parse");
 
800
    exitstatus = EX_OSERR;
 
801
    goto fallback;
 
802
  case EINVAL:
 
803
    exitstatus = EX_USAGE;
 
804
    goto fallback;
 
805
  }
 
806
  
 
807
  {
 
808
    char *pluginhelperenv;
 
809
    bool bret = true;
 
810
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
811
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
812
    if(ret != -1){
 
813
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
814
    }
 
815
    if(ret == -1 or not bret){
 
816
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
817
            " environment variable to \"%s\" for all plugins\n",
 
818
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
819
    }
 
820
    if(ret != -1){
 
821
      free(pluginhelperenv);
 
822
    }
675
823
  }
676
824
  
677
825
  if(debug){
678
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
826
    for(plugin *p = plugin_list; p != NULL; p = p->next){
679
827
      fprintf(stderr, "Plugin: %s has %d arguments\n",
680
828
              p->name ? p->name : "Global", p->argc - 1);
681
829
      for(char **a = p->argv; *a != NULL; a++){
688
836
    }
689
837
  }
690
838
  
691
 
  /* Strip permissions down to nobody */
692
 
  setgid(gid);
 
839
  if(getuid() == 0){
 
840
    /* Work around Debian bug #633582:
 
841
       <https://bugs.debian.org/633582> */
 
842
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
843
    if(plugindir_fd == -1){
 
844
      if(errno != ENOENT){
 
845
        error(0, errno, "open(\"" PDIR "\")");
 
846
      }
 
847
    } else {
 
848
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
849
      if(ret == -1){
 
850
        error(0, errno, "fstat");
 
851
      } else {
 
852
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
853
          ret = fchown(plugindir_fd, uid, gid);
 
854
          if(ret == -1){
 
855
            error(0, errno, "fchown");
 
856
          }
 
857
        }
 
858
      }
 
859
      close(plugindir_fd);
 
860
    }
 
861
  }
 
862
  
 
863
  /* Lower permissions */
 
864
  ret = setgid(gid);
693
865
  if(ret == -1){
694
 
    perror("setgid");
 
866
    error(0, errno, "setgid");
695
867
  }
696
868
  ret = setuid(uid);
697
869
  if(ret == -1){
698
 
    perror("setuid");
699
 
  }
700
 
  
701
 
  if(plugindir == NULL){
702
 
    dir = opendir(PDIR);
703
 
  } else {
704
 
    dir = opendir(plugindir);
705
 
  }
706
 
  
707
 
  if(dir == NULL){
708
 
    perror("Could not open plugin dir");
709
 
    exitstatus = EXIT_FAILURE;
710
 
    goto fallback;
711
 
  }
712
 
  
713
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
 
870
    error(0, errno, "setuid");
 
871
  }
 
872
  
 
873
  /* Open plugin directory with close_on_exec flag */
714
874
  {
715
 
    int dir_fd = dirfd(dir);
716
 
    if(dir_fd >= 0){
717
 
      ret = set_cloexec_flag(dir_fd);
718
 
      if(ret < 0){
719
 
        perror("set_cloexec_flag");
720
 
        exitstatus = EXIT_FAILURE;
721
 
        goto fallback;
 
875
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
876
#ifdef O_CLOEXEC
 
877
                  O_CLOEXEC
 
878
#else  /* not O_CLOEXEC */
 
879
                  0
 
880
#endif  /* not O_CLOEXEC */
 
881
                  );
 
882
    if(dir_fd == -1){
 
883
      error(0, errno, "Could not open plugin dir");
 
884
      exitstatus = EX_UNAVAILABLE;
 
885
      goto fallback;
 
886
    }
 
887
    
 
888
#ifndef O_CLOEXEC
 
889
  /* Set the FD_CLOEXEC flag on the directory */
 
890
    ret = set_cloexec_flag(dir_fd);
 
891
    if(ret < 0){
 
892
      error(0, errno, "set_cloexec_flag");
 
893
      exitstatus = EX_OSERR;
 
894
      goto fallback;
 
895
    }
 
896
#endif  /* O_CLOEXEC */
 
897
  }
 
898
  
 
899
  int good_name(const struct dirent * const dirent){
 
900
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
901
                                      "*.dpkg-old", "*.dpkg-bak",
 
902
                                      "*.dpkg-divert", NULL };
 
903
#ifdef __GNUC__
 
904
#pragma GCC diagnostic push
 
905
#pragma GCC diagnostic ignored "-Wcast-qual"
 
906
#endif
 
907
    for(const char **pat = (const char **)patterns;
 
908
        *pat != NULL; pat++){
 
909
#ifdef __GNUC__
 
910
#pragma GCC diagnostic pop
 
911
#endif
 
912
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
913
         != FNM_NOMATCH){
 
914
        if(debug){
 
915
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
916
                    " matching pattern %s\n", dirent->d_name, *pat);
 
917
        }
 
918
        return 0;
722
919
      }
723
920
    }
 
921
    return 1;
 
922
  }
 
923
  
 
924
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
925
                             alphasort);
 
926
  if(numplugins == -1){
 
927
    error(0, errno, "Could not scan plugin dir");
 
928
    direntries = NULL;
 
929
    exitstatus = EX_OSERR;
 
930
    goto fallback;
724
931
  }
725
932
  
726
933
  FD_ZERO(&rfds_all);
727
934
  
728
935
  /* Read and execute any executable in the plugin directory*/
729
 
  while(true){
730
 
    do {
731
 
      dirst = readdir(dir);
732
 
    } while(dirst == NULL and errno == EINTR);
733
 
    
734
 
    /* All directory entries have been processed */
735
 
    if(dirst == NULL){
736
 
      if(errno == EBADF){
737
 
        perror("readdir");
738
 
        exitstatus = EXIT_FAILURE;
739
 
        goto fallback;
740
 
      }
741
 
      break;
742
 
    }
743
 
    
744
 
    d_name_len = strlen(dirst->d_name);
745
 
    
746
 
    /* Ignore dotfiles, backup files and other junk */
747
 
    {
748
 
      bool bad_name = false;
749
 
      
750
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
751
 
      
752
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
753
 
                                           ".dpkg-old",
754
 
                                           ".dpkg-bak",
755
 
                                           ".dpkg-divert", NULL };
756
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
757
 
        size_t pre_len = strlen(*pre);
758
 
        if((d_name_len >= pre_len)
759
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
760
 
          if(debug){
761
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
762
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
763
 
          }
764
 
          bad_name = true;
765
 
          break;
766
 
        }
767
 
      }
768
 
      if(bad_name){
769
 
        continue;
770
 
      }
771
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
772
 
        size_t suf_len = strlen(*suf);
773
 
        if((d_name_len >= suf_len)
774
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
775
 
                == 0)){
776
 
          if(debug){
777
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
778
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
779
 
          }
780
 
          bad_name = true;
781
 
          break;
782
 
        }
783
 
      }
784
 
      
785
 
      if(bad_name){
786
 
        continue;
787
 
      }
788
 
    }
789
 
    
790
 
    char *filename;
791
 
    if(plugindir == NULL){
792
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
793
 
                                             dirst->d_name));
794
 
    } else {
795
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
796
 
                                             plugindir,
797
 
                                             dirst->d_name));
798
 
    }
799
 
    if(ret < 0){
800
 
      perror("asprintf");
 
936
  for(int i = 0; i < numplugins; i++){
 
937
    
 
938
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
939
    if(plugin_fd == -1){
 
940
      error(0, errno, "Could not open plugin");
 
941
      free(direntries[i]);
801
942
      continue;
802
943
    }
803
 
    
804
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
944
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
805
945
    if(ret == -1){
806
 
      perror("stat");
807
 
      free(filename);
 
946
      error(0, errno, "stat");
 
947
      close(plugin_fd);
 
948
      free(direntries[i]);
808
949
      continue;
809
950
    }
810
951
    
811
952
    /* Ignore non-executable files */
812
953
    if(not S_ISREG(st.st_mode)
813
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
954
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
955
                                        X_OK, 0)) != 0)){
814
956
      if(debug){
815
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
816
 
                " with bad type or mode\n", filename);
 
957
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
958
                " with bad type or mode\n",
 
959
                plugindir != NULL ? plugindir : PDIR,
 
960
                direntries[i]->d_name);
817
961
      }
818
 
      free(filename);
 
962
      close(plugin_fd);
 
963
      free(direntries[i]);
819
964
      continue;
820
965
    }
821
966
    
822
 
    plugin *p = getplugin(dirst->d_name);
 
967
    plugin *p = getplugin(direntries[i]->d_name);
823
968
    if(p == NULL){
824
 
      perror("getplugin");
825
 
      free(filename);
 
969
      error(0, errno, "getplugin");
 
970
      close(plugin_fd);
 
971
      free(direntries[i]);
826
972
      continue;
827
973
    }
828
974
    if(p->disabled){
829
975
      if(debug){
830
976
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
831
 
                dirst->d_name);
 
977
                direntries[i]->d_name);
832
978
      }
833
 
      free(filename);
 
979
      close(plugin_fd);
 
980
      free(direntries[i]);
834
981
      continue;
835
982
    }
836
983
    {
839
986
      if(g != NULL){
840
987
        for(char **a = g->argv + 1; *a != NULL; a++){
841
988
          if(not add_argument(p, *a)){
842
 
            perror("add_argument");
 
989
            error(0, errno, "add_argument");
843
990
          }
844
991
        }
845
992
        /* Add global environment variables */
846
993
        for(char **e = g->environ; *e != NULL; e++){
847
994
          if(not add_environment(p, *e, false)){
848
 
            perror("add_environment");
 
995
            error(0, errno, "add_environment");
849
996
          }
850
997
        }
851
998
      }
852
999
    }
853
 
    /* If this plugin has any environment variables, we will call
854
 
       using execve and need to duplicate the environment from this
855
 
       process, too. */
 
1000
    /* If this plugin has any environment variables, we need to
 
1001
       duplicate the environment from this process, too. */
856
1002
    if(p->environ[0] != NULL){
857
1003
      for(char **e = environ; *e != NULL; e++){
858
1004
        if(not add_environment(p, *e, false)){
859
 
          perror("add_environment");
 
1005
          error(0, errno, "add_environment");
860
1006
        }
861
1007
      }
862
1008
    }
863
1009
    
864
1010
    int pipefd[2];
 
1011
#ifndef O_CLOEXEC
865
1012
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1013
#else  /* O_CLOEXEC */
 
1014
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1015
#endif  /* O_CLOEXEC */
866
1016
    if(ret == -1){
867
 
      perror("pipe");
868
 
      exitstatus = EXIT_FAILURE;
869
 
      goto fallback;
870
 
    }
 
1017
      error(0, errno, "pipe");
 
1018
      exitstatus = EX_OSERR;
 
1019
      free(direntries[i]);
 
1020
      goto fallback;
 
1021
    }
 
1022
    if(pipefd[0] >= FD_SETSIZE){
 
1023
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1024
              FD_SETSIZE);
 
1025
      close(pipefd[0]);
 
1026
      close(pipefd[1]);
 
1027
      exitstatus = EX_OSERR;
 
1028
      free(direntries[i]);
 
1029
      goto fallback;
 
1030
    }
 
1031
#ifndef O_CLOEXEC
871
1032
    /* Ask OS to automatic close the pipe on exec */
872
1033
    ret = set_cloexec_flag(pipefd[0]);
873
1034
    if(ret < 0){
874
 
      perror("set_cloexec_flag");
875
 
      exitstatus = EXIT_FAILURE;
 
1035
      error(0, errno, "set_cloexec_flag");
 
1036
      close(pipefd[0]);
 
1037
      close(pipefd[1]);
 
1038
      exitstatus = EX_OSERR;
 
1039
      free(direntries[i]);
876
1040
      goto fallback;
877
1041
    }
878
1042
    ret = set_cloexec_flag(pipefd[1]);
879
1043
    if(ret < 0){
880
 
      perror("set_cloexec_flag");
881
 
      exitstatus = EXIT_FAILURE;
 
1044
      error(0, errno, "set_cloexec_flag");
 
1045
      close(pipefd[0]);
 
1046
      close(pipefd[1]);
 
1047
      exitstatus = EX_OSERR;
 
1048
      free(direntries[i]);
882
1049
      goto fallback;
883
1050
    }
 
1051
#endif  /* not O_CLOEXEC */
884
1052
    /* Block SIGCHLD until process is safely in process list */
885
1053
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
886
1054
                                              &sigchld_action.sa_mask,
887
1055
                                              NULL));
888
1056
    if(ret < 0){
889
 
      perror("sigprocmask");
890
 
      exitstatus = EXIT_FAILURE;
 
1057
      error(0, errno, "sigprocmask");
 
1058
      exitstatus = EX_OSERR;
 
1059
      free(direntries[i]);
891
1060
      goto fallback;
892
1061
    }
893
1062
    /* Starting a new process to be watched */
896
1065
      pid = fork();
897
1066
    } while(pid == -1 and errno == EINTR);
898
1067
    if(pid == -1){
899
 
      perror("fork");
900
 
      exitstatus = EXIT_FAILURE;
 
1068
      error(0, errno, "fork");
 
1069
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1070
                                     &sigchld_action.sa_mask, NULL));
 
1071
      close(pipefd[0]);
 
1072
      close(pipefd[1]);
 
1073
      exitstatus = EX_OSERR;
 
1074
      free(direntries[i]);
901
1075
      goto fallback;
902
1076
    }
903
1077
    if(pid == 0){
904
1078
      /* this is the child process */
905
1079
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
906
1080
      if(ret < 0){
907
 
        perror("sigaction");
908
 
        _exit(EXIT_FAILURE);
 
1081
        error(0, errno, "sigaction");
 
1082
        _exit(EX_OSERR);
909
1083
      }
910
1084
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
911
1085
      if(ret < 0){
912
 
        perror("sigprocmask");
913
 
        _exit(EXIT_FAILURE);
 
1086
        error(0, errno, "sigprocmask");
 
1087
        _exit(EX_OSERR);
914
1088
      }
915
1089
      
916
1090
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
917
1091
      if(ret == -1){
918
 
        perror("dup2");
919
 
        _exit(EXIT_FAILURE);
 
1092
        error(0, errno, "dup2");
 
1093
        _exit(EX_OSERR);
920
1094
      }
921
1095
      
922
 
      if(dirfd(dir) < 0){
923
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
924
 
           above and must now close it manually here. */
925
 
        closedir(dir);
926
 
      }
927
 
      if(p->environ[0] == NULL){
928
 
        if(execv(filename, p->argv) < 0){
929
 
          perror("execv");
930
 
          _exit(EXIT_FAILURE);
931
 
        }
932
 
      } else {
933
 
        if(execve(filename, p->argv, p->environ) < 0){
934
 
          perror("execve");
935
 
          _exit(EXIT_FAILURE);
936
 
        }
 
1096
      if(fexecve(plugin_fd, p->argv,
 
1097
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1098
        error(0, errno, "fexecve for %s/%s",
 
1099
              plugindir != NULL ? plugindir : PDIR,
 
1100
              direntries[i]->d_name);
 
1101
        _exit(EX_OSERR);
937
1102
      }
938
1103
      /* no return */
939
1104
    }
940
1105
    /* Parent process */
941
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
942
 
                                             pipe */
943
 
    free(filename);
944
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1106
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1107
    close(plugin_fd);
 
1108
    plugin *new_plugin = getplugin(direntries[i]->d_name);
945
1109
    if(new_plugin == NULL){
946
 
      perror("getplugin");
 
1110
      error(0, errno, "getplugin");
947
1111
      ret = (int)(TEMP_FAILURE_RETRY
948
1112
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
949
1113
                               NULL)));
950
1114
      if(ret < 0){
951
 
        perror("sigprocmask");
 
1115
        error(0, errno, "sigprocmask");
952
1116
      }
953
 
      exitstatus = EXIT_FAILURE;
 
1117
      exitstatus = EX_OSERR;
 
1118
      free(direntries[i]);
954
1119
      goto fallback;
955
1120
    }
 
1121
    free(direntries[i]);
956
1122
    
957
1123
    new_plugin->pid = pid;
958
1124
    new_plugin->fd = pipefd[0];
959
 
    
 
1125
 
 
1126
    if(debug){
 
1127
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1128
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1129
    }
 
1130
 
960
1131
    /* Unblock SIGCHLD so signal handler can be run if this process
961
1132
       has already completed */
962
1133
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
963
1134
                                              &sigchld_action.sa_mask,
964
1135
                                              NULL));
965
1136
    if(ret < 0){
966
 
      perror("sigprocmask");
967
 
      exitstatus = EXIT_FAILURE;
 
1137
      error(0, errno, "sigprocmask");
 
1138
      exitstatus = EX_OSERR;
968
1139
      goto fallback;
969
1140
    }
970
1141
    
975
1146
    }
976
1147
  }
977
1148
  
978
 
  TEMP_FAILURE_RETRY(closedir(dir));
979
 
  dir = NULL;
 
1149
  free(direntries);
 
1150
  direntries = NULL;
 
1151
  close(dir_fd);
 
1152
  dir_fd = -1;
980
1153
  free_plugin(getplugin(NULL));
981
1154
  
982
1155
  for(plugin *p = plugin_list; p != NULL; p = p->next){
995
1168
    fd_set rfds = rfds_all;
996
1169
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
997
1170
    if(select_ret == -1 and errno != EINTR){
998
 
      perror("select");
999
 
      exitstatus = EXIT_FAILURE;
 
1171
      error(0, errno, "select");
 
1172
      exitstatus = EX_OSERR;
1000
1173
      goto fallback;
1001
1174
    }
1002
1175
    /* OK, now either a process completed, or something can be read
1021
1194
                      (intmax_t) (proc->pid),
1022
1195
                      WTERMSIG(proc->status),
1023
1196
                      strsignal(WTERMSIG(proc->status)));
1024
 
            } else if(WCOREDUMP(proc->status)){
1025
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1026
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1027
1197
            }
1028
1198
          }
1029
1199
          
1036
1206
                                         &sigchld_action.sa_mask,
1037
1207
                                         NULL));
1038
1208
          if(ret < 0){
1039
 
            perror("sigprocmask");
1040
 
            exitstatus = EXIT_FAILURE;
 
1209
            error(0, errno, "sigprocmask");
 
1210
            exitstatus = EX_OSERR;
1041
1211
            goto fallback;
1042
1212
          }
1043
1213
          
1050
1220
                      (sigprocmask(SIG_UNBLOCK,
1051
1221
                                   &sigchld_action.sa_mask, NULL)));
1052
1222
          if(ret < 0){
1053
 
            perror("sigprocmask");
1054
 
            exitstatus = EXIT_FAILURE;
 
1223
            error(0, errno, "sigprocmask");
 
1224
            exitstatus = EX_OSERR;
1055
1225
            goto fallback;
1056
1226
          }
1057
1227
          
1067
1237
        bool bret = print_out_password(proc->buffer,
1068
1238
                                       proc->buffer_length);
1069
1239
        if(not bret){
1070
 
          perror("print_out_password");
1071
 
          exitstatus = EXIT_FAILURE;
 
1240
          error(0, errno, "print_out_password");
 
1241
          exitstatus = EX_IOERR;
1072
1242
        }
1073
1243
        goto fallback;
1074
1244
      }
1081
1251
      }
1082
1252
      /* Before reading, make the process' data buffer large enough */
1083
1253
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1084
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1085
 
                               + (size_t) BUFFER_SIZE);
1086
 
        if(proc->buffer == NULL){
1087
 
          perror("malloc");
1088
 
          exitstatus = EXIT_FAILURE;
 
1254
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1255
                                   + (size_t) BUFFER_SIZE);
 
1256
        if(new_buffer == NULL){
 
1257
          error(0, errno, "malloc");
 
1258
          exitstatus = EX_OSERR;
1089
1259
          goto fallback;
1090
1260
        }
 
1261
        proc->buffer = new_buffer;
1091
1262
        proc->buffer_size += BUFFER_SIZE;
1092
1263
      }
1093
1264
      /* Read from the process */
1112
1283
  
1113
1284
 fallback:
1114
1285
  
1115
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1286
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1287
                             and exitstatus != EX_OK)){
1116
1288
    /* Fallback if all plugins failed, none are found or an error
1117
1289
       occured */
1118
1290
    bool bret;
1126
1298
    }
1127
1299
    bret = print_out_password(passwordbuffer, len);
1128
1300
    if(not bret){
1129
 
      perror("print_out_password");
1130
 
      exitstatus = EXIT_FAILURE;
 
1301
      error(0, errno, "print_out_password");
 
1302
      exitstatus = EX_IOERR;
1131
1303
    }
1132
1304
  }
1133
1305
  
1134
1306
  /* Restore old signal handler */
1135
1307
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1136
1308
  if(ret == -1){
1137
 
    perror("sigaction");
1138
 
    exitstatus = EXIT_FAILURE;
 
1309
    error(0, errno, "sigaction");
 
1310
    exitstatus = EX_OSERR;
1139
1311
  }
1140
1312
  
1141
1313
  if(custom_argv != NULL){
1145
1317
    free(custom_argv);
1146
1318
  }
1147
1319
  
1148
 
  if(dir != NULL){
1149
 
    closedir(dir);
 
1320
  free(direntries);
 
1321
  
 
1322
  if(dir_fd != -1){
 
1323
    close(dir_fd);
1150
1324
  }
1151
1325
  
1152
1326
  /* Kill the processes */
1156
1330
      ret = kill(p->pid, SIGTERM);
1157
1331
      if(ret == -1 and errno != ESRCH){
1158
1332
        /* Set-uid proccesses might not get closed */
1159
 
        perror("kill");
 
1333
        error(0, errno, "kill");
1160
1334
      }
1161
1335
    }
1162
1336
  }
1166
1340
    ret = wait(NULL);
1167
1341
  } while(ret >= 0);
1168
1342
  if(errno != ECHILD){
1169
 
    perror("wait");
 
1343
    error(0, errno, "wait");
1170
1344
  }
1171
1345
  
1172
1346
  free_plugin_list();
1173
1347
  
1174
1348
  free(plugindir);
 
1349
  free(pluginhelperdir);
1175
1350
  free(argfile);
1176
1351
  
1177
1352
  return exitstatus;