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