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