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