/mandos/release

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

Show diffs side-by-side

added added

removed removed

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