/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: teddy at recompile
  • Date: 2020-04-05 21:30:59 UTC
  • Revision ID: teddy@recompile.se-20200405213059-fb2a61ckqynrmatk
Fix file descriptor leak in mandos-client

When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.)  The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.

This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route.  If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.

Fix this by eliminating the file descriptor leak in the client.

* plugins.d/mandos-client.c (add_delete_local_route): Do
  close(devnull) also in parent process, also if fork() fails, and on
  any failure in child process.

Show diffs side-by-side

added added

removed removed

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