/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
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,
65
66
#include <errno.h>              /* errno, EBADF */
66
67
 
67
68
#define BUFFER_SIZE 256
68
 
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.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;
81
90
  bool eof;
82
91
  volatile bool completed;
83
92
  volatile 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
 
  char **environ;
92
 
  int envc;
93
 
  bool disabled;
94
93
  struct plugin *next;
95
94
} plugin;
96
95
 
97
 
static plugin *getplugin(char *name, plugin **plugin_list){
98
 
  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){
99
103
    if ((p->name == name)
100
104
        or (p->name and name and (strcmp(p->name, name) == 0))){
101
105
      return p;
116
120
  
117
121
  *new_plugin = (plugin) { .name = copy_name,
118
122
                           .argc = 1,
119
 
                           .envc = 0,
120
123
                           .disabled = false,
121
 
                           .next = *plugin_list };
 
124
                           .next = plugin_list };
122
125
  
123
126
  new_plugin->argv = malloc(sizeof(char *) * 2);
124
127
  if (new_plugin->argv == NULL){
128
131
  }
129
132
  new_plugin->argv[0] = copy_name;
130
133
  new_plugin->argv[1] = NULL;
131
 
 
 
134
  
132
135
  new_plugin->environ = malloc(sizeof(char *));
133
136
  if(new_plugin->environ == NULL){
134
137
    free(copy_name);
137
140
    return NULL;
138
141
  }
139
142
  new_plugin->environ[0] = NULL;
 
143
  
140
144
  /* Append the new plugin to the list */
141
 
  *plugin_list = new_plugin;
 
145
  plugin_list = new_plugin;
142
146
  return new_plugin;
143
147
}
144
148
 
174
178
}
175
179
 
176
180
/* Add to a plugin's environment */
177
 
static bool add_environment(plugin *p, const char *def){
 
181
static bool add_environment(plugin *p, const char *def, bool replace){
178
182
  if(p == NULL){
179
183
    return false;
180
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
  }
181
202
  return add_to_char_array(def, &(p->environ), &(p->envc));
182
203
}
183
204
 
184
 
 
185
205
/*
186
206
 * Based on the example in the GNU LibC manual chapter 13.13 "File
187
207
 * Descriptor Flags".
188
208
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
189
209
 */
190
 
static int set_cloexec_flag(int fd)
191
 
{
 
210
static int set_cloexec_flag(int fd){
192
211
  int ret = fcntl(fd, F_GETFD, 0);
193
212
  /* If reading the flags failed, return error indication now. */
194
213
  if(ret < 0){
198
217
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
199
218
}
200
219
 
201
 
process *process_list = NULL;
202
220
 
203
221
/* Mark processes as completed when they exit, and save their exit
204
222
   status. */
205
 
void handle_sigchld(__attribute__((unused)) int sig){
 
223
static void handle_sigchld(__attribute__((unused)) int sig){
206
224
  while(true){
207
 
    process *proc = process_list;
 
225
    plugin *proc = plugin_list;
208
226
    int status;
209
227
    pid_t pid = waitpid(-1, &status, WNOHANG);
210
228
    if(pid == 0){
218
236
      /* No child processes */
219
237
      break;
220
238
    }
221
 
 
 
239
    
222
240
    /* A child exited, find it in process_list */
223
241
    while(proc != NULL and proc->pid != pid){
224
242
      proc = proc->next;
232
250
  }
233
251
}
234
252
 
235
 
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){
236
255
  ssize_t ret;
237
 
  if(length>0 and buffer[length-1] == '\n'){
238
 
    length--;
239
 
  }
240
256
  for(size_t written = 0; written < length; written += (size_t)ret){
241
257
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
242
258
                                   length - written));
247
263
  return true;
248
264
}
249
265
 
250
 
char **add_to_argv(char **argv, int *argc, char *arg){
251
 
  if (argv == NULL){
252
 
    *argc = 1;
253
 
    argv = malloc(sizeof(char*) * 2);
254
 
    if(argv == NULL){
255
 
      return NULL;
 
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);
 
278
 
 
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
      }
256
290
    }
257
 
    argv[0] = NULL;     /* Will be set to argv[0] in main before parsing */
258
 
    argv[1] = NULL;
259
 
  }
260
 
  *argc += 1;
261
 
  argv = realloc(argv, sizeof(char *)
262
 
                  * ((unsigned int) *argc + 1));
263
 
  if(argv == NULL){
264
 
    return NULL;
265
 
  }
266
 
  argv[*argc-1] = arg;
267
 
  argv[*argc] = NULL;
268
 
  return argv;
 
291
  }
 
292
  
 
293
  free(plugin_node);
269
294
}
270
295
 
271
 
static void free_plugin_list(plugin *plugin_list){
272
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
273
 
    next = plugin_list->next;
274
 
    for(char **arg = plugin_list->argv; *arg != NULL; arg++){
275
 
      free(*arg);
276
 
    }
277
 
    free(plugin_list->argv);
278
 
    for(char **env = plugin_list->environ; *env != NULL; env++){
279
 
      free(*env);
280
 
    }
281
 
    free(plugin_list->environ);
282
 
    free(plugin_list);
 
296
static void free_plugin_list(void){
 
297
  while(plugin_list != NULL){
 
298
    free_plugin(plugin_list);
283
299
  }
284
300
}
285
301
 
286
302
int main(int argc, char *argv[]){
287
 
  const char *plugindir = "/lib/mandos/plugins.d";
288
 
  const char *argfile = ARGFILE;
 
303
  char *plugindir = NULL;
 
304
  char *argfile = NULL;
289
305
  FILE *conffp;
290
306
  size_t d_name_len;
291
307
  DIR *dir = NULL;
323
339
    { .name = "global-options", .key = 'g',
324
340
      .arg = "OPTION[,OPTION[,...]]",
325
341
      .doc = "Options passed to all plugins" },
326
 
    { .name = "global-envs", .key = 'e',
 
342
    { .name = "global-env", .key = 'G',
327
343
      .arg = "VAR=value",
328
344
      .doc = "Environment variable passed to all plugins" },
329
345
    { .name = "options-for", .key = 'o',
330
346
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
331
347
      .doc = "Options passed only to specified plugin" },
332
 
    { .name = "envs-for", .key = 'f',
 
348
    { .name = "env-for", .key = 'E',
333
349
      .arg = "PLUGIN:ENV=value",
334
350
      .doc = "Environment variable passed to specified plugin" },
335
351
    { .name = "disable", .key = 'd',
336
352
      .arg = "PLUGIN",
337
353
      .doc = "Disable a specific plugin", .group = 1 },
 
354
    { .name = "enable", .key = 'e',
 
355
      .arg = "PLUGIN",
 
356
      .doc = "Enable a specific plugin", .group = 1 },
338
357
    { .name = "plugin-dir", .key = 128,
339
358
      .arg = "DIRECTORY",
340
359
      .doc = "Specify a different plugin directory", .group = 2 },
341
 
    { .name = "userid", .key = 129,
342
 
      .arg = "ID", .flags = 0,
343
 
      .doc = "User ID the plugins will run as", .group = 2 },
344
 
    { .name = "groupid", .key = 130,
345
 
      .arg = "ID", .flags = 0,
346
 
      .doc = "Group ID the plugins will run as", .group = 2 },
347
 
    { .name = "debug", .key = 131,
348
 
      .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 },
349
371
    { .name = NULL }
350
372
  };
351
373
  
352
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
353
 
    /* Get the INPUT argument from `argp_parse', which we know is a
354
 
       pointer to our plugin list pointer. */
355
 
    plugin **plugins = state->input;
 
374
  error_t parse_opt (int key, char *arg, __attribute__((unused))
 
375
                     struct argp_state *state) {
356
376
    switch (key) {
357
 
    case 'g':
 
377
    case 'g':                   /* --global-options */
358
378
      if (arg != NULL){
359
379
        char *p;
360
380
        while((p = strsep(&arg, ",")) != NULL){
361
381
          if(p[0] == '\0'){
362
382
            continue;
363
383
          }
364
 
          if(not add_argument(getplugin(NULL, plugins), p)){
 
384
          if(not add_argument(getplugin(NULL), p)){
365
385
            perror("add_argument");
366
386
            return ARGP_ERR_UNKNOWN;
367
387
          }
368
388
        }
369
389
      }
370
390
      break;
371
 
    case 'e':
 
391
    case 'G':                   /* --global-env */
372
392
      if(arg == NULL){
373
393
        break;
374
394
      }
375
 
      {
376
 
        char *envdef = strdup(arg);
377
 
        if(envdef == NULL){
378
 
          break;
379
 
        }
380
 
        if(not add_environment(getplugin(NULL, plugins), envdef)){
381
 
          perror("add_environment");
382
 
        }
 
395
      if(not add_environment(getplugin(NULL), arg, true)){
 
396
        perror("add_environment");
383
397
      }
384
398
      break;
385
 
    case 'o':
 
399
    case 'o':                   /* --options-for */
386
400
      if (arg != NULL){
387
401
        char *p_name = strsep(&arg, ":");
388
 
        if(p_name[0] == '\0'){
 
402
        if(p_name[0] == '\0' or arg == NULL){
389
403
          break;
390
404
        }
391
405
        char *opt = strsep(&arg, ":");
392
 
        if(opt[0] == '\0'){
 
406
        if(opt[0] == '\0' or opt == NULL){
393
407
          break;
394
408
        }
395
 
        if(opt != NULL){
396
 
          char *p;
397
 
          while((p = strsep(&opt, ",")) != NULL){
398
 
            if(p[0] == '\0'){
399
 
              continue;
400
 
            }
401
 
            if(not add_argument(getplugin(p_name, plugins), p)){
402
 
              perror("add_argument");
403
 
              return ARGP_ERR_UNKNOWN;
404
 
            }
 
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;
405
417
          }
406
418
        }
407
419
      }
408
420
      break;
409
 
    case 'f':
 
421
    case 'E':                   /* --env-for */
410
422
      if(arg == NULL){
411
423
        break;
412
424
      }
415
427
        if(envdef == NULL){
416
428
          break;
417
429
        }
418
 
        char *p_name = strndup(arg, (size_t) (envdef-arg));
419
 
        if(p_name == NULL){
420
 
          break;
421
 
        }
422
 
        envdef++;
423
 
        if(not add_environment(getplugin(p_name, plugins), envdef)){
 
430
        *envdef = '\0';
 
431
        if(not add_environment(getplugin(arg), envdef+1, true)){
424
432
          perror("add_environment");
425
433
        }
426
434
      }
427
435
      break;
428
 
    case 'd':
 
436
    case 'd':                   /* --disable */
429
437
      if (arg != NULL){
430
 
        plugin *p = getplugin(arg, plugins);
 
438
        plugin *p = getplugin(arg);
431
439
        if(p == NULL){
432
440
          return ARGP_ERR_UNKNOWN;
433
441
        }
434
442
        p->disabled = true;
435
443
      }
436
444
      break;
437
 
    case 128:
438
 
      plugindir = arg;
439
 
      break;
440
 
    case 129:
 
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 */
441
465
      uid = (uid_t)strtol(arg, NULL, 10);
442
466
      break;
443
 
    case 130:
 
467
    case 131:                   /* --groupid */
444
468
      gid = (gid_t)strtol(arg, NULL, 10);
445
469
      break;
446
 
    case 131:
 
470
    case 132:                   /* --debug */
447
471
      debug = true;
448
472
      break;
449
473
    case ARGP_KEY_ARG:
450
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
451
 
      break;
452
 
    case ARGP_KEY_END:
453
 
      break;
454
 
    default:
455
 
      return ARGP_ERR_UNKNOWN;
456
 
    }
457
 
    return 0;
458
 
  }
459
 
  
460
 
  plugin *plugin_list = NULL;
461
 
  
462
 
  struct argp argp = { .options = options, .parser = parse_opt,
463
 
                       .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 = "",
464
525
                       .doc = "Mandos plugin runner -- Run plugins" };
465
526
  
466
 
  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);
467
530
  if (ret == ARGP_ERR_UNKNOWN){
468
531
    fprintf(stderr, "Unknown error while parsing arguments\n");
469
532
    exitstatus = EXIT_FAILURE;
470
533
    goto fallback;
471
534
  }
472
 
 
473
 
  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
  }  
474
545
  if(conffp != NULL){
475
546
    char *org_line = NULL;
476
547
    char *p, *arg, *new_arg, *line;
479
550
    const char whitespace_delims[] = " \r\t\f\v\n";
480
551
    const char comment_delim[] = "#";
481
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 */
482
565
    while(true){
483
566
      sret = getline(&org_line, &size, conffp);
484
567
      if(sret == -1){
492
575
          continue;
493
576
        }
494
577
        new_arg = strdup(p);
495
 
        custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
496
 
        if (custom_argv == NULL){
497
 
          perror("add_to_argv");
498
 
          exitstatus = EXIT_FAILURE;
499
 
          goto fallback;
500
 
        }
 
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;        
501
596
      }
502
597
    }
503
598
    free(org_line);
504
 
  } else{
 
599
  } else {
505
600
    /* Check for harmful errors and go to fallback. Other errors might
506
601
       not affect opening plugins */
507
602
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
510
605
      goto fallback;
511
606
    }
512
607
  }
513
 
 
 
608
  /* If there was any arguments from configuration file,
 
609
     pass them to parser as command arguments */
514
610
  if(custom_argv != NULL){
515
 
    custom_argv[0] = argv[0];
516
 
    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);
517
613
    if (ret == ARGP_ERR_UNKNOWN){
518
614
      fprintf(stderr, "Unknown error while parsing arguments\n");
519
615
      exitstatus = EXIT_FAILURE;
521
617
    }
522
618
  }
523
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
  
524
629
  if(debug){
525
630
    for(plugin *p = plugin_list; p != NULL; p=p->next){
526
631
      fprintf(stderr, "Plugin: %s has %d arguments\n",
535
640
    }
536
641
  }
537
642
  
 
643
  /* Strip permissions down to nobody */
538
644
  ret = setuid(uid);
539
645
  if (ret == -1){
540
646
    perror("setuid");
541
 
  }
542
 
  
 
647
  }  
543
648
  setgid(gid);
544
649
  if (ret == -1){
545
650
    perror("setgid");
546
651
  }
547
652
  
548
 
  dir = opendir(plugindir);
 
653
  if (plugindir == NULL){
 
654
    dir = opendir(PDIR);
 
655
  } else {
 
656
    dir = opendir(plugindir);
 
657
  }
 
658
  
549
659
  if(dir == NULL){
550
660
    perror("Could not open plugin dir");
551
661
    exitstatus = EXIT_FAILURE;
567
677
  
568
678
  FD_ZERO(&rfds_all);
569
679
  
 
680
  /* Read and execute any executable in the plugin directory*/
570
681
  while(true){
571
682
    dirst = readdir(dir);
572
683
    
573
 
    // All directory entries have been processed
 
684
    /* All directory entries have been processed */
574
685
    if(dirst == NULL){
575
686
      if (errno == EBADF){
576
687
        perror("readdir");
582
693
    
583
694
    d_name_len = strlen(dirst->d_name);
584
695
    
585
 
    // Ignore dotfiles, backup files and other junk
 
696
    /* Ignore dotfiles, backup files and other junk */
586
697
    {
587
698
      bool bad_name = false;
588
699
      
590
701
      
591
702
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
592
703
                                           ".dpkg-old",
 
704
                                           ".dpkg-bak",
593
705
                                           ".dpkg-divert", NULL };
594
706
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
595
707
        size_t pre_len = strlen(*pre);
603
715
          break;
604
716
        }
605
717
      }
606
 
      
607
718
      if(bad_name){
608
719
        continue;
609
720
      }
610
 
      
611
721
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
612
722
        size_t suf_len = strlen(*suf);
613
723
        if((d_name_len >= suf_len)
628
738
    }
629
739
 
630
740
    char *filename;
631
 
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
 
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
    }
632
746
    if(ret < 0){
633
747
      perror("asprintf");
634
748
      continue;
640
754
      free(filename);
641
755
      continue;
642
756
    }
643
 
    
 
757
 
 
758
    /* Ignore non-executable files */
644
759
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
645
760
      if(debug){
646
761
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
649
764
      free(filename);
650
765
      continue;
651
766
    }
652
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
 
767
    
 
768
    plugin *p = getplugin(dirst->d_name);
653
769
    if(p == NULL){
654
770
      perror("getplugin");
655
771
      free(filename);
665
781
    }
666
782
    {
667
783
      /* Add global arguments to argument list for this plugin */
668
 
      plugin *g = getplugin(NULL, &plugin_list);
 
784
      plugin *g = getplugin(NULL);
669
785
      if(g != NULL){
670
786
        for(char **a = g->argv + 1; *a != NULL; a++){
671
787
          if(not add_argument(p, *a)){
674
790
        }
675
791
        /* Add global environment variables */
676
792
        for(char **e = g->environ; *e != NULL; e++){
677
 
          if(not add_environment(p, *e)){
 
793
          if(not add_environment(p, *e, false)){
678
794
            perror("add_environment");
679
795
          }
680
796
        }
685
801
       process, too. */
686
802
    if(p->environ[0] != NULL){
687
803
      for(char **e = environ; *e != NULL; e++){
688
 
        char *copy = strdup(*e);
689
 
        if(copy == NULL){
690
 
          perror("strdup");
691
 
          continue;
692
 
        }
693
 
        if(not add_environment(p, copy)){
 
804
        if(not add_environment(p, *e, false)){
694
805
          perror("add_environment");
695
806
        }
696
807
      }
703
814
      exitstatus = EXIT_FAILURE;
704
815
      goto fallback;
705
816
    }
 
817
    /* Ask OS to automatic close the pipe on exec */
706
818
    ret = set_cloexec_flag(pipefd[0]);
707
819
    if(ret < 0){
708
820
      perror("set_cloexec_flag");
722
834
      exitstatus = EXIT_FAILURE;
723
835
      goto fallback;
724
836
    }
725
 
    // Starting a new process to be watched
 
837
    /* Starting a new process to be watched */
726
838
    pid_t pid = fork();
727
839
    if(pid == -1){
728
840
      perror("fork");
736
848
        perror("sigaction");
737
849
        _exit(EXIT_FAILURE);
738
850
      }
739
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
851
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
740
852
      if(ret < 0){
741
853
        perror("sigprocmask");
742
854
        _exit(EXIT_FAILURE);
743
855
      }
744
 
 
 
856
      
745
857
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
746
858
      if(ret == -1){
747
859
        perror("dup2");
766
878
      }
767
879
      /* no return */
768
880
    }
769
 
    /* parent process */
 
881
    /* Parent process */
 
882
    close(pipefd[1]);           /* Close unused write end of pipe */
770
883
    free(filename);
771
 
    close(pipefd[1]);           /* close unused write end of pipe */
772
 
    process *new_process = malloc(sizeof(process));
773
 
    if (new_process == NULL){
774
 
      perror("malloc");
 
884
    plugin *new_plugin = getplugin(dirst->d_name);
 
885
    if (new_plugin == NULL){
 
886
      perror("getplugin");
775
887
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
776
888
      if(ret < 0){
777
 
        perror("sigprocmask");
 
889
        perror("sigprocmask");
778
890
      }
779
891
      exitstatus = EXIT_FAILURE;
780
892
      goto fallback;
781
893
    }
782
894
    
783
 
    *new_process = (struct process){ .pid = pid,
784
 
                                     .fd = pipefd[0],
785
 
                                     .next = process_list };
786
 
    // List handling
787
 
    process_list = new_process;
 
895
    new_plugin->pid = pid;
 
896
    new_plugin->fd = pipefd[0];
 
897
    
788
898
    /* Unblock SIGCHLD so signal handler can be run if this process
789
899
       has already completed */
790
900
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
794
904
      goto fallback;
795
905
    }
796
906
    
797
 
    FD_SET(new_process->fd, &rfds_all);
 
907
    FD_SET(new_plugin->fd, &rfds_all);
798
908
    
799
 
    if (maxfd < new_process->fd){
800
 
      maxfd = new_process->fd;
 
909
    if (maxfd < new_plugin->fd){
 
910
      maxfd = new_plugin->fd;
801
911
    }
802
 
    
803
912
  }
804
913
  
805
 
  free_plugin_list(plugin_list);
806
 
  plugin_list = NULL;
807
 
  
808
914
  closedir(dir);
809
915
  dir = NULL;
810
 
    
811
 
  if (process_list == NULL){
812
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
813
 
            " directory?\n");
814
 
    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
    }
815
926
  }
816
 
  while(process_list){
 
927
  
 
928
  /* Main loop while running plugins exist */
 
929
  while(plugin_list){
817
930
    fd_set rfds = rfds_all;
818
931
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
819
932
    if (select_ret == -1){
823
936
    }
824
937
    /* OK, now either a process completed, or something can be read
825
938
       from one of them */
826
 
    for(process *proc = process_list; proc ; proc = proc->next){
 
939
    for(plugin *proc = plugin_list; proc != NULL;){
827
940
      /* Is this process completely done? */
828
941
      if(proc->eof and proc->completed){
829
942
        /* Only accept the plugin output if it exited cleanly */
830
943
        if(not WIFEXITED(proc->status)
831
944
           or WEXITSTATUS(proc->status) != 0){
832
945
          /* Bad exit by plugin */
 
946
 
833
947
          if(debug){
834
948
            if(WIFEXITED(proc->status)){
835
949
              fprintf(stderr, "Plugin %u exited with status %d\n",
844
958
                      (unsigned int) (proc->pid));
845
959
            }
846
960
          }
 
961
          
847
962
          /* Remove the plugin */
848
963
          FD_CLR(proc->fd, &rfds_all);
 
964
 
849
965
          /* Block signal while modifying process_list */
850
966
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
851
967
          if(ret < 0){
853
969
            exitstatus = EXIT_FAILURE;
854
970
            goto fallback;
855
971
          }
856
 
          /* Delete this process entry from the list */
857
 
          if(process_list == proc){
858
 
            /* First one - simple */
859
 
            process_list = proc->next;
860
 
          } else {
861
 
            /* Second one or later */
862
 
            for(process *p = process_list; p != NULL; p = p->next){
863
 
              if(p->next == proc){
864
 
                p->next = proc->next;
865
 
                break;
866
 
              }
867
 
            }
868
 
          }
 
972
          
 
973
          plugin *next_plugin = proc->next;
 
974
          free_plugin(proc);
 
975
          proc = next_plugin;
 
976
          
869
977
          /* We are done modifying process list, so unblock signal */
870
978
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
871
979
                             NULL);
872
980
          if(ret < 0){
873
981
            perror("sigprocmask");
874
 
          }
875
 
          free(proc->buffer);
876
 
          free(proc);
877
 
          /* We deleted this process from the list, so we can't go
878
 
             proc->next.  Therefore, start over from the beginning of
879
 
             the process list */
880
 
          break;
 
982
            exitstatus = EXIT_FAILURE;
 
983
            goto fallback;
 
984
          }
 
985
          
 
986
          if(plugin_list == NULL){
 
987
            break;
 
988
          }
 
989
          
 
990
          continue;
881
991
        }
 
992
        
882
993
        /* This process exited nicely, so print its buffer */
883
 
 
 
994
        
884
995
        bool bret = print_out_password(proc->buffer,
885
996
                                       proc->buffer_length);
886
997
        if(not bret){
889
1000
        }
890
1001
        goto fallback;
891
1002
      }
 
1003
      
892
1004
      /* This process has not completed.  Does it have any output? */
893
1005
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
894
1006
        /* This process had nothing to say at this time */
 
1007
        proc = proc->next;
895
1008
        continue;
896
1009
      }
897
1010
      /* Before reading, make the process' data buffer large enough */
910
1023
                 BUFFER_SIZE);
911
1024
      if(ret < 0){
912
1025
        /* Read error from this process; ignore the error */
 
1026
        proc = proc->next;
913
1027
        continue;
914
1028
      }
915
1029
      if(ret == 0){
924
1038
 
925
1039
 fallback:
926
1040
  
927
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
 
1041
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
928
1042
    /* Fallback if all plugins failed, none are found or an error
929
1043
       occured */
930
1044
    bool bret;
931
1045
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
932
1046
    char *passwordbuffer = getpass("Password: ");
933
 
    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);
934
1054
    if(not bret){
935
1055
      perror("print_out_password");
936
1056
      exitstatus = EXIT_FAILURE;
943
1063
    perror("sigaction");
944
1064
    exitstatus = EXIT_FAILURE;
945
1065
  }
946
 
 
 
1066
  
947
1067
  if(custom_argv != NULL){
948
 
    for(char **arg = custom_argv; *arg != NULL; arg++){
 
1068
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
949
1069
      free(*arg);
950
1070
    }
951
1071
    free(custom_argv);
952
1072
  }
953
 
  free_plugin_list(plugin_list);
954
1073
  
955
1074
  if(dir != NULL){
956
1075
    closedir(dir);
957
1076
  }
958
1077
  
959
 
  /* Free the process list and kill the processes */
960
 
  for(process *next; process_list != NULL; process_list = next){
961
 
    next = process_list->next;
962
 
    close(process_list->fd);
963
 
    ret = kill(process_list->pid, SIGTERM);
964
 
    if(ret == -1 and errno != ESRCH){
965
 
      /* set-uid proccesses migth not get closed */
966
 
      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
      }
967
1087
    }
968
 
    free(process_list->buffer);
969
 
    free(process_list);
970
1088
  }
971
1089
  
972
1090
  /* Wait for any remaining child processes to terminate */
977
1095
    perror("wait");
978
1096
  }
979
1097
  
 
1098
  free_plugin_list();
 
1099
  
 
1100
  free(plugindir);
 
1101
  free(argfile);
 
1102
  
980
1103
  return exitstatus;
981
1104
}