/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: 2008-08-29 05:53:59 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080829055359-wkdasnyxtylmnxus
* mandos.xml (EXAMPLE): Replaced all occurences of command name with
                        "&COMMANDNAME;".

* plugins.d/password-prompt.c (main): Improved some documentation
                                      strings.  Do perror() of
                                      tcgetattr() fails.  Add debug
                                      output if interrupted by signal.
                                      Loop over write() instead of
                                      using fwrite() when outputting
                                      password.  Add debug output if
                                      getline() returns 0, unless it
                                      was caused by a signal.  Add
                                      exit status code to debug
                                      output.

* plugins.d/password-prompt.xml: Changed all single quotes to double
                                 quotes for consistency.  Removed
                                 <?xml-stylesheet>.
  (ENTITY TIMESTAMP): New.  Automatically updated by Emacs time-stamp
                      by using Emacs local variables.
  (/refentry/refentryinfo/title): Changed to "Mandos Manual".
  (/refentry/refentryinfo/productname): Changed to "Mandos".
  (/refentry/refentryinfo/date): New; set to "&TIMESTAMP;".
  (/refentry/refentryinfo/copyright): Split copyright holders.
  (/refentry/refnamediv/refpurpose): Improved wording.
  (SYNOPSIS): Fix to use correct markup.  Add short options.
  (DESCRIPTION, OPTIONS): Improved wording.
  (OPTIONS): Improved wording.  Use more correct markup.  Document
             short options.
  (EXIT STATUS): Add text.
  (ENVIRONMENT): Document use of "cryptsource" and "crypttarget".
  (FILES): REMOVED.
  (BUGS): Add text.
  (EXAMPLE): Added some examples.
  (SECURITY): Added text.
  (SEE ALSO): Remove reference to mandos(8).  Add reference to
              crypttab(5).

Show diffs side-by-side

added added

removed removed

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