/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: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

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