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