/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugin-runner.c

First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
5
 * Copyright © 2008 Teddy Hogeborn
 
6
 * Copyright © 2008 Björn Påhlsson
6
7
 * 
7
8
 * This program is free software: you can redistribute it and/or
8
9
 * modify it under the terms of the GNU General Public License as
21
22
 * Contact the authors at <mandos@fukt.bsnet.se>.
22
23
 */
23
24
 
24
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
25
 
 
 
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
 
26
                                   asprintf() */
26
27
#include <stddef.h>             /* size_t, NULL */
27
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
29
                                   EXIT_SUCCESS, realloc() */
29
30
#include <stdbool.h>            /* bool, true, false */
30
 
#include <stdio.h>              /* perror, popen(), fileno(),
31
 
                                   fprintf(), stderr, STDOUT_FILENO */
 
31
#include <stdio.h>              /* perror, fileno(), fprintf(),
 
32
                                   stderr, STDOUT_FILENO */
32
33
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
33
34
                                   stat, waitpid(), WIFEXITED(),
34
35
                                   WEXITSTATUS(), wait(), pid_t,
46
47
                                   fcntl(), setuid(), setgid(),
47
48
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
48
49
                                   access(), pipe(), fork(), close()
49
 
                                   dup2, STDOUT_FILENO, _exit(),
 
50
                                   dup2(), STDOUT_FILENO, _exit(),
50
51
                                   execv(), write(), read(),
51
52
                                   close() */
52
53
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
54
                                   FD_CLOEXEC */
54
 
#include <string.h>             /* strsep, strlen(), strcpy(),
55
 
                                   strcat() */
 
55
#include <string.h>             /* strsep, strlen(), asprintf() */
56
56
#include <errno.h>              /* errno */
57
57
#include <argp.h>               /* struct argp_option, struct
58
58
                                   argp_state, struct argp,
59
59
                                   argp_parse(), ARGP_ERR_UNKNOWN,
60
 
                                   ARGP_KEY_END, ARGP_KEY_ARG, error_t */
 
60
                                   ARGP_KEY_END, ARGP_KEY_ARG,
 
61
                                   error_t */
61
62
#include <signal.h>             /* struct sigaction, sigemptyset(),
62
63
                                   sigaddset(), sigaction(),
63
64
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
65
66
#include <errno.h>              /* errno, EBADF */
66
67
 
67
68
#define BUFFER_SIZE 256
68
 
#define ARGFILE "/conf/conf.d/mandos/plugins.conf"
69
 
 
70
 
const char *argp_program_version = "plugin-runner 1.0";
 
69
 
 
70
#define PDIR "/lib/mandos/plugins.d"
 
71
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
 
72
 
 
73
const char *argp_program_version = "plugin-runner " VERSION;
71
74
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
72
75
 
73
 
struct process;
 
76
typedef struct plugin{
 
77
  char *name;                   /* can be NULL or any plugin name */
 
78
  char **argv;
 
79
  int argc;
 
80
  char **environ;
 
81
  int envc;
 
82
  bool disabled;
74
83
 
75
 
typedef struct process{
 
84
  /* Variables used for running processes*/
76
85
  pid_t pid;
77
86
  int fd;
78
87
  char *buffer;
79
88
  size_t buffer_size;
80
89
  size_t buffer_length;
81
90
  bool eof;
82
 
  bool completed;
83
 
  int status;
84
 
  struct process *next;
85
 
} process;
86
 
 
87
 
typedef struct plugin{
88
 
  char *name;                   /* can be NULL or any plugin name */
89
 
  char **argv;
90
 
  int argc;
91
 
  bool disabled;
 
91
  volatile bool completed;
 
92
  volatile int status;
92
93
  struct plugin *next;
93
94
} plugin;
94
95
 
95
 
static plugin *getplugin(char *name, plugin **plugin_list){
96
 
  for (plugin *p = *plugin_list; p != NULL; p = p->next){
 
96
static plugin *plugin_list = NULL;
 
97
 
 
98
/* Gets an existing plugin based on name,
 
99
   or if none is found, creates a new one */
 
100
static plugin *getplugin(char *name){
 
101
  /* Check for exiting plugin with that name */
 
102
  for (plugin *p = plugin_list; p != NULL; p = p->next){
97
103
    if ((p->name == name)
98
104
        or (p->name and name and (strcmp(p->name, name) == 0))){
99
105
      return p;
102
108
  /* Create a new plugin */
103
109
  plugin *new_plugin = malloc(sizeof(plugin));
104
110
  if (new_plugin == NULL){
105
 
    perror("malloc");
106
 
    exit(EXIT_FAILURE);
107
 
  }
108
 
  new_plugin->name = name;
 
111
    return NULL;
 
112
  }
 
113
  char *copy_name = NULL;
 
114
  if(name != NULL){
 
115
    copy_name = strdup(name);
 
116
    if(copy_name == NULL){
 
117
      return NULL;
 
118
    }
 
119
  }
 
120
  
 
121
  *new_plugin = (plugin) { .name = copy_name,
 
122
                           .argc = 1,
 
123
                           .disabled = false,
 
124
                           .next = plugin_list };
 
125
  
109
126
  new_plugin->argv = malloc(sizeof(char *) * 2);
110
127
  if (new_plugin->argv == NULL){
111
 
    perror("malloc");
112
 
    exit(EXIT_FAILURE);
 
128
    free(copy_name);
 
129
    free(new_plugin);
 
130
    return NULL;
113
131
  }
114
 
  new_plugin->argv[0] = name;
 
132
  new_plugin->argv[0] = copy_name;
115
133
  new_plugin->argv[1] = NULL;
116
 
  new_plugin->argc = 1;
117
 
  new_plugin->disabled = false;
118
 
  new_plugin->next = *plugin_list;
 
134
  
 
135
  new_plugin->environ = malloc(sizeof(char *));
 
136
  if(new_plugin->environ == NULL){
 
137
    free(copy_name);
 
138
    free(new_plugin->argv);
 
139
    free(new_plugin);
 
140
    return NULL;
 
141
  }
 
142
  new_plugin->environ[0] = NULL;
 
143
  
119
144
  /* Append the new plugin to the list */
120
 
  *plugin_list = new_plugin;
 
145
  plugin_list = new_plugin;
121
146
  return new_plugin;
122
147
}
123
148
 
124
 
static void addargument(plugin *p, char *arg){
125
 
  p->argv[p->argc] = arg;
126
 
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
127
 
  if (p->argv == NULL){
128
 
    perror("malloc");
129
 
    exit(EXIT_FAILURE);
130
 
  }
131
 
  p->argc++;
132
 
  p->argv[p->argc] = NULL;
 
149
/* Helper function for add_argument and add_environment */
 
150
static bool add_to_char_array(const char *new, char ***array,
 
151
                              int *len){
 
152
  /* Resize the pointed-to array to hold one more pointer */
 
153
  *array = realloc(*array, sizeof(char *)
 
154
                   * (size_t) ((*len) + 2));
 
155
  /* Malloc check */
 
156
  if(*array == NULL){
 
157
    return false;
 
158
  }
 
159
  /* Make a copy of the new string */
 
160
  char *copy = strdup(new);
 
161
  if(copy == NULL){
 
162
    return false;
 
163
  }
 
164
  /* Insert the copy */
 
165
  (*array)[*len] = copy;
 
166
  (*len)++;
 
167
  /* Add a new terminating NULL pointer to the last element */
 
168
  (*array)[*len] = NULL;
 
169
  return true;
 
170
}
 
171
 
 
172
/* Add to a plugin's argument vector */
 
173
static bool add_argument(plugin *p, const char *arg){
 
174
  if(p == NULL){
 
175
    return false;
 
176
  }
 
177
  return add_to_char_array(arg, &(p->argv), &(p->argc));
 
178
}
 
179
 
 
180
/* Add to a plugin's environment */
 
181
static bool add_environment(plugin *p, const char *def, bool replace){
 
182
  if(p == NULL){
 
183
    return false;
 
184
  }
 
185
  /* namelen = length of name of environment variable */
 
186
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
 
187
  /* Search for this environment variable */
 
188
  for(char **e = p->environ; *e != NULL; e++){
 
189
    if(strncmp(*e, def, namelen + 1) == 0){
 
190
      /* It already exists */
 
191
      if(replace){
 
192
        char *new = realloc(*e, strlen(def) + 1);
 
193
        if(new == NULL){
 
194
          return false;
 
195
        }
 
196
        *e = new;
 
197
        strcpy(*e, def);
 
198
      }
 
199
      return true;
 
200
    }
 
201
  }
 
202
  return add_to_char_array(def, &(p->environ), &(p->envc));
133
203
}
134
204
 
135
205
/*
137
207
 * Descriptor Flags".
138
208
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
139
209
 */
140
 
static int set_cloexec_flag(int fd)
141
 
{
 
210
static int set_cloexec_flag(int fd){
142
211
  int ret = fcntl(fd, F_GETFD, 0);
143
212
  /* If reading the flags failed, return error indication now. */
144
213
  if(ret < 0){
148
217
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
149
218
}
150
219
 
151
 
process *process_list = NULL;
152
220
 
153
 
/* Mark a process as completed when it exits, and save its exit
 
221
/* Mark processes as completed when they exit, and save their exit
154
222
   status. */
155
 
void handle_sigchld(__attribute__((unused)) int sig){
156
 
  process *proc = process_list;
157
 
  int status;
158
 
  pid_t pid = wait(&status);
159
 
  if(pid == -1){
160
 
    perror("wait");
161
 
    return;
162
 
  }
163
 
  while(proc != NULL and proc->pid != pid){
164
 
    proc = proc->next;
165
 
  }
166
 
  if(proc == NULL){
167
 
    /* Process not found in process list */
168
 
    return;
169
 
  }
170
 
  proc->status = status;
171
 
  proc->completed = true;
 
223
static void handle_sigchld(__attribute__((unused)) int sig){
 
224
  while(true){
 
225
    plugin *proc = plugin_list;
 
226
    int status;
 
227
    pid_t pid = waitpid(-1, &status, WNOHANG);
 
228
    if(pid == 0){
 
229
      /* Only still running child processes */
 
230
      break;
 
231
    }
 
232
    if(pid == -1){
 
233
      if (errno != ECHILD){
 
234
        perror("waitpid");
 
235
      }
 
236
      /* No child processes */
 
237
      break;
 
238
    }
 
239
    
 
240
    /* A child exited, find it in process_list */
 
241
    while(proc != NULL and proc->pid != pid){
 
242
      proc = proc->next;
 
243
    }
 
244
    if(proc == NULL){
 
245
      /* Process not found in process list */
 
246
      continue;
 
247
    }
 
248
    proc->status = status;
 
249
    proc->completed = true;
 
250
  }
172
251
}
173
252
 
174
 
bool print_out_password(const char *buffer, size_t length){
 
253
/* Prints out a password to stdout */
 
254
static bool print_out_password(const char *buffer, size_t length){
175
255
  ssize_t ret;
176
 
  if(length>0 and buffer[length-1] == '\n'){
177
 
    length--;
178
 
  }
179
256
  for(size_t written = 0; written < length; written += (size_t)ret){
180
257
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
181
258
                                   length - written));
186
263
  return true;
187
264
}
188
265
 
189
 
char ** addcustomargument(char **argv, int *argc, char *arg){
 
266
/* Removes and free a plugin from the plugin list */
 
267
static void free_plugin(plugin *plugin_node){
 
268
  
 
269
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
270
    free(*arg);
 
271
  }
 
272
  free(plugin_node->argv);
 
273
  for(char **env = plugin_node->environ; *env != NULL; env++){
 
274
    free(*env);
 
275
  }
 
276
  free(plugin_node->environ);
 
277
  free(plugin_node->buffer);
190
278
 
191
 
  if (argv == NULL){
192
 
    *argc = 1;
193
 
    argv = malloc(sizeof(char*) * 2);
194
 
    if(argv == NULL){
195
 
      return NULL;
 
279
  /* Removes the plugin from the singly-linked list */
 
280
  if(plugin_node == plugin_list){
 
281
    /* First one - simple */
 
282
    plugin_list = plugin_list->next;
 
283
  } else {
 
284
    /* Second one or later */
 
285
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
286
      if(p->next == plugin_node){
 
287
        p->next = plugin_node->next;
 
288
        break;
 
289
      }
196
290
    }
197
 
    argv[0] = NULL;     /* Will be set to argv[0] in main before parsing */
198
 
    argv[1] = NULL;
199
 
  }
200
 
  *argc += 1;
201
 
  argv = realloc(argv, sizeof(char *)
202
 
                  * ((unsigned int) *argc + 1));
203
 
  if(argv == NULL){
204
 
    return NULL;
205
 
  }
206
 
  argv[*argc-1] = arg;
207
 
  argv[*argc] = NULL;   
208
 
  return argv;
 
291
  }
 
292
  
 
293
  free(plugin_node);
 
294
}
 
295
 
 
296
static void free_plugin_list(void){
 
297
  while(plugin_list != NULL){
 
298
    free_plugin(plugin_list);
 
299
  }
209
300
}
210
301
 
211
302
int main(int argc, char *argv[]){
212
 
  const char *plugindir = "/lib/mandos/plugins.d";
213
 
  const char *argfile = ARGFILE;
 
303
  char *plugindir = NULL;
 
304
  char *argfile = NULL;
214
305
  FILE *conffp;
215
306
  size_t d_name_len;
216
307
  DIR *dir = NULL;
231
322
  /* Establish a signal handler */
232
323
  sigemptyset(&sigchld_action.sa_mask);
233
324
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
234
 
  if(ret < 0){
 
325
  if(ret == -1){
235
326
    perror("sigaddset");
236
 
    exit(EXIT_FAILURE);
 
327
    exitstatus = EXIT_FAILURE;
 
328
    goto fallback;
237
329
  }
238
330
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
239
 
  if(ret < 0){
 
331
  if(ret == -1){
240
332
    perror("sigaction");
241
 
    exit(EXIT_FAILURE);
 
333
    exitstatus = EXIT_FAILURE;
 
334
    goto fallback;
242
335
  }
243
336
  
244
337
  /* The options we understand. */
246
339
    { .name = "global-options", .key = 'g',
247
340
      .arg = "OPTION[,OPTION[,...]]",
248
341
      .doc = "Options passed to all plugins" },
 
342
    { .name = "global-env", .key = 'G',
 
343
      .arg = "VAR=value",
 
344
      .doc = "Environment variable passed to all plugins" },
249
345
    { .name = "options-for", .key = 'o',
250
346
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
251
347
      .doc = "Options passed only to specified plugin" },
 
348
    { .name = "env-for", .key = 'E',
 
349
      .arg = "PLUGIN:ENV=value",
 
350
      .doc = "Environment variable passed to specified plugin" },
252
351
    { .name = "disable", .key = 'd',
253
352
      .arg = "PLUGIN",
254
353
      .doc = "Disable a specific plugin", .group = 1 },
 
354
    { .name = "enable", .key = 'e',
 
355
      .arg = "PLUGIN",
 
356
      .doc = "Enable a specific plugin", .group = 1 },
255
357
    { .name = "plugin-dir", .key = 128,
256
358
      .arg = "DIRECTORY",
257
359
      .doc = "Specify a different plugin directory", .group = 2 },
258
 
    { .name = "userid", .key = 129,
259
 
      .arg = "ID", .flags = 0,
260
 
      .doc = "User ID the plugins will run as", .group = 2 },
261
 
    { .name = "groupid", .key = 130,
262
 
      .arg = "ID", .flags = 0,
263
 
      .doc = "Group ID the plugins will run as", .group = 2 },
264
 
    { .name = "debug", .key = 131,
265
 
      .doc = "Debug mode", .group = 3 },
 
360
    { .name = "config-file", .key = 129,
 
361
      .arg = "FILE",
 
362
      .doc = "Specify a different configuration file", .group = 2 },
 
363
    { .name = "userid", .key = 130,
 
364
      .arg = "ID", .flags = 0,
 
365
      .doc = "User ID the plugins will run as", .group = 3 },
 
366
    { .name = "groupid", .key = 131,
 
367
      .arg = "ID", .flags = 0,
 
368
      .doc = "Group ID the plugins will run as", .group = 3 },
 
369
    { .name = "debug", .key = 132,
 
370
      .doc = "Debug mode", .group = 4 },
266
371
    { .name = NULL }
267
372
  };
268
373
  
269
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
270
 
    /* Get the INPUT argument from `argp_parse', which we know is a
271
 
       pointer to our plugin list pointer. */
272
 
    plugin **plugins = state->input;
 
374
  error_t parse_opt (int key, char *arg, __attribute__((unused))
 
375
                     struct argp_state *state) {
273
376
    switch (key) {
274
 
    case 'g':
 
377
    case 'g':                   /* --global-options */
275
378
      if (arg != NULL){
276
379
        char *p;
277
380
        while((p = strsep(&arg, ",")) != NULL){
278
381
          if(p[0] == '\0'){
279
382
            continue;
280
383
          }
281
 
          addargument(getplugin(NULL, plugins), p);
 
384
          if(not add_argument(getplugin(NULL), p)){
 
385
            perror("add_argument");
 
386
            return ARGP_ERR_UNKNOWN;
 
387
          }
282
388
        }
283
389
      }
284
390
      break;
285
 
    case 'o':
 
391
    case 'G':                   /* --global-env */
 
392
      if(arg == NULL){
 
393
        break;
 
394
      }
 
395
      if(not add_environment(getplugin(NULL), arg, true)){
 
396
        perror("add_environment");
 
397
      }
 
398
      break;
 
399
    case 'o':                   /* --options-for */
286
400
      if (arg != NULL){
287
 
        char *name = strsep(&arg, ":");
288
 
        if(name[0] == '\0'){
 
401
        char *p_name = strsep(&arg, ":");
 
402
        if(p_name[0] == '\0' or arg == NULL){
289
403
          break;
290
404
        }
291
405
        char *opt = strsep(&arg, ":");
292
 
        if(opt[0] == '\0'){
293
 
          break;
294
 
        }
295
 
        if(opt != NULL){
296
 
          char *p;
297
 
          while((p = strsep(&opt, ",")) != NULL){
298
 
            if(p[0] == '\0'){
299
 
              continue;
300
 
            }
301
 
            addargument(getplugin(name, plugins), p);
302
 
          }
303
 
        }
304
 
      }
305
 
      break;
306
 
    case 'd':
307
 
      if (arg != NULL){
308
 
        getplugin(arg, plugins)->disabled = true;
309
 
      }
310
 
      break;
311
 
    case 128:
312
 
      plugindir = arg;
313
 
      break;
314
 
    case 129:
 
406
        if(opt[0] == '\0' or opt == NULL){
 
407
          break;
 
408
        }
 
409
        char *p;
 
410
        while((p = strsep(&opt, ",")) != NULL){
 
411
          if(p[0] == '\0'){
 
412
            continue;
 
413
          }
 
414
          if(not add_argument(getplugin(p_name), p)){
 
415
            perror("add_argument");
 
416
            return ARGP_ERR_UNKNOWN;
 
417
          }
 
418
        }
 
419
      }
 
420
      break;
 
421
    case 'E':                   /* --env-for */
 
422
      if(arg == NULL){
 
423
        break;
 
424
      }
 
425
      {
 
426
        char *envdef = strchr(arg, ':');
 
427
        if(envdef == NULL){
 
428
          break;
 
429
        }
 
430
        *envdef = '\0';
 
431
        if(not add_environment(getplugin(arg), envdef+1, true)){
 
432
          perror("add_environment");
 
433
        }
 
434
      }
 
435
      break;
 
436
    case 'd':                   /* --disable */
 
437
      if (arg != NULL){
 
438
        plugin *p = getplugin(arg);
 
439
        if(p == NULL){
 
440
          return ARGP_ERR_UNKNOWN;
 
441
        }
 
442
        p->disabled = true;
 
443
      }
 
444
      break;
 
445
    case 'e':                   /* --enable */
 
446
      if (arg != NULL){
 
447
        plugin *p = getplugin(arg);
 
448
        if(p == NULL){
 
449
          return ARGP_ERR_UNKNOWN;
 
450
        }
 
451
        p->disabled = false;
 
452
      }
 
453
      break;
 
454
    case 128:                   /* --plugin-dir */
 
455
      free(plugindir);
 
456
      plugindir = strdup(arg);
 
457
      if(plugindir == NULL){
 
458
        perror("strdup");
 
459
      }      
 
460
      break;
 
461
    case 129:                   /* --config-file */
 
462
      /* This is already done by parse_opt_config_file() */
 
463
      break;
 
464
    case 130:                   /* --userid */
315
465
      uid = (uid_t)strtol(arg, NULL, 10);
316
466
      break;
317
 
    case 130:
 
467
    case 131:                   /* --groupid */
318
468
      gid = (gid_t)strtol(arg, NULL, 10);
319
469
      break;
320
 
    case 131:
 
470
    case 132:                   /* --debug */
321
471
      debug = true;
322
472
      break;
323
473
    case ARGP_KEY_ARG:
324
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg); 
325
 
      break;
326
 
    case ARGP_KEY_END:
327
 
      break;
328
 
    default:
329
 
      return ARGP_ERR_UNKNOWN;
330
 
    }
331
 
    return 0;
332
 
  }
333
 
  
334
 
  plugin *plugin_list = NULL;
335
 
  
336
 
  struct argp argp = { .options = options, .parser = parse_opt,
337
 
                       .args_doc = "[+PLUS_SEPARATED_OPTIONS]",
 
474
      /* Cryptsetup always passes an argument, which is an empty
 
475
         string if "none" was specified in /etc/crypttab.  So if
 
476
         argument was empty, we ignore it silently. */
 
477
      if(arg[0] != '\0'){
 
478
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
479
      }
 
480
      break;
 
481
    case ARGP_KEY_END:
 
482
      break;
 
483
    default:
 
484
      return ARGP_ERR_UNKNOWN;
 
485
    }
 
486
    return 0;
 
487
  }
 
488
  
 
489
  /* This option parser is the same as parse_opt() above, except it
 
490
     ignores everything but the --config-file option. */
 
491
  error_t parse_opt_config_file (int key, char *arg,
 
492
                                 __attribute__((unused))
 
493
                                 struct argp_state *state) {
 
494
    switch (key) {
 
495
    case 'g':                   /* --global-options */
 
496
    case 'G':                   /* --global-env */
 
497
    case 'o':                   /* --options-for */
 
498
    case 'E':                   /* --env-for */
 
499
    case 'd':                   /* --disable */
 
500
    case 'e':                   /* --enable */
 
501
    case 128:                   /* --plugin-dir */
 
502
      break;
 
503
    case 129:                   /* --config-file */
 
504
      free(argfile);
 
505
      argfile = strdup(arg);
 
506
      if(argfile == NULL){
 
507
        perror("strdup");
 
508
      }
 
509
      break;      
 
510
    case 130:                   /* --userid */
 
511
    case 131:                   /* --groupid */
 
512
    case 132:                   /* --debug */
 
513
    case ARGP_KEY_ARG:
 
514
    case ARGP_KEY_END:
 
515
      break;
 
516
    default:
 
517
      return ARGP_ERR_UNKNOWN;
 
518
    }
 
519
    return 0;
 
520
  }
 
521
  
 
522
  struct argp argp = { .options = options,
 
523
                       .parser = parse_opt_config_file,
 
524
                       .args_doc = "",
338
525
                       .doc = "Mandos plugin runner -- Run plugins" };
339
526
  
340
 
  ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
 
527
  /* Parse using the parse_opt_config_file in order to get the custom
 
528
     config file location, if any. */
 
529
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
341
530
  if (ret == ARGP_ERR_UNKNOWN){
342
531
    fprintf(stderr, "Unknown error while parsing arguments\n");
343
532
    exitstatus = EXIT_FAILURE;
344
 
    goto end;
 
533
    goto fallback;
345
534
  }
346
 
 
347
 
  conffp = fopen(argfile, "r");
 
535
  
 
536
  /* Reset to the normal argument parser */
 
537
  argp.parser = parse_opt;
 
538
  
 
539
  /* Open the configfile if available */
 
540
  if (argfile == NULL){
 
541
    conffp = fopen(AFILE, "r");
 
542
  } else {
 
543
    conffp = fopen(argfile, "r");
 
544
  }  
348
545
  if(conffp != NULL){
349
546
    char *org_line = NULL;
 
547
    char *p, *arg, *new_arg, *line;
350
548
    size_t size = 0;
351
549
    ssize_t sret;
352
 
    char *p, *arg, *new_arg, *line;
353
550
    const char whitespace_delims[] = " \r\t\f\v\n";
354
551
    const char comment_delim[] = "#";
355
552
 
 
553
    custom_argc = 1;
 
554
    custom_argv = malloc(sizeof(char*) * 2);
 
555
    if(custom_argv == NULL){
 
556
      perror("malloc");
 
557
      exitstatus = EXIT_FAILURE;
 
558
      goto fallback;
 
559
    }
 
560
    custom_argv[0] = argv[0];
 
561
    custom_argv[1] = NULL;
 
562
 
 
563
    /* for each line in the config file, strip whitespace and ignore
 
564
       commented text */
356
565
    while(true){
357
566
      sret = getline(&org_line, &size, conffp);
358
567
      if(sret == -1){
366
575
          continue;
367
576
        }
368
577
        new_arg = strdup(p);
369
 
        custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
370
 
        if (custom_argv == NULL){
371
 
          perror("addcustomargument");
372
 
          exitstatus = EXIT_FAILURE;
373
 
          goto end;
374
 
        }
 
578
        if(new_arg == NULL){
 
579
          perror("strdup");
 
580
          exitstatus = EXIT_FAILURE;
 
581
          free(org_line);
 
582
          goto fallback;
 
583
        }
 
584
        
 
585
        custom_argc += 1;
 
586
        custom_argv = realloc(custom_argv, sizeof(char *)
 
587
                              * ((unsigned int) custom_argc + 1));
 
588
        if(custom_argv == NULL){
 
589
          perror("realloc");
 
590
          exitstatus = EXIT_FAILURE;
 
591
          free(org_line);
 
592
          goto fallback;
 
593
        }
 
594
        custom_argv[custom_argc-1] = new_arg;
 
595
        custom_argv[custom_argc] = NULL;        
375
596
      }
376
597
    }
377
598
    free(org_line);
378
 
  } else{
 
599
  } else {
379
600
    /* Check for harmful errors and go to fallback. Other errors might
380
601
       not affect opening plugins */
381
602
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
382
603
      perror("fopen");
383
604
      exitstatus = EXIT_FAILURE;
384
 
      goto end;
 
605
      goto fallback;
385
606
    }
386
607
  }
387
 
 
 
608
  /* If there was any arguments from configuration file,
 
609
     pass them to parser as command arguments */
388
610
  if(custom_argv != NULL){
389
 
    custom_argv[0] = argv[0];
390
 
    ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
 
611
    ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
 
612
                      0, NULL);
391
613
    if (ret == ARGP_ERR_UNKNOWN){
392
614
      fprintf(stderr, "Unknown error while parsing arguments\n");
393
615
      exitstatus = EXIT_FAILURE;
394
 
      goto end;
 
616
      goto fallback;
395
617
    }
396
618
  }
397
619
  
 
620
  /* Parse actual command line arguments, to let them override the
 
621
     config file */
 
622
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
 
623
  if (ret == ARGP_ERR_UNKNOWN){
 
624
    fprintf(stderr, "Unknown error while parsing arguments\n");
 
625
    exitstatus = EXIT_FAILURE;
 
626
    goto fallback;
 
627
  }
 
628
  
398
629
  if(debug){
399
630
    for(plugin *p = plugin_list; p != NULL; p=p->next){
400
631
      fprintf(stderr, "Plugin: %s has %d arguments\n",
402
633
      for(char **a = p->argv; *a != NULL; a++){
403
634
        fprintf(stderr, "\tArg: %s\n", *a);
404
635
      }
 
636
      fprintf(stderr, "...and %u environment variables\n", p->envc);
 
637
      for(char **a = p->environ; *a != NULL; a++){
 
638
        fprintf(stderr, "\t%s\n", *a);
 
639
      }
405
640
    }
406
641
  }
407
642
  
 
643
  /* Strip permissions down to nobody */
408
644
  ret = setuid(uid);
409
645
  if (ret == -1){
410
646
    perror("setuid");
411
 
  }
412
 
  
 
647
  }  
413
648
  setgid(gid);
414
649
  if (ret == -1){
415
650
    perror("setgid");
416
651
  }
417
652
  
418
 
  dir = opendir(plugindir);
 
653
  if (plugindir == NULL){
 
654
    dir = opendir(PDIR);
 
655
  } else {
 
656
    dir = opendir(plugindir);
 
657
  }
 
658
  
419
659
  if(dir == NULL){
420
660
    perror("Could not open plugin dir");
421
661
    exitstatus = EXIT_FAILURE;
422
 
    goto end;
 
662
    goto fallback;
423
663
  }
424
664
  
425
665
  /* Set the FD_CLOEXEC flag on the directory, if possible */
430
670
      if(ret < 0){
431
671
        perror("set_cloexec_flag");
432
672
        exitstatus = EXIT_FAILURE;
433
 
        goto end;
 
673
        goto fallback;
434
674
      }
435
675
    }
436
676
  }
437
677
  
438
678
  FD_ZERO(&rfds_all);
439
679
  
 
680
  /* Read and execute any executable in the plugin directory*/
440
681
  while(true){
441
682
    dirst = readdir(dir);
442
683
    
443
 
    // All directory entries have been processed
 
684
    /* All directory entries have been processed */
444
685
    if(dirst == NULL){
445
686
      if (errno == EBADF){
446
687
        perror("readdir");
447
688
        exitstatus = EXIT_FAILURE;
448
 
        goto end;
 
689
        goto fallback;
449
690
      }
450
691
      break;
451
692
    }
452
693
    
453
694
    d_name_len = strlen(dirst->d_name);
454
695
    
455
 
    // Ignore dotfiles, backup files and other junk
 
696
    /* Ignore dotfiles, backup files and other junk */
456
697
    {
457
698
      bool bad_name = false;
458
699
      
460
701
      
461
702
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
462
703
                                           ".dpkg-old",
 
704
                                           ".dpkg-bak",
463
705
                                           ".dpkg-divert", NULL };
464
706
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
465
707
        size_t pre_len = strlen(*pre);
473
715
          break;
474
716
        }
475
717
      }
476
 
      
477
718
      if(bad_name){
478
719
        continue;
479
720
      }
480
 
      
481
721
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
482
722
        size_t suf_len = strlen(*suf);
483
723
        if((d_name_len >= suf_len)
496
736
        continue;
497
737
      }
498
738
    }
499
 
    
500
 
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
501
 
    if (filename == NULL){
502
 
      perror("malloc");
 
739
 
 
740
    char *filename;
 
741
    if(plugindir == NULL){
 
742
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
 
743
    } else {
 
744
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
 
745
    }
 
746
    if(ret < 0){
 
747
      perror("asprintf");
503
748
      continue;
504
749
    }
505
 
    strcpy(filename, plugindir); /* Spurious warning */
506
 
    strcat(filename, "/");      /* Spurious warning */
507
 
    strcat(filename, dirst->d_name); /* Spurious warning */
508
750
    
509
751
    ret = stat(filename, &st);
510
752
    if (ret == -1){
512
754
      free(filename);
513
755
      continue;
514
756
    }
515
 
    
 
757
 
 
758
    /* Ignore non-executable files */
516
759
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
517
760
      if(debug){
518
761
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
521
764
      free(filename);
522
765
      continue;
523
766
    }
524
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
 
767
    
 
768
    plugin *p = getplugin(dirst->d_name);
 
769
    if(p == NULL){
 
770
      perror("getplugin");
 
771
      free(filename);
 
772
      continue;
 
773
    }
 
774
    if(p->disabled){
525
775
      if(debug){
526
776
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
527
777
                dirst->d_name);
529
779
      free(filename);
530
780
      continue;
531
781
    }
532
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
533
782
    {
534
783
      /* Add global arguments to argument list for this plugin */
535
 
      plugin *g = getplugin(NULL, &plugin_list);
536
 
      for(char **a = g->argv + 1; *a != NULL; a++){
537
 
        addargument(p, *a);
538
 
      }
539
 
    }
540
 
    int pipefd[2]; 
 
784
      plugin *g = getplugin(NULL);
 
785
      if(g != NULL){
 
786
        for(char **a = g->argv + 1; *a != NULL; a++){
 
787
          if(not add_argument(p, *a)){
 
788
            perror("add_argument");
 
789
          }
 
790
        }
 
791
        /* Add global environment variables */
 
792
        for(char **e = g->environ; *e != NULL; e++){
 
793
          if(not add_environment(p, *e, false)){
 
794
            perror("add_environment");
 
795
          }
 
796
        }
 
797
      }
 
798
    }
 
799
    /* If this plugin has any environment variables, we will call
 
800
       using execve and need to duplicate the environment from this
 
801
       process, too. */
 
802
    if(p->environ[0] != NULL){
 
803
      for(char **e = environ; *e != NULL; e++){
 
804
        if(not add_environment(p, *e, false)){
 
805
          perror("add_environment");
 
806
        }
 
807
      }
 
808
    }
 
809
    
 
810
    int pipefd[2];
541
811
    ret = pipe(pipefd);
542
812
    if (ret == -1){
543
813
      perror("pipe");
544
814
      exitstatus = EXIT_FAILURE;
545
 
      goto end;
 
815
      goto fallback;
546
816
    }
 
817
    /* Ask OS to automatic close the pipe on exec */
547
818
    ret = set_cloexec_flag(pipefd[0]);
548
819
    if(ret < 0){
549
820
      perror("set_cloexec_flag");
550
821
      exitstatus = EXIT_FAILURE;
551
 
      goto end;
 
822
      goto fallback;
552
823
    }
553
824
    ret = set_cloexec_flag(pipefd[1]);
554
825
    if(ret < 0){
555
826
      perror("set_cloexec_flag");
556
827
      exitstatus = EXIT_FAILURE;
557
 
      goto end;
 
828
      goto fallback;
558
829
    }
559
830
    /* Block SIGCHLD until process is safely in process list */
560
831
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
561
832
    if(ret < 0){
562
833
      perror("sigprocmask");
563
834
      exitstatus = EXIT_FAILURE;
564
 
      goto end;
 
835
      goto fallback;
565
836
    }
566
 
    // Starting a new process to be watched
 
837
    /* Starting a new process to be watched */
567
838
    pid_t pid = fork();
568
839
    if(pid == -1){
569
840
      perror("fork");
570
841
      exitstatus = EXIT_FAILURE;
571
 
      goto end;
 
842
      goto fallback;
572
843
    }
573
844
    if(pid == 0){
574
845
      /* this is the child process */
577
848
        perror("sigaction");
578
849
        _exit(EXIT_FAILURE);
579
850
      }
580
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
851
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
581
852
      if(ret < 0){
582
853
        perror("sigprocmask");
583
854
        _exit(EXIT_FAILURE);
584
855
      }
585
 
 
 
856
      
586
857
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
587
858
      if(ret == -1){
588
859
        perror("dup2");
594
865
           above and must now close it manually here. */
595
866
        closedir(dir);
596
867
      }
597
 
      if(execv(filename, p->argv) < 0){
598
 
        perror("execv");
599
 
        _exit(EXIT_FAILURE);
 
868
      if(p->environ[0] == NULL){
 
869
        if(execv(filename, p->argv) < 0){
 
870
          perror("execv");
 
871
          _exit(EXIT_FAILURE);
 
872
        }
 
873
      } else {
 
874
        if(execve(filename, p->argv, p->environ) < 0){
 
875
          perror("execve");
 
876
          _exit(EXIT_FAILURE);
 
877
        }
600
878
      }
601
879
      /* no return */
602
880
    }
603
 
    /* parent process */
 
881
    /* Parent process */
 
882
    close(pipefd[1]);           /* Close unused write end of pipe */
604
883
    free(filename);
605
 
    close(pipefd[1]);           /* close unused write end of pipe */
606
 
    process *new_process = malloc(sizeof(process));
607
 
    if (new_process == NULL){
608
 
      perror("malloc");
 
884
    plugin *new_plugin = getplugin(dirst->d_name);
 
885
    if (new_plugin == NULL){
 
886
      perror("getplugin");
609
887
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
610
888
      if(ret < 0){
611
 
        perror("sigprocmask");
 
889
        perror("sigprocmask");
612
890
      }
613
891
      exitstatus = EXIT_FAILURE;
614
 
      goto end;
 
892
      goto fallback;
615
893
    }
616
894
    
617
 
    *new_process = (struct process){ .pid = pid,
618
 
                                     .fd = pipefd[0],
619
 
                                     .next = process_list };
620
 
    // List handling
621
 
    process_list = new_process;
 
895
    new_plugin->pid = pid;
 
896
    new_plugin->fd = pipefd[0];
 
897
    
622
898
    /* Unblock SIGCHLD so signal handler can be run if this process
623
899
       has already completed */
624
900
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
625
901
    if(ret < 0){
626
902
      perror("sigprocmask");
627
903
      exitstatus = EXIT_FAILURE;
628
 
      goto end;
629
 
    }
630
 
    
631
 
    FD_SET(new_process->fd, &rfds_all);
632
 
    
633
 
    if (maxfd < new_process->fd){
634
 
      maxfd = new_process->fd;
635
 
    }
636
 
    
637
 
  }
638
 
  
639
 
  /* Free the plugin list */
640
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
641
 
    next = plugin_list->next;
642
 
    free(plugin_list->argv);
643
 
    free(plugin_list);
 
904
      goto fallback;
 
905
    }
 
906
    
 
907
    FD_SET(new_plugin->fd, &rfds_all);
 
908
    
 
909
    if (maxfd < new_plugin->fd){
 
910
      maxfd = new_plugin->fd;
 
911
    }
644
912
  }
645
913
  
646
914
  closedir(dir);
647
915
  dir = NULL;
648
 
    
649
 
  if (process_list == NULL){
650
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
651
 
            " directory?\n");
652
 
    process_list = NULL;
 
916
  
 
917
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
918
    if(p->pid != 0){
 
919
      break;
 
920
    }
 
921
    if(p->next == NULL){
 
922
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
 
923
              " directory?\n");
 
924
      free_plugin_list();
 
925
    }
653
926
  }
654
 
  while(process_list){
 
927
  
 
928
  /* Main loop while running plugins exist */
 
929
  while(plugin_list){
655
930
    fd_set rfds = rfds_all;
656
931
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
657
932
    if (select_ret == -1){
658
933
      perror("select");
659
934
      exitstatus = EXIT_FAILURE;
660
 
      goto end;
 
935
      goto fallback;
661
936
    }
662
937
    /* OK, now either a process completed, or something can be read
663
938
       from one of them */
664
 
    for(process *proc = process_list; proc ; proc = proc->next){
 
939
    for(plugin *proc = plugin_list; proc != NULL;){
665
940
      /* Is this process completely done? */
666
941
      if(proc->eof and proc->completed){
667
942
        /* Only accept the plugin output if it exited cleanly */
668
943
        if(not WIFEXITED(proc->status)
669
944
           or WEXITSTATUS(proc->status) != 0){
670
945
          /* Bad exit by plugin */
 
946
 
671
947
          if(debug){
672
948
            if(WIFEXITED(proc->status)){
673
949
              fprintf(stderr, "Plugin %u exited with status %d\n",
682
958
                      (unsigned int) (proc->pid));
683
959
            }
684
960
          }
 
961
          
685
962
          /* Remove the plugin */
686
963
          FD_CLR(proc->fd, &rfds_all);
 
964
 
687
965
          /* Block signal while modifying process_list */
688
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
966
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
689
967
          if(ret < 0){
690
968
            perror("sigprocmask");
691
969
            exitstatus = EXIT_FAILURE;
692
 
            goto end;
693
 
          }
694
 
          /* Delete this process entry from the list */
695
 
          if(process_list == proc){
696
 
            /* First one - simple */
697
 
            process_list = proc->next;
698
 
          } else {
699
 
            /* Second one or later */
700
 
            for(process *p = process_list; p != NULL; p = p->next){
701
 
              if(p->next == proc){
702
 
                p->next = proc->next;
703
 
                break;
704
 
              }
705
 
            }
706
 
          }
 
970
            goto fallback;
 
971
          }
 
972
          
 
973
          plugin *next_plugin = proc->next;
 
974
          free_plugin(proc);
 
975
          proc = next_plugin;
 
976
          
707
977
          /* We are done modifying process list, so unblock signal */
708
978
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
709
979
                             NULL);
710
980
          if(ret < 0){
711
981
            perror("sigprocmask");
712
 
          }
713
 
          free(proc->buffer);
714
 
          free(proc);
715
 
          /* We deleted this process from the list, so we can't go
716
 
             proc->next.  Therefore, start over from the beginning of
717
 
             the process list */
718
 
          break;
 
982
            exitstatus = EXIT_FAILURE;
 
983
            goto fallback;
 
984
          }
 
985
          
 
986
          if(plugin_list == NULL){
 
987
            break;
 
988
          }
 
989
          
 
990
          continue;
719
991
        }
 
992
        
720
993
        /* This process exited nicely, so print its buffer */
721
 
 
722
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
 
994
        
 
995
        bool bret = print_out_password(proc->buffer,
 
996
                                       proc->buffer_length);
723
997
        if(not bret){
724
998
          perror("print_out_password");
725
999
          exitstatus = EXIT_FAILURE;
726
1000
        }
727
 
        goto end;
 
1001
        goto fallback;
728
1002
      }
 
1003
      
729
1004
      /* This process has not completed.  Does it have any output? */
730
1005
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
731
1006
        /* This process had nothing to say at this time */
 
1007
        proc = proc->next;
732
1008
        continue;
733
1009
      }
734
1010
      /* Before reading, make the process' data buffer large enough */
738
1014
        if (proc->buffer == NULL){
739
1015
          perror("malloc");
740
1016
          exitstatus = EXIT_FAILURE;
741
 
          goto end;
 
1017
          goto fallback;
742
1018
        }
743
1019
        proc->buffer_size += BUFFER_SIZE;
744
1020
      }
747
1023
                 BUFFER_SIZE);
748
1024
      if(ret < 0){
749
1025
        /* Read error from this process; ignore the error */
 
1026
        proc = proc->next;
750
1027
        continue;
751
1028
      }
752
1029
      if(ret == 0){
759
1036
  }
760
1037
 
761
1038
 
762
 
 end:
 
1039
 fallback:
763
1040
  
764
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
765
 
    /* Fallback if all plugins failed, none are found or an error occured */
 
1041
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1042
    /* Fallback if all plugins failed, none are found or an error
 
1043
       occured */
766
1044
    bool bret;
767
1045
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
768
1046
    char *passwordbuffer = getpass("Password: ");
769
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
 
1047
    size_t len = strlen(passwordbuffer);
 
1048
    /* Strip trailing newline */
 
1049
    if(len > 0 and passwordbuffer[len-1] == '\n'){
 
1050
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
 
1051
      len--;
 
1052
    }
 
1053
    bret = print_out_password(passwordbuffer, len);
770
1054
    if(not bret){
771
1055
      perror("print_out_password");
772
1056
      exitstatus = EXIT_FAILURE;
773
 
      goto end;
774
1057
    }
775
1058
  }
776
1059
  
777
1060
  /* Restore old signal handler */
778
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
779
 
  
780
 
  free(custom_argv);
781
 
  
782
 
  /* Free the plugin list */
783
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
784
 
    next = plugin_list->next;
785
 
    free(plugin_list->argv);
786
 
    free(plugin_list);
 
1061
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
 
1062
  if(ret == -1){
 
1063
    perror("sigaction");
 
1064
    exitstatus = EXIT_FAILURE;
 
1065
  }
 
1066
  
 
1067
  if(custom_argv != NULL){
 
1068
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
 
1069
      free(*arg);
 
1070
    }
 
1071
    free(custom_argv);
787
1072
  }
788
1073
  
789
1074
  if(dir != NULL){
790
1075
    closedir(dir);
791
1076
  }
792
1077
  
793
 
  /* Free the process list and kill the processes */
794
 
  for(process *next; process_list != NULL; process_list = next){
795
 
    next = process_list->next;
796
 
    close(process_list->fd);
797
 
    ret = kill(process_list->pid, SIGTERM);
798
 
    if(ret == -1 and errno != ESRCH){
799
 
      /* set-uid proccesses migth not get closed */
800
 
      perror("kill");
 
1078
  /* Kill the processes */
 
1079
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1080
    if(p->pid != 0){
 
1081
      close(p->fd);
 
1082
      ret = kill(p->pid, SIGTERM);
 
1083
      if(ret == -1 and errno != ESRCH){
 
1084
        /* Set-uid proccesses might not get closed */
 
1085
        perror("kill");
 
1086
      }
801
1087
    }
802
 
    free(process_list->buffer);
803
 
    free(process_list);
804
1088
  }
805
1089
  
806
1090
  /* Wait for any remaining child processes to terminate */
811
1095
    perror("wait");
812
1096
  }
813
1097
  
 
1098
  free_plugin_list();
 
1099
  
 
1100
  free(plugindir);
 
1101
  free(argfile);
 
1102
  
814
1103
  return exitstatus;
815
1104
}