/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugbasedclient.c

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

Show diffs side-by-side

added added

removed removed

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