/mandos/release

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2015-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

Show diffs side-by-side

added added

removed removed

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