/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 Hogeborn
  • Date: 2024-09-09 01:36:41 UTC
  • Revision ID: teddy@recompile.se-20240909013641-6zu6kx2f7meu134k
Make all required directories when installing

When installing into a normal system, one can assume that target
directories, such as /usr/bin, already exists.  But when installing
into a subdirectory for the purpose of creating a package, one cannot
assume that all directories already exist.  Therefore, when
installing, we must not check if any directories exist, and must
instead always create any directories we want to install into.

* Makefile (confdir/mandos.conf, confdir/clients.conf, install-html):
  Use the "-D" option to "install" instead of creating the directory
  separately.
  (install-server): Move creation of $(CONFDIR) down to before it is
  needed.  Don't check if the $(TMPFILES) or $(SYSUSERS) directories
  exist; instead create them by using the "-D" option to "install".
  Create the $(PREFIX)/sbin directory.  Always use
  "--target-directory" if possible; i.e. if the file name is the same.
  Create the $(DBUSPOLICYDIR) and $(DESTDIR)/etc/init.d directories by
  using the "-D" option to "install".  Don't check if the $(SYSTEMD)
  directory exists; instead create it by using the "-D" option to
  "install".  Create the $(DESTDIR)/etc/default and $(MANDIR)/man8
  directories by using the "-D" option to "install".  Create the
  $(MANDIR)/man5 directories explicitly.
  (install-client-nokey): Remove unnecessary creation of the
  $(CONFDIR) directory.  Don't check if the $(SYSUSERS) directory
  exists; instead create it by using the "-D" option to "install".
  Move the "--directory" argument to be the first argument, for
  clarity.  Create the $(PREFIX)/sbin directory.  Use the "-D"
  argument to "install" when installing
  $(INITRAMFSTOOLS)/hooks/mandos,
  $(INITRAMFSTOOLS)/conf.d/mandos-conf,
  $(INITRAMFSTOOLS)/conf-hooks.d/zz-mandos,
  $(INITRAMFSTOOLS)/scripts/init-premount/mandos,
  $(INITRAMFSTOOLS)/scripts/local-premount/mandos,
  $(DRACUTMODULE)/ask-password-mandos.path, and
  $(DRACUTMODULE)/dracut-module/ask-password-mandos.service.  Create
  the $(MANDIR)/man8 directory.

Reported-By: Erich Eckner <erich@eckner.net>
Thanks: Erich Eckner <erich@eckner.net> for analysis

Show diffs side-by-side

added added

removed removed

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