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