/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2024-09-09 01:36:41 UTC
  • Revision ID: teddy@recompile.se-20240909013641-6zu6kx2f7meu134k
Make all required directories when installing

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

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2008-2011 Teddy Hogeborn
6
 
 * Copyright © 2008-2011 Björn Påhlsson
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
 
5
 * Copyright © 2008-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2022 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
27
                                   getline(), asprintf(), O_CLOEXEC,
 
28
                                   scandirat(), pipe2() */
 
29
#include <argp.h>               /* argp_program_version,
 
30
                                   argp_program_bug_address,
 
31
                                   struct argp_option,
 
32
                                   struct argp_state, argp_error(),
 
33
                                   ARGP_NO_EXIT, argp_state_help,
 
34
                                   ARGP_HELP_STD_HELP,
 
35
                                   ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
 
36
                                   ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
 
37
                                   struct argp, argp_parse(),
 
38
                                   ARGP_IN_ORDER, ARGP_NO_HELP */
 
39
#include <stdbool.h>            /* bool, false, true */
 
40
#include <sys/types.h>          /* pid_t, sig_atomic_t, uid_t, gid_t,
 
41
                                   getuid(), setgid(), setuid() */
27
42
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
 
                                   realloc() */
30
 
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
38
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
44
 
#include <iso646.h>             /* and, or, not */
45
 
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
46
 
                                   readdir(), closedir(), dirfd() */
47
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
48
 
                                   fcntl(), setuid(), setgid(),
49
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
50
 
                                   access(), pipe(), fork(), close()
51
 
                                   dup2(), STDOUT_FILENO, _exit(),
52
 
                                   execv(), write(), read(),
53
 
                                   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() */
54
63
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
58
 
#include <errno.h>              /* errno */
59
 
#include <argp.h>               /* struct argp_option, struct
60
 
                                   argp_state, struct argp,
61
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
62
 
                                   ARGP_KEY_END, ARGP_KEY_ARG,
63
 
                                   error_t */
64
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
65
 
                                   sigaddset(), sigaction(),
66
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
67
 
                                   SIG_UNBLOCK, kill(), sig_atomic_t
68
 
                                */
69
 
#include <errno.h>              /* errno, EBADF */
70
 
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
 
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 */
71
84
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
72
85
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
 
#include <errno.h>              /* errno */
74
 
#include <error.h>              /* error() */
 
86
#include <inttypes.h>           /* intmax_t, strtoimax(), PRIdMAX */
 
87
#include <fnmatch.h>            /* fnmatch(), FNM_FILE_NAME,
 
88
                                   FNM_PERIOD, FNM_NOMATCH */
75
89
 
76
90
#define BUFFER_SIZE 256
77
91
 
78
92
#define PDIR "/lib/mandos/plugins.d"
 
93
#define PHDIR "/lib/mandos/plugin-helpers"
79
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
95
 
81
96
const char *argp_program_version = "plugin-runner " VERSION;
105
120
 
106
121
/* Gets an existing plugin based on name,
107
122
   or if none is found, creates a new one */
 
123
__attribute__((warn_unused_result))
108
124
static plugin *getplugin(char *name){
109
125
  /* Check for existing plugin with that name */
110
126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
171
187
}
172
188
 
173
189
/* Helper function for add_argument and add_environment */
 
190
__attribute__((nonnull, warn_unused_result))
174
191
static bool add_to_char_array(const char *new, char ***array,
175
192
                              int *len){
176
193
  /* Resize the pointed-to array to hold one more pointer */
 
194
  char **new_array = NULL;
177
195
  do {
178
 
    *array = realloc(*array, sizeof(char *)
179
 
                     * (size_t) ((*len) + 2));
180
 
  } while(*array == NULL and errno == EINTR);
 
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);
181
210
  /* Malloc check */
182
 
  if(*array == NULL){
 
211
  if(new_array == NULL){
183
212
    return false;
184
213
  }
 
214
  *array = new_array;
185
215
  /* Make a copy of the new string */
186
216
  char *copy;
187
217
  do {
199
229
}
200
230
 
201
231
/* Add to a plugin's argument vector */
 
232
__attribute__((nonnull(2), warn_unused_result))
202
233
static bool add_argument(plugin *p, const char *arg){
203
234
  if(p == NULL){
204
235
    return false;
207
238
}
208
239
 
209
240
/* Add to a plugin's environment */
 
241
__attribute__((nonnull(2), warn_unused_result))
210
242
static bool add_environment(plugin *p, const char *def, bool replace){
211
243
  if(p == NULL){
212
244
    return false;
214
246
  /* namelen = length of name of environment variable */
215
247
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
216
248
  /* Search for this environment variable */
217
 
  for(char **e = p->environ; *e != NULL; e++){
218
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
249
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
250
    if(strncmp(*envdef, def, namelen + 1) == 0){
219
251
      /* It already exists */
220
252
      if(replace){
221
 
        char *new;
 
253
        char *new_envdef;
222
254
        do {
223
 
          new = realloc(*e, strlen(def) + 1);
224
 
        } while(new == NULL and errno == EINTR);
225
 
        if(new == NULL){
 
255
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
256
        } while(new_envdef == NULL and errno == EINTR);
 
257
        if(new_envdef == NULL){
226
258
          return false;
227
259
        }
228
 
        *e = new;
229
 
        strcpy(*e, def);
 
260
        *envdef = new_envdef;
 
261
        strcpy(*envdef, def);
230
262
      }
231
263
      return true;
232
264
    }
234
266
  return add_to_char_array(def, &(p->environ), &(p->envc));
235
267
}
236
268
 
 
269
#ifndef O_CLOEXEC
237
270
/*
238
271
 * Based on the example in the GNU LibC manual chapter 13.13 "File
239
272
 * Descriptor Flags".
240
273
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
241
274
 */
 
275
__attribute__((warn_unused_result))
242
276
static int set_cloexec_flag(int fd){
243
277
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
244
278
  /* If reading the flags failed, return error indication now. */
249
283
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
250
284
                                       ret | FD_CLOEXEC));
251
285
}
 
286
#endif  /* not O_CLOEXEC */
252
287
 
253
288
 
254
289
/* Mark processes as completed when they exit, and save their exit
286
321
}
287
322
 
288
323
/* Prints out a password to stdout */
 
324
__attribute__((nonnull, warn_unused_result))
289
325
static bool print_out_password(const char *buffer, size_t length){
290
326
  ssize_t ret;
291
327
  for(size_t written = 0; written < length; written += (size_t)ret){
299
335
}
300
336
 
301
337
/* Removes and free a plugin from the plugin list */
 
338
__attribute__((nonnull))
302
339
static void free_plugin(plugin *plugin_node){
303
340
  
304
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
305
342
    free(*arg);
306
343
  }
 
344
  free(plugin_node->name);
307
345
  free(plugin_node->argv);
308
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
309
347
    free(*env);
336
374
 
337
375
int main(int argc, char *argv[]){
338
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
339
378
  char *argfile = NULL;
340
379
  FILE *conffp;
341
 
  size_t d_name_len;
342
 
  DIR *dir = NULL;
343
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
344
381
  struct stat st;
345
382
  fd_set rfds_all;
346
383
  int ret, maxfd = 0;
354
391
                                      .sa_flags = SA_NOCLDSTOP };
355
392
  char **custom_argv = NULL;
356
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
357
395
  
358
396
  /* Establish a signal handler */
359
397
  sigemptyset(&sigchld_action.sa_mask);
404
442
      .doc = "Group ID the plugins will run as", .group = 3 },
405
443
    { .name = "debug", .key = 132,
406
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 },
407
449
    /*
408
450
     * These reproduce what we would get without ARGP_NO_HELP
409
451
     */
416
458
    { .name = NULL }
417
459
  };
418
460
  
 
461
  __attribute__((nonnull(3)))
419
462
  error_t parse_opt(int key, char *arg, struct argp_state *state){
420
463
    errno = 0;
421
464
    switch(key){
422
465
      char *tmp;
423
 
      intmax_t tmpmax;
 
466
      intmax_t tmp_id;
424
467
    case 'g':                   /* --global-options */
425
468
      {
426
469
        char *plugin_option;
429
472
            break;
430
473
          }
431
474
        }
 
475
        errno = 0;
432
476
      }
433
477
      break;
434
478
    case 'G':                   /* --global-env */
435
 
      add_environment(getplugin(NULL), arg, true);
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
 
481
      }
436
482
      break;
437
483
    case 'o':                   /* --options-for */
438
484
      {
455
501
            break;
456
502
          }
457
503
        }
 
504
        errno = 0;
458
505
      }
459
506
      break;
460
507
    case 'E':                   /* --env-for */
472
519
          errno = EINVAL;
473
520
          break;
474
521
        }
475
 
        add_environment(getplugin(arg), envdef, true);
 
522
        if(add_environment(getplugin(arg), envdef, true)){
 
523
          errno = 0;
 
524
        }
476
525
      }
477
526
      break;
478
527
    case 'd':                   /* --disable */
480
529
        plugin *p = getplugin(arg);
481
530
        if(p != NULL){
482
531
          p->disabled = true;
 
532
          errno = 0;
483
533
        }
484
534
      }
485
535
      break;
488
538
        plugin *p = getplugin(arg);
489
539
        if(p != NULL){
490
540
          p->disabled = false;
 
541
          errno = 0;
491
542
        }
492
543
      }
493
544
      break;
494
545
    case 128:                   /* --plugin-dir */
495
546
      free(plugindir);
496
547
      plugindir = strdup(arg);
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
497
551
      break;
498
552
    case 129:                   /* --config-file */
499
553
      /* This is already done by parse_opt_config_file() */
500
554
      break;
501
555
    case 130:                   /* --userid */
502
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
556
      tmp_id = strtoimax(arg, &tmp, 10);
503
557
      if(errno != 0 or tmp == arg or *tmp != '\0'
504
 
         or tmpmax != (uid_t)tmpmax){
 
558
         or tmp_id != (uid_t)tmp_id){
505
559
        argp_error(state, "Bad user ID number: \"%s\", using %"
506
560
                   PRIdMAX, arg, (intmax_t)uid);
507
561
        break;
508
562
      }
509
 
      uid = (uid_t)tmpmax;
 
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
510
565
      break;
511
566
    case 131:                   /* --groupid */
512
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
567
      tmp_id = strtoimax(arg, &tmp, 10);
513
568
      if(errno != 0 or tmp == arg or *tmp != '\0'
514
 
         or tmpmax != (gid_t)tmpmax){
 
569
         or tmp_id != (gid_t)tmp_id){
515
570
        argp_error(state, "Bad group ID number: \"%s\", using %"
516
571
                   PRIdMAX, arg, (intmax_t)gid);
517
572
        break;
518
573
      }
519
 
      gid = (gid_t)tmpmax;
 
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
520
576
      break;
521
577
    case 132:                   /* --debug */
522
578
      debug = true;
523
579
      break;
 
580
    case 133:                   /* --plugin-helper-dir */
 
581
      free(pluginhelperdir);
 
582
      pluginhelperdir = strdup(arg);
 
583
      if(pluginhelperdir != NULL){
 
584
        errno = 0;
 
585
      }
 
586
      break;
524
587
      /*
525
588
       * These reproduce what we would get without ARGP_NO_HELP
526
589
       */
527
590
    case '?':                   /* --help */
528
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
530
594
    case -3:                    /* --usage */
531
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
532
596
      argp_state_help(state, state->out_stream,
533
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
534
599
    case 'V':                   /* --version */
535
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
536
601
      exit(EXIT_SUCCESS);
546
611
      if(arg[0] == '\0'){
547
612
        break;
548
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
549
619
    default:
550
620
      return ARGP_ERR_UNKNOWN;
551
621
    }
570
640
    case 129:                   /* --config-file */
571
641
      free(argfile);
572
642
      argfile = strdup(arg);
 
643
      if(argfile != NULL){
 
644
        errno = 0;
 
645
      }
573
646
      break;
574
647
    case 130:                   /* --userid */
575
648
    case 131:                   /* --groupid */
576
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
577
651
    case '?':                   /* --help */
578
652
    case -3:                    /* --usage */
579
653
    case 'V':                   /* --version */
658
732
        }
659
733
        
660
734
        custom_argc += 1;
661
 
        custom_argv = realloc(custom_argv, sizeof(char *)
662
 
                              * ((unsigned int) custom_argc + 1));
663
 
        if(custom_argv == NULL){
664
 
          error(0, errno, "realloc");
665
 
          exitstatus = EX_OSERR;
666
 
          free(org_line);
667
 
          goto fallback;
 
735
        {
 
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
737
          char **new_argv = reallocarray(custom_argv,
 
738
                                         (size_t)custom_argc + 1,
 
739
                                         sizeof(char *));
 
740
#else
 
741
          char **new_argv = NULL;
 
742
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
743
            /* overflow */
 
744
            errno = ENOMEM;
 
745
          } else {
 
746
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
747
                               * sizeof(char *));
 
748
          }
 
749
#endif
 
750
          if(new_argv == NULL){
 
751
            error(0, errno, "reallocarray");
 
752
            exitstatus = EX_OSERR;
 
753
            free(new_arg);
 
754
            free(org_line);
 
755
            goto fallback;
 
756
          } else {
 
757
            custom_argv = new_argv;
 
758
          }
668
759
        }
669
760
        custom_argv[custom_argc-1] = new_arg;
670
761
        custom_argv[custom_argc] = NULL;
728
819
    goto fallback;
729
820
  }
730
821
  
 
822
  {
 
823
    char *pluginhelperenv;
 
824
    bool bret = true;
 
825
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
826
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
827
    if(ret != -1){
 
828
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
829
    }
 
830
    if(ret == -1 or not bret){
 
831
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
832
            " environment variable to \"%s\" for all plugins\n",
 
833
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
834
    }
 
835
    if(ret != -1){
 
836
      free(pluginhelperenv);
 
837
    }
 
838
  }
 
839
  
731
840
  if(debug){
732
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
841
    for(plugin *p = plugin_list; p != NULL; p = p->next){
733
842
      fprintf(stderr, "Plugin: %s has %d arguments\n",
734
843
              p->name ? p->name : "Global", p->argc - 1);
735
844
      for(char **a = p->argv; *a != NULL; a++){
744
853
  
745
854
  if(getuid() == 0){
746
855
    /* Work around Debian bug #633582:
747
 
       <http://bugs.debian.org/633582> */
 
856
       <https://bugs.debian.org/633582> */
748
857
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
749
858
    if(plugindir_fd == -1){
750
 
      error(0, errno, "open");
 
859
      if(errno != ENOENT){
 
860
        error(0, errno, "open(\"" PDIR "\")");
 
861
      }
751
862
    } else {
752
863
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
753
864
      if(ret == -1){
760
871
          }
761
872
        }
762
873
      }
763
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
874
      close(plugindir_fd);
 
875
    }
 
876
 
 
877
    /* Work around Debian bug #981302
 
878
       <https://bugs.debian.org/981302> */
 
879
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
880
      ret = symlink("/proc/self/fd", "/dev/fd");
 
881
      if(ret == -1){
 
882
        error(0, errno, "Failed to create /dev/fd symlink");
 
883
      }
764
884
    }
765
885
  }
766
886
  
767
887
  /* Lower permissions */
768
 
  setgid(gid);
 
888
  ret = setgid(gid);
769
889
  if(ret == -1){
770
890
    error(0, errno, "setgid");
771
891
  }
776
896
  
777
897
  /* Open plugin directory with close_on_exec flag */
778
898
  {
779
 
    int dir_fd = -1;
780
 
    if(plugindir == NULL){
781
 
      dir_fd = open(PDIR, O_RDONLY |
782
 
#ifdef O_CLOEXEC
783
 
                    O_CLOEXEC
784
 
#else  /* not O_CLOEXEC */
785
 
                    0
786
 
#endif  /* not O_CLOEXEC */
787
 
                    );
788
 
    } else {
789
 
      dir_fd = open(plugindir, O_RDONLY |
790
 
#ifdef O_CLOEXEC
791
 
                    O_CLOEXEC
792
 
#else  /* not O_CLOEXEC */
793
 
                    0
794
 
#endif  /* not O_CLOEXEC */
795
 
                    );
796
 
    }
 
899
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
900
#ifdef O_CLOEXEC
 
901
                  O_CLOEXEC
 
902
#else  /* not O_CLOEXEC */
 
903
                  0
 
904
#endif  /* not O_CLOEXEC */
 
905
                  );
797
906
    if(dir_fd == -1){
798
907
      error(0, errno, "Could not open plugin dir");
799
908
      exitstatus = EX_UNAVAILABLE;
805
914
    ret = set_cloexec_flag(dir_fd);
806
915
    if(ret < 0){
807
916
      error(0, errno, "set_cloexec_flag");
808
 
      TEMP_FAILURE_RETRY(close(dir_fd));
809
917
      exitstatus = EX_OSERR;
810
918
      goto fallback;
811
919
    }
812
920
#endif  /* O_CLOEXEC */
813
 
    
814
 
    dir = fdopendir(dir_fd);
815
 
    if(dir == NULL){
816
 
      error(0, errno, "Could not open plugin dir");
817
 
      TEMP_FAILURE_RETRY(close(dir_fd));
818
 
      exitstatus = EX_OSERR;
819
 
      goto fallback;
 
921
  }
 
922
  
 
923
  int good_name(const struct dirent * const dirent){
 
924
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
925
                                      "*.dpkg-old", "*.dpkg-bak",
 
926
                                      "*.dpkg-divert", NULL };
 
927
#ifdef __GNUC__
 
928
#pragma GCC diagnostic push
 
929
#pragma GCC diagnostic ignored "-Wcast-qual"
 
930
#endif
 
931
    for(const char **pat = (const char **)patterns;
 
932
        *pat != NULL; pat++){
 
933
#ifdef __GNUC__
 
934
#pragma GCC diagnostic pop
 
935
#endif
 
936
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
937
         != FNM_NOMATCH){
 
938
        if(debug){
 
939
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
940
                    " matching pattern %s\n", dirent->d_name, *pat);
 
941
        }
 
942
        return 0;
 
943
      }
820
944
    }
 
945
    return 1;
 
946
  }
 
947
  
 
948
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
949
                             alphasort);
 
950
  if(numplugins == -1){
 
951
    error(0, errno, "Could not scan plugin dir");
 
952
    direntries = NULL;
 
953
    exitstatus = EX_OSERR;
 
954
    goto fallback;
821
955
  }
822
956
  
823
957
  FD_ZERO(&rfds_all);
824
958
  
825
959
  /* Read and execute any executable in the plugin directory*/
826
 
  while(true){
827
 
    do {
828
 
      dirst = readdir(dir);
829
 
    } while(dirst == NULL and errno == EINTR);
830
 
    
831
 
    /* All directory entries have been processed */
832
 
    if(dirst == NULL){
833
 
      if(errno == EBADF){
834
 
        error(0, errno, "readdir");
835
 
        exitstatus = EX_IOERR;
836
 
        goto fallback;
837
 
      }
838
 
      break;
839
 
    }
840
 
    
841
 
    d_name_len = strlen(dirst->d_name);
842
 
    
843
 
    /* Ignore dotfiles, backup files and other junk */
844
 
    {
845
 
      bool bad_name = false;
846
 
      
847
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
848
 
      
849
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
850
 
                                           ".dpkg-old",
851
 
                                           ".dpkg-bak",
852
 
                                           ".dpkg-divert", NULL };
853
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
854
 
        size_t pre_len = strlen(*pre);
855
 
        if((d_name_len >= pre_len)
856
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
857
 
          if(debug){
858
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
859
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
860
 
          }
861
 
          bad_name = true;
862
 
          break;
863
 
        }
864
 
      }
865
 
      if(bad_name){
866
 
        continue;
867
 
      }
868
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
869
 
        size_t suf_len = strlen(*suf);
870
 
        if((d_name_len >= suf_len)
871
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
872
 
                == 0)){
873
 
          if(debug){
874
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
875
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
876
 
          }
877
 
          bad_name = true;
878
 
          break;
879
 
        }
880
 
      }
881
 
      
882
 
      if(bad_name){
883
 
        continue;
884
 
      }
885
 
    }
886
 
    
887
 
    char *filename;
888
 
    if(plugindir == NULL){
889
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
890
 
                                             dirst->d_name));
891
 
    } else {
892
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
893
 
                                             plugindir,
894
 
                                             dirst->d_name));
895
 
    }
896
 
    if(ret < 0){
897
 
      error(0, errno, "asprintf");
 
960
  for(int i = 0; i < numplugins; i++){
 
961
    
 
962
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
963
    if(plugin_fd == -1){
 
964
      error(0, errno, "Could not open plugin");
 
965
      free(direntries[i]);
898
966
      continue;
899
967
    }
900
 
    
901
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
968
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
902
969
    if(ret == -1){
903
970
      error(0, errno, "stat");
904
 
      free(filename);
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
905
973
      continue;
906
974
    }
907
975
    
908
976
    /* Ignore non-executable files */
909
977
    if(not S_ISREG(st.st_mode)
910
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
978
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
979
                                        X_OK, 0)) != 0)){
911
980
      if(debug){
912
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
913
 
                " with bad type or mode\n", filename);
 
981
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
982
                " with bad type or mode\n",
 
983
                plugindir != NULL ? plugindir : PDIR,
 
984
                direntries[i]->d_name);
914
985
      }
915
 
      free(filename);
 
986
      close(plugin_fd);
 
987
      free(direntries[i]);
916
988
      continue;
917
989
    }
918
990
    
919
 
    plugin *p = getplugin(dirst->d_name);
 
991
    plugin *p = getplugin(direntries[i]->d_name);
920
992
    if(p == NULL){
921
993
      error(0, errno, "getplugin");
922
 
      free(filename);
 
994
      close(plugin_fd);
 
995
      free(direntries[i]);
923
996
      continue;
924
997
    }
925
998
    if(p->disabled){
926
999
      if(debug){
927
1000
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
928
 
                dirst->d_name);
 
1001
                direntries[i]->d_name);
929
1002
      }
930
 
      free(filename);
 
1003
      close(plugin_fd);
 
1004
      free(direntries[i]);
931
1005
      continue;
932
1006
    }
933
1007
    {
947
1021
        }
948
1022
      }
949
1023
    }
950
 
    /* If this plugin has any environment variables, we will call
951
 
       using execve and need to duplicate the environment from this
952
 
       process, too. */
 
1024
    /* If this plugin has any environment variables, we need to
 
1025
       duplicate the environment from this process, too. */
953
1026
    if(p->environ[0] != NULL){
954
1027
      for(char **e = environ; *e != NULL; e++){
955
1028
        if(not add_environment(p, *e, false)){
959
1032
    }
960
1033
    
961
1034
    int pipefd[2];
 
1035
#ifndef O_CLOEXEC
962
1036
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1037
#else  /* O_CLOEXEC */
 
1038
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1039
#endif  /* O_CLOEXEC */
963
1040
    if(ret == -1){
964
1041
      error(0, errno, "pipe");
965
1042
      exitstatus = EX_OSERR;
966
 
      goto fallback;
967
 
    }
 
1043
      free(direntries[i]);
 
1044
      goto fallback;
 
1045
    }
 
1046
    if(pipefd[0] >= FD_SETSIZE){
 
1047
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1048
              FD_SETSIZE);
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
 
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
 
1053
      goto fallback;
 
1054
    }
 
1055
#ifndef O_CLOEXEC
968
1056
    /* Ask OS to automatic close the pipe on exec */
969
1057
    ret = set_cloexec_flag(pipefd[0]);
970
1058
    if(ret < 0){
971
1059
      error(0, errno, "set_cloexec_flag");
 
1060
      close(pipefd[0]);
 
1061
      close(pipefd[1]);
972
1062
      exitstatus = EX_OSERR;
 
1063
      free(direntries[i]);
973
1064
      goto fallback;
974
1065
    }
975
1066
    ret = set_cloexec_flag(pipefd[1]);
976
1067
    if(ret < 0){
977
1068
      error(0, errno, "set_cloexec_flag");
 
1069
      close(pipefd[0]);
 
1070
      close(pipefd[1]);
978
1071
      exitstatus = EX_OSERR;
 
1072
      free(direntries[i]);
979
1073
      goto fallback;
980
1074
    }
 
1075
#endif  /* not O_CLOEXEC */
981
1076
    /* Block SIGCHLD until process is safely in process list */
982
1077
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
983
1078
                                              &sigchld_action.sa_mask,
985
1080
    if(ret < 0){
986
1081
      error(0, errno, "sigprocmask");
987
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
988
1084
      goto fallback;
989
1085
    }
990
1086
    /* Starting a new process to be watched */
994
1090
    } while(pid == -1 and errno == EINTR);
995
1091
    if(pid == -1){
996
1092
      error(0, errno, "fork");
 
1093
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1094
                                     &sigchld_action.sa_mask, NULL));
 
1095
      close(pipefd[0]);
 
1096
      close(pipefd[1]);
997
1097
      exitstatus = EX_OSERR;
 
1098
      free(direntries[i]);
998
1099
      goto fallback;
999
1100
    }
1000
1101
    if(pid == 0){
1016
1117
        _exit(EX_OSERR);
1017
1118
      }
1018
1119
      
1019
 
      if(dirfd(dir) < 0){
1020
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1021
 
           above and must now close it manually here. */
1022
 
        closedir(dir);
1023
 
      }
1024
 
      if(p->environ[0] == NULL){
1025
 
        if(execv(filename, p->argv) < 0){
1026
 
          error(0, errno, "execv for %s", filename);
1027
 
          _exit(EX_OSERR);
1028
 
        }
1029
 
      } else {
1030
 
        if(execve(filename, p->argv, p->environ) < 0){
1031
 
          error(0, errno, "execve for %s", filename);
1032
 
          _exit(EX_OSERR);
1033
 
        }
 
1120
      if(fexecve(plugin_fd, p->argv,
 
1121
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1122
        error(0, errno, "fexecve for %s/%s",
 
1123
              plugindir != NULL ? plugindir : PDIR,
 
1124
              direntries[i]->d_name);
 
1125
        _exit(EX_OSERR);
1034
1126
      }
1035
1127
      /* no return */
1036
1128
    }
1037
1129
    /* Parent process */
1038
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1039
 
                                             pipe */
1040
 
    free(filename);
1041
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1130
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1131
    close(plugin_fd);
 
1132
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1042
1133
    if(new_plugin == NULL){
1043
1134
      error(0, errno, "getplugin");
1044
1135
      ret = (int)(TEMP_FAILURE_RETRY
1048
1139
        error(0, errno, "sigprocmask");
1049
1140
      }
1050
1141
      exitstatus = EX_OSERR;
 
1142
      free(direntries[i]);
1051
1143
      goto fallback;
1052
1144
    }
 
1145
    free(direntries[i]);
1053
1146
    
1054
1147
    new_plugin->pid = pid;
1055
1148
    new_plugin->fd = pipefd[0];
1056
 
    
 
1149
 
 
1150
    if(debug){
 
1151
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1152
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1153
    }
 
1154
 
1057
1155
    /* Unblock SIGCHLD so signal handler can be run if this process
1058
1156
       has already completed */
1059
1157
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1065
1163
      goto fallback;
1066
1164
    }
1067
1165
    
1068
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1069
 
                                          -Wconversion */
 
1166
    FD_SET(new_plugin->fd, &rfds_all);
1070
1167
    
1071
1168
    if(maxfd < new_plugin->fd){
1072
1169
      maxfd = new_plugin->fd;
1073
1170
    }
1074
1171
  }
1075
1172
  
1076
 
  TEMP_FAILURE_RETRY(closedir(dir));
1077
 
  dir = NULL;
 
1173
  free(direntries);
 
1174
  direntries = NULL;
 
1175
  close(dir_fd);
 
1176
  dir_fd = -1;
1078
1177
  free_plugin(getplugin(NULL));
1079
1178
  
1080
1179
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1119
1218
                      (intmax_t) (proc->pid),
1120
1219
                      WTERMSIG(proc->status),
1121
1220
                      strsignal(WTERMSIG(proc->status)));
1122
 
            } else if(WCOREDUMP(proc->status)){
1123
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1124
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1125
1221
            }
1126
1222
          }
1127
1223
          
1128
1224
          /* Remove the plugin */
1129
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1130
 
                                          -Wconversion */
 
1225
          FD_CLR(proc->fd, &rfds_all);
1131
1226
          
1132
1227
          /* Block signal while modifying process_list */
1133
1228
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1173
1268
      }
1174
1269
      
1175
1270
      /* This process has not completed.  Does it have any output? */
1176
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1177
 
                                                         warning from
1178
 
                                                         -Wconversion */
 
1271
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1179
1272
        /* This process had nothing to say at this time */
1180
1273
        proc = proc->next;
1181
1274
        continue;
1182
1275
      }
1183
1276
      /* Before reading, make the process' data buffer large enough */
1184
1277
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1185
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1186
 
                               + (size_t) BUFFER_SIZE);
1187
 
        if(proc->buffer == NULL){
 
1278
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1279
                                   + (size_t) BUFFER_SIZE);
 
1280
        if(new_buffer == NULL){
1188
1281
          error(0, errno, "malloc");
1189
1282
          exitstatus = EX_OSERR;
1190
1283
          goto fallback;
1191
1284
        }
 
1285
        proc->buffer = new_buffer;
1192
1286
        proc->buffer_size += BUFFER_SIZE;
1193
1287
      }
1194
1288
      /* Read from the process */
1247
1341
    free(custom_argv);
1248
1342
  }
1249
1343
  
1250
 
  if(dir != NULL){
1251
 
    closedir(dir);
 
1344
  free(direntries);
 
1345
  
 
1346
  if(dir_fd != -1){
 
1347
    close(dir_fd);
1252
1348
  }
1253
1349
  
1254
1350
  /* Kill the processes */
1274
1370
  free_plugin_list();
1275
1371
  
1276
1372
  free(plugindir);
 
1373
  free(pluginhelperdir);
1277
1374
  free(argfile);
1278
1375
  
1279
1376
  return exitstatus;