/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2021-02-04 17:59:45 UTC
  • Revision ID: teddy@recompile.se-20210204175945-8druo6d88ipc1z58
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 key id, 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 " ${key_id}".

Show diffs side-by-side

added added

removed removed

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