/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: 2021-02-03 23:10:42 UTC
  • Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues

The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server.  But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing.  Fix this.

In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).

Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.

* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
  original "clients" dict, and loop over those instead.  Add assertion
  that all clients were indeed removed.  Also fix the code which looks
  for the Remove command, which now needs to actually work.
  (TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
  assertion that there are still clients before looping over them.
  (TestPropertySetterCmd.runTest): Add assertion that the list of
  values to get is not empty before looping over them.  Also add check
  that there are still clients before looping over clients.

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