/mandos/release

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2024-09-09 04:24:39 UTC
  • mto: This revision was merged to the branch mainline in revision 410.
  • Revision ID: teddy@recompile.se-20240909042439-j85mr20uli2hnyis
Eliminate compiler warnings

Many programs use nested functions, which now result in a linker
warning about executable stack.  Hide this warning.  Also, rewrite a
loop in the plymouth plugin to avoid warning about signed overflow.
This change also makes the plugin pick the alphabetically first
process entry instead of the last, in case many plymouth processes are
found (which should be unlikely).

* Makefile (plugin-runner, dracut-module/password-agent,
  plugins.d/password-prompt, plugins.d/mandos-client,
  plugins.d/plymouth): New target; set LDFLAGS to add "-Xlinker
  --no-warn-execstack".
* plugins.d/plymouth.c (get_pid): When no pid files are found, and we
  are looking through the process list, go though it from the start
  instead of from the end, i.e. in normal alphabetical order and not
  in reverse order.

Show diffs side-by-side

added added

removed removed

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