/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2016-03-17 20:40:55 UTC
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
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{
 
1
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
 
2
/*
 
3
 * Mandos plugin runner - Run Mandos plugins
 
4
 *
 
5
 * Copyright © 2008-2016 Teddy Hogeborn
 
6
 * Copyright © 2008-2016 Björn Påhlsson
 
7
 * 
 
8
 * This program is free software: you can redistribute it and/or
 
9
 * modify it under the terms of the GNU General Public License as
 
10
 * published by the Free Software Foundation, either version 3 of the
 
11
 * License, or (at your option) any later version.
 
12
 * 
 
13
 * This program is distributed in the hope that it will be useful, but
 
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * General Public License for more details.
 
17
 * 
 
18
 * You should have received a copy of the GNU General Public License
 
19
 * along with this program.  If not, see
 
20
 * <http://www.gnu.org/licenses/>.
 
21
 * 
 
22
 * Contact the authors at <mandos@recompile.se>.
 
23
 */
 
24
 
 
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
 
26
                                   O_CLOEXEC, pipe2() */
 
27
#include <stddef.h>             /* size_t, NULL */
 
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
 
29
                                   realloc() */
 
30
#include <stdbool.h>            /* bool, true, false */
 
31
#include <stdio.h>              /* fileno(), fprintf(),
 
32
                                   stderr, STDOUT_FILENO, fclose() */
 
33
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
34
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
35
                                   pid_t, uid_t, gid_t, getuid(),
 
36
                                   getgid() */
 
37
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
 
38
                                   FD_SET(), FD_ISSET(), FD_CLR */
 
39
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
 
40
                                   WEXITSTATUS(), WTERMSIG(),
 
41
                                   WCOREDUMP() */
 
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*/
19
94
  pid_t pid;
20
95
  int fd;
21
96
  char *buffer;
22
 
  int buffer_size;
23
 
  int buffer_length;
24
 
  struct process *next;
25
 
} process;
26
 
 
27
 
#define BUFFER_SIZE 256
 
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
}
28
348
 
29
349
int main(int argc, char *argv[]){
30
 
  char plugindir[] = "plugins.d";
31
 
  size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
32
 
  DIR *dir;
33
 
  struct dirent *dirst;
 
350
  char *plugindir = NULL;
 
351
  char *pluginhelperdir = NULL;
 
352
  char *argfile = NULL;
 
353
  FILE *conffp;
 
354
  struct dirent **direntries = NULL;
34
355
  struct stat st;
35
 
  fd_set rfds_orig;
 
356
  fd_set rfds_all;
36
357
  int ret, maxfd = 0;
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){
 
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
    default:
 
587
      return ARGP_ERR_UNKNOWN;
 
588
    }
 
589
    return errno;               /* Set to 0 at start */
 
590
  }
 
591
  
 
592
  /* This option parser is the same as parse_opt() above, except it
 
593
     ignores everything but the --config-file option. */
 
594
  error_t parse_opt_config_file(int key, char *arg,
 
595
                                __attribute__((unused))
 
596
                                struct argp_state *state){
 
597
    errno = 0;
 
598
    switch(key){
 
599
    case 'g':                   /* --global-options */
 
600
    case 'G':                   /* --global-env */
 
601
    case 'o':                   /* --options-for */
 
602
    case 'E':                   /* --env-for */
 
603
    case 'd':                   /* --disable */
 
604
    case 'e':                   /* --enable */
 
605
    case 128:                   /* --plugin-dir */
 
606
      break;
 
607
    case 129:                   /* --config-file */
 
608
      free(argfile);
 
609
      argfile = strdup(arg);
 
610
      if(argfile != NULL){
 
611
        errno = 0;
 
612
      }
 
613
      break;
 
614
    case 130:                   /* --userid */
 
615
    case 131:                   /* --groupid */
 
616
    case 132:                   /* --debug */
 
617
    case 133:                   /* --plugin-helper-dir */
 
618
    case '?':                   /* --help */
 
619
    case -3:                    /* --usage */
 
620
    case 'V':                   /* --version */
 
621
    case ARGP_KEY_ARG:
 
622
      break;
 
623
    default:
 
624
      return ARGP_ERR_UNKNOWN;
 
625
    }
 
626
    return errno;
 
627
  }
 
628
  
 
629
  struct argp argp = { .options = options,
 
630
                       .parser = parse_opt_config_file,
 
631
                       .args_doc = "",
 
632
                       .doc = "Mandos plugin runner -- Run plugins" };
 
633
  
 
634
  /* Parse using parse_opt_config_file() in order to get the custom
 
635
     config file location, if any. */
 
636
  ret = argp_parse(&argp, argc, argv,
 
637
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
638
                   NULL, NULL);
 
639
  switch(ret){
 
640
  case 0:
 
641
    break;
 
642
  case ENOMEM:
 
643
  default:
 
644
    errno = ret;
 
645
    error(0, errno, "argp_parse");
 
646
    exitstatus = EX_OSERR;
 
647
    goto fallback;
 
648
  case EINVAL:
 
649
    exitstatus = EX_USAGE;
 
650
    goto fallback;
 
651
  }
 
652
  
 
653
  /* Reset to the normal argument parser */
 
654
  argp.parser = parse_opt;
 
655
  
 
656
  /* Open the configfile if available */
 
657
  if(argfile == NULL){
 
658
    conffp = fopen(AFILE, "r");
 
659
  } else {
 
660
    conffp = fopen(argfile, "r");
 
661
  }
 
662
  if(conffp != NULL){
 
663
    char *org_line = NULL;
 
664
    char *p, *arg, *new_arg, *line;
 
665
    size_t size = 0;
 
666
    const char whitespace_delims[] = " \r\t\f\v\n";
 
667
    const char comment_delim[] = "#";
 
668
    
 
669
    custom_argc = 1;
 
670
    custom_argv = malloc(sizeof(char*) * 2);
 
671
    if(custom_argv == NULL){
 
672
      error(0, errno, "malloc");
 
673
      exitstatus = EX_OSERR;
 
674
      goto fallback;
 
675
    }
 
676
    custom_argv[0] = argv[0];
 
677
    custom_argv[1] = NULL;
 
678
    
 
679
    /* for each line in the config file, strip whitespace and ignore
 
680
       commented text */
120
681
    while(true){
121
 
      fd_set rfds = rfds_orig;
122
 
      int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
123
 
      if (select_ret == -1){
124
 
        perror(argv[0]);
125
 
        goto end;
126
 
      }else{    
127
 
        for(process *process_itr = process_list; process_itr != NULL;
128
 
            process_itr = process_itr->next){
129
 
          if(FD_ISSET(process_itr->fd, &rfds)){
130
 
            if(process_itr->buffer_length + BUFFER_SIZE
131
 
               > process_itr->buffer_size){
132
 
                process_itr->buffer = realloc(process_itr->buffer,
133
 
                                              process_itr->buffer_size
134
 
                                              + BUFFER_SIZE);
135
 
                if (process_itr->buffer == NULL){
136
 
                  perror(argv[0]);
137
 
                  goto end;
138
 
                }
139
 
                process_itr->buffer_size += BUFFER_SIZE;
140
 
            }
141
 
            ret = read(process_itr->fd, process_itr->buffer
142
 
                       + process_itr->buffer_length, BUFFER_SIZE);
143
 
            process_itr->buffer_length+=ret;
144
 
            if(ret == 0){
145
 
              /* got EOF */
146
 
              /* wait for process exit */
147
 
              int status;
148
 
              waitpid(process_itr->pid, &status, 0);
149
 
              if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
150
 
                write(STDOUT_FILENO, process_itr->buffer,
151
 
                      process_itr->buffer_length);
152
 
                goto end;
153
 
              } else {
154
 
                FD_CLR(process_itr->fd, &rfds_orig);
155
 
              }
156
 
            }
157
 
          }
158
 
        }
159
 
      }
160
 
    }
161
 
  }
162
 
  
163
 
 end:
164
 
  for(process *process_itr = process_list; process_itr != NULL;
165
 
      process_itr = process_itr->next){
166
 
    close(process_itr->fd);
167
 
    kill(process_itr->pid, SIGTERM);
168
 
    free(process_itr->buffer);
169
 
  }
170
 
  
171
 
  while(true){
172
 
    int status;
173
 
    ret = wait(&status);
174
 
    if (ret == -1){
175
 
      if(errno != ECHILD){
176
 
        perror("wait");
177
 
      }
178
 
      break;
179
 
    }
180
 
  }  
181
 
  return EXIT_SUCCESS;
 
682
      sret = getline(&org_line, &size, conffp);
 
683
      if(sret == -1){
 
684
        break;
 
685
      }
 
686
      
 
687
      line = org_line;
 
688
      arg = strsep(&line, comment_delim);
 
689
      while((p = strsep(&arg, whitespace_delims)) != NULL){
 
690
        if(p[0] == '\0'){
 
691
          continue;
 
692
        }
 
693
        new_arg = strdup(p);
 
694
        if(new_arg == NULL){
 
695
          error(0, errno, "strdup");
 
696
          exitstatus = EX_OSERR;
 
697
          free(org_line);
 
698
          goto fallback;
 
699
        }
 
700
        
 
701
        custom_argc += 1;
 
702
        {
 
703
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
704
                                    * ((size_t)custom_argc + 1));
 
705
          if(new_argv == NULL){
 
706
            error(0, errno, "realloc");
 
707
            exitstatus = EX_OSERR;
 
708
            free(new_arg);
 
709
            free(org_line);
 
710
            goto fallback;
 
711
          } else {
 
712
            custom_argv = new_argv;
 
713
          }
 
714
        }
 
715
        custom_argv[custom_argc-1] = new_arg;
 
716
        custom_argv[custom_argc] = NULL;
 
717
      }
 
718
    }
 
719
    do {
 
720
      ret = fclose(conffp);
 
721
    } while(ret == EOF and errno == EINTR);
 
722
    if(ret == EOF){
 
723
      error(0, errno, "fclose");
 
724
      exitstatus = EX_IOERR;
 
725
      goto fallback;
 
726
    }
 
727
    free(org_line);
 
728
  } else {
 
729
    /* Check for harmful errors and go to fallback. Other errors might
 
730
       not affect opening plugins */
 
731
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
 
732
      error(0, errno, "fopen");
 
733
      exitstatus = EX_OSERR;
 
734
      goto fallback;
 
735
    }
 
736
  }
 
737
  /* If there were any arguments from the configuration file, pass
 
738
     them to parser as command line arguments */
 
739
  if(custom_argv != NULL){
 
740
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
741
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
742
                     NULL, NULL);
 
743
    switch(ret){
 
744
    case 0:
 
745
      break;
 
746
    case ENOMEM:
 
747
    default:
 
748
      errno = ret;
 
749
      error(0, errno, "argp_parse");
 
750
      exitstatus = EX_OSERR;
 
751
      goto fallback;
 
752
    case EINVAL:
 
753
      exitstatus = EX_CONFIG;
 
754
      goto fallback;
 
755
    }
 
756
  }
 
757
  
 
758
  /* Parse actual command line arguments, to let them override the
 
759
     config file */
 
760
  ret = argp_parse(&argp, argc, argv,
 
761
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
762
                   NULL, NULL);
 
763
  switch(ret){
 
764
  case 0:
 
765
    break;
 
766
  case ENOMEM:
 
767
  default:
 
768
    errno = ret;
 
769
    error(0, errno, "argp_parse");
 
770
    exitstatus = EX_OSERR;
 
771
    goto fallback;
 
772
  case EINVAL:
 
773
    exitstatus = EX_USAGE;
 
774
    goto fallback;
 
775
  }
 
776
  
 
777
  {
 
778
    char *pluginhelperenv;
 
779
    bool bret = true;
 
780
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
781
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
782
    if(ret != -1){
 
783
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
784
    }
 
785
    if(ret == -1 or not bret){
 
786
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
787
            " environment variable to \"%s\" for all plugins\n",
 
788
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
789
    }
 
790
    if(ret != -1){
 
791
      free(pluginhelperenv);
 
792
    }
 
793
  }
 
794
  
 
795
  if(debug){
 
796
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
797
      fprintf(stderr, "Plugin: %s has %d arguments\n",
 
798
              p->name ? p->name : "Global", p->argc - 1);
 
799
      for(char **a = p->argv; *a != NULL; a++){
 
800
        fprintf(stderr, "\tArg: %s\n", *a);
 
801
      }
 
802
      fprintf(stderr, "...and %d environment variables\n", p->envc);
 
803
      for(char **a = p->environ; *a != NULL; a++){
 
804
        fprintf(stderr, "\t%s\n", *a);
 
805
      }
 
806
    }
 
807
  }
 
808
  
 
809
  if(getuid() == 0){
 
810
    /* Work around Debian bug #633582:
 
811
       <http://bugs.debian.org/633582> */
 
812
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
813
    if(plugindir_fd == -1){
 
814
      if(errno != ENOENT){
 
815
        error(0, errno, "open(\"" PDIR "\")");
 
816
      }
 
817
    } else {
 
818
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
819
      if(ret == -1){
 
820
        error(0, errno, "fstat");
 
821
      } else {
 
822
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
823
          ret = fchown(plugindir_fd, uid, gid);
 
824
          if(ret == -1){
 
825
            error(0, errno, "fchown");
 
826
          }
 
827
        }
 
828
      }
 
829
      close(plugindir_fd);
 
830
    }
 
831
  }
 
832
  
 
833
  /* Lower permissions */
 
834
  ret = setgid(gid);
 
835
  if(ret == -1){
 
836
    error(0, errno, "setgid");
 
837
  }
 
838
  ret = setuid(uid);
 
839
  if(ret == -1){
 
840
    error(0, errno, "setuid");
 
841
  }
 
842
  
 
843
  /* Open plugin directory with close_on_exec flag */
 
844
  {
 
845
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
846
#ifdef O_CLOEXEC
 
847
                  O_CLOEXEC
 
848
#else  /* not O_CLOEXEC */
 
849
                  0
 
850
#endif  /* not O_CLOEXEC */
 
851
                  );
 
852
    if(dir_fd == -1){
 
853
      error(0, errno, "Could not open plugin dir");
 
854
      exitstatus = EX_UNAVAILABLE;
 
855
      goto fallback;
 
856
    }
 
857
    
 
858
#ifndef O_CLOEXEC
 
859
  /* Set the FD_CLOEXEC flag on the directory */
 
860
    ret = set_cloexec_flag(dir_fd);
 
861
    if(ret < 0){
 
862
      error(0, errno, "set_cloexec_flag");
 
863
      exitstatus = EX_OSERR;
 
864
      goto fallback;
 
865
    }
 
866
#endif  /* O_CLOEXEC */
 
867
  }
 
868
  
 
869
  int good_name(const struct dirent * const dirent){
 
870
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
871
                                      "*.dpkg-old", "*.dpkg-bak",
 
872
                                      "*.dpkg-divert", NULL };
 
873
#ifdef __GNUC__
 
874
#pragma GCC diagnostic push
 
875
#pragma GCC diagnostic ignored "-Wcast-qual"
 
876
#endif
 
877
    for(const char **pat = (const char **)patterns;
 
878
        *pat != NULL; pat++){
 
879
#ifdef __GNUC__
 
880
#pragma GCC diagnostic pop
 
881
#endif
 
882
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
883
         != FNM_NOMATCH){
 
884
        if(debug){
 
885
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
886
                    " matching pattern %s\n", dirent->d_name, *pat);
 
887
        }
 
888
        return 0;
 
889
      }
 
890
    }
 
891
    return 1;
 
892
  }
 
893
  
 
894
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
895
                             alphasort);
 
896
  if(numplugins == -1){
 
897
    error(0, errno, "Could not scan plugin dir");
 
898
    direntries = NULL;
 
899
    exitstatus = EX_OSERR;
 
900
    goto fallback;
 
901
  }
 
902
  
 
903
  FD_ZERO(&rfds_all);
 
904
  
 
905
  /* Read and execute any executable in the plugin directory*/
 
906
  for(int i = 0; i < numplugins; i++){
 
907
    
 
908
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
909
    if(plugin_fd == -1){
 
910
      error(0, errno, "Could not open plugin");
 
911
      free(direntries[i]);
 
912
      continue;
 
913
    }
 
914
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
 
915
    if(ret == -1){
 
916
      error(0, errno, "stat");
 
917
      close(plugin_fd);
 
918
      free(direntries[i]);
 
919
      continue;
 
920
    }
 
921
    
 
922
    /* Ignore non-executable files */
 
923
    if(not S_ISREG(st.st_mode)
 
924
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
925
                                        X_OK, 0)) != 0)){
 
926
      if(debug){
 
927
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
928
                " with bad type or mode\n",
 
929
                plugindir != NULL ? plugindir : PDIR,
 
930
                direntries[i]->d_name);
 
931
      }
 
932
      close(plugin_fd);
 
933
      free(direntries[i]);
 
934
      continue;
 
935
    }
 
936
    
 
937
    plugin *p = getplugin(direntries[i]->d_name);
 
938
    if(p == NULL){
 
939
      error(0, errno, "getplugin");
 
940
      close(plugin_fd);
 
941
      free(direntries[i]);
 
942
      continue;
 
943
    }
 
944
    if(p->disabled){
 
945
      if(debug){
 
946
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
 
947
                direntries[i]->d_name);
 
948
      }
 
949
      close(plugin_fd);
 
950
      free(direntries[i]);
 
951
      continue;
 
952
    }
 
953
    {
 
954
      /* Add global arguments to argument list for this plugin */
 
955
      plugin *g = getplugin(NULL);
 
956
      if(g != NULL){
 
957
        for(char **a = g->argv + 1; *a != NULL; a++){
 
958
          if(not add_argument(p, *a)){
 
959
            error(0, errno, "add_argument");
 
960
          }
 
961
        }
 
962
        /* Add global environment variables */
 
963
        for(char **e = g->environ; *e != NULL; e++){
 
964
          if(not add_environment(p, *e, false)){
 
965
            error(0, errno, "add_environment");
 
966
          }
 
967
        }
 
968
      }
 
969
    }
 
970
    /* If this plugin has any environment variables, we need to
 
971
       duplicate the environment from this process, too. */
 
972
    if(p->environ[0] != NULL){
 
973
      for(char **e = environ; *e != NULL; e++){
 
974
        if(not add_environment(p, *e, false)){
 
975
          error(0, errno, "add_environment");
 
976
        }
 
977
      }
 
978
    }
 
979
    
 
980
    int pipefd[2];
 
981
#ifndef O_CLOEXEC
 
982
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
983
#else  /* O_CLOEXEC */
 
984
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
985
#endif  /* O_CLOEXEC */
 
986
    if(ret == -1){
 
987
      error(0, errno, "pipe");
 
988
      exitstatus = EX_OSERR;
 
989
      free(direntries[i]);
 
990
      goto fallback;
 
991
    }
 
992
    if(pipefd[0] >= FD_SETSIZE){
 
993
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
994
              FD_SETSIZE);
 
995
      close(pipefd[0]);
 
996
      close(pipefd[1]);
 
997
      exitstatus = EX_OSERR;
 
998
      free(direntries[i]);
 
999
      goto fallback;
 
1000
    }
 
1001
#ifndef O_CLOEXEC
 
1002
    /* Ask OS to automatic close the pipe on exec */
 
1003
    ret = set_cloexec_flag(pipefd[0]);
 
1004
    if(ret < 0){
 
1005
      error(0, errno, "set_cloexec_flag");
 
1006
      close(pipefd[0]);
 
1007
      close(pipefd[1]);
 
1008
      exitstatus = EX_OSERR;
 
1009
      free(direntries[i]);
 
1010
      goto fallback;
 
1011
    }
 
1012
    ret = set_cloexec_flag(pipefd[1]);
 
1013
    if(ret < 0){
 
1014
      error(0, errno, "set_cloexec_flag");
 
1015
      close(pipefd[0]);
 
1016
      close(pipefd[1]);
 
1017
      exitstatus = EX_OSERR;
 
1018
      free(direntries[i]);
 
1019
      goto fallback;
 
1020
    }
 
1021
#endif  /* not O_CLOEXEC */
 
1022
    /* Block SIGCHLD until process is safely in process list */
 
1023
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
 
1024
                                              &sigchld_action.sa_mask,
 
1025
                                              NULL));
 
1026
    if(ret < 0){
 
1027
      error(0, errno, "sigprocmask");
 
1028
      exitstatus = EX_OSERR;
 
1029
      free(direntries[i]);
 
1030
      goto fallback;
 
1031
    }
 
1032
    /* Starting a new process to be watched */
 
1033
    pid_t pid;
 
1034
    do {
 
1035
      pid = fork();
 
1036
    } while(pid == -1 and errno == EINTR);
 
1037
    if(pid == -1){
 
1038
      error(0, errno, "fork");
 
1039
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1040
                                     &sigchld_action.sa_mask, NULL));
 
1041
      close(pipefd[0]);
 
1042
      close(pipefd[1]);
 
1043
      exitstatus = EX_OSERR;
 
1044
      free(direntries[i]);
 
1045
      goto fallback;
 
1046
    }
 
1047
    if(pid == 0){
 
1048
      /* this is the child process */
 
1049
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
 
1050
      if(ret < 0){
 
1051
        error(0, errno, "sigaction");
 
1052
        _exit(EX_OSERR);
 
1053
      }
 
1054
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1055
      if(ret < 0){
 
1056
        error(0, errno, "sigprocmask");
 
1057
        _exit(EX_OSERR);
 
1058
      }
 
1059
      
 
1060
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
 
1061
      if(ret == -1){
 
1062
        error(0, errno, "dup2");
 
1063
        _exit(EX_OSERR);
 
1064
      }
 
1065
      
 
1066
      if(fexecve(plugin_fd, p->argv,
 
1067
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1068
        error(0, errno, "fexecve for %s/%s",
 
1069
              plugindir != NULL ? plugindir : PDIR,
 
1070
              direntries[i]->d_name);
 
1071
        _exit(EX_OSERR);
 
1072
      }
 
1073
      /* no return */
 
1074
    }
 
1075
    /* Parent process */
 
1076
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1077
    close(plugin_fd);
 
1078
    plugin *new_plugin = getplugin(direntries[i]->d_name);
 
1079
    if(new_plugin == NULL){
 
1080
      error(0, errno, "getplugin");
 
1081
      ret = (int)(TEMP_FAILURE_RETRY
 
1082
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
 
1083
                               NULL)));
 
1084
      if(ret < 0){
 
1085
        error(0, errno, "sigprocmask");
 
1086
      }
 
1087
      exitstatus = EX_OSERR;
 
1088
      free(direntries[i]);
 
1089
      goto fallback;
 
1090
    }
 
1091
    free(direntries[i]);
 
1092
    
 
1093
    new_plugin->pid = pid;
 
1094
    new_plugin->fd = pipefd[0];
 
1095
    
 
1096
    /* Unblock SIGCHLD so signal handler can be run if this process
 
1097
       has already completed */
 
1098
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1099
                                              &sigchld_action.sa_mask,
 
1100
                                              NULL));
 
1101
    if(ret < 0){
 
1102
      error(0, errno, "sigprocmask");
 
1103
      exitstatus = EX_OSERR;
 
1104
      goto fallback;
 
1105
    }
 
1106
    
 
1107
    FD_SET(new_plugin->fd, &rfds_all);
 
1108
    
 
1109
    if(maxfd < new_plugin->fd){
 
1110
      maxfd = new_plugin->fd;
 
1111
    }
 
1112
  }
 
1113
  
 
1114
  free(direntries);
 
1115
  direntries = NULL;
 
1116
  close(dir_fd);
 
1117
  dir_fd = -1;
 
1118
  free_plugin(getplugin(NULL));
 
1119
  
 
1120
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1121
    if(p->pid != 0){
 
1122
      break;
 
1123
    }
 
1124
    if(p->next == NULL){
 
1125
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
 
1126
              " directory?\n");
 
1127
      free_plugin_list();
 
1128
    }
 
1129
  }
 
1130
  
 
1131
  /* Main loop while running plugins exist */
 
1132
  while(plugin_list){
 
1133
    fd_set rfds = rfds_all;
 
1134
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
 
1135
    if(select_ret == -1 and errno != EINTR){
 
1136
      error(0, errno, "select");
 
1137
      exitstatus = EX_OSERR;
 
1138
      goto fallback;
 
1139
    }
 
1140
    /* OK, now either a process completed, or something can be read
 
1141
       from one of them */
 
1142
    for(plugin *proc = plugin_list; proc != NULL;){
 
1143
      /* Is this process completely done? */
 
1144
      if(proc->completed and proc->eof){
 
1145
        /* Only accept the plugin output if it exited cleanly */
 
1146
        if(not WIFEXITED(proc->status)
 
1147
           or WEXITSTATUS(proc->status) != 0){
 
1148
          /* Bad exit by plugin */
 
1149
          
 
1150
          if(debug){
 
1151
            if(WIFEXITED(proc->status)){
 
1152
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1153
                      " status %d\n", proc->name,
 
1154
                      (intmax_t) (proc->pid),
 
1155
                      WEXITSTATUS(proc->status));
 
1156
            } else if(WIFSIGNALED(proc->status)){
 
1157
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
 
1158
                      " signal %d: %s\n", proc->name,
 
1159
                      (intmax_t) (proc->pid),
 
1160
                      WTERMSIG(proc->status),
 
1161
                      strsignal(WTERMSIG(proc->status)));
 
1162
            } else if(WCOREDUMP(proc->status)){
 
1163
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
 
1164
                      " core\n", proc->name, (intmax_t) (proc->pid));
 
1165
            }
 
1166
          }
 
1167
          
 
1168
          /* Remove the plugin */
 
1169
          FD_CLR(proc->fd, &rfds_all);
 
1170
          
 
1171
          /* Block signal while modifying process_list */
 
1172
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1173
                                        (SIG_BLOCK,
 
1174
                                         &sigchld_action.sa_mask,
 
1175
                                         NULL));
 
1176
          if(ret < 0){
 
1177
            error(0, errno, "sigprocmask");
 
1178
            exitstatus = EX_OSERR;
 
1179
            goto fallback;
 
1180
          }
 
1181
          
 
1182
          plugin *next_plugin = proc->next;
 
1183
          free_plugin(proc);
 
1184
          proc = next_plugin;
 
1185
          
 
1186
          /* We are done modifying process list, so unblock signal */
 
1187
          ret = (int)(TEMP_FAILURE_RETRY
 
1188
                      (sigprocmask(SIG_UNBLOCK,
 
1189
                                   &sigchld_action.sa_mask, NULL)));
 
1190
          if(ret < 0){
 
1191
            error(0, errno, "sigprocmask");
 
1192
            exitstatus = EX_OSERR;
 
1193
            goto fallback;
 
1194
          }
 
1195
          
 
1196
          if(plugin_list == NULL){
 
1197
            break;
 
1198
          }
 
1199
          
 
1200
          continue;
 
1201
        }
 
1202
        
 
1203
        /* This process exited nicely, so print its buffer */
 
1204
        
 
1205
        bool bret = print_out_password(proc->buffer,
 
1206
                                       proc->buffer_length);
 
1207
        if(not bret){
 
1208
          error(0, errno, "print_out_password");
 
1209
          exitstatus = EX_IOERR;
 
1210
        }
 
1211
        goto fallback;
 
1212
      }
 
1213
      
 
1214
      /* This process has not completed.  Does it have any output? */
 
1215
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
 
1216
        /* This process had nothing to say at this time */
 
1217
        proc = proc->next;
 
1218
        continue;
 
1219
      }
 
1220
      /* Before reading, make the process' data buffer large enough */
 
1221
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
 
1222
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1223
                                   + (size_t) BUFFER_SIZE);
 
1224
        if(new_buffer == NULL){
 
1225
          error(0, errno, "malloc");
 
1226
          exitstatus = EX_OSERR;
 
1227
          goto fallback;
 
1228
        }
 
1229
        proc->buffer = new_buffer;
 
1230
        proc->buffer_size += BUFFER_SIZE;
 
1231
      }
 
1232
      /* Read from the process */
 
1233
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1234
                                     proc->buffer
 
1235
                                     + proc->buffer_length,
 
1236
                                     BUFFER_SIZE));
 
1237
      if(sret < 0){
 
1238
        /* Read error from this process; ignore the error */
 
1239
        proc = proc->next;
 
1240
        continue;
 
1241
      }
 
1242
      if(sret == 0){
 
1243
        /* got EOF */
 
1244
        proc->eof = true;
 
1245
      } else {
 
1246
        proc->buffer_length += (size_t) sret;
 
1247
      }
 
1248
    }
 
1249
  }
 
1250
  
 
1251
  
 
1252
 fallback:
 
1253
  
 
1254
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1255
                             and exitstatus != EX_OK)){
 
1256
    /* Fallback if all plugins failed, none are found or an error
 
1257
       occured */
 
1258
    bool bret;
 
1259
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
 
1260
    char *passwordbuffer = getpass("Password: ");
 
1261
    size_t len = strlen(passwordbuffer);
 
1262
    /* Strip trailing newline */
 
1263
    if(len > 0 and passwordbuffer[len-1] == '\n'){
 
1264
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
 
1265
      len--;
 
1266
    }
 
1267
    bret = print_out_password(passwordbuffer, len);
 
1268
    if(not bret){
 
1269
      error(0, errno, "print_out_password");
 
1270
      exitstatus = EX_IOERR;
 
1271
    }
 
1272
  }
 
1273
  
 
1274
  /* Restore old signal handler */
 
1275
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
 
1276
  if(ret == -1){
 
1277
    error(0, errno, "sigaction");
 
1278
    exitstatus = EX_OSERR;
 
1279
  }
 
1280
  
 
1281
  if(custom_argv != NULL){
 
1282
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
 
1283
      free(*arg);
 
1284
    }
 
1285
    free(custom_argv);
 
1286
  }
 
1287
  
 
1288
  free(direntries);
 
1289
  
 
1290
  if(dir_fd != -1){
 
1291
    close(dir_fd);
 
1292
  }
 
1293
  
 
1294
  /* Kill the processes */
 
1295
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1296
    if(p->pid != 0){
 
1297
      close(p->fd);
 
1298
      ret = kill(p->pid, SIGTERM);
 
1299
      if(ret == -1 and errno != ESRCH){
 
1300
        /* Set-uid proccesses might not get closed */
 
1301
        error(0, errno, "kill");
 
1302
      }
 
1303
    }
 
1304
  }
 
1305
  
 
1306
  /* Wait for any remaining child processes to terminate */
 
1307
  do {
 
1308
    ret = wait(NULL);
 
1309
  } while(ret >= 0);
 
1310
  if(errno != ECHILD){
 
1311
    error(0, errno, "wait");
 
1312
  }
 
1313
  
 
1314
  free_plugin_list();
 
1315
  
 
1316
  free(plugindir);
 
1317
  free(pluginhelperdir);
 
1318
  free(argfile);
 
1319
  
 
1320
  return exitstatus;
182
1321
}