/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: 2019-07-14 22:39:15 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190714223915-aqjkms3t3taa6tye
Only use sanitizing options when debugging

The C compiler's sanitizing options introduce code in the output
binary which is fragile and not very security conscious.  It has
become clear that sanitizing is only really meant for use while
debugging.

As a side effect, this makes compilation faster, as the Makefile, for
production builds, no longer runs the compiler repeatedly to find all
its currently supported sanitizing options.

* Makefile (DEBUG): Add "$(SANITIZE)".
  (SANITIZE): Comment out.
  (CFLAGS): Remove "$(SANITIZE)".
  (plugins.d/mandos-client): Revert back to use plain $(LINK.c), since
                             we no longer need to remove the leak
                             sanitizer by overriding CFLAGS.

Show diffs side-by-side

added added

removed removed

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