/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2011-12-31 20:07:11 UTC
  • mfrom: (535.1.9 wireless-network-hook)
  • Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook.  Fix bridge network hook to use
hardware addresses instead of interface names.  Implement and document
new "CONNECT" environment variable for network hooks.

Show diffs side-by-side

added added

removed removed

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