/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2021-02-04 17:59:45 UTC
  • Revision ID: teddy@recompile.se-20210204175945-8druo6d88ipc1z58
Fix issue with french translation

Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation.  The string is a raw key id, and therefore did not need
translation, so this was never a user-visible issue.

* debian/po/fr.po: Add missing whitespace to the id and translation
  for msgid " ${key_id}".

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-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 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-2021 Teddy Hogeborn
 
6
 * Copyright © 2008-2021 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), 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;
82
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
83
98
 
84
99
typedef struct plugin{
85
100
  char *name;                   /* can be NULL or any plugin name */
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, (size_t)custom_argc + 1,
 
738
                                         sizeof(char *));
 
739
#else
 
740
          char **new_argv = NULL;
 
741
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
742
            /* overflow */
 
743
            errno = ENOMEM;
 
744
          } else {
 
745
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
746
                               * sizeof(char *));
 
747
          }
 
748
#endif
 
749
          if(new_argv == NULL){
 
750
            error(0, errno, "reallocarray");
 
751
            exitstatus = EX_OSERR;
 
752
            free(new_arg);
 
753
            free(org_line);
 
754
            goto fallback;
 
755
          } else {
 
756
            custom_argv = new_argv;
 
757
          }
668
758
        }
669
759
        custom_argv[custom_argc-1] = new_arg;
670
760
        custom_argv[custom_argc] = NULL;
728
818
    goto fallback;
729
819
  }
730
820
  
 
821
  {
 
822
    char *pluginhelperenv;
 
823
    bool bret = true;
 
824
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
825
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
826
    if(ret != -1){
 
827
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
828
    }
 
829
    if(ret == -1 or not bret){
 
830
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
831
            " environment variable to \"%s\" for all plugins\n",
 
832
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
833
    }
 
834
    if(ret != -1){
 
835
      free(pluginhelperenv);
 
836
    }
 
837
  }
 
838
  
731
839
  if(debug){
732
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
840
    for(plugin *p = plugin_list; p != NULL; p = p->next){
733
841
      fprintf(stderr, "Plugin: %s has %d arguments\n",
734
842
              p->name ? p->name : "Global", p->argc - 1);
735
843
      for(char **a = p->argv; *a != NULL; a++){
742
850
    }
743
851
  }
744
852
  
745
 
  {
 
853
  if(getuid() == 0){
746
854
    /* Work around Debian bug #633582:
747
 
       <http://bugs.debian.org/633582> */
 
855
       <https://bugs.debian.org/633582> */
748
856
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
749
857
    if(plugindir_fd == -1){
750
 
      error(0, errno, "open");
 
858
      if(errno != ENOENT){
 
859
        error(0, errno, "open(\"" PDIR "\")");
 
860
      }
751
861
    } else {
752
862
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
753
863
      if(ret == -1){
760
870
          }
761
871
        }
762
872
      }
763
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
873
      close(plugindir_fd);
 
874
    }
 
875
 
 
876
    /* Work around Debian bug #981302
 
877
       <https://bugs.debian.org/981302> */
 
878
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
879
      ret = symlink("/proc/self/fd", "/dev/fd");
 
880
      if(ret == -1){
 
881
        error(0, errno, "Failed to create /dev/fd symlink");
 
882
      }
764
883
    }
765
884
  }
766
885
  
767
886
  /* Lower permissions */
768
 
  setgid(gid);
 
887
  ret = setgid(gid);
769
888
  if(ret == -1){
770
889
    error(0, errno, "setgid");
771
890
  }
776
895
  
777
896
  /* Open plugin directory with close_on_exec flag */
778
897
  {
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
 
    }
 
898
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
899
#ifdef O_CLOEXEC
 
900
                  O_CLOEXEC
 
901
#else  /* not O_CLOEXEC */
 
902
                  0
 
903
#endif  /* not O_CLOEXEC */
 
904
                  );
797
905
    if(dir_fd == -1){
798
906
      error(0, errno, "Could not open plugin dir");
799
907
      exitstatus = EX_UNAVAILABLE;
805
913
    ret = set_cloexec_flag(dir_fd);
806
914
    if(ret < 0){
807
915
      error(0, errno, "set_cloexec_flag");
808
 
      TEMP_FAILURE_RETRY(close(dir_fd));
809
916
      exitstatus = EX_OSERR;
810
917
      goto fallback;
811
918
    }
812
919
#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;
 
920
  }
 
921
  
 
922
  int good_name(const struct dirent * const dirent){
 
923
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
924
                                      "*.dpkg-old", "*.dpkg-bak",
 
925
                                      "*.dpkg-divert", NULL };
 
926
#ifdef __GNUC__
 
927
#pragma GCC diagnostic push
 
928
#pragma GCC diagnostic ignored "-Wcast-qual"
 
929
#endif
 
930
    for(const char **pat = (const char **)patterns;
 
931
        *pat != NULL; pat++){
 
932
#ifdef __GNUC__
 
933
#pragma GCC diagnostic pop
 
934
#endif
 
935
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
936
         != FNM_NOMATCH){
 
937
        if(debug){
 
938
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
939
                    " matching pattern %s\n", dirent->d_name, *pat);
 
940
        }
 
941
        return 0;
 
942
      }
820
943
    }
 
944
    return 1;
 
945
  }
 
946
  
 
947
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
948
                             alphasort);
 
949
  if(numplugins == -1){
 
950
    error(0, errno, "Could not scan plugin dir");
 
951
    direntries = NULL;
 
952
    exitstatus = EX_OSERR;
 
953
    goto fallback;
821
954
  }
822
955
  
823
956
  FD_ZERO(&rfds_all);
824
957
  
825
958
  /* 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");
 
959
  for(int i = 0; i < numplugins; i++){
 
960
    
 
961
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
962
    if(plugin_fd == -1){
 
963
      error(0, errno, "Could not open plugin");
 
964
      free(direntries[i]);
898
965
      continue;
899
966
    }
900
 
    
901
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
967
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
902
968
    if(ret == -1){
903
969
      error(0, errno, "stat");
904
 
      free(filename);
 
970
      close(plugin_fd);
 
971
      free(direntries[i]);
905
972
      continue;
906
973
    }
907
974
    
908
975
    /* Ignore non-executable files */
909
976
    if(not S_ISREG(st.st_mode)
910
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
977
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
978
                                        X_OK, 0)) != 0)){
911
979
      if(debug){
912
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
913
 
                " with bad type or mode\n", filename);
 
980
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
981
                " with bad type or mode\n",
 
982
                plugindir != NULL ? plugindir : PDIR,
 
983
                direntries[i]->d_name);
914
984
      }
915
 
      free(filename);
 
985
      close(plugin_fd);
 
986
      free(direntries[i]);
916
987
      continue;
917
988
    }
918
989
    
919
 
    plugin *p = getplugin(dirst->d_name);
 
990
    plugin *p = getplugin(direntries[i]->d_name);
920
991
    if(p == NULL){
921
992
      error(0, errno, "getplugin");
922
 
      free(filename);
 
993
      close(plugin_fd);
 
994
      free(direntries[i]);
923
995
      continue;
924
996
    }
925
997
    if(p->disabled){
926
998
      if(debug){
927
999
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
928
 
                dirst->d_name);
 
1000
                direntries[i]->d_name);
929
1001
      }
930
 
      free(filename);
 
1002
      close(plugin_fd);
 
1003
      free(direntries[i]);
931
1004
      continue;
932
1005
    }
933
1006
    {
947
1020
        }
948
1021
      }
949
1022
    }
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. */
 
1023
    /* If this plugin has any environment variables, we need to
 
1024
       duplicate the environment from this process, too. */
953
1025
    if(p->environ[0] != NULL){
954
1026
      for(char **e = environ; *e != NULL; e++){
955
1027
        if(not add_environment(p, *e, false)){
959
1031
    }
960
1032
    
961
1033
    int pipefd[2];
 
1034
#ifndef O_CLOEXEC
962
1035
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1036
#else  /* O_CLOEXEC */
 
1037
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1038
#endif  /* O_CLOEXEC */
963
1039
    if(ret == -1){
964
1040
      error(0, errno, "pipe");
965
1041
      exitstatus = EX_OSERR;
966
 
      goto fallback;
967
 
    }
 
1042
      free(direntries[i]);
 
1043
      goto fallback;
 
1044
    }
 
1045
    if(pipefd[0] >= FD_SETSIZE){
 
1046
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1047
              FD_SETSIZE);
 
1048
      close(pipefd[0]);
 
1049
      close(pipefd[1]);
 
1050
      exitstatus = EX_OSERR;
 
1051
      free(direntries[i]);
 
1052
      goto fallback;
 
1053
    }
 
1054
#ifndef O_CLOEXEC
968
1055
    /* Ask OS to automatic close the pipe on exec */
969
1056
    ret = set_cloexec_flag(pipefd[0]);
970
1057
    if(ret < 0){
971
1058
      error(0, errno, "set_cloexec_flag");
 
1059
      close(pipefd[0]);
 
1060
      close(pipefd[1]);
972
1061
      exitstatus = EX_OSERR;
 
1062
      free(direntries[i]);
973
1063
      goto fallback;
974
1064
    }
975
1065
    ret = set_cloexec_flag(pipefd[1]);
976
1066
    if(ret < 0){
977
1067
      error(0, errno, "set_cloexec_flag");
 
1068
      close(pipefd[0]);
 
1069
      close(pipefd[1]);
978
1070
      exitstatus = EX_OSERR;
 
1071
      free(direntries[i]);
979
1072
      goto fallback;
980
1073
    }
 
1074
#endif  /* not O_CLOEXEC */
981
1075
    /* Block SIGCHLD until process is safely in process list */
982
1076
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
983
1077
                                              &sigchld_action.sa_mask,
985
1079
    if(ret < 0){
986
1080
      error(0, errno, "sigprocmask");
987
1081
      exitstatus = EX_OSERR;
 
1082
      free(direntries[i]);
988
1083
      goto fallback;
989
1084
    }
990
1085
    /* Starting a new process to be watched */
994
1089
    } while(pid == -1 and errno == EINTR);
995
1090
    if(pid == -1){
996
1091
      error(0, errno, "fork");
 
1092
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1093
                                     &sigchld_action.sa_mask, NULL));
 
1094
      close(pipefd[0]);
 
1095
      close(pipefd[1]);
997
1096
      exitstatus = EX_OSERR;
 
1097
      free(direntries[i]);
998
1098
      goto fallback;
999
1099
    }
1000
1100
    if(pid == 0){
1016
1116
        _exit(EX_OSERR);
1017
1117
      }
1018
1118
      
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
 
        }
 
1119
      if(fexecve(plugin_fd, p->argv,
 
1120
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1121
        error(0, errno, "fexecve for %s/%s",
 
1122
              plugindir != NULL ? plugindir : PDIR,
 
1123
              direntries[i]->d_name);
 
1124
        _exit(EX_OSERR);
1034
1125
      }
1035
1126
      /* no return */
1036
1127
    }
1037
1128
    /* 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);
 
1129
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1130
    close(plugin_fd);
 
1131
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1042
1132
    if(new_plugin == NULL){
1043
1133
      error(0, errno, "getplugin");
1044
1134
      ret = (int)(TEMP_FAILURE_RETRY
1048
1138
        error(0, errno, "sigprocmask");
1049
1139
      }
1050
1140
      exitstatus = EX_OSERR;
 
1141
      free(direntries[i]);
1051
1142
      goto fallback;
1052
1143
    }
 
1144
    free(direntries[i]);
1053
1145
    
1054
1146
    new_plugin->pid = pid;
1055
1147
    new_plugin->fd = pipefd[0];
1056
 
    
 
1148
 
 
1149
    if(debug){
 
1150
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1151
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1152
    }
 
1153
 
1057
1154
    /* Unblock SIGCHLD so signal handler can be run if this process
1058
1155
       has already completed */
1059
1156
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1065
1162
      goto fallback;
1066
1163
    }
1067
1164
    
1068
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1069
 
                                          -Wconversion */
 
1165
    FD_SET(new_plugin->fd, &rfds_all);
1070
1166
    
1071
1167
    if(maxfd < new_plugin->fd){
1072
1168
      maxfd = new_plugin->fd;
1073
1169
    }
1074
1170
  }
1075
1171
  
1076
 
  TEMP_FAILURE_RETRY(closedir(dir));
1077
 
  dir = NULL;
 
1172
  free(direntries);
 
1173
  direntries = NULL;
 
1174
  close(dir_fd);
 
1175
  dir_fd = -1;
1078
1176
  free_plugin(getplugin(NULL));
1079
1177
  
1080
1178
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1119
1217
                      (intmax_t) (proc->pid),
1120
1218
                      WTERMSIG(proc->status),
1121
1219
                      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
1220
            }
1126
1221
          }
1127
1222
          
1128
1223
          /* Remove the plugin */
1129
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1130
 
                                          -Wconversion */
 
1224
          FD_CLR(proc->fd, &rfds_all);
1131
1225
          
1132
1226
          /* Block signal while modifying process_list */
1133
1227
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1173
1267
      }
1174
1268
      
1175
1269
      /* 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 */
 
1270
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1179
1271
        /* This process had nothing to say at this time */
1180
1272
        proc = proc->next;
1181
1273
        continue;
1182
1274
      }
1183
1275
      /* Before reading, make the process' data buffer large enough */
1184
1276
      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){
 
1277
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1278
                                   + (size_t) BUFFER_SIZE);
 
1279
        if(new_buffer == NULL){
1188
1280
          error(0, errno, "malloc");
1189
1281
          exitstatus = EX_OSERR;
1190
1282
          goto fallback;
1191
1283
        }
 
1284
        proc->buffer = new_buffer;
1192
1285
        proc->buffer_size += BUFFER_SIZE;
1193
1286
      }
1194
1287
      /* Read from the process */
1247
1340
    free(custom_argv);
1248
1341
  }
1249
1342
  
1250
 
  if(dir != NULL){
1251
 
    closedir(dir);
 
1343
  free(direntries);
 
1344
  
 
1345
  if(dir_fd != -1){
 
1346
    close(dir_fd);
1252
1347
  }
1253
1348
  
1254
1349
  /* Kill the processes */
1274
1369
  free_plugin_list();
1275
1370
  
1276
1371
  free(plugindir);
 
1372
  free(pluginhelperdir);
1277
1373
  free(argfile);
1278
1374
  
1279
1375
  return exitstatus;