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