/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 plugbasedclient.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

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