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