/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

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