/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 at recompile
  • Date: 2020-04-05 21:30:59 UTC
  • Revision ID: teddy@recompile.se-20200405213059-fb2a61ckqynrmatk
Fix file descriptor leak in mandos-client

When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.)  The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.

This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route.  If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.

Fix this by eliminating the file descriptor leak in the client.

* plugins.d/mandos-client.c (add_delete_local_route): Do
  close(devnull) also in parent process, also if fork() fails, and on
  any failure in child process.

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