/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: 2021-02-01 19:30:45 UTC
  • mto: This revision was merged to the branch mainline in revision 404.
  • Revision ID: teddy@recompile.se-20210201193045-lpg6aprpc4srem6k
Fix issue with french translation

Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation.  The string is a raw command line command, and therefore
did not need translation, so this was never a user-visible issue.

* debian/po/fr.po: Add missing whitespace to the id and translation
  for msgid " mandos-keygen -F/dev/null|grep ^key_id".

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-2020 Teddy Hogeborn
 
6
 * Copyright © 2008-2020 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf() */
 
27
                                   O_CLOEXEC, pipe2() */
27
28
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
29
 
                                   EXIT_SUCCESS, realloc() */
 
29
#include <stdlib.h>             /* malloc(), reallocarray(), realloc(),
 
30
                                   EXIT_SUCCESS, exit() */
30
31
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
 
32
#include <stdio.h>              /* fileno(), fprintf(),
 
33
                                   stderr, STDOUT_FILENO, fclose() */
 
34
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
35
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
36
                                   pid_t, uid_t, gid_t, getuid(),
 
37
                                   getgid() */
38
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS() */
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
                                   lstat(), symlink() */
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;
89
97
  size_t buffer_size;
90
98
  size_t buffer_length;
91
99
  bool eof;
92
 
  volatile bool completed;
93
 
  volatile int status;
 
100
  volatile sig_atomic_t completed;
 
101
  int status;
94
102
  struct plugin *next;
95
103
} plugin;
96
104
 
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
  }
122
138
  
123
 
  *new_plugin = (plugin) { .name = copy_name,
124
 
                           .argc = 1,
125
 
                           .disabled = false,
126
 
                           .next = plugin_list };
 
139
  *new_plugin = (plugin){ .name = copy_name,
 
140
                          .argc = 1,
 
141
                          .disabled = false,
 
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
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
183
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
184
                             sizeof(char *));
 
185
#else
 
186
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
187
      /* overflow */
 
188
      new_array = NULL;
 
189
      errno = ENOMEM;
 
190
    } else {
 
191
      new_array = realloc(*array, (size_t)((*len) + 2)
 
192
                          * sizeof(char *));
 
193
    }
 
194
#endif
 
195
  } while(new_array == NULL and errno == EINTR);
157
196
  /* Malloc check */
158
 
  if(*array == NULL){
 
197
  if(new_array == NULL){
159
198
    return false;
160
199
  }
 
200
  *array = new_array;
161
201
  /* Make a copy of the new string */
162
 
  char *copy = strdup(new);
 
202
  char *copy;
 
203
  do {
 
204
    copy = strdup(new);
 
205
  } while(copy == NULL and errno == EINTR);
163
206
  if(copy == NULL){
164
207
    return false;
165
208
  }
172
215
}
173
216
 
174
217
/* Add to a plugin's argument vector */
 
218
__attribute__((nonnull(2), warn_unused_result))
175
219
static bool add_argument(plugin *p, const char *arg){
176
220
  if(p == NULL){
177
221
    return false;
180
224
}
181
225
 
182
226
/* Add to a plugin's environment */
 
227
__attribute__((nonnull(2), warn_unused_result))
183
228
static bool add_environment(plugin *p, const char *def, bool replace){
184
229
  if(p == NULL){
185
230
    return false;
187
232
  /* namelen = length of name of environment variable */
188
233
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
189
234
  /* Search for this environment variable */
190
 
  for(char **e = p->environ; *e != NULL; e++){
191
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
235
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
236
    if(strncmp(*envdef, def, namelen + 1) == 0){
192
237
      /* It already exists */
193
238
      if(replace){
194
 
        char *new = realloc(*e, strlen(def) + 1);
195
 
        if(new == NULL){
 
239
        char *new_envdef;
 
240
        do {
 
241
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
242
        } while(new_envdef == NULL and errno == EINTR);
 
243
        if(new_envdef == NULL){
196
244
          return false;
197
245
        }
198
 
        *e = new;
199
 
        strcpy(*e, def);
 
246
        *envdef = new_envdef;
 
247
        strcpy(*envdef, def);
200
248
      }
201
249
      return true;
202
250
    }
204
252
  return add_to_char_array(def, &(p->environ), &(p->envc));
205
253
}
206
254
 
 
255
#ifndef O_CLOEXEC
207
256
/*
208
257
 * Based on the example in the GNU LibC manual chapter 13.13 "File
209
258
 * Descriptor Flags".
210
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
 
259
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
211
260
 */
 
261
__attribute__((warn_unused_result))
212
262
static int set_cloexec_flag(int fd){
213
 
  int ret = fcntl(fd, F_GETFD, 0);
 
263
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
214
264
  /* If reading the flags failed, return error indication now. */
215
265
  if(ret < 0){
216
266
    return ret;
217
267
  }
218
268
  /* Store modified flag word in the descriptor. */
219
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
 
269
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
 
270
                                       ret | FD_CLOEXEC));
220
271
}
 
272
#endif  /* not O_CLOEXEC */
221
273
 
222
274
 
223
275
/* Mark processes as completed when they exit, and save their exit
224
276
   status. */
225
277
static void handle_sigchld(__attribute__((unused)) int sig){
 
278
  int old_errno = errno;
226
279
  while(true){
227
280
    plugin *proc = plugin_list;
228
281
    int status;
232
285
      break;
233
286
    }
234
287
    if(pid == -1){
235
 
      if(errno != ECHILD){
236
 
        perror("waitpid");
 
288
      if(errno == ECHILD){
 
289
        /* No child processes */
 
290
        break;
237
291
      }
238
 
      /* No child processes */
239
 
      break;
 
292
      error(0, errno, "waitpid");
240
293
    }
241
294
    
242
295
    /* A child exited, find it in process_list */
248
301
      continue;
249
302
    }
250
303
    proc->status = status;
251
 
    proc->completed = true;
 
304
    proc->completed = 1;
252
305
  }
 
306
  errno = old_errno;
253
307
}
254
308
 
255
309
/* Prints out a password to stdout */
 
310
__attribute__((nonnull, warn_unused_result))
256
311
static bool print_out_password(const char *buffer, size_t length){
257
312
  ssize_t ret;
258
313
  for(size_t written = 0; written < length; written += (size_t)ret){
266
321
}
267
322
 
268
323
/* Removes and free a plugin from the plugin list */
 
324
__attribute__((nonnull))
269
325
static void free_plugin(plugin *plugin_node){
270
326
  
271
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
327
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
272
328
    free(*arg);
273
329
  }
 
330
  free(plugin_node->name);
274
331
  free(plugin_node->argv);
275
332
  for(char **env = plugin_node->environ; *env != NULL; env++){
276
333
    free(*env);
277
334
  }
278
335
  free(plugin_node->environ);
279
336
  free(plugin_node->buffer);
280
 
 
 
337
  
281
338
  /* Removes the plugin from the singly-linked list */
282
339
  if(plugin_node == plugin_list){
283
340
    /* First one - simple */
303
360
 
304
361
int main(int argc, char *argv[]){
305
362
  char *plugindir = NULL;
 
363
  char *pluginhelperdir = NULL;
306
364
  char *argfile = NULL;
307
365
  FILE *conffp;
308
 
  size_t d_name_len;
309
 
  DIR *dir = NULL;
310
 
  struct dirent *dirst;
 
366
  struct dirent **direntries = NULL;
311
367
  struct stat st;
312
368
  fd_set rfds_all;
313
 
  int ret, numchars, maxfd = 0;
 
369
  int ret, maxfd = 0;
314
370
  ssize_t sret;
315
 
  intmax_t tmpmax;
316
371
  uid_t uid = 65534;
317
372
  gid_t gid = 65534;
318
373
  bool debug = false;
322
377
                                      .sa_flags = SA_NOCLDSTOP };
323
378
  char **custom_argv = NULL;
324
379
  int custom_argc = 0;
 
380
  int dir_fd = -1;
325
381
  
326
382
  /* Establish a signal handler */
327
383
  sigemptyset(&sigchld_action.sa_mask);
328
384
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
329
385
  if(ret == -1){
330
 
    perror("sigaddset");
331
 
    exitstatus = EXIT_FAILURE;
 
386
    error(0, errno, "sigaddset");
 
387
    exitstatus = EX_OSERR;
332
388
    goto fallback;
333
389
  }
334
390
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
335
391
  if(ret == -1){
336
 
    perror("sigaction");
337
 
    exitstatus = EXIT_FAILURE;
 
392
    error(0, errno, "sigaction");
 
393
    exitstatus = EX_OSERR;
338
394
    goto fallback;
339
395
  }
340
396
  
372
428
      .doc = "Group ID the plugins will run as", .group = 3 },
373
429
    { .name = "debug", .key = 132,
374
430
      .doc = "Debug mode", .group = 4 },
 
431
    { .name = "plugin-helper-dir", .key = 133,
 
432
      .arg = "DIRECTORY",
 
433
      .doc = "Specify a different plugin helper directory",
 
434
      .group = 2 },
 
435
    /*
 
436
     * These reproduce what we would get without ARGP_NO_HELP
 
437
     */
 
438
    { .name = "help", .key = '?',
 
439
      .doc = "Give this help list", .group = -1 },
 
440
    { .name = "usage", .key = -3,
 
441
      .doc = "Give a short usage message", .group = -1 },
 
442
    { .name = "version", .key = 'V',
 
443
      .doc = "Print program version", .group = -1 },
375
444
    { .name = NULL }
376
445
  };
377
446
  
378
 
  error_t parse_opt(int key, char *arg, __attribute__((unused))
379
 
                    struct argp_state *state) {
380
 
    switch(key) {
 
447
  __attribute__((nonnull(3)))
 
448
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
449
    errno = 0;
 
450
    switch(key){
 
451
      char *tmp;
 
452
      intmax_t tmp_id;
381
453
    case 'g':                   /* --global-options */
382
 
      if(arg != NULL){
383
 
        char *p;
384
 
        while((p = strsep(&arg, ",")) != NULL){
385
 
          if(p[0] == '\0'){
386
 
            continue;
387
 
          }
388
 
          if(not add_argument(getplugin(NULL), p)){
389
 
            perror("add_argument");
390
 
            return ARGP_ERR_UNKNOWN;
 
454
      {
 
455
        char *plugin_option;
 
456
        while((plugin_option = strsep(&arg, ",")) != NULL){
 
457
          if(not add_argument(getplugin(NULL), plugin_option)){
 
458
            break;
391
459
          }
392
460
        }
 
461
        errno = 0;
393
462
      }
394
463
      break;
395
464
    case 'G':                   /* --global-env */
396
 
      if(arg == NULL){
397
 
        break;
398
 
      }
399
 
      if(not add_environment(getplugin(NULL), arg, true)){
400
 
        perror("add_environment");
 
465
      if(add_environment(getplugin(NULL), arg, true)){
 
466
        errno = 0;
401
467
      }
402
468
      break;
403
469
    case 'o':                   /* --options-for */
404
 
      if(arg != NULL){
405
 
        char *p_name = strsep(&arg, ":");
406
 
        if(p_name[0] == '\0' or arg == NULL){
407
 
          break;
408
 
        }
409
 
        char *opt = strsep(&arg, ":");
410
 
        if(opt[0] == '\0' or opt == NULL){
411
 
          break;
412
 
        }
413
 
        char *p;
414
 
        while((p = strsep(&opt, ",")) != NULL){
415
 
          if(p[0] == '\0'){
416
 
            continue;
417
 
          }
418
 
          if(not add_argument(getplugin(p_name), p)){
419
 
            perror("add_argument");
420
 
            return ARGP_ERR_UNKNOWN;
421
 
          }
422
 
        }
 
470
      {
 
471
        char *option_list = strchr(arg, ':');
 
472
        if(option_list == NULL){
 
473
          argp_error(state, "No colon in \"%s\"", arg);
 
474
          errno = EINVAL;
 
475
          break;
 
476
        }
 
477
        *option_list = '\0';
 
478
        option_list++;
 
479
        if(arg[0] == '\0'){
 
480
          argp_error(state, "Empty plugin name");
 
481
          errno = EINVAL;
 
482
          break;
 
483
        }
 
484
        char *option;
 
485
        while((option = strsep(&option_list, ",")) != NULL){
 
486
          if(not add_argument(getplugin(arg), option)){
 
487
            break;
 
488
          }
 
489
        }
 
490
        errno = 0;
423
491
      }
424
492
      break;
425
493
    case 'E':                   /* --env-for */
426
 
      if(arg == NULL){
427
 
        break;
428
 
      }
429
494
      {
430
495
        char *envdef = strchr(arg, ':');
431
496
        if(envdef == NULL){
 
497
          argp_error(state, "No colon in \"%s\"", arg);
 
498
          errno = EINVAL;
432
499
          break;
433
500
        }
434
501
        *envdef = '\0';
435
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
436
 
          perror("add_environment");
 
502
        envdef++;
 
503
        if(arg[0] == '\0'){
 
504
          argp_error(state, "Empty plugin name");
 
505
          errno = EINVAL;
 
506
          break;
 
507
        }
 
508
        if(add_environment(getplugin(arg), envdef, true)){
 
509
          errno = 0;
437
510
        }
438
511
      }
439
512
      break;
440
513
    case 'd':                   /* --disable */
441
 
      if(arg != NULL){
 
514
      {
442
515
        plugin *p = getplugin(arg);
443
 
        if(p == NULL){
444
 
          return ARGP_ERR_UNKNOWN;
 
516
        if(p != NULL){
 
517
          p->disabled = true;
 
518
          errno = 0;
445
519
        }
446
 
        p->disabled = true;
447
520
      }
448
521
      break;
449
522
    case 'e':                   /* --enable */
450
 
      if(arg != NULL){
 
523
      {
451
524
        plugin *p = getplugin(arg);
452
 
        if(p == NULL){
453
 
          return ARGP_ERR_UNKNOWN;
 
525
        if(p != NULL){
 
526
          p->disabled = false;
 
527
          errno = 0;
454
528
        }
455
 
        p->disabled = false;
456
529
      }
457
530
      break;
458
531
    case 128:                   /* --plugin-dir */
459
532
      free(plugindir);
460
533
      plugindir = strdup(arg);
461
 
      if(plugindir == NULL){
462
 
        perror("strdup");
463
 
      }      
 
534
      if(plugindir != NULL){
 
535
        errno = 0;
 
536
      }
464
537
      break;
465
538
    case 129:                   /* --config-file */
466
539
      /* This is already done by parse_opt_config_file() */
467
540
      break;
468
541
    case 130:                   /* --userid */
469
 
      ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
470
 
      if(ret < 1 or tmpmax != (uid_t)tmpmax
471
 
         or arg[numchars] != '\0'){
472
 
        fprintf(stderr, "Bad user ID number: \"%s\", using %"
473
 
                PRIdMAX "\n", arg, (intmax_t)uid);
474
 
      } else {
475
 
        uid = (uid_t)tmpmax;
 
542
      tmp_id = strtoimax(arg, &tmp, 10);
 
543
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
544
         or tmp_id != (uid_t)tmp_id){
 
545
        argp_error(state, "Bad user ID number: \"%s\", using %"
 
546
                   PRIdMAX, arg, (intmax_t)uid);
 
547
        break;
476
548
      }
 
549
      uid = (uid_t)tmp_id;
 
550
      errno = 0;
477
551
      break;
478
552
    case 131:                   /* --groupid */
479
 
      ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
480
 
      if(ret < 1 or tmpmax != (gid_t)tmpmax
481
 
         or arg[numchars] != '\0'){
482
 
        fprintf(stderr, "Bad group ID number: \"%s\", using %"
483
 
                PRIdMAX "\n", arg, (intmax_t)gid);
484
 
      } else {
485
 
        gid = (gid_t)tmpmax;
 
553
      tmp_id = strtoimax(arg, &tmp, 10);
 
554
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
555
         or tmp_id != (gid_t)tmp_id){
 
556
        argp_error(state, "Bad group ID number: \"%s\", using %"
 
557
                   PRIdMAX, arg, (intmax_t)gid);
 
558
        break;
486
559
      }
 
560
      gid = (gid_t)tmp_id;
 
561
      errno = 0;
487
562
      break;
488
563
    case 132:                   /* --debug */
489
564
      debug = true;
490
565
      break;
 
566
    case 133:                   /* --plugin-helper-dir */
 
567
      free(pluginhelperdir);
 
568
      pluginhelperdir = strdup(arg);
 
569
      if(pluginhelperdir != NULL){
 
570
        errno = 0;
 
571
      }
 
572
      break;
 
573
      /*
 
574
       * These reproduce what we would get without ARGP_NO_HELP
 
575
       */
 
576
    case '?':                   /* --help */
 
577
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
578
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
579
      __builtin_unreachable();
 
580
    case -3:                    /* --usage */
 
581
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
582
      argp_state_help(state, state->out_stream,
 
583
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
584
      __builtin_unreachable();
 
585
    case 'V':                   /* --version */
 
586
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
587
      exit(EXIT_SUCCESS);
 
588
      break;
491
589
/*
492
590
 * When adding more options before this line, remember to also add a
493
591
 * "case" to the "parse_opt_config_file" function below.
496
594
      /* Cryptsetup always passes an argument, which is an empty
497
595
         string if "none" was specified in /etc/crypttab.  So if
498
596
         argument was empty, we ignore it silently. */
499
 
      if(arg[0] != '\0'){
500
 
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
597
      if(arg[0] == '\0'){
 
598
        break;
501
599
      }
502
 
      break;
503
 
    case ARGP_KEY_END:
504
 
      break;
 
600
#if __GNUC__ >= 7
 
601
      __attribute__((fallthrough));
 
602
#else
 
603
          /* FALLTHROUGH */
 
604
#endif
505
605
    default:
506
606
      return ARGP_ERR_UNKNOWN;
507
607
    }
508
 
    return 0;
 
608
    return errno;               /* Set to 0 at start */
509
609
  }
510
610
  
511
611
  /* This option parser is the same as parse_opt() above, except it
512
612
     ignores everything but the --config-file option. */
513
613
  error_t parse_opt_config_file(int key, char *arg,
514
614
                                __attribute__((unused))
515
 
                                struct argp_state *state) {
516
 
    switch(key) {
 
615
                                struct argp_state *state){
 
616
    errno = 0;
 
617
    switch(key){
517
618
    case 'g':                   /* --global-options */
518
619
    case 'G':                   /* --global-env */
519
620
    case 'o':                   /* --options-for */
525
626
    case 129:                   /* --config-file */
526
627
      free(argfile);
527
628
      argfile = strdup(arg);
528
 
      if(argfile == NULL){
529
 
        perror("strdup");
 
629
      if(argfile != NULL){
 
630
        errno = 0;
530
631
      }
531
 
      break;      
 
632
      break;
532
633
    case 130:                   /* --userid */
533
634
    case 131:                   /* --groupid */
534
635
    case 132:                   /* --debug */
 
636
    case 133:                   /* --plugin-helper-dir */
 
637
    case '?':                   /* --help */
 
638
    case -3:                    /* --usage */
 
639
    case 'V':                   /* --version */
535
640
    case ARGP_KEY_ARG:
536
 
    case ARGP_KEY_END:
537
641
      break;
538
642
    default:
539
643
      return ARGP_ERR_UNKNOWN;
540
644
    }
541
 
    return 0;
 
645
    return errno;
542
646
  }
543
647
  
544
648
  struct argp argp = { .options = options,
548
652
  
549
653
  /* Parse using parse_opt_config_file() in order to get the custom
550
654
     config file location, if any. */
551
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
552
 
  if(ret == ARGP_ERR_UNKNOWN){
553
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
554
 
    exitstatus = EXIT_FAILURE;
 
655
  ret = argp_parse(&argp, argc, argv,
 
656
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
657
                   NULL, NULL);
 
658
  switch(ret){
 
659
  case 0:
 
660
    break;
 
661
  case ENOMEM:
 
662
  default:
 
663
    errno = ret;
 
664
    error(0, errno, "argp_parse");
 
665
    exitstatus = EX_OSERR;
 
666
    goto fallback;
 
667
  case EINVAL:
 
668
    exitstatus = EX_USAGE;
555
669
    goto fallback;
556
670
  }
557
671
  
563
677
    conffp = fopen(AFILE, "r");
564
678
  } else {
565
679
    conffp = fopen(argfile, "r");
566
 
  }  
 
680
  }
567
681
  if(conffp != NULL){
568
682
    char *org_line = NULL;
569
683
    char *p, *arg, *new_arg, *line;
570
684
    size_t size = 0;
571
685
    const char whitespace_delims[] = " \r\t\f\v\n";
572
686
    const char comment_delim[] = "#";
573
 
 
 
687
    
574
688
    custom_argc = 1;
575
689
    custom_argv = malloc(sizeof(char*) * 2);
576
690
    if(custom_argv == NULL){
577
 
      perror("malloc");
578
 
      exitstatus = EXIT_FAILURE;
 
691
      error(0, errno, "malloc");
 
692
      exitstatus = EX_OSERR;
579
693
      goto fallback;
580
694
    }
581
695
    custom_argv[0] = argv[0];
582
696
    custom_argv[1] = NULL;
583
 
 
 
697
    
584
698
    /* for each line in the config file, strip whitespace and ignore
585
699
       commented text */
586
700
    while(true){
588
702
      if(sret == -1){
589
703
        break;
590
704
      }
591
 
 
 
705
      
592
706
      line = org_line;
593
707
      arg = strsep(&line, comment_delim);
594
708
      while((p = strsep(&arg, whitespace_delims)) != NULL){
597
711
        }
598
712
        new_arg = strdup(p);
599
713
        if(new_arg == NULL){
600
 
          perror("strdup");
601
 
          exitstatus = EXIT_FAILURE;
 
714
          error(0, errno, "strdup");
 
715
          exitstatus = EX_OSERR;
602
716
          free(org_line);
603
717
          goto fallback;
604
718
        }
605
719
        
606
720
        custom_argc += 1;
607
 
        custom_argv = realloc(custom_argv, sizeof(char *)
608
 
                              * ((unsigned int) custom_argc + 1));
609
 
        if(custom_argv == NULL){
610
 
          perror("realloc");
611
 
          exitstatus = EXIT_FAILURE;
612
 
          free(org_line);
613
 
          goto fallback;
 
721
        {
 
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
723
          char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
 
724
                                         sizeof(char *));
 
725
#else
 
726
          char **new_argv = NULL;
 
727
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
728
            /* overflow */
 
729
            errno = ENOMEM;
 
730
          } else {
 
731
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
732
                               * sizeof(char *));
 
733
          }
 
734
#endif
 
735
          if(new_argv == NULL){
 
736
            error(0, errno, "reallocarray");
 
737
            exitstatus = EX_OSERR;
 
738
            free(new_arg);
 
739
            free(org_line);
 
740
            goto fallback;
 
741
          } else {
 
742
            custom_argv = new_argv;
 
743
          }
614
744
        }
615
745
        custom_argv[custom_argc-1] = new_arg;
616
 
        custom_argv[custom_argc] = NULL;        
 
746
        custom_argv[custom_argc] = NULL;
617
747
      }
618
748
    }
 
749
    do {
 
750
      ret = fclose(conffp);
 
751
    } while(ret == EOF and errno == EINTR);
 
752
    if(ret == EOF){
 
753
      error(0, errno, "fclose");
 
754
      exitstatus = EX_IOERR;
 
755
      goto fallback;
 
756
    }
619
757
    free(org_line);
620
758
  } else {
621
759
    /* Check for harmful errors and go to fallback. Other errors might
622
760
       not affect opening plugins */
623
761
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
624
 
      perror("fopen");
625
 
      exitstatus = EXIT_FAILURE;
 
762
      error(0, errno, "fopen");
 
763
      exitstatus = EX_OSERR;
626
764
      goto fallback;
627
765
    }
628
766
  }
629
 
  /* If there was any arguments from configuration file,
630
 
     pass them to parser as command arguments */
 
767
  /* If there were any arguments from the configuration file, pass
 
768
     them to parser as command line arguments */
631
769
  if(custom_argv != NULL){
632
 
    ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
633
 
                     0, NULL);
634
 
    if(ret == ARGP_ERR_UNKNOWN){
635
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
636
 
      exitstatus = EXIT_FAILURE;
 
770
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
771
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
772
                     NULL, NULL);
 
773
    switch(ret){
 
774
    case 0:
 
775
      break;
 
776
    case ENOMEM:
 
777
    default:
 
778
      errno = ret;
 
779
      error(0, errno, "argp_parse");
 
780
      exitstatus = EX_OSERR;
 
781
      goto fallback;
 
782
    case EINVAL:
 
783
      exitstatus = EX_CONFIG;
637
784
      goto fallback;
638
785
    }
639
786
  }
640
787
  
641
788
  /* Parse actual command line arguments, to let them override the
642
789
     config file */
643
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
644
 
  if(ret == ARGP_ERR_UNKNOWN){
645
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
646
 
    exitstatus = EXIT_FAILURE;
647
 
    goto fallback;
 
790
  ret = argp_parse(&argp, argc, argv,
 
791
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
792
                   NULL, NULL);
 
793
  switch(ret){
 
794
  case 0:
 
795
    break;
 
796
  case ENOMEM:
 
797
  default:
 
798
    errno = ret;
 
799
    error(0, errno, "argp_parse");
 
800
    exitstatus = EX_OSERR;
 
801
    goto fallback;
 
802
  case EINVAL:
 
803
    exitstatus = EX_USAGE;
 
804
    goto fallback;
 
805
  }
 
806
  
 
807
  {
 
808
    char *pluginhelperenv;
 
809
    bool bret = true;
 
810
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
811
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
812
    if(ret != -1){
 
813
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
814
    }
 
815
    if(ret == -1 or not bret){
 
816
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
817
            " environment variable to \"%s\" for all plugins\n",
 
818
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
819
    }
 
820
    if(ret != -1){
 
821
      free(pluginhelperenv);
 
822
    }
648
823
  }
649
824
  
650
825
  if(debug){
651
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
826
    for(plugin *p = plugin_list; p != NULL; p = p->next){
652
827
      fprintf(stderr, "Plugin: %s has %d arguments\n",
653
828
              p->name ? p->name : "Global", p->argc - 1);
654
829
      for(char **a = p->argv; *a != NULL; a++){
661
836
    }
662
837
  }
663
838
  
664
 
  /* Strip permissions down to nobody */
 
839
  if(getuid() == 0){
 
840
    /* Work around Debian bug #633582:
 
841
       <https://bugs.debian.org/633582> */
 
842
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
843
    if(plugindir_fd == -1){
 
844
      if(errno != ENOENT){
 
845
        error(0, errno, "open(\"" PDIR "\")");
 
846
      }
 
847
    } else {
 
848
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
849
      if(ret == -1){
 
850
        error(0, errno, "fstat");
 
851
      } else {
 
852
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
853
          ret = fchown(plugindir_fd, uid, gid);
 
854
          if(ret == -1){
 
855
            error(0, errno, "fchown");
 
856
          }
 
857
        }
 
858
      }
 
859
      close(plugindir_fd);
 
860
    }
 
861
 
 
862
    /* Work around Debian bug #981302
 
863
       <https://bugs.debian.org/981302> */
 
864
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
865
      ret = symlink("/proc/self/fd", "/dev/fd");
 
866
      if(ret == -1){
 
867
        error(0, errno, "Failed to create /dev/fd symlink");
 
868
      }
 
869
    }
 
870
  }
 
871
  
 
872
  /* Lower permissions */
 
873
  ret = setgid(gid);
 
874
  if(ret == -1){
 
875
    error(0, errno, "setgid");
 
876
  }
665
877
  ret = setuid(uid);
666
878
  if(ret == -1){
667
 
    perror("setuid");
668
 
  }  
669
 
  setgid(gid);
670
 
  if(ret == -1){
671
 
    perror("setgid");
672
 
  }
673
 
  
674
 
  if(plugindir == NULL){
675
 
    dir = opendir(PDIR);
676
 
  } else {
677
 
    dir = opendir(plugindir);
678
 
  }
679
 
  
680
 
  if(dir == NULL){
681
 
    perror("Could not open plugin dir");
682
 
    exitstatus = EXIT_FAILURE;
683
 
    goto fallback;
684
 
  }
685
 
  
686
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
 
879
    error(0, errno, "setuid");
 
880
  }
 
881
  
 
882
  /* Open plugin directory with close_on_exec flag */
687
883
  {
688
 
    int dir_fd = dirfd(dir);
689
 
    if(dir_fd >= 0){
690
 
      ret = set_cloexec_flag(dir_fd);
691
 
      if(ret < 0){
692
 
        perror("set_cloexec_flag");
693
 
        exitstatus = EXIT_FAILURE;
694
 
        goto fallback;
 
884
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
885
#ifdef O_CLOEXEC
 
886
                  O_CLOEXEC
 
887
#else  /* not O_CLOEXEC */
 
888
                  0
 
889
#endif  /* not O_CLOEXEC */
 
890
                  );
 
891
    if(dir_fd == -1){
 
892
      error(0, errno, "Could not open plugin dir");
 
893
      exitstatus = EX_UNAVAILABLE;
 
894
      goto fallback;
 
895
    }
 
896
    
 
897
#ifndef O_CLOEXEC
 
898
  /* Set the FD_CLOEXEC flag on the directory */
 
899
    ret = set_cloexec_flag(dir_fd);
 
900
    if(ret < 0){
 
901
      error(0, errno, "set_cloexec_flag");
 
902
      exitstatus = EX_OSERR;
 
903
      goto fallback;
 
904
    }
 
905
#endif  /* O_CLOEXEC */
 
906
  }
 
907
  
 
908
  int good_name(const struct dirent * const dirent){
 
909
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
910
                                      "*.dpkg-old", "*.dpkg-bak",
 
911
                                      "*.dpkg-divert", NULL };
 
912
#ifdef __GNUC__
 
913
#pragma GCC diagnostic push
 
914
#pragma GCC diagnostic ignored "-Wcast-qual"
 
915
#endif
 
916
    for(const char **pat = (const char **)patterns;
 
917
        *pat != NULL; pat++){
 
918
#ifdef __GNUC__
 
919
#pragma GCC diagnostic pop
 
920
#endif
 
921
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
922
         != FNM_NOMATCH){
 
923
        if(debug){
 
924
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
925
                    " matching pattern %s\n", dirent->d_name, *pat);
 
926
        }
 
927
        return 0;
695
928
      }
696
929
    }
 
930
    return 1;
 
931
  }
 
932
  
 
933
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
934
                             alphasort);
 
935
  if(numplugins == -1){
 
936
    error(0, errno, "Could not scan plugin dir");
 
937
    direntries = NULL;
 
938
    exitstatus = EX_OSERR;
 
939
    goto fallback;
697
940
  }
698
941
  
699
942
  FD_ZERO(&rfds_all);
700
943
  
701
944
  /* Read and execute any executable in the plugin directory*/
702
 
  while(true){
703
 
    dirst = readdir(dir);
704
 
    
705
 
    /* All directory entries have been processed */
706
 
    if(dirst == NULL){
707
 
      if(errno == EBADF){
708
 
        perror("readdir");
709
 
        exitstatus = EXIT_FAILURE;
710
 
        goto fallback;
711
 
      }
712
 
      break;
713
 
    }
714
 
    
715
 
    d_name_len = strlen(dirst->d_name);
716
 
    
717
 
    /* Ignore dotfiles, backup files and other junk */
718
 
    {
719
 
      bool bad_name = false;
720
 
      
721
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
722
 
      
723
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
724
 
                                           ".dpkg-old",
725
 
                                           ".dpkg-bak",
726
 
                                           ".dpkg-divert", NULL };
727
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
728
 
        size_t pre_len = strlen(*pre);
729
 
        if((d_name_len >= pre_len)
730
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
731
 
          if(debug){
732
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
733
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
734
 
          }
735
 
          bad_name = true;
736
 
          break;
737
 
        }
738
 
      }
739
 
      if(bad_name){
740
 
        continue;
741
 
      }
742
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
743
 
        size_t suf_len = strlen(*suf);
744
 
        if((d_name_len >= suf_len)
745
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
746
 
                == 0)){
747
 
          if(debug){
748
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
749
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
750
 
          }
751
 
          bad_name = true;
752
 
          break;
753
 
        }
754
 
      }
755
 
      
756
 
      if(bad_name){
757
 
        continue;
758
 
      }
759
 
    }
760
 
 
761
 
    char *filename;
762
 
    if(plugindir == NULL){
763
 
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
764
 
    } else {
765
 
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
766
 
    }
767
 
    if(ret < 0){
768
 
      perror("asprintf");
 
945
  for(int i = 0; i < numplugins; i++){
 
946
    
 
947
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
948
    if(plugin_fd == -1){
 
949
      error(0, errno, "Could not open plugin");
 
950
      free(direntries[i]);
769
951
      continue;
770
952
    }
771
 
    
772
 
    ret = stat(filename, &st);
 
953
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
773
954
    if(ret == -1){
774
 
      perror("stat");
775
 
      free(filename);
 
955
      error(0, errno, "stat");
 
956
      close(plugin_fd);
 
957
      free(direntries[i]);
776
958
      continue;
777
959
    }
778
 
 
 
960
    
779
961
    /* Ignore non-executable files */
780
 
    if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
 
962
    if(not S_ISREG(st.st_mode)
 
963
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
964
                                        X_OK, 0)) != 0)){
781
965
      if(debug){
782
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
783
 
                " with bad type or mode\n", filename);
 
966
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
967
                " with bad type or mode\n",
 
968
                plugindir != NULL ? plugindir : PDIR,
 
969
                direntries[i]->d_name);
784
970
      }
785
 
      free(filename);
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
786
973
      continue;
787
974
    }
788
975
    
789
 
    plugin *p = getplugin(dirst->d_name);
 
976
    plugin *p = getplugin(direntries[i]->d_name);
790
977
    if(p == NULL){
791
 
      perror("getplugin");
792
 
      free(filename);
 
978
      error(0, errno, "getplugin");
 
979
      close(plugin_fd);
 
980
      free(direntries[i]);
793
981
      continue;
794
982
    }
795
983
    if(p->disabled){
796
984
      if(debug){
797
985
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
798
 
                dirst->d_name);
 
986
                direntries[i]->d_name);
799
987
      }
800
 
      free(filename);
 
988
      close(plugin_fd);
 
989
      free(direntries[i]);
801
990
      continue;
802
991
    }
803
992
    {
806
995
      if(g != NULL){
807
996
        for(char **a = g->argv + 1; *a != NULL; a++){
808
997
          if(not add_argument(p, *a)){
809
 
            perror("add_argument");
 
998
            error(0, errno, "add_argument");
810
999
          }
811
1000
        }
812
1001
        /* Add global environment variables */
813
1002
        for(char **e = g->environ; *e != NULL; e++){
814
1003
          if(not add_environment(p, *e, false)){
815
 
            perror("add_environment");
 
1004
            error(0, errno, "add_environment");
816
1005
          }
817
1006
        }
818
1007
      }
819
1008
    }
820
 
    /* If this plugin has any environment variables, we will call
821
 
       using execve and need to duplicate the environment from this
822
 
       process, too. */
 
1009
    /* If this plugin has any environment variables, we need to
 
1010
       duplicate the environment from this process, too. */
823
1011
    if(p->environ[0] != NULL){
824
1012
      for(char **e = environ; *e != NULL; e++){
825
1013
        if(not add_environment(p, *e, false)){
826
 
          perror("add_environment");
 
1014
          error(0, errno, "add_environment");
827
1015
        }
828
1016
      }
829
1017
    }
830
1018
    
831
1019
    int pipefd[2];
832
 
    ret = pipe(pipefd);
 
1020
#ifndef O_CLOEXEC
 
1021
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1022
#else  /* O_CLOEXEC */
 
1023
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1024
#endif  /* O_CLOEXEC */
833
1025
    if(ret == -1){
834
 
      perror("pipe");
835
 
      exitstatus = EXIT_FAILURE;
836
 
      goto fallback;
837
 
    }
 
1026
      error(0, errno, "pipe");
 
1027
      exitstatus = EX_OSERR;
 
1028
      free(direntries[i]);
 
1029
      goto fallback;
 
1030
    }
 
1031
    if(pipefd[0] >= FD_SETSIZE){
 
1032
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1033
              FD_SETSIZE);
 
1034
      close(pipefd[0]);
 
1035
      close(pipefd[1]);
 
1036
      exitstatus = EX_OSERR;
 
1037
      free(direntries[i]);
 
1038
      goto fallback;
 
1039
    }
 
1040
#ifndef O_CLOEXEC
838
1041
    /* Ask OS to automatic close the pipe on exec */
839
1042
    ret = set_cloexec_flag(pipefd[0]);
840
1043
    if(ret < 0){
841
 
      perror("set_cloexec_flag");
842
 
      exitstatus = EXIT_FAILURE;
 
1044
      error(0, errno, "set_cloexec_flag");
 
1045
      close(pipefd[0]);
 
1046
      close(pipefd[1]);
 
1047
      exitstatus = EX_OSERR;
 
1048
      free(direntries[i]);
843
1049
      goto fallback;
844
1050
    }
845
1051
    ret = set_cloexec_flag(pipefd[1]);
846
1052
    if(ret < 0){
847
 
      perror("set_cloexec_flag");
848
 
      exitstatus = EXIT_FAILURE;
 
1053
      error(0, errno, "set_cloexec_flag");
 
1054
      close(pipefd[0]);
 
1055
      close(pipefd[1]);
 
1056
      exitstatus = EX_OSERR;
 
1057
      free(direntries[i]);
849
1058
      goto fallback;
850
1059
    }
 
1060
#endif  /* not O_CLOEXEC */
851
1061
    /* Block SIGCHLD until process is safely in process list */
852
 
    ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1062
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
 
1063
                                              &sigchld_action.sa_mask,
 
1064
                                              NULL));
853
1065
    if(ret < 0){
854
 
      perror("sigprocmask");
855
 
      exitstatus = EXIT_FAILURE;
 
1066
      error(0, errno, "sigprocmask");
 
1067
      exitstatus = EX_OSERR;
 
1068
      free(direntries[i]);
856
1069
      goto fallback;
857
1070
    }
858
1071
    /* Starting a new process to be watched */
859
 
    pid_t pid = fork();
 
1072
    pid_t pid;
 
1073
    do {
 
1074
      pid = fork();
 
1075
    } while(pid == -1 and errno == EINTR);
860
1076
    if(pid == -1){
861
 
      perror("fork");
862
 
      exitstatus = EXIT_FAILURE;
 
1077
      error(0, errno, "fork");
 
1078
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1079
                                     &sigchld_action.sa_mask, NULL));
 
1080
      close(pipefd[0]);
 
1081
      close(pipefd[1]);
 
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
863
1084
      goto fallback;
864
1085
    }
865
1086
    if(pid == 0){
866
1087
      /* this is the child process */
867
1088
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
868
1089
      if(ret < 0){
869
 
        perror("sigaction");
870
 
        _exit(EXIT_FAILURE);
 
1090
        error(0, errno, "sigaction");
 
1091
        _exit(EX_OSERR);
871
1092
      }
872
1093
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
873
1094
      if(ret < 0){
874
 
        perror("sigprocmask");
875
 
        _exit(EXIT_FAILURE);
 
1095
        error(0, errno, "sigprocmask");
 
1096
        _exit(EX_OSERR);
876
1097
      }
877
1098
      
878
1099
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
879
1100
      if(ret == -1){
880
 
        perror("dup2");
881
 
        _exit(EXIT_FAILURE);
 
1101
        error(0, errno, "dup2");
 
1102
        _exit(EX_OSERR);
882
1103
      }
883
1104
      
884
 
      if(dirfd(dir) < 0){
885
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
886
 
           above and must now close it manually here. */
887
 
        closedir(dir);
888
 
      }
889
 
      if(p->environ[0] == NULL){
890
 
        if(execv(filename, p->argv) < 0){
891
 
          perror("execv");
892
 
          _exit(EXIT_FAILURE);
893
 
        }
894
 
      } else {
895
 
        if(execve(filename, p->argv, p->environ) < 0){
896
 
          perror("execve");
897
 
          _exit(EXIT_FAILURE);
898
 
        }
 
1105
      if(fexecve(plugin_fd, p->argv,
 
1106
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1107
        error(0, errno, "fexecve for %s/%s",
 
1108
              plugindir != NULL ? plugindir : PDIR,
 
1109
              direntries[i]->d_name);
 
1110
        _exit(EX_OSERR);
899
1111
      }
900
1112
      /* no return */
901
1113
    }
902
1114
    /* Parent process */
903
1115
    close(pipefd[1]);           /* Close unused write end of pipe */
904
 
    free(filename);
905
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1116
    close(plugin_fd);
 
1117
    plugin *new_plugin = getplugin(direntries[i]->d_name);
906
1118
    if(new_plugin == NULL){
907
 
      perror("getplugin");
908
 
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1119
      error(0, errno, "getplugin");
 
1120
      ret = (int)(TEMP_FAILURE_RETRY
 
1121
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
 
1122
                               NULL)));
909
1123
      if(ret < 0){
910
 
        perror("sigprocmask");
 
1124
        error(0, errno, "sigprocmask");
911
1125
      }
912
 
      exitstatus = EXIT_FAILURE;
 
1126
      exitstatus = EX_OSERR;
 
1127
      free(direntries[i]);
913
1128
      goto fallback;
914
1129
    }
 
1130
    free(direntries[i]);
915
1131
    
916
1132
    new_plugin->pid = pid;
917
1133
    new_plugin->fd = pipefd[0];
918
 
    
 
1134
 
 
1135
    if(debug){
 
1136
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1137
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1138
    }
 
1139
 
919
1140
    /* Unblock SIGCHLD so signal handler can be run if this process
920
1141
       has already completed */
921
 
    ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1142
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1143
                                              &sigchld_action.sa_mask,
 
1144
                                              NULL));
922
1145
    if(ret < 0){
923
 
      perror("sigprocmask");
924
 
      exitstatus = EXIT_FAILURE;
 
1146
      error(0, errno, "sigprocmask");
 
1147
      exitstatus = EX_OSERR;
925
1148
      goto fallback;
926
1149
    }
927
1150
    
932
1155
    }
933
1156
  }
934
1157
  
935
 
  closedir(dir);
936
 
  dir = NULL;
 
1158
  free(direntries);
 
1159
  direntries = NULL;
 
1160
  close(dir_fd);
 
1161
  dir_fd = -1;
 
1162
  free_plugin(getplugin(NULL));
937
1163
  
938
1164
  for(plugin *p = plugin_list; p != NULL; p = p->next){
939
1165
    if(p->pid != 0){
950
1176
  while(plugin_list){
951
1177
    fd_set rfds = rfds_all;
952
1178
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
953
 
    if(select_ret == -1){
954
 
      perror("select");
955
 
      exitstatus = EXIT_FAILURE;
 
1179
    if(select_ret == -1 and errno != EINTR){
 
1180
      error(0, errno, "select");
 
1181
      exitstatus = EX_OSERR;
956
1182
      goto fallback;
957
1183
    }
958
1184
    /* OK, now either a process completed, or something can be read
959
1185
       from one of them */
960
1186
    for(plugin *proc = plugin_list; proc != NULL;){
961
1187
      /* Is this process completely done? */
962
 
      if(proc->eof and proc->completed){
 
1188
      if(proc->completed and proc->eof){
963
1189
        /* Only accept the plugin output if it exited cleanly */
964
1190
        if(not WIFEXITED(proc->status)
965
1191
           or WEXITSTATUS(proc->status) != 0){
966
1192
          /* Bad exit by plugin */
967
 
 
 
1193
          
968
1194
          if(debug){
969
1195
            if(WIFEXITED(proc->status)){
970
 
              fprintf(stderr, "Plugin %" PRIdMAX " exited with status"
971
 
                      " %d\n", (intmax_t) (proc->pid),
 
1196
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1197
                      " status %d\n", proc->name,
 
1198
                      (intmax_t) (proc->pid),
972
1199
                      WEXITSTATUS(proc->status));
973
 
            } else if(WIFSIGNALED(proc->status)) {
974
 
              fprintf(stderr, "Plugin %" PRIdMAX " killed by signal"
975
 
                      " %d\n", (intmax_t) (proc->pid),
976
 
                      WTERMSIG(proc->status));
977
 
            } else if(WCOREDUMP(proc->status)){
978
 
              fprintf(stderr, "Plugin %" PRIdMAX " dumped core\n",
979
 
                      (intmax_t) (proc->pid));
 
1200
            } else if(WIFSIGNALED(proc->status)){
 
1201
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
 
1202
                      " signal %d: %s\n", proc->name,
 
1203
                      (intmax_t) (proc->pid),
 
1204
                      WTERMSIG(proc->status),
 
1205
                      strsignal(WTERMSIG(proc->status)));
980
1206
            }
981
1207
          }
982
1208
          
983
1209
          /* Remove the plugin */
984
1210
          FD_CLR(proc->fd, &rfds_all);
985
 
 
 
1211
          
986
1212
          /* Block signal while modifying process_list */
987
 
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1213
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1214
                                        (SIG_BLOCK,
 
1215
                                         &sigchld_action.sa_mask,
 
1216
                                         NULL));
988
1217
          if(ret < 0){
989
 
            perror("sigprocmask");
990
 
            exitstatus = EXIT_FAILURE;
 
1218
            error(0, errno, "sigprocmask");
 
1219
            exitstatus = EX_OSERR;
991
1220
            goto fallback;
992
1221
          }
993
1222
          
996
1225
          proc = next_plugin;
997
1226
          
998
1227
          /* We are done modifying process list, so unblock signal */
999
 
          ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1000
 
                            NULL);
 
1228
          ret = (int)(TEMP_FAILURE_RETRY
 
1229
                      (sigprocmask(SIG_UNBLOCK,
 
1230
                                   &sigchld_action.sa_mask, NULL)));
1001
1231
          if(ret < 0){
1002
 
            perror("sigprocmask");
1003
 
            exitstatus = EXIT_FAILURE;
 
1232
            error(0, errno, "sigprocmask");
 
1233
            exitstatus = EX_OSERR;
1004
1234
            goto fallback;
1005
1235
          }
1006
1236
          
1016
1246
        bool bret = print_out_password(proc->buffer,
1017
1247
                                       proc->buffer_length);
1018
1248
        if(not bret){
1019
 
          perror("print_out_password");
1020
 
          exitstatus = EXIT_FAILURE;
 
1249
          error(0, errno, "print_out_password");
 
1250
          exitstatus = EX_IOERR;
1021
1251
        }
1022
1252
        goto fallback;
1023
1253
      }
1030
1260
      }
1031
1261
      /* Before reading, make the process' data buffer large enough */
1032
1262
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1033
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1034
 
                               + (size_t) BUFFER_SIZE);
1035
 
        if(proc->buffer == NULL){
1036
 
          perror("malloc");
1037
 
          exitstatus = EXIT_FAILURE;
 
1263
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1264
                                   + (size_t) BUFFER_SIZE);
 
1265
        if(new_buffer == NULL){
 
1266
          error(0, errno, "malloc");
 
1267
          exitstatus = EX_OSERR;
1038
1268
          goto fallback;
1039
1269
        }
 
1270
        proc->buffer = new_buffer;
1040
1271
        proc->buffer_size += BUFFER_SIZE;
1041
1272
      }
1042
1273
      /* Read from the process */
1043
 
      sret = read(proc->fd, proc->buffer + proc->buffer_length,
1044
 
                  BUFFER_SIZE);
 
1274
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1275
                                     proc->buffer
 
1276
                                     + proc->buffer_length,
 
1277
                                     BUFFER_SIZE));
1045
1278
      if(sret < 0){
1046
1279
        /* Read error from this process; ignore the error */
1047
1280
        proc = proc->next;
1055
1288
      }
1056
1289
    }
1057
1290
  }
1058
 
 
1059
 
 
 
1291
  
 
1292
  
1060
1293
 fallback:
1061
1294
  
1062
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1295
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1296
                             and exitstatus != EX_OK)){
1063
1297
    /* Fallback if all plugins failed, none are found or an error
1064
1298
       occured */
1065
1299
    bool bret;
1073
1307
    }
1074
1308
    bret = print_out_password(passwordbuffer, len);
1075
1309
    if(not bret){
1076
 
      perror("print_out_password");
1077
 
      exitstatus = EXIT_FAILURE;
 
1310
      error(0, errno, "print_out_password");
 
1311
      exitstatus = EX_IOERR;
1078
1312
    }
1079
1313
  }
1080
1314
  
1081
1315
  /* Restore old signal handler */
1082
1316
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1083
1317
  if(ret == -1){
1084
 
    perror("sigaction");
1085
 
    exitstatus = EXIT_FAILURE;
 
1318
    error(0, errno, "sigaction");
 
1319
    exitstatus = EX_OSERR;
1086
1320
  }
1087
1321
  
1088
1322
  if(custom_argv != NULL){
1092
1326
    free(custom_argv);
1093
1327
  }
1094
1328
  
1095
 
  if(dir != NULL){
1096
 
    closedir(dir);
 
1329
  free(direntries);
 
1330
  
 
1331
  if(dir_fd != -1){
 
1332
    close(dir_fd);
1097
1333
  }
1098
1334
  
1099
1335
  /* Kill the processes */
1103
1339
      ret = kill(p->pid, SIGTERM);
1104
1340
      if(ret == -1 and errno != ESRCH){
1105
1341
        /* Set-uid proccesses might not get closed */
1106
 
        perror("kill");
 
1342
        error(0, errno, "kill");
1107
1343
      }
1108
1344
    }
1109
1345
  }
1110
1346
  
1111
1347
  /* Wait for any remaining child processes to terminate */
1112
 
  do{
 
1348
  do {
1113
1349
    ret = wait(NULL);
1114
1350
  } while(ret >= 0);
1115
1351
  if(errno != ECHILD){
1116
 
    perror("wait");
 
1352
    error(0, errno, "wait");
1117
1353
  }
1118
1354
  
1119
1355
  free_plugin_list();
1120
1356
  
1121
1357
  free(plugindir);
 
1358
  free(pluginhelperdir);
1122
1359
  free(argfile);
1123
1360
  
1124
1361
  return exitstatus;