/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: 2024-11-17 18:43:11 UTC
  • Revision ID: teddy@recompile.se-20241117184311-ox25kvngy62h209g
Debian package: Avoid suggesting a C compiler unnecessarily

The list of suggested packages, meant to enable the "mandos" program
to find the correct value of SO_BINDTODEVICE by using a C compiler,
are not necessary when Python 3.3 or later is used, since it has the
SO_BINDTODEVICE constant defined in the "socket" module.  Also, Python
2.6 or older has the same constant in the old "IN" module.  Therefore,
we should suggest these Python versions as alternatives to a C
compiler, so that a C compiler is not installed unnecessarily.

debian/control (Package: mandos/Suggests): Add "python3 (>= 3.3)" and
"python (<= 2.6)" as alternatives to "libc6-dev | libc-dev" and
"c-compiler".

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-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2022 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
 
  if(length>0 and buffer[length-1] == '\n'){
259
 
    length--;
260
 
  }
261
327
  for(size_t written = 0; written < length; written += (size_t)ret){
262
328
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
263
329
                                   length - written));
269
335
}
270
336
 
271
337
/* Removes and free a plugin from the plugin list */
 
338
__attribute__((nonnull))
272
339
static void free_plugin(plugin *plugin_node){
273
340
  
274
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
275
342
    free(*arg);
276
343
  }
 
344
  free(plugin_node->name);
277
345
  free(plugin_node->argv);
278
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
279
347
    free(*env);
280
348
  }
281
349
  free(plugin_node->environ);
282
350
  free(plugin_node->buffer);
283
 
 
 
351
  
284
352
  /* Removes the plugin from the singly-linked list */
285
353
  if(plugin_node == plugin_list){
286
354
    /* First one - simple */
306
374
 
307
375
int main(int argc, char *argv[]){
308
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
309
378
  char *argfile = NULL;
310
379
  FILE *conffp;
311
 
  size_t d_name_len;
312
 
  DIR *dir = NULL;
313
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
314
381
  struct stat st;
315
382
  fd_set rfds_all;
316
383
  int ret, maxfd = 0;
 
384
  ssize_t sret;
317
385
  uid_t uid = 65534;
318
386
  gid_t gid = 65534;
319
387
  bool debug = false;
323
391
                                      .sa_flags = SA_NOCLDSTOP };
324
392
  char **custom_argv = NULL;
325
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
326
395
  
327
396
  /* Establish a signal handler */
328
397
  sigemptyset(&sigchld_action.sa_mask);
329
398
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
330
399
  if(ret == -1){
331
 
    perror("sigaddset");
332
 
    exitstatus = EXIT_FAILURE;
 
400
    error(0, errno, "sigaddset");
 
401
    exitstatus = EX_OSERR;
333
402
    goto fallback;
334
403
  }
335
404
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
336
405
  if(ret == -1){
337
 
    perror("sigaction");
338
 
    exitstatus = EXIT_FAILURE;
 
406
    error(0, errno, "sigaction");
 
407
    exitstatus = EX_OSERR;
339
408
    goto fallback;
340
409
  }
341
410
  
373
442
      .doc = "Group ID the plugins will run as", .group = 3 },
374
443
    { .name = "debug", .key = 132,
375
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 },
376
458
    { .name = NULL }
377
459
  };
378
460
  
379
 
  error_t parse_opt (int key, char *arg, __attribute__((unused))
380
 
                     struct argp_state *state) {
381
 
    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;
382
467
    case 'g':                   /* --global-options */
383
 
      if (arg != NULL){
384
 
        char *p;
385
 
        while((p = strsep(&arg, ",")) != NULL){
386
 
          if(p[0] == '\0'){
387
 
            continue;
388
 
          }
389
 
          if(not add_argument(getplugin(NULL), p)){
390
 
            perror("add_argument");
391
 
            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;
392
473
          }
393
474
        }
 
475
        errno = 0;
394
476
      }
395
477
      break;
396
478
    case 'G':                   /* --global-env */
397
 
      if(arg == NULL){
398
 
        break;
399
 
      }
400
 
      {
401
 
        char *envdef = strdup(arg);
402
 
        if(envdef == NULL){
403
 
          break;
404
 
        }
405
 
        if(not add_environment(getplugin(NULL), envdef, true)){
406
 
          perror("add_environment");
407
 
        }
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
408
481
      }
409
482
      break;
410
483
    case 'o':                   /* --options-for */
411
 
      if (arg != NULL){
412
 
        char *p_name = strsep(&arg, ":");
413
 
        if(p_name[0] == '\0' or arg == NULL){
414
 
          break;
415
 
        }
416
 
        char *opt = strsep(&arg, ":");
417
 
        if(opt[0] == '\0' or opt == NULL){
418
 
          break;
419
 
        }
420
 
        char *p;
421
 
        while((p = strsep(&opt, ",")) != NULL){
422
 
          if(p[0] == '\0'){
423
 
            continue;
424
 
          }
425
 
          if(not add_argument(getplugin(p_name), p)){
426
 
            perror("add_argument");
427
 
            return ARGP_ERR_UNKNOWN;
428
 
          }
429
 
        }
 
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;
430
505
      }
431
506
      break;
432
507
    case 'E':                   /* --env-for */
433
 
      if(arg == NULL){
434
 
        break;
435
 
      }
436
508
      {
437
509
        char *envdef = strchr(arg, ':');
438
510
        if(envdef == NULL){
439
 
          break;
440
 
        }
441
 
        char *p_name = strndup(arg, (size_t) (envdef-arg));
442
 
        if(p_name == NULL){
443
 
          break;
444
 
        }
 
511
          argp_error(state, "No colon in \"%s\"", arg);
 
512
          errno = EINVAL;
 
513
          break;
 
514
        }
 
515
        *envdef = '\0';
445
516
        envdef++;
446
 
        if(not add_environment(getplugin(p_name), envdef, true)){
447
 
          perror("add_environment");
 
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;
448
524
        }
449
525
      }
450
526
      break;
451
527
    case 'd':                   /* --disable */
452
 
      if (arg != NULL){
 
528
      {
453
529
        plugin *p = getplugin(arg);
454
 
        if(p == NULL){
455
 
          return ARGP_ERR_UNKNOWN;
 
530
        if(p != NULL){
 
531
          p->disabled = true;
 
532
          errno = 0;
456
533
        }
457
 
        p->disabled = true;
458
534
      }
459
535
      break;
460
536
    case 'e':                   /* --enable */
461
 
      if (arg != NULL){
 
537
      {
462
538
        plugin *p = getplugin(arg);
463
 
        if(p == NULL){
464
 
          return ARGP_ERR_UNKNOWN;
 
539
        if(p != NULL){
 
540
          p->disabled = false;
 
541
          errno = 0;
465
542
        }
466
 
        p->disabled = false;
467
543
      }
468
544
      break;
469
545
    case 128:                   /* --plugin-dir */
 
546
      free(plugindir);
470
547
      plugindir = strdup(arg);
471
 
      if(plugindir == NULL){
472
 
        perror("strdup");
473
 
      }      
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
474
551
      break;
475
552
    case 129:                   /* --config-file */
476
553
      /* This is already done by parse_opt_config_file() */
477
554
      break;
478
555
    case 130:                   /* --userid */
479
 
      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;
480
565
      break;
481
566
    case 131:                   /* --groupid */
482
 
      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;
483
576
      break;
484
577
    case 132:                   /* --debug */
485
578
      debug = true;
486
579
      break;
 
580
    case 133:                   /* --plugin-helper-dir */
 
581
      free(pluginhelperdir);
 
582
      pluginhelperdir = strdup(arg);
 
583
      if(pluginhelperdir != NULL){
 
584
        errno = 0;
 
585
      }
 
586
      break;
 
587
      /*
 
588
       * These reproduce what we would get without ARGP_NO_HELP
 
589
       */
 
590
    case '?':                   /* --help */
 
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
 
594
    case -3:                    /* --usage */
 
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
596
      argp_state_help(state, state->out_stream,
 
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
 
599
    case 'V':                   /* --version */
 
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
601
      exit(EXIT_SUCCESS);
 
602
      break;
 
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
 */
487
607
    case ARGP_KEY_ARG:
488
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
489
 
      break;
490
 
    case ARGP_KEY_END:
491
 
      break;
 
608
      /* Cryptsetup always passes an argument, which is an empty
 
609
         string if "none" was specified in /etc/crypttab.  So if
 
610
         argument was empty, we ignore it silently. */
 
611
      if(arg[0] == '\0'){
 
612
        break;
 
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
492
619
    default:
493
620
      return ARGP_ERR_UNKNOWN;
494
621
    }
495
 
    return 0;
 
622
    return errno;               /* Set to 0 at start */
496
623
  }
497
624
  
498
625
  /* This option parser is the same as parse_opt() above, except it
499
626
     ignores everything but the --config-file option. */
500
 
  error_t parse_opt_config_file (int key, char *arg,
501
 
                                 __attribute__((unused))
502
 
                                 struct argp_state *state) {
503
 
    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){
504
632
    case 'g':                   /* --global-options */
505
633
    case 'G':                   /* --global-env */
506
634
    case 'o':                   /* --options-for */
510
638
    case 128:                   /* --plugin-dir */
511
639
      break;
512
640
    case 129:                   /* --config-file */
 
641
      free(argfile);
513
642
      argfile = strdup(arg);
514
 
      if(argfile == NULL){
515
 
        perror("strdup");
 
643
      if(argfile != NULL){
 
644
        errno = 0;
516
645
      }
517
 
      break;      
 
646
      break;
518
647
    case 130:                   /* --userid */
519
648
    case 131:                   /* --groupid */
520
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
 
651
    case '?':                   /* --help */
 
652
    case -3:                    /* --usage */
 
653
    case 'V':                   /* --version */
521
654
    case ARGP_KEY_ARG:
522
 
    case ARGP_KEY_END:
523
655
      break;
524
656
    default:
525
657
      return ARGP_ERR_UNKNOWN;
526
658
    }
527
 
    return 0;
 
659
    return errno;
528
660
  }
529
661
  
530
662
  struct argp argp = { .options = options,
532
664
                       .args_doc = "",
533
665
                       .doc = "Mandos plugin runner -- Run plugins" };
534
666
  
535
 
  /* 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
536
668
     config file location, if any. */
537
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
538
 
  if (ret == ARGP_ERR_UNKNOWN){
539
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
540
 
    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;
541
683
    goto fallback;
542
684
  }
543
685
  
545
687
  argp.parser = parse_opt;
546
688
  
547
689
  /* Open the configfile if available */
548
 
  if (argfile == NULL){
 
690
  if(argfile == NULL){
549
691
    conffp = fopen(AFILE, "r");
550
692
  } else {
551
693
    conffp = fopen(argfile, "r");
552
 
  }  
 
694
  }
553
695
  if(conffp != NULL){
554
696
    char *org_line = NULL;
555
697
    char *p, *arg, *new_arg, *line;
556
698
    size_t size = 0;
557
 
    ssize_t sret;
558
699
    const char whitespace_delims[] = " \r\t\f\v\n";
559
700
    const char comment_delim[] = "#";
560
 
 
 
701
    
561
702
    custom_argc = 1;
562
703
    custom_argv = malloc(sizeof(char*) * 2);
563
704
    if(custom_argv == NULL){
564
 
      perror("malloc");
565
 
      exitstatus = EXIT_FAILURE;
 
705
      error(0, errno, "malloc");
 
706
      exitstatus = EX_OSERR;
566
707
      goto fallback;
567
708
    }
568
709
    custom_argv[0] = argv[0];
569
710
    custom_argv[1] = NULL;
570
 
 
 
711
    
571
712
    /* for each line in the config file, strip whitespace and ignore
572
713
       commented text */
573
714
    while(true){
575
716
      if(sret == -1){
576
717
        break;
577
718
      }
578
 
 
 
719
      
579
720
      line = org_line;
580
721
      arg = strsep(&line, comment_delim);
581
722
      while((p = strsep(&arg, whitespace_delims)) != NULL){
584
725
        }
585
726
        new_arg = strdup(p);
586
727
        if(new_arg == NULL){
587
 
          perror("strdup");
588
 
          exitstatus = EXIT_FAILURE;
 
728
          error(0, errno, "strdup");
 
729
          exitstatus = EX_OSERR;
589
730
          free(org_line);
590
731
          goto fallback;
591
732
        }
592
733
        
593
734
        custom_argc += 1;
594
 
        custom_argv = realloc(custom_argv, sizeof(char *)
595
 
                              * ((unsigned int) custom_argc + 1));
596
 
        if(custom_argv == NULL){
597
 
          perror("realloc");
598
 
          exitstatus = EXIT_FAILURE;
599
 
          free(org_line);
600
 
          goto fallback;
 
735
        {
 
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
737
          char **new_argv = reallocarray(custom_argv,
 
738
                                         (size_t)custom_argc + 1,
 
739
                                         sizeof(char *));
 
740
#else
 
741
          char **new_argv = NULL;
 
742
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
743
            /* overflow */
 
744
            errno = ENOMEM;
 
745
          } else {
 
746
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
747
                               * sizeof(char *));
 
748
          }
 
749
#endif
 
750
          if(new_argv == NULL){
 
751
            error(0, errno, "reallocarray");
 
752
            exitstatus = EX_OSERR;
 
753
            free(new_arg);
 
754
            free(org_line);
 
755
            goto fallback;
 
756
          } else {
 
757
            custom_argv = new_argv;
 
758
          }
601
759
        }
602
760
        custom_argv[custom_argc-1] = new_arg;
603
 
        custom_argv[custom_argc] = NULL;        
 
761
        custom_argv[custom_argc] = NULL;
604
762
      }
605
763
    }
 
764
    do {
 
765
      ret = fclose(conffp);
 
766
    } while(ret == EOF and errno == EINTR);
 
767
    if(ret == EOF){
 
768
      error(0, errno, "fclose");
 
769
      exitstatus = EX_IOERR;
 
770
      goto fallback;
 
771
    }
606
772
    free(org_line);
607
773
  } else {
608
774
    /* Check for harmful errors and go to fallback. Other errors might
609
775
       not affect opening plugins */
610
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
611
 
      perror("fopen");
612
 
      exitstatus = EXIT_FAILURE;
 
776
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
 
777
      error(0, errno, "fopen");
 
778
      exitstatus = EX_OSERR;
613
779
      goto fallback;
614
780
    }
615
781
  }
616
 
  /* If there was any arguments from configuration file,
617
 
     pass them to parser as command arguments */
 
782
  /* If there were any arguments from the configuration file, pass
 
783
     them to parser as command line arguments */
618
784
  if(custom_argv != NULL){
619
 
    ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
620
 
                      0, NULL);
621
 
    if (ret == ARGP_ERR_UNKNOWN){
622
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
623
 
      exitstatus = EXIT_FAILURE;
 
785
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
786
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
787
                     NULL, NULL);
 
788
    switch(ret){
 
789
    case 0:
 
790
      break;
 
791
    case ENOMEM:
 
792
    default:
 
793
      errno = ret;
 
794
      error(0, errno, "argp_parse");
 
795
      exitstatus = EX_OSERR;
 
796
      goto fallback;
 
797
    case EINVAL:
 
798
      exitstatus = EX_CONFIG;
624
799
      goto fallback;
625
800
    }
626
801
  }
627
802
  
628
803
  /* Parse actual command line arguments, to let them override the
629
804
     config file */
630
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
631
 
  if (ret == ARGP_ERR_UNKNOWN){
632
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
633
 
    exitstatus = EXIT_FAILURE;
634
 
    goto fallback;
 
805
  ret = argp_parse(&argp, argc, argv,
 
806
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
807
                   NULL, NULL);
 
808
  switch(ret){
 
809
  case 0:
 
810
    break;
 
811
  case ENOMEM:
 
812
  default:
 
813
    errno = ret;
 
814
    error(0, errno, "argp_parse");
 
815
    exitstatus = EX_OSERR;
 
816
    goto fallback;
 
817
  case EINVAL:
 
818
    exitstatus = EX_USAGE;
 
819
    goto fallback;
 
820
  }
 
821
  
 
822
  {
 
823
    char *pluginhelperenv;
 
824
    bool bret = true;
 
825
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
826
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
827
    if(ret != -1){
 
828
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
829
    }
 
830
    if(ret == -1 or not bret){
 
831
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
832
            " environment variable to \"%s\" for all plugins\n",
 
833
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
834
    }
 
835
    if(ret != -1){
 
836
      free(pluginhelperenv);
 
837
    }
635
838
  }
636
839
  
637
840
  if(debug){
638
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
841
    for(plugin *p = plugin_list; p != NULL; p = p->next){
639
842
      fprintf(stderr, "Plugin: %s has %d arguments\n",
640
843
              p->name ? p->name : "Global", p->argc - 1);
641
844
      for(char **a = p->argv; *a != NULL; a++){
642
845
        fprintf(stderr, "\tArg: %s\n", *a);
643
846
      }
644
 
      fprintf(stderr, "...and %u environment variables\n", p->envc);
 
847
      fprintf(stderr, "...and %d environment variables\n", p->envc);
645
848
      for(char **a = p->environ; *a != NULL; a++){
646
849
        fprintf(stderr, "\t%s\n", *a);
647
850
      }
648
851
    }
649
852
  }
650
853
  
651
 
  /* Strip permissions down to nobody */
 
854
  if(getuid() == 0){
 
855
    /* Work around Debian bug #633582:
 
856
       <https://bugs.debian.org/633582> */
 
857
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
858
    if(plugindir_fd == -1){
 
859
      if(errno != ENOENT){
 
860
        error(0, errno, "open(\"" PDIR "\")");
 
861
      }
 
862
    } else {
 
863
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
864
      if(ret == -1){
 
865
        error(0, errno, "fstat");
 
866
      } else {
 
867
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
868
          ret = fchown(plugindir_fd, uid, gid);
 
869
          if(ret == -1){
 
870
            error(0, errno, "fchown");
 
871
          }
 
872
        }
 
873
      }
 
874
      close(plugindir_fd);
 
875
    }
 
876
 
 
877
    /* Work around Debian bug #981302
 
878
       <https://bugs.debian.org/981302> */
 
879
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
880
      ret = symlink("/proc/self/fd", "/dev/fd");
 
881
      if(ret == -1){
 
882
        error(0, errno, "Failed to create /dev/fd symlink");
 
883
      }
 
884
    }
 
885
  }
 
886
  
 
887
  /* Lower permissions */
 
888
  ret = setgid(gid);
 
889
  if(ret == -1){
 
890
    error(0, errno, "setgid");
 
891
  }
652
892
  ret = setuid(uid);
653
 
  if (ret == -1){
654
 
    perror("setuid");
655
 
  }  
656
 
  setgid(gid);
657
 
  if (ret == -1){
658
 
    perror("setgid");
659
 
  }
660
 
  
661
 
  if (plugindir == NULL){
662
 
    dir = opendir(PDIR);
663
 
  } else {
664
 
    dir = opendir(plugindir);
665
 
  }
666
 
  
667
 
  if(dir == NULL){
668
 
    perror("Could not open plugin dir");
669
 
    exitstatus = EXIT_FAILURE;
670
 
    goto fallback;
671
 
  }
672
 
  
673
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
 
893
  if(ret == -1){
 
894
    error(0, errno, "setuid");
 
895
  }
 
896
  
 
897
  /* Open plugin directory with close_on_exec flag */
674
898
  {
675
 
    int dir_fd = dirfd(dir);
676
 
    if(dir_fd >= 0){
677
 
      ret = set_cloexec_flag(dir_fd);
678
 
      if(ret < 0){
679
 
        perror("set_cloexec_flag");
680
 
        exitstatus = EXIT_FAILURE;
681
 
        goto fallback;
 
899
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
900
#ifdef O_CLOEXEC
 
901
                  O_CLOEXEC
 
902
#else  /* not O_CLOEXEC */
 
903
                  0
 
904
#endif  /* not O_CLOEXEC */
 
905
                  );
 
906
    if(dir_fd == -1){
 
907
      error(0, errno, "Could not open plugin dir");
 
908
      exitstatus = EX_UNAVAILABLE;
 
909
      goto fallback;
 
910
    }
 
911
    
 
912
#ifndef O_CLOEXEC
 
913
  /* Set the FD_CLOEXEC flag on the directory */
 
914
    ret = set_cloexec_flag(dir_fd);
 
915
    if(ret < 0){
 
916
      error(0, errno, "set_cloexec_flag");
 
917
      exitstatus = EX_OSERR;
 
918
      goto fallback;
 
919
    }
 
920
#endif  /* O_CLOEXEC */
 
921
  }
 
922
  
 
923
  int good_name(const struct dirent * const dirent){
 
924
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
925
                                      "*.dpkg-old", "*.dpkg-bak",
 
926
                                      "*.dpkg-divert", NULL };
 
927
#ifdef __GNUC__
 
928
#pragma GCC diagnostic push
 
929
#pragma GCC diagnostic ignored "-Wcast-qual"
 
930
#endif
 
931
    for(const char **pat = (const char **)patterns;
 
932
        *pat != NULL; pat++){
 
933
#ifdef __GNUC__
 
934
#pragma GCC diagnostic pop
 
935
#endif
 
936
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
937
         != FNM_NOMATCH){
 
938
        if(debug){
 
939
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
940
                    " matching pattern %s\n", dirent->d_name, *pat);
 
941
        }
 
942
        return 0;
682
943
      }
683
944
    }
 
945
    return 1;
 
946
  }
 
947
  
 
948
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
949
                             alphasort);
 
950
  if(numplugins == -1){
 
951
    error(0, errno, "Could not scan plugin dir");
 
952
    direntries = NULL;
 
953
    exitstatus = EX_OSERR;
 
954
    goto fallback;
684
955
  }
685
956
  
686
957
  FD_ZERO(&rfds_all);
687
958
  
688
959
  /* Read and execute any executable in the plugin directory*/
689
 
  while(true){
690
 
    dirst = readdir(dir);
691
 
    
692
 
    /* All directory entries have been processed */
693
 
    if(dirst == NULL){
694
 
      if (errno == EBADF){
695
 
        perror("readdir");
696
 
        exitstatus = EXIT_FAILURE;
697
 
        goto fallback;
698
 
      }
699
 
      break;
700
 
    }
701
 
    
702
 
    d_name_len = strlen(dirst->d_name);
703
 
    
704
 
    /* Ignore dotfiles, backup files and other junk */
705
 
    {
706
 
      bool bad_name = false;
707
 
      
708
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
709
 
      
710
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
711
 
                                           ".dpkg-old",
712
 
                                           ".dpkg-divert", NULL };
713
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
714
 
        size_t pre_len = strlen(*pre);
715
 
        if((d_name_len >= pre_len)
716
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
717
 
          if(debug){
718
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
719
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
720
 
          }
721
 
          bad_name = true;
722
 
          break;
723
 
        }
724
 
      }
725
 
      if(bad_name){
726
 
        continue;
727
 
      }
728
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
729
 
        size_t suf_len = strlen(*suf);
730
 
        if((d_name_len >= suf_len)
731
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
732
 
                == 0)){
733
 
          if(debug){
734
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
735
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
736
 
          }
737
 
          bad_name = true;
738
 
          break;
739
 
        }
740
 
      }
741
 
      
742
 
      if(bad_name){
743
 
        continue;
744
 
      }
745
 
    }
746
 
 
747
 
    char *filename;
748
 
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
749
 
    if(ret < 0){
750
 
      perror("asprintf");
751
 
      continue;
752
 
    }
753
 
    
754
 
    ret = stat(filename, &st);
755
 
    if (ret == -1){
756
 
      perror("stat");
757
 
      free(filename);
758
 
      continue;
759
 
    }
760
 
 
 
960
  for(int i = 0; i < numplugins; i++){
 
961
    
 
962
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
963
    if(plugin_fd == -1){
 
964
      error(0, errno, "Could not open plugin");
 
965
      free(direntries[i]);
 
966
      continue;
 
967
    }
 
968
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
 
969
    if(ret == -1){
 
970
      error(0, errno, "stat");
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
 
973
      continue;
 
974
    }
 
975
    
761
976
    /* Ignore non-executable files */
762
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
 
977
    if(not S_ISREG(st.st_mode)
 
978
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
979
                                        X_OK, 0)) != 0)){
763
980
      if(debug){
764
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
765
 
                " with bad type or mode\n", filename);
 
981
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
982
                " with bad type or mode\n",
 
983
                plugindir != NULL ? plugindir : PDIR,
 
984
                direntries[i]->d_name);
766
985
      }
767
 
      free(filename);
 
986
      close(plugin_fd);
 
987
      free(direntries[i]);
768
988
      continue;
769
989
    }
770
990
    
771
 
    plugin *p = getplugin(dirst->d_name);
 
991
    plugin *p = getplugin(direntries[i]->d_name);
772
992
    if(p == NULL){
773
 
      perror("getplugin");
774
 
      free(filename);
 
993
      error(0, errno, "getplugin");
 
994
      close(plugin_fd);
 
995
      free(direntries[i]);
775
996
      continue;
776
997
    }
777
998
    if(p->disabled){
778
999
      if(debug){
779
1000
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
780
 
                dirst->d_name);
 
1001
                direntries[i]->d_name);
781
1002
      }
782
 
      free(filename);
 
1003
      close(plugin_fd);
 
1004
      free(direntries[i]);
783
1005
      continue;
784
1006
    }
785
1007
    {
788
1010
      if(g != NULL){
789
1011
        for(char **a = g->argv + 1; *a != NULL; a++){
790
1012
          if(not add_argument(p, *a)){
791
 
            perror("add_argument");
 
1013
            error(0, errno, "add_argument");
792
1014
          }
793
1015
        }
794
1016
        /* Add global environment variables */
795
1017
        for(char **e = g->environ; *e != NULL; e++){
796
1018
          if(not add_environment(p, *e, false)){
797
 
            perror("add_environment");
 
1019
            error(0, errno, "add_environment");
798
1020
          }
799
1021
        }
800
1022
      }
801
1023
    }
802
 
    /* If this plugin has any environment variables, we will call
803
 
       using execve and need to duplicate the environment from this
804
 
       process, too. */
 
1024
    /* If this plugin has any environment variables, we need to
 
1025
       duplicate the environment from this process, too. */
805
1026
    if(p->environ[0] != NULL){
806
1027
      for(char **e = environ; *e != NULL; e++){
807
1028
        if(not add_environment(p, *e, false)){
808
 
          perror("add_environment");
 
1029
          error(0, errno, "add_environment");
809
1030
        }
810
1031
      }
811
1032
    }
812
1033
    
813
1034
    int pipefd[2];
814
 
    ret = pipe(pipefd);
815
 
    if (ret == -1){
816
 
      perror("pipe");
817
 
      exitstatus = EXIT_FAILURE;
818
 
      goto fallback;
819
 
    }
 
1035
#ifndef O_CLOEXEC
 
1036
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1037
#else  /* O_CLOEXEC */
 
1038
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1039
#endif  /* O_CLOEXEC */
 
1040
    if(ret == -1){
 
1041
      error(0, errno, "pipe");
 
1042
      exitstatus = EX_OSERR;
 
1043
      free(direntries[i]);
 
1044
      goto fallback;
 
1045
    }
 
1046
    if(pipefd[0] >= FD_SETSIZE){
 
1047
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1048
              FD_SETSIZE);
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
 
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
 
1053
      goto fallback;
 
1054
    }
 
1055
#ifndef O_CLOEXEC
820
1056
    /* Ask OS to automatic close the pipe on exec */
821
1057
    ret = set_cloexec_flag(pipefd[0]);
822
1058
    if(ret < 0){
823
 
      perror("set_cloexec_flag");
824
 
      exitstatus = EXIT_FAILURE;
 
1059
      error(0, errno, "set_cloexec_flag");
 
1060
      close(pipefd[0]);
 
1061
      close(pipefd[1]);
 
1062
      exitstatus = EX_OSERR;
 
1063
      free(direntries[i]);
825
1064
      goto fallback;
826
1065
    }
827
1066
    ret = set_cloexec_flag(pipefd[1]);
828
1067
    if(ret < 0){
829
 
      perror("set_cloexec_flag");
830
 
      exitstatus = EXIT_FAILURE;
 
1068
      error(0, errno, "set_cloexec_flag");
 
1069
      close(pipefd[0]);
 
1070
      close(pipefd[1]);
 
1071
      exitstatus = EX_OSERR;
 
1072
      free(direntries[i]);
831
1073
      goto fallback;
832
1074
    }
 
1075
#endif  /* not O_CLOEXEC */
833
1076
    /* Block SIGCHLD until process is safely in process list */
834
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1077
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
 
1078
                                              &sigchld_action.sa_mask,
 
1079
                                              NULL));
835
1080
    if(ret < 0){
836
 
      perror("sigprocmask");
837
 
      exitstatus = EXIT_FAILURE;
 
1081
      error(0, errno, "sigprocmask");
 
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
838
1084
      goto fallback;
839
1085
    }
840
1086
    /* Starting a new process to be watched */
841
 
    pid_t pid = fork();
 
1087
    pid_t pid;
 
1088
    do {
 
1089
      pid = fork();
 
1090
    } while(pid == -1 and errno == EINTR);
842
1091
    if(pid == -1){
843
 
      perror("fork");
844
 
      exitstatus = EXIT_FAILURE;
 
1092
      error(0, errno, "fork");
 
1093
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1094
                                     &sigchld_action.sa_mask, NULL));
 
1095
      close(pipefd[0]);
 
1096
      close(pipefd[1]);
 
1097
      exitstatus = EX_OSERR;
 
1098
      free(direntries[i]);
845
1099
      goto fallback;
846
1100
    }
847
1101
    if(pid == 0){
848
1102
      /* this is the child process */
849
1103
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
850
1104
      if(ret < 0){
851
 
        perror("sigaction");
852
 
        _exit(EXIT_FAILURE);
 
1105
        error(0, errno, "sigaction");
 
1106
        _exit(EX_OSERR);
853
1107
      }
854
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1108
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
855
1109
      if(ret < 0){
856
 
        perror("sigprocmask");
857
 
        _exit(EXIT_FAILURE);
 
1110
        error(0, errno, "sigprocmask");
 
1111
        _exit(EX_OSERR);
858
1112
      }
859
 
 
 
1113
      
860
1114
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
861
1115
      if(ret == -1){
862
 
        perror("dup2");
863
 
        _exit(EXIT_FAILURE);
 
1116
        error(0, errno, "dup2");
 
1117
        _exit(EX_OSERR);
864
1118
      }
865
1119
      
866
 
      if(dirfd(dir) < 0){
867
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
868
 
           above and must now close it manually here. */
869
 
        closedir(dir);
870
 
      }
871
 
      if(p->environ[0] == NULL){
872
 
        if(execv(filename, p->argv) < 0){
873
 
          perror("execv");
874
 
          _exit(EXIT_FAILURE);
875
 
        }
876
 
      } else {
877
 
        if(execve(filename, p->argv, p->environ) < 0){
878
 
          perror("execve");
879
 
          _exit(EXIT_FAILURE);
880
 
        }
 
1120
      if(fexecve(plugin_fd, p->argv,
 
1121
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1122
        error(0, errno, "fexecve for %s/%s",
 
1123
              plugindir != NULL ? plugindir : PDIR,
 
1124
              direntries[i]->d_name);
 
1125
        _exit(EX_OSERR);
881
1126
      }
882
1127
      /* no return */
883
1128
    }
884
1129
    /* Parent process */
885
1130
    close(pipefd[1]);           /* Close unused write end of pipe */
886
 
    free(filename);
887
 
    plugin *new_plugin = getplugin(dirst->d_name);
888
 
    if (new_plugin == NULL){
889
 
      perror("getplugin");
890
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1131
    close(plugin_fd);
 
1132
    plugin *new_plugin = getplugin(direntries[i]->d_name);
 
1133
    if(new_plugin == NULL){
 
1134
      error(0, errno, "getplugin");
 
1135
      ret = (int)(TEMP_FAILURE_RETRY
 
1136
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
 
1137
                               NULL)));
891
1138
      if(ret < 0){
892
 
        perror("sigprocmask");
 
1139
        error(0, errno, "sigprocmask");
893
1140
      }
894
 
      exitstatus = EXIT_FAILURE;
 
1141
      exitstatus = EX_OSERR;
 
1142
      free(direntries[i]);
895
1143
      goto fallback;
896
1144
    }
 
1145
    free(direntries[i]);
897
1146
    
898
1147
    new_plugin->pid = pid;
899
1148
    new_plugin->fd = pipefd[0];
900
 
    
 
1149
 
 
1150
    if(debug){
 
1151
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1152
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1153
    }
 
1154
 
901
1155
    /* Unblock SIGCHLD so signal handler can be run if this process
902
1156
       has already completed */
903
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1157
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1158
                                              &sigchld_action.sa_mask,
 
1159
                                              NULL));
904
1160
    if(ret < 0){
905
 
      perror("sigprocmask");
906
 
      exitstatus = EXIT_FAILURE;
 
1161
      error(0, errno, "sigprocmask");
 
1162
      exitstatus = EX_OSERR;
907
1163
      goto fallback;
908
1164
    }
909
1165
    
910
1166
    FD_SET(new_plugin->fd, &rfds_all);
911
1167
    
912
 
    if (maxfd < new_plugin->fd){
 
1168
    if(maxfd < new_plugin->fd){
913
1169
      maxfd = new_plugin->fd;
914
1170
    }
915
 
    
916
1171
  }
917
1172
  
918
 
  closedir(dir);
919
 
  dir = NULL;
920
 
 
 
1173
  free(direntries);
 
1174
  direntries = NULL;
 
1175
  close(dir_fd);
 
1176
  dir_fd = -1;
 
1177
  free_plugin(getplugin(NULL));
 
1178
  
921
1179
  for(plugin *p = plugin_list; p != NULL; p = p->next){
922
1180
    if(p->pid != 0){
923
1181
      break;
928
1186
      free_plugin_list();
929
1187
    }
930
1188
  }
931
 
 
 
1189
  
932
1190
  /* Main loop while running plugins exist */
933
1191
  while(plugin_list){
934
1192
    fd_set rfds = rfds_all;
935
1193
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
936
 
    if (select_ret == -1){
937
 
      perror("select");
938
 
      exitstatus = EXIT_FAILURE;
 
1194
    if(select_ret == -1 and errno != EINTR){
 
1195
      error(0, errno, "select");
 
1196
      exitstatus = EX_OSERR;
939
1197
      goto fallback;
940
1198
    }
941
1199
    /* OK, now either a process completed, or something can be read
942
1200
       from one of them */
943
 
    for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
 
1201
    for(plugin *proc = plugin_list; proc != NULL;){
944
1202
      /* Is this process completely done? */
945
 
      if(proc->eof and proc->completed){
 
1203
      if(proc->completed and proc->eof){
946
1204
        /* Only accept the plugin output if it exited cleanly */
947
1205
        if(not WIFEXITED(proc->status)
948
1206
           or WEXITSTATUS(proc->status) != 0){
949
1207
          /* Bad exit by plugin */
950
 
 
 
1208
          
951
1209
          if(debug){
952
1210
            if(WIFEXITED(proc->status)){
953
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
954
 
                      (unsigned int) (proc->pid),
 
1211
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1212
                      " status %d\n", proc->name,
 
1213
                      (intmax_t) (proc->pid),
955
1214
                      WEXITSTATUS(proc->status));
956
 
            } else if(WIFSIGNALED(proc->status)) {
957
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
958
 
                      (unsigned int) (proc->pid),
959
 
                      WTERMSIG(proc->status));
960
 
            } else if(WCOREDUMP(proc->status)){
961
 
              fprintf(stderr, "Plugin %d dumped core\n",
962
 
                      (unsigned int) (proc->pid));
 
1215
            } else if(WIFSIGNALED(proc->status)){
 
1216
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
 
1217
                      " signal %d: %s\n", proc->name,
 
1218
                      (intmax_t) (proc->pid),
 
1219
                      WTERMSIG(proc->status),
 
1220
                      strsignal(WTERMSIG(proc->status)));
963
1221
            }
964
1222
          }
965
1223
          
966
1224
          /* Remove the plugin */
967
1225
          FD_CLR(proc->fd, &rfds_all);
968
 
 
 
1226
          
969
1227
          /* Block signal while modifying process_list */
970
 
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1228
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1229
                                        (SIG_BLOCK,
 
1230
                                         &sigchld_action.sa_mask,
 
1231
                                         NULL));
971
1232
          if(ret < 0){
972
 
            perror("sigprocmask");
973
 
            exitstatus = EXIT_FAILURE;
 
1233
            error(0, errno, "sigprocmask");
 
1234
            exitstatus = EX_OSERR;
974
1235
            goto fallback;
975
1236
          }
 
1237
          
 
1238
          plugin *next_plugin = proc->next;
976
1239
          free_plugin(proc);
 
1240
          proc = next_plugin;
 
1241
          
977
1242
          /* We are done modifying process list, so unblock signal */
978
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
979
 
                             NULL);
 
1243
          ret = (int)(TEMP_FAILURE_RETRY
 
1244
                      (sigprocmask(SIG_UNBLOCK,
 
1245
                                   &sigchld_action.sa_mask, NULL)));
980
1246
          if(ret < 0){
981
 
            perror("sigprocmask");
982
 
            exitstatus = EXIT_FAILURE;
 
1247
            error(0, errno, "sigprocmask");
 
1248
            exitstatus = EX_OSERR;
983
1249
            goto fallback;
984
1250
          }
985
1251
          
986
1252
          if(plugin_list == NULL){
987
1253
            break;
988
1254
          }
 
1255
          
989
1256
          continue;
990
1257
        }
991
1258
        
992
1259
        /* This process exited nicely, so print its buffer */
993
 
 
 
1260
        
994
1261
        bool bret = print_out_password(proc->buffer,
995
1262
                                       proc->buffer_length);
996
1263
        if(not bret){
997
 
          perror("print_out_password");
998
 
          exitstatus = EXIT_FAILURE;
 
1264
          error(0, errno, "print_out_password");
 
1265
          exitstatus = EX_IOERR;
999
1266
        }
1000
1267
        goto fallback;
1001
1268
      }
1003
1270
      /* This process has not completed.  Does it have any output? */
1004
1271
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1005
1272
        /* This process had nothing to say at this time */
 
1273
        proc = proc->next;
1006
1274
        continue;
1007
1275
      }
1008
1276
      /* Before reading, make the process' data buffer large enough */
1009
1277
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1010
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1011
 
                               + (size_t) BUFFER_SIZE);
1012
 
        if (proc->buffer == NULL){
1013
 
          perror("malloc");
1014
 
          exitstatus = EXIT_FAILURE;
 
1278
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1279
                                   + (size_t) BUFFER_SIZE);
 
1280
        if(new_buffer == NULL){
 
1281
          error(0, errno, "malloc");
 
1282
          exitstatus = EX_OSERR;
1015
1283
          goto fallback;
1016
1284
        }
 
1285
        proc->buffer = new_buffer;
1017
1286
        proc->buffer_size += BUFFER_SIZE;
1018
1287
      }
1019
1288
      /* Read from the process */
1020
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
1021
 
                 BUFFER_SIZE);
1022
 
      if(ret < 0){
 
1289
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1290
                                     proc->buffer
 
1291
                                     + proc->buffer_length,
 
1292
                                     BUFFER_SIZE));
 
1293
      if(sret < 0){
1023
1294
        /* Read error from this process; ignore the error */
 
1295
        proc = proc->next;
1024
1296
        continue;
1025
1297
      }
1026
 
      if(ret == 0){
 
1298
      if(sret == 0){
1027
1299
        /* got EOF */
1028
1300
        proc->eof = true;
1029
1301
      } else {
1030
 
        proc->buffer_length += (size_t) ret;
 
1302
        proc->buffer_length += (size_t) sret;
1031
1303
      }
1032
1304
    }
1033
1305
  }
1034
 
 
1035
 
 
 
1306
  
 
1307
  
1036
1308
 fallback:
1037
1309
  
1038
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1310
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1311
                             and exitstatus != EX_OK)){
1039
1312
    /* Fallback if all plugins failed, none are found or an error
1040
1313
       occured */
1041
1314
    bool bret;
1042
1315
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
1043
1316
    char *passwordbuffer = getpass("Password: ");
1044
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
 
1317
    size_t len = strlen(passwordbuffer);
 
1318
    /* Strip trailing newline */
 
1319
    if(len > 0 and passwordbuffer[len-1] == '\n'){
 
1320
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
 
1321
      len--;
 
1322
    }
 
1323
    bret = print_out_password(passwordbuffer, len);
1045
1324
    if(not bret){
1046
 
      perror("print_out_password");
1047
 
      exitstatus = EXIT_FAILURE;
 
1325
      error(0, errno, "print_out_password");
 
1326
      exitstatus = EX_IOERR;
1048
1327
    }
1049
1328
  }
1050
1329
  
1051
1330
  /* Restore old signal handler */
1052
1331
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1053
1332
  if(ret == -1){
1054
 
    perror("sigaction");
1055
 
    exitstatus = EXIT_FAILURE;
 
1333
    error(0, errno, "sigaction");
 
1334
    exitstatus = EX_OSERR;
1056
1335
  }
1057
 
 
 
1336
  
1058
1337
  if(custom_argv != NULL){
1059
1338
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
1060
1339
      free(*arg);
1062
1341
    free(custom_argv);
1063
1342
  }
1064
1343
  
1065
 
  if(dir != NULL){
1066
 
    closedir(dir);
 
1344
  free(direntries);
 
1345
  
 
1346
  if(dir_fd != -1){
 
1347
    close(dir_fd);
1067
1348
  }
1068
1349
  
1069
 
  /* Free the process list and kill the processes */
 
1350
  /* Kill the processes */
1070
1351
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1071
1352
    if(p->pid != 0){
1072
1353
      close(p->fd);
1073
1354
      ret = kill(p->pid, SIGTERM);
1074
1355
      if(ret == -1 and errno != ESRCH){
1075
1356
        /* Set-uid proccesses might not get closed */
1076
 
        perror("kill");
 
1357
        error(0, errno, "kill");
1077
1358
      }
1078
1359
    }
1079
1360
  }
1080
1361
  
1081
1362
  /* Wait for any remaining child processes to terminate */
1082
 
  do{
 
1363
  do {
1083
1364
    ret = wait(NULL);
1084
1365
  } while(ret >= 0);
1085
1366
  if(errno != ECHILD){
1086
 
    perror("wait");
 
1367
    error(0, errno, "wait");
1087
1368
  }
1088
 
 
 
1369
  
1089
1370
  free_plugin_list();
1090
1371
  
1091
1372
  free(plugindir);
 
1373
  free(pluginhelperdir);
1092
1374
  free(argfile);
1093
1375
  
1094
1376
  return exitstatus;