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