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