/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-03 23:10:42 UTC
  • Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues

The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server.  But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing.  Fix this.

In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).

Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.

* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
  original "clients" dict, and loop over those instead.  Add assertion
  that all clients were indeed removed.  Also fix the code which looks
  for the Remove command, which now needs to actually work.
  (TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
  assertion that there are still clients before looping over them.
  (TestPropertySetterCmd.runTest): Add assertion that the list of
  values to get is not empty before looping over them.  Also add check
  that there are still clients before looping over clients.

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, 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 */
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 */
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);
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
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){
383
 
    char *tmp;
 
461
  __attribute__((nonnull(3)))
 
462
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
463
    errno = 0;
384
464
    switch(key){
 
465
      char *tmp;
 
466
      intmax_t tmp_id;
385
467
    case 'g':                   /* --global-options */
386
 
      if(arg != NULL){
 
468
      {
387
469
        char *plugin_option;
388
470
        while((plugin_option = strsep(&arg, ",")) != NULL){
389
 
          if(plugin_option[0] == '\0'){
390
 
            continue;
391
 
          }
392
471
          if(not add_argument(getplugin(NULL), plugin_option)){
393
 
            perror("add_argument");
394
 
            return ARGP_ERR_UNKNOWN;
 
472
            break;
395
473
          }
396
474
        }
 
475
        errno = 0;
397
476
      }
398
477
      break;
399
478
    case 'G':                   /* --global-env */
400
 
      if(arg == NULL){
401
 
        break;
402
 
      }
403
 
      if(not add_environment(getplugin(NULL), arg, true)){
404
 
        perror("add_environment");
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
405
481
      }
406
482
      break;
407
483
    case 'o':                   /* --options-for */
408
 
      if(arg != NULL){
409
 
        char *plugin_name = strsep(&arg, ":");
410
 
        if(plugin_name[0] == '\0'){
411
 
          break;
412
 
        }
413
 
        char *plugin_option;
414
 
        while((plugin_option = strsep(&arg, ",")) != NULL){
415
 
          if(not add_argument(getplugin(plugin_name), plugin_option)){
416
 
            perror("add_argument");
417
 
            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;
418
502
          }
419
503
        }
 
504
        errno = 0;
420
505
      }
421
506
      break;
422
507
    case 'E':                   /* --env-for */
423
 
      if(arg == NULL){
424
 
        break;
425
 
      }
426
508
      {
427
509
        char *envdef = strchr(arg, ':');
428
510
        if(envdef == NULL){
 
511
          argp_error(state, "No colon in \"%s\"", arg);
 
512
          errno = EINVAL;
429
513
          break;
430
514
        }
431
515
        *envdef = '\0';
432
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
433
 
          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;
434
524
        }
435
525
      }
436
526
      break;
437
527
    case 'd':                   /* --disable */
438
 
      if(arg != NULL){
 
528
      {
439
529
        plugin *p = getplugin(arg);
440
 
        if(p == NULL){
441
 
          return ARGP_ERR_UNKNOWN;
 
530
        if(p != NULL){
 
531
          p->disabled = true;
 
532
          errno = 0;
442
533
        }
443
 
        p->disabled = true;
444
534
      }
445
535
      break;
446
536
    case 'e':                   /* --enable */
447
 
      if(arg != NULL){
 
537
      {
448
538
        plugin *p = getplugin(arg);
449
 
        if(p == NULL){
450
 
          return ARGP_ERR_UNKNOWN;
 
539
        if(p != NULL){
 
540
          p->disabled = false;
 
541
          errno = 0;
451
542
        }
452
 
        p->disabled = false;
453
543
      }
454
544
      break;
455
545
    case 128:                   /* --plugin-dir */
456
546
      free(plugindir);
457
547
      plugindir = strdup(arg);
458
 
      if(plugindir == NULL){
459
 
        perror("strdup");
460
 
      }      
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
461
551
      break;
462
552
    case 129:                   /* --config-file */
463
553
      /* This is already done by parse_opt_config_file() */
464
554
      break;
465
555
    case 130:                   /* --userid */
466
 
      errno = 0;
467
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
556
      tmp_id = strtoimax(arg, &tmp, 10);
468
557
      if(errno != 0 or tmp == arg or *tmp != '\0'
469
 
         or tmpmax != (uid_t)tmpmax){
470
 
        fprintf(stderr, "Bad user ID number: \"%s\", using %"
471
 
                PRIdMAX "\n", arg, (intmax_t)uid);
472
 
      } else {
473
 
        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;
474
562
      }
 
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
475
565
      break;
476
566
    case 131:                   /* --groupid */
477
 
      errno = 0;
478
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
567
      tmp_id = strtoimax(arg, &tmp, 10);
479
568
      if(errno != 0 or tmp == arg or *tmp != '\0'
480
 
         or tmpmax != (gid_t)tmpmax){
481
 
        fprintf(stderr, "Bad group ID number: \"%s\", using %"
482
 
                PRIdMAX "\n", arg, (intmax_t)gid);
483
 
      } else {
484
 
        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;
485
573
      }
 
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
486
576
      break;
487
577
    case 132:                   /* --debug */
488
578
      debug = true;
489
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;
490
603
/*
491
604
 * When adding more options before this line, remember to also add a
492
605
 * "case" to the "parse_opt_config_file" function below.
495
608
      /* Cryptsetup always passes an argument, which is an empty
496
609
         string if "none" was specified in /etc/crypttab.  So if
497
610
         argument was empty, we ignore it silently. */
498
 
      if(arg[0] != '\0'){
499
 
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
611
      if(arg[0] == '\0'){
 
612
        break;
500
613
      }
501
 
      break;
502
 
    case ARGP_KEY_END:
503
 
      break;
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
504
619
    default:
505
620
      return ARGP_ERR_UNKNOWN;
506
621
    }
507
 
    return 0;
 
622
    return errno;               /* Set to 0 at start */
508
623
  }
509
624
  
510
625
  /* This option parser is the same as parse_opt() above, except it
512
627
  error_t parse_opt_config_file(int key, char *arg,
513
628
                                __attribute__((unused))
514
629
                                struct argp_state *state){
 
630
    errno = 0;
515
631
    switch(key){
516
632
    case 'g':                   /* --global-options */
517
633
    case 'G':                   /* --global-env */
524
640
    case 129:                   /* --config-file */
525
641
      free(argfile);
526
642
      argfile = strdup(arg);
527
 
      if(argfile == NULL){
528
 
        perror("strdup");
 
643
      if(argfile != NULL){
 
644
        errno = 0;
529
645
      }
530
 
      break;      
 
646
      break;
531
647
    case 130:                   /* --userid */
532
648
    case 131:                   /* --groupid */
533
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
 
651
    case '?':                   /* --help */
 
652
    case -3:                    /* --usage */
 
653
    case 'V':                   /* --version */
534
654
    case ARGP_KEY_ARG:
535
 
    case ARGP_KEY_END:
536
655
      break;
537
656
    default:
538
657
      return ARGP_ERR_UNKNOWN;
539
658
    }
540
 
    return 0;
 
659
    return errno;
541
660
  }
542
661
  
543
662
  struct argp argp = { .options = options,
547
666
  
548
667
  /* Parse using parse_opt_config_file() in order to get the custom
549
668
     config file location, if any. */
550
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
551
 
  if(ret == ARGP_ERR_UNKNOWN){
552
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
553
 
    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;
554
683
    goto fallback;
555
684
  }
556
685
  
562
691
    conffp = fopen(AFILE, "r");
563
692
  } else {
564
693
    conffp = fopen(argfile, "r");
565
 
  }  
 
694
  }
566
695
  if(conffp != NULL){
567
696
    char *org_line = NULL;
568
697
    char *p, *arg, *new_arg, *line;
573
702
    custom_argc = 1;
574
703
    custom_argv = malloc(sizeof(char*) * 2);
575
704
    if(custom_argv == NULL){
576
 
      perror("malloc");
577
 
      exitstatus = EXIT_FAILURE;
 
705
      error(0, errno, "malloc");
 
706
      exitstatus = EX_OSERR;
578
707
      goto fallback;
579
708
    }
580
709
    custom_argv[0] = argv[0];
596
725
        }
597
726
        new_arg = strdup(p);
598
727
        if(new_arg == NULL){
599
 
          perror("strdup");
600
 
          exitstatus = EXIT_FAILURE;
 
728
          error(0, errno, "strdup");
 
729
          exitstatus = EX_OSERR;
601
730
          free(org_line);
602
731
          goto fallback;
603
732
        }
604
733
        
605
734
        custom_argc += 1;
606
 
        custom_argv = realloc(custom_argv, sizeof(char *)
607
 
                              * ((unsigned int) custom_argc + 1));
608
 
        if(custom_argv == NULL){
609
 
          perror("realloc");
610
 
          exitstatus = EXIT_FAILURE;
611
 
          free(org_line);
612
 
          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
          }
613
758
        }
614
759
        custom_argv[custom_argc-1] = new_arg;
615
 
        custom_argv[custom_argc] = NULL;        
 
760
        custom_argv[custom_argc] = NULL;
616
761
      }
617
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
    }
618
771
    free(org_line);
619
772
  } else {
620
773
    /* Check for harmful errors and go to fallback. Other errors might
621
774
       not affect opening plugins */
622
775
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
623
 
      perror("fopen");
624
 
      exitstatus = EXIT_FAILURE;
 
776
      error(0, errno, "fopen");
 
777
      exitstatus = EX_OSERR;
625
778
      goto fallback;
626
779
    }
627
780
  }
628
 
  /* If there was any arguments from configuration file,
629
 
     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 */
630
783
  if(custom_argv != NULL){
631
 
    ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
632
 
                     0, NULL);
633
 
    if(ret == ARGP_ERR_UNKNOWN){
634
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
635
 
      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;
636
798
      goto fallback;
637
799
    }
638
800
  }
639
801
  
640
802
  /* Parse actual command line arguments, to let them override the
641
803
     config file */
642
 
  ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
643
 
  if(ret == ARGP_ERR_UNKNOWN){
644
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
645
 
    exitstatus = EXIT_FAILURE;
646
 
    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
    }
647
837
  }
648
838
  
649
839
  if(debug){
650
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
840
    for(plugin *p = plugin_list; p != NULL; p = p->next){
651
841
      fprintf(stderr, "Plugin: %s has %d arguments\n",
652
842
              p->name ? p->name : "Global", p->argc - 1);
653
843
      for(char **a = p->argv; *a != NULL; a++){
660
850
    }
661
851
  }
662
852
  
663
 
  /* Strip permissions down to nobody */
664
 
  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);
665
888
  if(ret == -1){
666
 
    perror("setgid");
 
889
    error(0, errno, "setgid");
667
890
  }
668
891
  ret = setuid(uid);
669
892
  if(ret == -1){
670
 
    perror("setuid");
671
 
  }
672
 
  
673
 
  if(plugindir == NULL){
674
 
    dir = opendir(PDIR);
675
 
  } else {
676
 
    dir = opendir(plugindir);
677
 
  }
678
 
  
679
 
  if(dir == NULL){
680
 
    perror("Could not open plugin dir");
681
 
    exitstatus = EXIT_FAILURE;
682
 
    goto fallback;
683
 
  }
684
 
  
685
 
  /* 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 */
686
897
  {
687
 
    int dir_fd = dirfd(dir);
688
 
    if(dir_fd >= 0){
689
 
      ret = set_cloexec_flag(dir_fd);
690
 
      if(ret < 0){
691
 
        perror("set_cloexec_flag");
692
 
        exitstatus = EXIT_FAILURE;
693
 
        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;
694
942
      }
695
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;
696
954
  }
697
955
  
698
956
  FD_ZERO(&rfds_all);
699
957
  
700
958
  /* Read and execute any executable in the plugin directory*/
701
 
  while(true){
702
 
    dirst = readdir(dir);
703
 
    
704
 
    /* All directory entries have been processed */
705
 
    if(dirst == NULL){
706
 
      if(errno == EBADF){
707
 
        perror("readdir");
708
 
        exitstatus = EXIT_FAILURE;
709
 
        goto fallback;
710
 
      }
711
 
      break;
712
 
    }
713
 
    
714
 
    d_name_len = strlen(dirst->d_name);
715
 
    
716
 
    /* Ignore dotfiles, backup files and other junk */
717
 
    {
718
 
      bool bad_name = false;
719
 
      
720
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
721
 
      
722
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
723
 
                                           ".dpkg-old",
724
 
                                           ".dpkg-bak",
725
 
                                           ".dpkg-divert", NULL };
726
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
727
 
        size_t pre_len = strlen(*pre);
728
 
        if((d_name_len >= pre_len)
729
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
730
 
          if(debug){
731
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
732
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
733
 
          }
734
 
          bad_name = true;
735
 
          break;
736
 
        }
737
 
      }
738
 
      if(bad_name){
739
 
        continue;
740
 
      }
741
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
742
 
        size_t suf_len = strlen(*suf);
743
 
        if((d_name_len >= suf_len)
744
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
745
 
                == 0)){
746
 
          if(debug){
747
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
748
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
749
 
          }
750
 
          bad_name = true;
751
 
          break;
752
 
        }
753
 
      }
754
 
      
755
 
      if(bad_name){
756
 
        continue;
757
 
      }
758
 
    }
759
 
    
760
 
    char *filename;
761
 
    if(plugindir == NULL){
762
 
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
763
 
    } else {
764
 
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
765
 
    }
766
 
    if(ret < 0){
767
 
      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]);
768
965
      continue;
769
966
    }
770
 
    
771
 
    ret = stat(filename, &st);
 
967
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
772
968
    if(ret == -1){
773
 
      perror("stat");
774
 
      free(filename);
 
969
      error(0, errno, "stat");
 
970
      close(plugin_fd);
 
971
      free(direntries[i]);
775
972
      continue;
776
973
    }
777
974
    
778
975
    /* Ignore non-executable files */
779
 
    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)){
780
979
      if(debug){
781
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
782
 
                " 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);
783
984
      }
784
 
      free(filename);
 
985
      close(plugin_fd);
 
986
      free(direntries[i]);
785
987
      continue;
786
988
    }
787
989
    
788
 
    plugin *p = getplugin(dirst->d_name);
 
990
    plugin *p = getplugin(direntries[i]->d_name);
789
991
    if(p == NULL){
790
 
      perror("getplugin");
791
 
      free(filename);
 
992
      error(0, errno, "getplugin");
 
993
      close(plugin_fd);
 
994
      free(direntries[i]);
792
995
      continue;
793
996
    }
794
997
    if(p->disabled){
795
998
      if(debug){
796
999
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
797
 
                dirst->d_name);
 
1000
                direntries[i]->d_name);
798
1001
      }
799
 
      free(filename);
 
1002
      close(plugin_fd);
 
1003
      free(direntries[i]);
800
1004
      continue;
801
1005
    }
802
1006
    {
805
1009
      if(g != NULL){
806
1010
        for(char **a = g->argv + 1; *a != NULL; a++){
807
1011
          if(not add_argument(p, *a)){
808
 
            perror("add_argument");
 
1012
            error(0, errno, "add_argument");
809
1013
          }
810
1014
        }
811
1015
        /* Add global environment variables */
812
1016
        for(char **e = g->environ; *e != NULL; e++){
813
1017
          if(not add_environment(p, *e, false)){
814
 
            perror("add_environment");
 
1018
            error(0, errno, "add_environment");
815
1019
          }
816
1020
        }
817
1021
      }
818
1022
    }
819
 
    /* If this plugin has any environment variables, we will call
820
 
       using execve and need to duplicate the environment from this
821
 
       process, too. */
 
1023
    /* If this plugin has any environment variables, we need to
 
1024
       duplicate the environment from this process, too. */
822
1025
    if(p->environ[0] != NULL){
823
1026
      for(char **e = environ; *e != NULL; e++){
824
1027
        if(not add_environment(p, *e, false)){
825
 
          perror("add_environment");
 
1028
          error(0, errno, "add_environment");
826
1029
        }
827
1030
      }
828
1031
    }
829
1032
    
830
1033
    int pipefd[2];
831
 
    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 */
832
1039
    if(ret == -1){
833
 
      perror("pipe");
834
 
      exitstatus = EXIT_FAILURE;
835
 
      goto fallback;
836
 
    }
 
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
837
1055
    /* Ask OS to automatic close the pipe on exec */
838
1056
    ret = set_cloexec_flag(pipefd[0]);
839
1057
    if(ret < 0){
840
 
      perror("set_cloexec_flag");
841
 
      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]);
842
1063
      goto fallback;
843
1064
    }
844
1065
    ret = set_cloexec_flag(pipefd[1]);
845
1066
    if(ret < 0){
846
 
      perror("set_cloexec_flag");
847
 
      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]);
848
1072
      goto fallback;
849
1073
    }
 
1074
#endif  /* not O_CLOEXEC */
850
1075
    /* Block SIGCHLD until process is safely in process list */
851
 
    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));
852
1079
    if(ret < 0){
853
 
      perror("sigprocmask");
854
 
      exitstatus = EXIT_FAILURE;
 
1080
      error(0, errno, "sigprocmask");
 
1081
      exitstatus = EX_OSERR;
 
1082
      free(direntries[i]);
855
1083
      goto fallback;
856
1084
    }
857
1085
    /* Starting a new process to be watched */
858
 
    pid_t pid = fork();
 
1086
    pid_t pid;
 
1087
    do {
 
1088
      pid = fork();
 
1089
    } while(pid == -1 and errno == EINTR);
859
1090
    if(pid == -1){
860
 
      perror("fork");
861
 
      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]);
862
1098
      goto fallback;
863
1099
    }
864
1100
    if(pid == 0){
865
1101
      /* this is the child process */
866
1102
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
867
1103
      if(ret < 0){
868
 
        perror("sigaction");
869
 
        _exit(EXIT_FAILURE);
 
1104
        error(0, errno, "sigaction");
 
1105
        _exit(EX_OSERR);
870
1106
      }
871
1107
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
872
1108
      if(ret < 0){
873
 
        perror("sigprocmask");
874
 
        _exit(EXIT_FAILURE);
 
1109
        error(0, errno, "sigprocmask");
 
1110
        _exit(EX_OSERR);
875
1111
      }
876
1112
      
877
1113
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
878
1114
      if(ret == -1){
879
 
        perror("dup2");
880
 
        _exit(EXIT_FAILURE);
 
1115
        error(0, errno, "dup2");
 
1116
        _exit(EX_OSERR);
881
1117
      }
882
1118
      
883
 
      if(dirfd(dir) < 0){
884
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
885
 
           above and must now close it manually here. */
886
 
        closedir(dir);
887
 
      }
888
 
      if(p->environ[0] == NULL){
889
 
        if(execv(filename, p->argv) < 0){
890
 
          perror("execv");
891
 
          _exit(EXIT_FAILURE);
892
 
        }
893
 
      } else {
894
 
        if(execve(filename, p->argv, p->environ) < 0){
895
 
          perror("execve");
896
 
          _exit(EXIT_FAILURE);
897
 
        }
 
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);
898
1125
      }
899
1126
      /* no return */
900
1127
    }
901
1128
    /* Parent process */
902
1129
    close(pipefd[1]);           /* Close unused write end of pipe */
903
 
    free(filename);
904
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1130
    close(plugin_fd);
 
1131
    plugin *new_plugin = getplugin(direntries[i]->d_name);
905
1132
    if(new_plugin == NULL){
906
 
      perror("getplugin");
907
 
      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)));
908
1137
      if(ret < 0){
909
 
        perror("sigprocmask");
 
1138
        error(0, errno, "sigprocmask");
910
1139
      }
911
 
      exitstatus = EXIT_FAILURE;
 
1140
      exitstatus = EX_OSERR;
 
1141
      free(direntries[i]);
912
1142
      goto fallback;
913
1143
    }
 
1144
    free(direntries[i]);
914
1145
    
915
1146
    new_plugin->pid = pid;
916
1147
    new_plugin->fd = pipefd[0];
917
 
    
 
1148
 
 
1149
    if(debug){
 
1150
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1151
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1152
    }
 
1153
 
918
1154
    /* Unblock SIGCHLD so signal handler can be run if this process
919
1155
       has already completed */
920
 
    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));
921
1159
    if(ret < 0){
922
 
      perror("sigprocmask");
923
 
      exitstatus = EXIT_FAILURE;
 
1160
      error(0, errno, "sigprocmask");
 
1161
      exitstatus = EX_OSERR;
924
1162
      goto fallback;
925
1163
    }
926
1164
    
931
1169
    }
932
1170
  }
933
1171
  
934
 
  closedir(dir);
935
 
  dir = NULL;
 
1172
  free(direntries);
 
1173
  direntries = NULL;
 
1174
  close(dir_fd);
 
1175
  dir_fd = -1;
936
1176
  free_plugin(getplugin(NULL));
937
1177
  
938
1178
  for(plugin *p = plugin_list; p != NULL; p = p->next){
950
1190
  while(plugin_list){
951
1191
    fd_set rfds = rfds_all;
952
1192
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
953
 
    if(select_ret == -1){
954
 
      perror("select");
955
 
      exitstatus = EXIT_FAILURE;
 
1193
    if(select_ret == -1 and errno != EINTR){
 
1194
      error(0, errno, "select");
 
1195
      exitstatus = EX_OSERR;
956
1196
      goto fallback;
957
1197
    }
958
1198
    /* OK, now either a process completed, or something can be read
973
1213
                      WEXITSTATUS(proc->status));
974
1214
            } else if(WIFSIGNALED(proc->status)){
975
1215
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
976
 
                      " signal %d\n", proc->name,
 
1216
                      " signal %d: %s\n", proc->name,
977
1217
                      (intmax_t) (proc->pid),
978
 
                      WTERMSIG(proc->status));
979
 
            } else if(WCOREDUMP(proc->status)){
980
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
981
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
 
1218
                      WTERMSIG(proc->status),
 
1219
                      strsignal(WTERMSIG(proc->status)));
982
1220
            }
983
1221
          }
984
1222
          
986
1224
          FD_CLR(proc->fd, &rfds_all);
987
1225
          
988
1226
          /* Block signal while modifying process_list */
989
 
          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));
990
1231
          if(ret < 0){
991
 
            perror("sigprocmask");
992
 
            exitstatus = EXIT_FAILURE;
 
1232
            error(0, errno, "sigprocmask");
 
1233
            exitstatus = EX_OSERR;
993
1234
            goto fallback;
994
1235
          }
995
1236
          
998
1239
          proc = next_plugin;
999
1240
          
1000
1241
          /* We are done modifying process list, so unblock signal */
1001
 
          ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1002
 
                            NULL);
 
1242
          ret = (int)(TEMP_FAILURE_RETRY
 
1243
                      (sigprocmask(SIG_UNBLOCK,
 
1244
                                   &sigchld_action.sa_mask, NULL)));
1003
1245
          if(ret < 0){
1004
 
            perror("sigprocmask");
1005
 
            exitstatus = EXIT_FAILURE;
 
1246
            error(0, errno, "sigprocmask");
 
1247
            exitstatus = EX_OSERR;
1006
1248
            goto fallback;
1007
1249
          }
1008
1250
          
1018
1260
        bool bret = print_out_password(proc->buffer,
1019
1261
                                       proc->buffer_length);
1020
1262
        if(not bret){
1021
 
          perror("print_out_password");
1022
 
          exitstatus = EXIT_FAILURE;
 
1263
          error(0, errno, "print_out_password");
 
1264
          exitstatus = EX_IOERR;
1023
1265
        }
1024
1266
        goto fallback;
1025
1267
      }
1032
1274
      }
1033
1275
      /* Before reading, make the process' data buffer large enough */
1034
1276
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1035
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1036
 
                               + (size_t) BUFFER_SIZE);
1037
 
        if(proc->buffer == NULL){
1038
 
          perror("malloc");
1039
 
          exitstatus = EXIT_FAILURE;
 
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;
1040
1282
          goto fallback;
1041
1283
        }
 
1284
        proc->buffer = new_buffer;
1042
1285
        proc->buffer_size += BUFFER_SIZE;
1043
1286
      }
1044
1287
      /* Read from the process */
1045
 
      sret = read(proc->fd, proc->buffer + proc->buffer_length,
1046
 
                  BUFFER_SIZE);
 
1288
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1289
                                     proc->buffer
 
1290
                                     + proc->buffer_length,
 
1291
                                     BUFFER_SIZE));
1047
1292
      if(sret < 0){
1048
1293
        /* Read error from this process; ignore the error */
1049
1294
        proc = proc->next;
1061
1306
  
1062
1307
 fallback:
1063
1308
  
1064
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1309
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1310
                             and exitstatus != EX_OK)){
1065
1311
    /* Fallback if all plugins failed, none are found or an error
1066
1312
       occured */
1067
1313
    bool bret;
1075
1321
    }
1076
1322
    bret = print_out_password(passwordbuffer, len);
1077
1323
    if(not bret){
1078
 
      perror("print_out_password");
1079
 
      exitstatus = EXIT_FAILURE;
 
1324
      error(0, errno, "print_out_password");
 
1325
      exitstatus = EX_IOERR;
1080
1326
    }
1081
1327
  }
1082
1328
  
1083
1329
  /* Restore old signal handler */
1084
1330
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1085
1331
  if(ret == -1){
1086
 
    perror("sigaction");
1087
 
    exitstatus = EXIT_FAILURE;
 
1332
    error(0, errno, "sigaction");
 
1333
    exitstatus = EX_OSERR;
1088
1334
  }
1089
1335
  
1090
1336
  if(custom_argv != NULL){
1094
1340
    free(custom_argv);
1095
1341
  }
1096
1342
  
1097
 
  if(dir != NULL){
1098
 
    closedir(dir);
 
1343
  free(direntries);
 
1344
  
 
1345
  if(dir_fd != -1){
 
1346
    close(dir_fd);
1099
1347
  }
1100
1348
  
1101
1349
  /* Kill the processes */
1105
1353
      ret = kill(p->pid, SIGTERM);
1106
1354
      if(ret == -1 and errno != ESRCH){
1107
1355
        /* Set-uid proccesses might not get closed */
1108
 
        perror("kill");
 
1356
        error(0, errno, "kill");
1109
1357
      }
1110
1358
    }
1111
1359
  }
1112
1360
  
1113
1361
  /* Wait for any remaining child processes to terminate */
1114
 
  do{
 
1362
  do {
1115
1363
    ret = wait(NULL);
1116
1364
  } while(ret >= 0);
1117
1365
  if(errno != ECHILD){
1118
 
    perror("wait");
 
1366
    error(0, errno, "wait");
1119
1367
  }
1120
1368
  
1121
1369
  free_plugin_list();
1122
1370
  
1123
1371
  free(plugindir);
 
1372
  free(pluginhelperdir);
1124
1373
  free(argfile);
1125
1374
  
1126
1375
  return exitstatus;