/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-08-05 21:14:05 UTC
  • mto: This revision was merged to the branch mainline in revision 388.
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

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 © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * 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
13
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
18
 * General Public License for more details.
16
19
 * 
17
20
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see
19
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
20
22
 * 
21
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
22
24
 */
23
25
 
24
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
25
 
                                   asprintf() */
 
27
                                   O_CLOEXEC, pipe2() */
26
28
#include <stddef.h>             /* size_t, NULL */
27
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
 
                                   EXIT_SUCCESS, realloc() */
 
29
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
 
30
                                   realloc() */
29
31
#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() */
 
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() */
37
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS() */
41
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
 
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
 
98
106
 
99
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
138
  
122
 
  *new_plugin = (plugin) { .name = copy_name,
123
 
                           .argc = 1,
124
 
                           .disabled = false,
125
 
                           .next = plugin_list };
 
139
  *new_plugin = (plugin){ .name = copy_name,
 
140
                          .argc = 1,
 
141
                          .disabled = false,
 
142
                          .next = plugin_list };
126
143
  
127
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
128
 
  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;
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) + 1);
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 */
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
302
  for(size_t written = 0; written < length; written += (size_t)ret){
259
303
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
266
310
}
267
311
 
268
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
269
314
static void free_plugin(plugin *plugin_node){
270
315
  
271
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
316
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
272
317
    free(*arg);
273
318
  }
 
319
  free(plugin_node->name);
274
320
  free(plugin_node->argv);
275
321
  for(char **env = plugin_node->environ; *env != NULL; env++){
276
322
    free(*env);
277
323
  }
278
324
  free(plugin_node->environ);
279
325
  free(plugin_node->buffer);
280
 
 
 
326
  
281
327
  /* Removes the plugin from the singly-linked list */
282
328
  if(plugin_node == plugin_list){
283
329
    /* First one - simple */
303
349
 
304
350
int main(int argc, char *argv[]){
305
351
  char *plugindir = NULL;
 
352
  char *pluginhelperdir = NULL;
306
353
  char *argfile = NULL;
307
354
  FILE *conffp;
308
 
  size_t d_name_len;
309
 
  DIR *dir = NULL;
310
 
  struct dirent *dirst;
 
355
  struct dirent **direntries = NULL;
311
356
  struct stat st;
312
357
  fd_set rfds_all;
313
358
  int ret, maxfd = 0;
 
359
  ssize_t sret;
314
360
  uid_t uid = 65534;
315
361
  gid_t gid = 65534;
316
362
  bool debug = false;
320
366
                                      .sa_flags = SA_NOCLDSTOP };
321
367
  char **custom_argv = NULL;
322
368
  int custom_argc = 0;
 
369
  int dir_fd = -1;
323
370
  
324
371
  /* Establish a signal handler */
325
372
  sigemptyset(&sigchld_action.sa_mask);
326
373
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
327
374
  if(ret == -1){
328
 
    perror("sigaddset");
329
 
    exitstatus = EXIT_FAILURE;
 
375
    error(0, errno, "sigaddset");
 
376
    exitstatus = EX_OSERR;
330
377
    goto fallback;
331
378
  }
332
379
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
333
380
  if(ret == -1){
334
 
    perror("sigaction");
335
 
    exitstatus = EXIT_FAILURE;
 
381
    error(0, errno, "sigaction");
 
382
    exitstatus = EX_OSERR;
336
383
    goto fallback;
337
384
  }
338
385
  
370
417
      .doc = "Group ID the plugins will run as", .group = 3 },
371
418
    { .name = "debug", .key = 132,
372
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 },
373
433
    { .name = NULL }
374
434
  };
375
435
  
376
 
  error_t parse_opt (int key, char *arg, __attribute__((unused))
377
 
                     struct argp_state *state) {
378
 
    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;
379
442
    case 'g':                   /* --global-options */
380
 
      if (arg != NULL){
381
 
        char *p;
382
 
        while((p = strsep(&arg, ",")) != NULL){
383
 
          if(p[0] == '\0'){
384
 
            continue;
385
 
          }
386
 
          if(not add_argument(getplugin(NULL), p)){
387
 
            perror("add_argument");
388
 
            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;
389
448
          }
390
449
        }
 
450
        errno = 0;
391
451
      }
392
452
      break;
393
453
    case 'G':                   /* --global-env */
394
 
      if(arg == NULL){
395
 
        break;
396
 
      }
397
 
      if(not add_environment(getplugin(NULL), arg, true)){
398
 
        perror("add_environment");
 
454
      if(add_environment(getplugin(NULL), arg, true)){
 
455
        errno = 0;
399
456
      }
400
457
      break;
401
458
    case 'o':                   /* --options-for */
402
 
      if (arg != NULL){
403
 
        char *p_name = strsep(&arg, ":");
404
 
        if(p_name[0] == '\0' or arg == NULL){
405
 
          break;
406
 
        }
407
 
        char *opt = strsep(&arg, ":");
408
 
        if(opt[0] == '\0' or opt == NULL){
409
 
          break;
410
 
        }
411
 
        char *p;
412
 
        while((p = strsep(&opt, ",")) != NULL){
413
 
          if(p[0] == '\0'){
414
 
            continue;
415
 
          }
416
 
          if(not add_argument(getplugin(p_name), p)){
417
 
            perror("add_argument");
418
 
            return ARGP_ERR_UNKNOWN;
419
 
          }
420
 
        }
 
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;
421
480
      }
422
481
      break;
423
482
    case 'E':                   /* --env-for */
424
 
      if(arg == NULL){
425
 
        break;
426
 
      }
427
483
      {
428
484
        char *envdef = strchr(arg, ':');
429
485
        if(envdef == NULL){
 
486
          argp_error(state, "No colon in \"%s\"", arg);
 
487
          errno = EINVAL;
430
488
          break;
431
489
        }
432
490
        *envdef = '\0';
433
 
        if(not add_environment(getplugin(arg), envdef+1, true)){
434
 
          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;
435
499
        }
436
500
      }
437
501
      break;
438
502
    case 'd':                   /* --disable */
439
 
      if (arg != NULL){
 
503
      {
440
504
        plugin *p = getplugin(arg);
441
 
        if(p == NULL){
442
 
          return ARGP_ERR_UNKNOWN;
 
505
        if(p != NULL){
 
506
          p->disabled = true;
 
507
          errno = 0;
443
508
        }
444
 
        p->disabled = true;
445
509
      }
446
510
      break;
447
511
    case 'e':                   /* --enable */
448
 
      if (arg != NULL){
 
512
      {
449
513
        plugin *p = getplugin(arg);
450
 
        if(p == NULL){
451
 
          return ARGP_ERR_UNKNOWN;
 
514
        if(p != NULL){
 
515
          p->disabled = false;
 
516
          errno = 0;
452
517
        }
453
 
        p->disabled = false;
454
518
      }
455
519
      break;
456
520
    case 128:                   /* --plugin-dir */
457
521
      free(plugindir);
458
522
      plugindir = strdup(arg);
459
 
      if(plugindir == NULL){
460
 
        perror("strdup");
461
 
      }      
 
523
      if(plugindir != NULL){
 
524
        errno = 0;
 
525
      }
462
526
      break;
463
527
    case 129:                   /* --config-file */
464
528
      /* This is already done by parse_opt_config_file() */
465
529
      break;
466
530
    case 130:                   /* --userid */
467
 
      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;
468
540
      break;
469
541
    case 131:                   /* --groupid */
470
 
      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;
471
551
      break;
472
552
    case 132:                   /* --debug */
473
553
      debug = true;
474
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
 */
475
582
    case ARGP_KEY_ARG:
476
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
477
 
      break;
478
 
    case ARGP_KEY_END:
479
 
      break;
 
583
      /* Cryptsetup always passes an argument, which is an empty
 
584
         string if "none" was specified in /etc/crypttab.  So if
 
585
         argument was empty, we ignore it silently. */
 
586
      if(arg[0] == '\0'){
 
587
        break;
 
588
      }
 
589
#if __GNUC__ >= 7
 
590
      __attribute__((fallthrough));
 
591
#else
 
592
          /* FALLTHROUGH */
 
593
#endif
480
594
    default:
481
595
      return ARGP_ERR_UNKNOWN;
482
596
    }
483
 
    return 0;
 
597
    return errno;               /* Set to 0 at start */
484
598
  }
485
599
  
486
600
  /* This option parser is the same as parse_opt() above, except it
487
601
     ignores everything but the --config-file option. */
488
 
  error_t parse_opt_config_file (int key, char *arg,
489
 
                                 __attribute__((unused))
490
 
                                 struct argp_state *state) {
491
 
    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){
492
607
    case 'g':                   /* --global-options */
493
608
    case 'G':                   /* --global-env */
494
609
    case 'o':                   /* --options-for */
500
615
    case 129:                   /* --config-file */
501
616
      free(argfile);
502
617
      argfile = strdup(arg);
503
 
      if(argfile == NULL){
504
 
        perror("strdup");
 
618
      if(argfile != NULL){
 
619
        errno = 0;
505
620
      }
506
 
      break;      
 
621
      break;
507
622
    case 130:                   /* --userid */
508
623
    case 131:                   /* --groupid */
509
624
    case 132:                   /* --debug */
 
625
    case 133:                   /* --plugin-helper-dir */
 
626
    case '?':                   /* --help */
 
627
    case -3:                    /* --usage */
 
628
    case 'V':                   /* --version */
510
629
    case ARGP_KEY_ARG:
511
 
    case ARGP_KEY_END:
512
630
      break;
513
631
    default:
514
632
      return ARGP_ERR_UNKNOWN;
515
633
    }
516
 
    return 0;
 
634
    return errno;
517
635
  }
518
636
  
519
637
  struct argp argp = { .options = options,
521
639
                       .args_doc = "",
522
640
                       .doc = "Mandos plugin runner -- Run plugins" };
523
641
  
524
 
  /* 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
525
643
     config file location, if any. */
526
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
527
 
  if (ret == ARGP_ERR_UNKNOWN){
528
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
529
 
    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;
530
658
    goto fallback;
531
659
  }
532
660
  
534
662
  argp.parser = parse_opt;
535
663
  
536
664
  /* Open the configfile if available */
537
 
  if (argfile == NULL){
 
665
  if(argfile == NULL){
538
666
    conffp = fopen(AFILE, "r");
539
667
  } else {
540
668
    conffp = fopen(argfile, "r");
541
 
  }  
 
669
  }
542
670
  if(conffp != NULL){
543
671
    char *org_line = NULL;
544
672
    char *p, *arg, *new_arg, *line;
545
673
    size_t size = 0;
546
 
    ssize_t sret;
547
674
    const char whitespace_delims[] = " \r\t\f\v\n";
548
675
    const char comment_delim[] = "#";
549
 
 
 
676
    
550
677
    custom_argc = 1;
551
678
    custom_argv = malloc(sizeof(char*) * 2);
552
679
    if(custom_argv == NULL){
553
 
      perror("malloc");
554
 
      exitstatus = EXIT_FAILURE;
 
680
      error(0, errno, "malloc");
 
681
      exitstatus = EX_OSERR;
555
682
      goto fallback;
556
683
    }
557
684
    custom_argv[0] = argv[0];
558
685
    custom_argv[1] = NULL;
559
 
 
 
686
    
560
687
    /* for each line in the config file, strip whitespace and ignore
561
688
       commented text */
562
689
    while(true){
564
691
      if(sret == -1){
565
692
        break;
566
693
      }
567
 
 
 
694
      
568
695
      line = org_line;
569
696
      arg = strsep(&line, comment_delim);
570
697
      while((p = strsep(&arg, whitespace_delims)) != NULL){
573
700
        }
574
701
        new_arg = strdup(p);
575
702
        if(new_arg == NULL){
576
 
          perror("strdup");
577
 
          exitstatus = EXIT_FAILURE;
 
703
          error(0, errno, "strdup");
 
704
          exitstatus = EX_OSERR;
578
705
          free(org_line);
579
706
          goto fallback;
580
707
        }
581
708
        
582
709
        custom_argc += 1;
583
 
        custom_argv = realloc(custom_argv, sizeof(char *)
584
 
                              * ((unsigned int) custom_argc + 1));
585
 
        if(custom_argv == NULL){
586
 
          perror("realloc");
587
 
          exitstatus = EXIT_FAILURE;
588
 
          free(org_line);
589
 
          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
          }
590
722
        }
591
723
        custom_argv[custom_argc-1] = new_arg;
592
 
        custom_argv[custom_argc] = NULL;        
 
724
        custom_argv[custom_argc] = NULL;
593
725
      }
594
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
    }
595
735
    free(org_line);
596
736
  } else {
597
737
    /* Check for harmful errors and go to fallback. Other errors might
598
738
       not affect opening plugins */
599
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
600
 
      perror("fopen");
601
 
      exitstatus = EXIT_FAILURE;
 
739
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
 
740
      error(0, errno, "fopen");
 
741
      exitstatus = EX_OSERR;
602
742
      goto fallback;
603
743
    }
604
744
  }
605
 
  /* If there was any arguments from configuration file,
606
 
     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 */
607
747
  if(custom_argv != NULL){
608
 
    ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
609
 
                      0, NULL);
610
 
    if (ret == ARGP_ERR_UNKNOWN){
611
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
612
 
      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;
613
762
      goto fallback;
614
763
    }
615
764
  }
616
765
  
617
766
  /* Parse actual command line arguments, to let them override the
618
767
     config file */
619
 
  ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
620
 
  if (ret == ARGP_ERR_UNKNOWN){
621
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
622
 
    exitstatus = EXIT_FAILURE;
623
 
    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
    }
624
801
  }
625
802
  
626
803
  if(debug){
627
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
804
    for(plugin *p = plugin_list; p != NULL; p = p->next){
628
805
      fprintf(stderr, "Plugin: %s has %d arguments\n",
629
806
              p->name ? p->name : "Global", p->argc - 1);
630
807
      for(char **a = p->argv; *a != NULL; a++){
631
808
        fprintf(stderr, "\tArg: %s\n", *a);
632
809
      }
633
 
      fprintf(stderr, "...and %u environment variables\n", p->envc);
 
810
      fprintf(stderr, "...and %d environment variables\n", p->envc);
634
811
      for(char **a = p->environ; *a != NULL; a++){
635
812
        fprintf(stderr, "\t%s\n", *a);
636
813
      }
637
814
    }
638
815
  }
639
816
  
640
 
  /* 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
  }
641
846
  ret = setuid(uid);
642
 
  if (ret == -1){
643
 
    perror("setuid");
644
 
  }  
645
 
  setgid(gid);
646
 
  if (ret == -1){
647
 
    perror("setgid");
648
 
  }
649
 
  
650
 
  if (plugindir == NULL){
651
 
    dir = opendir(PDIR);
652
 
  } else {
653
 
    dir = opendir(plugindir);
654
 
  }
655
 
  
656
 
  if(dir == NULL){
657
 
    perror("Could not open plugin dir");
658
 
    exitstatus = EXIT_FAILURE;
659
 
    goto fallback;
660
 
  }
661
 
  
662
 
  /* 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 */
663
852
  {
664
 
    int dir_fd = dirfd(dir);
665
 
    if(dir_fd >= 0){
666
 
      ret = set_cloexec_flag(dir_fd);
667
 
      if(ret < 0){
668
 
        perror("set_cloexec_flag");
669
 
        exitstatus = EXIT_FAILURE;
670
 
        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;
671
897
      }
672
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;
673
909
  }
674
910
  
675
911
  FD_ZERO(&rfds_all);
676
912
  
677
913
  /* Read and execute any executable in the plugin directory*/
678
 
  while(true){
679
 
    dirst = readdir(dir);
680
 
    
681
 
    /* All directory entries have been processed */
682
 
    if(dirst == NULL){
683
 
      if (errno == EBADF){
684
 
        perror("readdir");
685
 
        exitstatus = EXIT_FAILURE;
686
 
        goto fallback;
687
 
      }
688
 
      break;
689
 
    }
690
 
    
691
 
    d_name_len = strlen(dirst->d_name);
692
 
    
693
 
    /* Ignore dotfiles, backup files and other junk */
694
 
    {
695
 
      bool bad_name = false;
696
 
      
697
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
698
 
      
699
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
700
 
                                           ".dpkg-old",
701
 
                                           ".dpkg-divert", NULL };
702
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
703
 
        size_t pre_len = strlen(*pre);
704
 
        if((d_name_len >= pre_len)
705
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
706
 
          if(debug){
707
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
708
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
709
 
          }
710
 
          bad_name = true;
711
 
          break;
712
 
        }
713
 
      }
714
 
      if(bad_name){
715
 
        continue;
716
 
      }
717
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
718
 
        size_t suf_len = strlen(*suf);
719
 
        if((d_name_len >= suf_len)
720
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
721
 
                == 0)){
722
 
          if(debug){
723
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
724
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
725
 
          }
726
 
          bad_name = true;
727
 
          break;
728
 
        }
729
 
      }
730
 
      
731
 
      if(bad_name){
732
 
        continue;
733
 
      }
734
 
    }
735
 
 
736
 
    char *filename;
737
 
    if(plugindir == NULL){
738
 
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
739
 
    } else {
740
 
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
741
 
    }
742
 
    if(ret < 0){
743
 
      perror("asprintf");
744
 
      continue;
745
 
    }
746
 
    
747
 
    ret = stat(filename, &st);
748
 
    if (ret == -1){
749
 
      perror("stat");
750
 
      free(filename);
751
 
      continue;
752
 
    }
753
 
 
 
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
    
754
930
    /* Ignore non-executable files */
755
 
    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)){
756
934
      if(debug){
757
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
758
 
                " 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);
759
939
      }
760
 
      free(filename);
 
940
      close(plugin_fd);
 
941
      free(direntries[i]);
761
942
      continue;
762
943
    }
763
944
    
764
 
    plugin *p = getplugin(dirst->d_name);
 
945
    plugin *p = getplugin(direntries[i]->d_name);
765
946
    if(p == NULL){
766
 
      perror("getplugin");
767
 
      free(filename);
 
947
      error(0, errno, "getplugin");
 
948
      close(plugin_fd);
 
949
      free(direntries[i]);
768
950
      continue;
769
951
    }
770
952
    if(p->disabled){
771
953
      if(debug){
772
954
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
773
 
                dirst->d_name);
 
955
                direntries[i]->d_name);
774
956
      }
775
 
      free(filename);
 
957
      close(plugin_fd);
 
958
      free(direntries[i]);
776
959
      continue;
777
960
    }
778
961
    {
781
964
      if(g != NULL){
782
965
        for(char **a = g->argv + 1; *a != NULL; a++){
783
966
          if(not add_argument(p, *a)){
784
 
            perror("add_argument");
 
967
            error(0, errno, "add_argument");
785
968
          }
786
969
        }
787
970
        /* Add global environment variables */
788
971
        for(char **e = g->environ; *e != NULL; e++){
789
972
          if(not add_environment(p, *e, false)){
790
 
            perror("add_environment");
 
973
            error(0, errno, "add_environment");
791
974
          }
792
975
        }
793
976
      }
794
977
    }
795
 
    /* If this plugin has any environment variables, we will call
796
 
       using execve and need to duplicate the environment from this
797
 
       process, too. */
 
978
    /* If this plugin has any environment variables, we need to
 
979
       duplicate the environment from this process, too. */
798
980
    if(p->environ[0] != NULL){
799
981
      for(char **e = environ; *e != NULL; e++){
800
982
        if(not add_environment(p, *e, false)){
801
 
          perror("add_environment");
 
983
          error(0, errno, "add_environment");
802
984
        }
803
985
      }
804
986
    }
805
987
    
806
988
    int pipefd[2];
807
 
    ret = pipe(pipefd);
808
 
    if (ret == -1){
809
 
      perror("pipe");
810
 
      exitstatus = EXIT_FAILURE;
811
 
      goto fallback;
812
 
    }
 
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
813
1010
    /* Ask OS to automatic close the pipe on exec */
814
1011
    ret = set_cloexec_flag(pipefd[0]);
815
1012
    if(ret < 0){
816
 
      perror("set_cloexec_flag");
817
 
      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]);
818
1018
      goto fallback;
819
1019
    }
820
1020
    ret = set_cloexec_flag(pipefd[1]);
821
1021
    if(ret < 0){
822
 
      perror("set_cloexec_flag");
823
 
      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]);
824
1027
      goto fallback;
825
1028
    }
 
1029
#endif  /* not O_CLOEXEC */
826
1030
    /* Block SIGCHLD until process is safely in process list */
827
 
    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));
828
1034
    if(ret < 0){
829
 
      perror("sigprocmask");
830
 
      exitstatus = EXIT_FAILURE;
 
1035
      error(0, errno, "sigprocmask");
 
1036
      exitstatus = EX_OSERR;
 
1037
      free(direntries[i]);
831
1038
      goto fallback;
832
1039
    }
833
1040
    /* Starting a new process to be watched */
834
 
    pid_t pid = fork();
 
1041
    pid_t pid;
 
1042
    do {
 
1043
      pid = fork();
 
1044
    } while(pid == -1 and errno == EINTR);
835
1045
    if(pid == -1){
836
 
      perror("fork");
837
 
      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]);
838
1053
      goto fallback;
839
1054
    }
840
1055
    if(pid == 0){
841
1056
      /* this is the child process */
842
1057
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
843
1058
      if(ret < 0){
844
 
        perror("sigaction");
845
 
        _exit(EXIT_FAILURE);
 
1059
        error(0, errno, "sigaction");
 
1060
        _exit(EX_OSERR);
846
1061
      }
847
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1062
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
848
1063
      if(ret < 0){
849
 
        perror("sigprocmask");
850
 
        _exit(EXIT_FAILURE);
 
1064
        error(0, errno, "sigprocmask");
 
1065
        _exit(EX_OSERR);
851
1066
      }
852
 
 
 
1067
      
853
1068
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
854
1069
      if(ret == -1){
855
 
        perror("dup2");
856
 
        _exit(EXIT_FAILURE);
 
1070
        error(0, errno, "dup2");
 
1071
        _exit(EX_OSERR);
857
1072
      }
858
1073
      
859
 
      if(dirfd(dir) < 0){
860
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
861
 
           above and must now close it manually here. */
862
 
        closedir(dir);
863
 
      }
864
 
      if(p->environ[0] == NULL){
865
 
        if(execv(filename, p->argv) < 0){
866
 
          perror("execv");
867
 
          _exit(EXIT_FAILURE);
868
 
        }
869
 
      } else {
870
 
        if(execve(filename, p->argv, p->environ) < 0){
871
 
          perror("execve");
872
 
          _exit(EXIT_FAILURE);
873
 
        }
 
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);
874
1080
      }
875
1081
      /* no return */
876
1082
    }
877
1083
    /* Parent process */
878
1084
    close(pipefd[1]);           /* Close unused write end of pipe */
879
 
    free(filename);
880
 
    plugin *new_plugin = getplugin(dirst->d_name);
881
 
    if (new_plugin == NULL){
882
 
      perror("getplugin");
883
 
      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)));
884
1092
      if(ret < 0){
885
 
        perror("sigprocmask");
 
1093
        error(0, errno, "sigprocmask");
886
1094
      }
887
 
      exitstatus = EXIT_FAILURE;
 
1095
      exitstatus = EX_OSERR;
 
1096
      free(direntries[i]);
888
1097
      goto fallback;
889
1098
    }
 
1099
    free(direntries[i]);
890
1100
    
891
1101
    new_plugin->pid = pid;
892
1102
    new_plugin->fd = pipefd[0];
893
 
    
 
1103
 
 
1104
    if(debug){
 
1105
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1106
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1107
    }
 
1108
 
894
1109
    /* Unblock SIGCHLD so signal handler can be run if this process
895
1110
       has already completed */
896
 
    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));
897
1114
    if(ret < 0){
898
 
      perror("sigprocmask");
899
 
      exitstatus = EXIT_FAILURE;
 
1115
      error(0, errno, "sigprocmask");
 
1116
      exitstatus = EX_OSERR;
900
1117
      goto fallback;
901
1118
    }
902
1119
    
903
1120
    FD_SET(new_plugin->fd, &rfds_all);
904
1121
    
905
 
    if (maxfd < new_plugin->fd){
 
1122
    if(maxfd < new_plugin->fd){
906
1123
      maxfd = new_plugin->fd;
907
1124
    }
908
 
    
909
1125
  }
910
1126
  
911
 
  closedir(dir);
912
 
  dir = NULL;
913
 
 
 
1127
  free(direntries);
 
1128
  direntries = NULL;
 
1129
  close(dir_fd);
 
1130
  dir_fd = -1;
 
1131
  free_plugin(getplugin(NULL));
 
1132
  
914
1133
  for(plugin *p = plugin_list; p != NULL; p = p->next){
915
1134
    if(p->pid != 0){
916
1135
      break;
921
1140
      free_plugin_list();
922
1141
    }
923
1142
  }
924
 
 
 
1143
  
925
1144
  /* Main loop while running plugins exist */
926
1145
  while(plugin_list){
927
1146
    fd_set rfds = rfds_all;
928
1147
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
929
 
    if (select_ret == -1){
930
 
      perror("select");
931
 
      exitstatus = EXIT_FAILURE;
 
1148
    if(select_ret == -1 and errno != EINTR){
 
1149
      error(0, errno, "select");
 
1150
      exitstatus = EX_OSERR;
932
1151
      goto fallback;
933
1152
    }
934
1153
    /* OK, now either a process completed, or something can be read
935
1154
       from one of them */
936
1155
    for(plugin *proc = plugin_list; proc != NULL;){
937
1156
      /* Is this process completely done? */
938
 
      if(proc->eof and proc->completed){
 
1157
      if(proc->completed and proc->eof){
939
1158
        /* Only accept the plugin output if it exited cleanly */
940
1159
        if(not WIFEXITED(proc->status)
941
1160
           or WEXITSTATUS(proc->status) != 0){
942
1161
          /* Bad exit by plugin */
943
 
 
 
1162
          
944
1163
          if(debug){
945
1164
            if(WIFEXITED(proc->status)){
946
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
947
 
                      (unsigned int) (proc->pid),
 
1165
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1166
                      " status %d\n", proc->name,
 
1167
                      (intmax_t) (proc->pid),
948
1168
                      WEXITSTATUS(proc->status));
949
 
            } else if(WIFSIGNALED(proc->status)) {
950
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
951
 
                      (unsigned int) (proc->pid),
952
 
                      WTERMSIG(proc->status));
953
 
            } else if(WCOREDUMP(proc->status)){
954
 
              fprintf(stderr, "Plugin %d dumped core\n",
955
 
                      (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)));
956
1175
            }
957
1176
          }
958
1177
          
959
1178
          /* Remove the plugin */
960
1179
          FD_CLR(proc->fd, &rfds_all);
961
 
 
 
1180
          
962
1181
          /* Block signal while modifying process_list */
963
 
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
964
 
          if(ret < 0){
965
 
            perror("sigprocmask");
966
 
            exitstatus = EXIT_FAILURE;
967
 
            goto fallback;
968
 
          }
969
 
          
970
 
          /* We are done modifying process list, so unblock signal */
971
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
972
 
                             NULL);
973
 
          if(ret < 0){
974
 
            perror("sigprocmask");
975
 
            exitstatus = EXIT_FAILURE;
976
 
            goto fallback;
977
 
          }
978
 
          
979
 
          if(plugin_list == NULL){
980
 
            break;
 
1182
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1183
                                        (SIG_BLOCK,
 
1184
                                         &sigchld_action.sa_mask,
 
1185
                                         NULL));
 
1186
          if(ret < 0){
 
1187
            error(0, errno, "sigprocmask");
 
1188
            exitstatus = EX_OSERR;
 
1189
            goto fallback;
981
1190
          }
982
1191
          
983
1192
          plugin *next_plugin = proc->next;
984
1193
          free_plugin(proc);
985
1194
          proc = next_plugin;
 
1195
          
 
1196
          /* We are done modifying process list, so unblock signal */
 
1197
          ret = (int)(TEMP_FAILURE_RETRY
 
1198
                      (sigprocmask(SIG_UNBLOCK,
 
1199
                                   &sigchld_action.sa_mask, NULL)));
 
1200
          if(ret < 0){
 
1201
            error(0, errno, "sigprocmask");
 
1202
            exitstatus = EX_OSERR;
 
1203
            goto fallback;
 
1204
          }
 
1205
          
 
1206
          if(plugin_list == NULL){
 
1207
            break;
 
1208
          }
 
1209
          
986
1210
          continue;
987
1211
        }
988
1212
        
989
1213
        /* This process exited nicely, so print its buffer */
990
 
 
 
1214
        
991
1215
        bool bret = print_out_password(proc->buffer,
992
1216
                                       proc->buffer_length);
993
1217
        if(not bret){
994
 
          perror("print_out_password");
995
 
          exitstatus = EXIT_FAILURE;
 
1218
          error(0, errno, "print_out_password");
 
1219
          exitstatus = EX_IOERR;
996
1220
        }
997
1221
        goto fallback;
998
1222
      }
1005
1229
      }
1006
1230
      /* Before reading, make the process' data buffer large enough */
1007
1231
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1008
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1009
 
                               + (size_t) BUFFER_SIZE);
1010
 
        if (proc->buffer == NULL){
1011
 
          perror("malloc");
1012
 
          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;
1013
1237
          goto fallback;
1014
1238
        }
 
1239
        proc->buffer = new_buffer;
1015
1240
        proc->buffer_size += BUFFER_SIZE;
1016
1241
      }
1017
1242
      /* Read from the process */
1018
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
1019
 
                 BUFFER_SIZE);
1020
 
      if(ret < 0){
 
1243
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1244
                                     proc->buffer
 
1245
                                     + proc->buffer_length,
 
1246
                                     BUFFER_SIZE));
 
1247
      if(sret < 0){
1021
1248
        /* Read error from this process; ignore the error */
1022
1249
        proc = proc->next;
1023
1250
        continue;
1024
1251
      }
1025
 
      if(ret == 0){
 
1252
      if(sret == 0){
1026
1253
        /* got EOF */
1027
1254
        proc->eof = true;
1028
1255
      } else {
1029
 
        proc->buffer_length += (size_t) ret;
 
1256
        proc->buffer_length += (size_t) sret;
1030
1257
      }
1031
1258
    }
1032
1259
  }
1033
 
 
1034
 
 
 
1260
  
 
1261
  
1035
1262
 fallback:
1036
1263
  
1037
 
  if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
 
1264
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1265
                             and exitstatus != EX_OK)){
1038
1266
    /* Fallback if all plugins failed, none are found or an error
1039
1267
       occured */
1040
1268
    bool bret;
1048
1276
    }
1049
1277
    bret = print_out_password(passwordbuffer, len);
1050
1278
    if(not bret){
1051
 
      perror("print_out_password");
1052
 
      exitstatus = EXIT_FAILURE;
 
1279
      error(0, errno, "print_out_password");
 
1280
      exitstatus = EX_IOERR;
1053
1281
    }
1054
1282
  }
1055
1283
  
1056
1284
  /* Restore old signal handler */
1057
1285
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1058
1286
  if(ret == -1){
1059
 
    perror("sigaction");
1060
 
    exitstatus = EXIT_FAILURE;
 
1287
    error(0, errno, "sigaction");
 
1288
    exitstatus = EX_OSERR;
1061
1289
  }
1062
 
 
 
1290
  
1063
1291
  if(custom_argv != NULL){
1064
1292
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
1065
1293
      free(*arg);
1067
1295
    free(custom_argv);
1068
1296
  }
1069
1297
  
1070
 
  if(dir != NULL){
1071
 
    closedir(dir);
 
1298
  free(direntries);
 
1299
  
 
1300
  if(dir_fd != -1){
 
1301
    close(dir_fd);
1072
1302
  }
1073
1303
  
1074
 
  /* Free the process list and kill the processes */
 
1304
  /* Kill the processes */
1075
1305
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1076
1306
    if(p->pid != 0){
1077
1307
      close(p->fd);
1078
1308
      ret = kill(p->pid, SIGTERM);
1079
1309
      if(ret == -1 and errno != ESRCH){
1080
1310
        /* Set-uid proccesses might not get closed */
1081
 
        perror("kill");
 
1311
        error(0, errno, "kill");
1082
1312
      }
1083
1313
    }
1084
1314
  }
1085
1315
  
1086
1316
  /* Wait for any remaining child processes to terminate */
1087
 
  do{
 
1317
  do {
1088
1318
    ret = wait(NULL);
1089
1319
  } while(ret >= 0);
1090
1320
  if(errno != ECHILD){
1091
 
    perror("wait");
 
1321
    error(0, errno, "wait");
1092
1322
  }
1093
 
 
 
1323
  
1094
1324
  free_plugin_list();
1095
1325
  
1096
1326
  free(plugindir);
 
1327
  free(pluginhelperdir);
1097
1328
  free(argfile);
1098
1329
  
1099
1330
  return exitstatus;