/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-2013 Teddy Hogeborn
6
 
 * Copyright © 2008-2013 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
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 */
174
 
__attribute__((nonnull))
 
190
__attribute__((nonnull, warn_unused_result))
175
191
static bool add_to_char_array(const char *new, char ***array,
176
192
                              int *len){
177
193
  /* Resize the pointed-to array to hold one more pointer */
 
194
  char **new_array = NULL;
178
195
  do {
179
 
    *array = realloc(*array, sizeof(char *)
180
 
                     * (size_t) ((*len) + 2));
181
 
  } 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);
182
210
  /* Malloc check */
183
 
  if(*array == NULL){
 
211
  if(new_array == NULL){
184
212
    return false;
185
213
  }
 
214
  *array = new_array;
186
215
  /* Make a copy of the new string */
187
216
  char *copy;
188
217
  do {
200
229
}
201
230
 
202
231
/* Add to a plugin's argument vector */
203
 
__attribute__((nonnull(2)))
 
232
__attribute__((nonnull(2), warn_unused_result))
204
233
static bool add_argument(plugin *p, const char *arg){
205
234
  if(p == NULL){
206
235
    return false;
209
238
}
210
239
 
211
240
/* Add to a plugin's environment */
212
 
__attribute__((nonnull(2)))
 
241
__attribute__((nonnull(2), warn_unused_result))
213
242
static bool add_environment(plugin *p, const char *def, bool replace){
214
243
  if(p == NULL){
215
244
    return false;
217
246
  /* namelen = length of name of environment variable */
218
247
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
248
  /* Search for this environment variable */
220
 
  for(char **e = p->environ; *e != NULL; e++){
221
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
249
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
250
    if(strncmp(*envdef, def, namelen + 1) == 0){
222
251
      /* It already exists */
223
252
      if(replace){
224
 
        char *new;
 
253
        char *new_envdef;
225
254
        do {
226
 
          new = realloc(*e, strlen(def) + 1);
227
 
        } while(new == NULL and errno == EINTR);
228
 
        if(new == NULL){
 
255
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
256
        } while(new_envdef == NULL and errno == EINTR);
 
257
        if(new_envdef == NULL){
229
258
          return false;
230
259
        }
231
 
        *e = new;
232
 
        strcpy(*e, def);
 
260
        *envdef = new_envdef;
 
261
        strcpy(*envdef, def);
233
262
      }
234
263
      return true;
235
264
    }
237
266
  return add_to_char_array(def, &(p->environ), &(p->envc));
238
267
}
239
268
 
 
269
#ifndef O_CLOEXEC
240
270
/*
241
271
 * Based on the example in the GNU LibC manual chapter 13.13 "File
242
272
 * Descriptor Flags".
243
273
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
244
274
 */
 
275
__attribute__((warn_unused_result))
245
276
static int set_cloexec_flag(int fd){
246
277
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
247
278
  /* If reading the flags failed, return error indication now. */
252
283
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
284
                                       ret | FD_CLOEXEC));
254
285
}
 
286
#endif  /* not O_CLOEXEC */
255
287
 
256
288
 
257
289
/* Mark processes as completed when they exit, and save their exit
289
321
}
290
322
 
291
323
/* Prints out a password to stdout */
292
 
__attribute__((nonnull))
 
324
__attribute__((nonnull, warn_unused_result))
293
325
static bool print_out_password(const char *buffer, size_t length){
294
326
  ssize_t ret;
295
327
  for(size_t written = 0; written < length; written += (size_t)ret){
306
338
__attribute__((nonnull))
307
339
static void free_plugin(plugin *plugin_node){
308
340
  
309
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
310
342
    free(*arg);
311
343
  }
 
344
  free(plugin_node->name);
312
345
  free(plugin_node->argv);
313
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
314
347
    free(*env);
341
374
 
342
375
int main(int argc, char *argv[]){
343
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
344
378
  char *argfile = NULL;
345
379
  FILE *conffp;
346
 
  size_t d_name_len;
347
 
  DIR *dir = NULL;
348
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
349
381
  struct stat st;
350
382
  fd_set rfds_all;
351
383
  int ret, maxfd = 0;
359
391
                                      .sa_flags = SA_NOCLDSTOP };
360
392
  char **custom_argv = NULL;
361
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
362
395
  
363
396
  /* Establish a signal handler */
364
397
  sigemptyset(&sigchld_action.sa_mask);
409
442
      .doc = "Group ID the plugins will run as", .group = 3 },
410
443
    { .name = "debug", .key = 132,
411
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 },
412
449
    /*
413
450
     * These reproduce what we would get without ARGP_NO_HELP
414
451
     */
435
472
            break;
436
473
          }
437
474
        }
 
475
        errno = 0;
438
476
      }
439
477
      break;
440
478
    case 'G':                   /* --global-env */
441
 
      add_environment(getplugin(NULL), arg, true);
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
 
481
      }
442
482
      break;
443
483
    case 'o':                   /* --options-for */
444
484
      {
461
501
            break;
462
502
          }
463
503
        }
 
504
        errno = 0;
464
505
      }
465
506
      break;
466
507
    case 'E':                   /* --env-for */
478
519
          errno = EINVAL;
479
520
          break;
480
521
        }
481
 
        add_environment(getplugin(arg), envdef, true);
 
522
        if(add_environment(getplugin(arg), envdef, true)){
 
523
          errno = 0;
 
524
        }
482
525
      }
483
526
      break;
484
527
    case 'd':                   /* --disable */
486
529
        plugin *p = getplugin(arg);
487
530
        if(p != NULL){
488
531
          p->disabled = true;
 
532
          errno = 0;
489
533
        }
490
534
      }
491
535
      break;
494
538
        plugin *p = getplugin(arg);
495
539
        if(p != NULL){
496
540
          p->disabled = false;
 
541
          errno = 0;
497
542
        }
498
543
      }
499
544
      break;
500
545
    case 128:                   /* --plugin-dir */
501
546
      free(plugindir);
502
547
      plugindir = strdup(arg);
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
503
551
      break;
504
552
    case 129:                   /* --config-file */
505
553
      /* This is already done by parse_opt_config_file() */
513
561
        break;
514
562
      }
515
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
516
565
      break;
517
566
    case 131:                   /* --groupid */
518
567
      tmp_id = strtoimax(arg, &tmp, 10);
523
572
        break;
524
573
      }
525
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
526
576
      break;
527
577
    case 132:                   /* --debug */
528
578
      debug = true;
529
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;
530
587
      /*
531
588
       * These reproduce what we would get without ARGP_NO_HELP
532
589
       */
533
590
    case '?':                   /* --help */
534
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
536
594
    case -3:                    /* --usage */
537
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
596
      argp_state_help(state, state->out_stream,
539
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
540
599
    case 'V':                   /* --version */
541
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
542
601
      exit(EXIT_SUCCESS);
552
611
      if(arg[0] == '\0'){
553
612
        break;
554
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
555
619
    default:
556
620
      return ARGP_ERR_UNKNOWN;
557
621
    }
576
640
    case 129:                   /* --config-file */
577
641
      free(argfile);
578
642
      argfile = strdup(arg);
 
643
      if(argfile != NULL){
 
644
        errno = 0;
 
645
      }
579
646
      break;
580
647
    case 130:                   /* --userid */
581
648
    case 131:                   /* --groupid */
582
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
583
651
    case '?':                   /* --help */
584
652
    case -3:                    /* --usage */
585
653
    case 'V':                   /* --version */
664
732
        }
665
733
        
666
734
        custom_argc += 1;
667
 
        custom_argv = realloc(custom_argv, sizeof(char *)
668
 
                              * ((unsigned int) custom_argc + 1));
669
 
        if(custom_argv == NULL){
670
 
          error(0, errno, "realloc");
671
 
          exitstatus = EX_OSERR;
672
 
          free(org_line);
673
 
          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
          }
674
758
        }
675
759
        custom_argv[custom_argc-1] = new_arg;
676
760
        custom_argv[custom_argc] = NULL;
734
818
    goto fallback;
735
819
  }
736
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
  
737
839
  if(debug){
738
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
840
    for(plugin *p = plugin_list; p != NULL; p = p->next){
739
841
      fprintf(stderr, "Plugin: %s has %d arguments\n",
740
842
              p->name ? p->name : "Global", p->argc - 1);
741
843
      for(char **a = p->argv; *a != NULL; a++){
750
852
  
751
853
  if(getuid() == 0){
752
854
    /* Work around Debian bug #633582:
753
 
       <http://bugs.debian.org/633582> */
 
855
       <https://bugs.debian.org/633582> */
754
856
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
857
    if(plugindir_fd == -1){
756
 
      error(0, errno, "open");
 
858
      if(errno != ENOENT){
 
859
        error(0, errno, "open(\"" PDIR "\")");
 
860
      }
757
861
    } else {
758
862
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
863
      if(ret == -1){
766
870
          }
767
871
        }
768
872
      }
769
 
      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
      }
770
883
    }
771
884
  }
772
885
  
782
895
  
783
896
  /* Open plugin directory with close_on_exec flag */
784
897
  {
785
 
    int dir_fd = -1;
786
 
    if(plugindir == NULL){
787
 
      dir_fd = open(PDIR, O_RDONLY |
788
 
#ifdef O_CLOEXEC
789
 
                    O_CLOEXEC
790
 
#else  /* not O_CLOEXEC */
791
 
                    0
792
 
#endif  /* not O_CLOEXEC */
793
 
                    );
794
 
    } else {
795
 
      dir_fd = open(plugindir, O_RDONLY |
796
 
#ifdef O_CLOEXEC
797
 
                    O_CLOEXEC
798
 
#else  /* not O_CLOEXEC */
799
 
                    0
800
 
#endif  /* not O_CLOEXEC */
801
 
                    );
802
 
    }
 
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
                  );
803
905
    if(dir_fd == -1){
804
906
      error(0, errno, "Could not open plugin dir");
805
907
      exitstatus = EX_UNAVAILABLE;
811
913
    ret = set_cloexec_flag(dir_fd);
812
914
    if(ret < 0){
813
915
      error(0, errno, "set_cloexec_flag");
814
 
      TEMP_FAILURE_RETRY(close(dir_fd));
815
916
      exitstatus = EX_OSERR;
816
917
      goto fallback;
817
918
    }
818
919
#endif  /* O_CLOEXEC */
819
 
    
820
 
    dir = fdopendir(dir_fd);
821
 
    if(dir == NULL){
822
 
      error(0, errno, "Could not open plugin dir");
823
 
      TEMP_FAILURE_RETRY(close(dir_fd));
824
 
      exitstatus = EX_OSERR;
825
 
      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
      }
826
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;
827
954
  }
828
955
  
829
956
  FD_ZERO(&rfds_all);
830
957
  
831
958
  /* Read and execute any executable in the plugin directory*/
832
 
  while(true){
833
 
    do {
834
 
      dirst = readdir(dir);
835
 
    } while(dirst == NULL and errno == EINTR);
836
 
    
837
 
    /* All directory entries have been processed */
838
 
    if(dirst == NULL){
839
 
      if(errno == EBADF){
840
 
        error(0, errno, "readdir");
841
 
        exitstatus = EX_IOERR;
842
 
        goto fallback;
843
 
      }
844
 
      break;
845
 
    }
846
 
    
847
 
    d_name_len = strlen(dirst->d_name);
848
 
    
849
 
    /* Ignore dotfiles, backup files and other junk */
850
 
    {
851
 
      bool bad_name = false;
852
 
      
853
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
854
 
      
855
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
856
 
                                           ".dpkg-old",
857
 
                                           ".dpkg-bak",
858
 
                                           ".dpkg-divert", NULL };
859
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
860
 
        size_t pre_len = strlen(*pre);
861
 
        if((d_name_len >= pre_len)
862
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
863
 
          if(debug){
864
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
865
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
866
 
          }
867
 
          bad_name = true;
868
 
          break;
869
 
        }
870
 
      }
871
 
      if(bad_name){
872
 
        continue;
873
 
      }
874
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
875
 
        size_t suf_len = strlen(*suf);
876
 
        if((d_name_len >= suf_len)
877
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
878
 
                == 0)){
879
 
          if(debug){
880
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
881
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
882
 
          }
883
 
          bad_name = true;
884
 
          break;
885
 
        }
886
 
      }
887
 
      
888
 
      if(bad_name){
889
 
        continue;
890
 
      }
891
 
    }
892
 
    
893
 
    char *filename;
894
 
    if(plugindir == NULL){
895
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
 
                                             dirst->d_name));
897
 
    } else {
898
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
 
                                             plugindir,
900
 
                                             dirst->d_name));
901
 
    }
902
 
    if(ret < 0){
903
 
      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]);
904
965
      continue;
905
966
    }
906
 
    
907
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
967
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
908
968
    if(ret == -1){
909
969
      error(0, errno, "stat");
910
 
      free(filename);
 
970
      close(plugin_fd);
 
971
      free(direntries[i]);
911
972
      continue;
912
973
    }
913
974
    
914
975
    /* Ignore non-executable files */
915
976
    if(not S_ISREG(st.st_mode)
916
 
       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)){
917
979
      if(debug){
918
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
919
 
                " 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);
920
984
      }
921
 
      free(filename);
 
985
      close(plugin_fd);
 
986
      free(direntries[i]);
922
987
      continue;
923
988
    }
924
989
    
925
 
    plugin *p = getplugin(dirst->d_name);
 
990
    plugin *p = getplugin(direntries[i]->d_name);
926
991
    if(p == NULL){
927
992
      error(0, errno, "getplugin");
928
 
      free(filename);
 
993
      close(plugin_fd);
 
994
      free(direntries[i]);
929
995
      continue;
930
996
    }
931
997
    if(p->disabled){
932
998
      if(debug){
933
999
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
934
 
                dirst->d_name);
 
1000
                direntries[i]->d_name);
935
1001
      }
936
 
      free(filename);
 
1002
      close(plugin_fd);
 
1003
      free(direntries[i]);
937
1004
      continue;
938
1005
    }
939
1006
    {
953
1020
        }
954
1021
      }
955
1022
    }
956
 
    /* If this plugin has any environment variables, we will call
957
 
       using execve and need to duplicate the environment from this
958
 
       process, too. */
 
1023
    /* If this plugin has any environment variables, we need to
 
1024
       duplicate the environment from this process, too. */
959
1025
    if(p->environ[0] != NULL){
960
1026
      for(char **e = environ; *e != NULL; e++){
961
1027
        if(not add_environment(p, *e, false)){
965
1031
    }
966
1032
    
967
1033
    int pipefd[2];
 
1034
#ifndef O_CLOEXEC
968
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 */
969
1039
    if(ret == -1){
970
1040
      error(0, errno, "pipe");
971
1041
      exitstatus = EX_OSERR;
972
 
      goto fallback;
973
 
    }
 
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
974
1055
    /* Ask OS to automatic close the pipe on exec */
975
1056
    ret = set_cloexec_flag(pipefd[0]);
976
1057
    if(ret < 0){
977
1058
      error(0, errno, "set_cloexec_flag");
 
1059
      close(pipefd[0]);
 
1060
      close(pipefd[1]);
978
1061
      exitstatus = EX_OSERR;
 
1062
      free(direntries[i]);
979
1063
      goto fallback;
980
1064
    }
981
1065
    ret = set_cloexec_flag(pipefd[1]);
982
1066
    if(ret < 0){
983
1067
      error(0, errno, "set_cloexec_flag");
 
1068
      close(pipefd[0]);
 
1069
      close(pipefd[1]);
984
1070
      exitstatus = EX_OSERR;
 
1071
      free(direntries[i]);
985
1072
      goto fallback;
986
1073
    }
 
1074
#endif  /* not O_CLOEXEC */
987
1075
    /* Block SIGCHLD until process is safely in process list */
988
1076
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
1077
                                              &sigchld_action.sa_mask,
991
1079
    if(ret < 0){
992
1080
      error(0, errno, "sigprocmask");
993
1081
      exitstatus = EX_OSERR;
 
1082
      free(direntries[i]);
994
1083
      goto fallback;
995
1084
    }
996
1085
    /* Starting a new process to be watched */
1000
1089
    } while(pid == -1 and errno == EINTR);
1001
1090
    if(pid == -1){
1002
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]);
1003
1096
      exitstatus = EX_OSERR;
 
1097
      free(direntries[i]);
1004
1098
      goto fallback;
1005
1099
    }
1006
1100
    if(pid == 0){
1022
1116
        _exit(EX_OSERR);
1023
1117
      }
1024
1118
      
1025
 
      if(dirfd(dir) < 0){
1026
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1027
 
           above and must now close it manually here. */
1028
 
        closedir(dir);
1029
 
      }
1030
 
      if(p->environ[0] == NULL){
1031
 
        if(execv(filename, p->argv) < 0){
1032
 
          error(0, errno, "execv for %s", filename);
1033
 
          _exit(EX_OSERR);
1034
 
        }
1035
 
      } else {
1036
 
        if(execve(filename, p->argv, p->environ) < 0){
1037
 
          error(0, errno, "execve for %s", filename);
1038
 
          _exit(EX_OSERR);
1039
 
        }
 
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);
1040
1125
      }
1041
1126
      /* no return */
1042
1127
    }
1043
1128
    /* Parent process */
1044
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
 
                                             pipe */
1046
 
    free(filename);
1047
 
    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);
1048
1132
    if(new_plugin == NULL){
1049
1133
      error(0, errno, "getplugin");
1050
1134
      ret = (int)(TEMP_FAILURE_RETRY
1054
1138
        error(0, errno, "sigprocmask");
1055
1139
      }
1056
1140
      exitstatus = EX_OSERR;
 
1141
      free(direntries[i]);
1057
1142
      goto fallback;
1058
1143
    }
 
1144
    free(direntries[i]);
1059
1145
    
1060
1146
    new_plugin->pid = pid;
1061
1147
    new_plugin->fd = pipefd[0];
1062
 
    
 
1148
 
 
1149
    if(debug){
 
1150
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1151
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1152
    }
 
1153
 
1063
1154
    /* Unblock SIGCHLD so signal handler can be run if this process
1064
1155
       has already completed */
1065
1156
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1071
1162
      goto fallback;
1072
1163
    }
1073
1164
    
1074
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
 
                                          -Wconversion */
 
1165
    FD_SET(new_plugin->fd, &rfds_all);
1076
1166
    
1077
1167
    if(maxfd < new_plugin->fd){
1078
1168
      maxfd = new_plugin->fd;
1079
1169
    }
1080
1170
  }
1081
1171
  
1082
 
  TEMP_FAILURE_RETRY(closedir(dir));
1083
 
  dir = NULL;
 
1172
  free(direntries);
 
1173
  direntries = NULL;
 
1174
  close(dir_fd);
 
1175
  dir_fd = -1;
1084
1176
  free_plugin(getplugin(NULL));
1085
1177
  
1086
1178
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1125
1217
                      (intmax_t) (proc->pid),
1126
1218
                      WTERMSIG(proc->status),
1127
1219
                      strsignal(WTERMSIG(proc->status)));
1128
 
            } else if(WCOREDUMP(proc->status)){
1129
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1131
1220
            }
1132
1221
          }
1133
1222
          
1134
1223
          /* Remove the plugin */
1135
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
 
                                          -Wconversion */
 
1224
          FD_CLR(proc->fd, &rfds_all);
1137
1225
          
1138
1226
          /* Block signal while modifying process_list */
1139
1227
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1179
1267
      }
1180
1268
      
1181
1269
      /* This process has not completed.  Does it have any output? */
1182
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1183
 
                                                         warning from
1184
 
                                                         -Wconversion */
 
1270
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1185
1271
        /* This process had nothing to say at this time */
1186
1272
        proc = proc->next;
1187
1273
        continue;
1188
1274
      }
1189
1275
      /* Before reading, make the process' data buffer large enough */
1190
1276
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1191
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1192
 
                               + (size_t) BUFFER_SIZE);
1193
 
        if(proc->buffer == NULL){
 
1277
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1278
                                   + (size_t) BUFFER_SIZE);
 
1279
        if(new_buffer == NULL){
1194
1280
          error(0, errno, "malloc");
1195
1281
          exitstatus = EX_OSERR;
1196
1282
          goto fallback;
1197
1283
        }
 
1284
        proc->buffer = new_buffer;
1198
1285
        proc->buffer_size += BUFFER_SIZE;
1199
1286
      }
1200
1287
      /* Read from the process */
1253
1340
    free(custom_argv);
1254
1341
  }
1255
1342
  
1256
 
  if(dir != NULL){
1257
 
    closedir(dir);
 
1343
  free(direntries);
 
1344
  
 
1345
  if(dir_fd != -1){
 
1346
    close(dir_fd);
1258
1347
  }
1259
1348
  
1260
1349
  /* Kill the processes */
1280
1369
  free_plugin_list();
1281
1370
  
1282
1371
  free(plugindir);
 
1372
  free(pluginhelperdir);
1283
1373
  free(argfile);
1284
1374
  
1285
1375
  return exitstatus;