/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: 2019-07-29 16:35:53 UTC
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
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-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-2018 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
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
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
27
                                   O_CLOEXEC, pipe2() */
27
28
#include <stddef.h>             /* size_t, NULL */
28
29
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
30
                                   realloc() */
30
31
#include <stdbool.h>            /* bool, true, false */
31
32
#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() */
 
33
                                   stderr, STDOUT_FILENO, fclose() */
 
34
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
35
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
36
                                   pid_t, uid_t, gid_t, getuid(),
 
37
                                   getgid() */
38
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
 
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
44
43
#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() */
 
44
#include <dirent.h>             /* struct dirent, scandirat() */
 
45
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
 
46
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
 
47
                                   struct stat, fstat(), close(),
 
48
                                   setgid(), setuid(), S_ISREG(),
 
49
                                   faccessat() pipe2(), fork(),
 
50
                                   _exit(), dup2(), fexecve(), read()
 
51
                                */
54
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
 
55
#include <string.h>             /* strsep, strlen(), strsignal(),
 
56
                                   strcmp(), strncmp() */
58
57
#include <errno.h>              /* errno */
59
58
#include <argp.h>               /* struct argp_option, struct
60
59
                                   argp_state, struct argp,
72
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
72
#include <errno.h>              /* errno */
74
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
75
75
 
76
76
#define BUFFER_SIZE 256
77
77
 
78
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
79
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
 
81
82
const char *argp_program_version = "plugin-runner " VERSION;
82
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
83
84
 
84
85
typedef struct plugin{
85
86
  char *name;                   /* can be NULL or any plugin name */
105
106
 
106
107
/* Gets an existing plugin based on name,
107
108
   or if none is found, creates a new one */
 
109
__attribute__((warn_unused_result))
108
110
static plugin *getplugin(char *name){
109
111
  /* Check for existing plugin with that name */
110
112
  for(plugin *p = plugin_list; p != NULL; p = p->next){
171
173
}
172
174
 
173
175
/* Helper function for add_argument and add_environment */
 
176
__attribute__((nonnull, warn_unused_result))
174
177
static bool add_to_char_array(const char *new, char ***array,
175
178
                              int *len){
176
179
  /* Resize the pointed-to array to hold one more pointer */
 
180
  char **new_array = NULL;
177
181
  do {
178
 
    *array = realloc(*array, sizeof(char *)
179
 
                     * (size_t) ((*len) + 2));
180
 
  } while(*array == NULL and errno == EINTR);
 
182
    new_array = realloc(*array, sizeof(char *)
 
183
                        * (size_t) ((*len) + 2));
 
184
  } while(new_array == NULL and errno == EINTR);
181
185
  /* Malloc check */
182
 
  if(*array == NULL){
 
186
  if(new_array == NULL){
183
187
    return false;
184
188
  }
 
189
  *array = new_array;
185
190
  /* Make a copy of the new string */
186
191
  char *copy;
187
192
  do {
199
204
}
200
205
 
201
206
/* Add to a plugin's argument vector */
 
207
__attribute__((nonnull(2), warn_unused_result))
202
208
static bool add_argument(plugin *p, const char *arg){
203
209
  if(p == NULL){
204
210
    return false;
207
213
}
208
214
 
209
215
/* Add to a plugin's environment */
 
216
__attribute__((nonnull(2), warn_unused_result))
210
217
static bool add_environment(plugin *p, const char *def, bool replace){
211
218
  if(p == NULL){
212
219
    return false;
214
221
  /* namelen = length of name of environment variable */
215
222
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
216
223
  /* Search for this environment variable */
217
 
  for(char **e = p->environ; *e != NULL; e++){
218
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
224
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
225
    if(strncmp(*envdef, def, namelen + 1) == 0){
219
226
      /* It already exists */
220
227
      if(replace){
221
 
        char *new;
 
228
        char *new_envdef;
222
229
        do {
223
 
          new = realloc(*e, strlen(def) + 1);
224
 
        } while(new == NULL and errno == EINTR);
225
 
        if(new == NULL){
 
230
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
231
        } while(new_envdef == NULL and errno == EINTR);
 
232
        if(new_envdef == NULL){
226
233
          return false;
227
234
        }
228
 
        *e = new;
229
 
        strcpy(*e, def);
 
235
        *envdef = new_envdef;
 
236
        strcpy(*envdef, def);
230
237
      }
231
238
      return true;
232
239
    }
234
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
235
242
}
236
243
 
 
244
#ifndef O_CLOEXEC
237
245
/*
238
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
239
247
 * Descriptor Flags".
240
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
241
249
 */
 
250
__attribute__((warn_unused_result))
242
251
static int set_cloexec_flag(int fd){
243
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
244
253
  /* If reading the flags failed, return error indication now. */
249
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
250
259
                                       ret | FD_CLOEXEC));
251
260
}
 
261
#endif  /* not O_CLOEXEC */
252
262
 
253
263
 
254
264
/* Mark processes as completed when they exit, and save their exit
286
296
}
287
297
 
288
298
/* Prints out a password to stdout */
 
299
__attribute__((nonnull, warn_unused_result))
289
300
static bool print_out_password(const char *buffer, size_t length){
290
301
  ssize_t ret;
291
302
  for(size_t written = 0; written < length; written += (size_t)ret){
299
310
}
300
311
 
301
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
302
314
static void free_plugin(plugin *plugin_node){
303
315
  
304
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
316
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
305
317
    free(*arg);
306
318
  }
 
319
  free(plugin_node->name);
307
320
  free(plugin_node->argv);
308
321
  for(char **env = plugin_node->environ; *env != NULL; env++){
309
322
    free(*env);
336
349
 
337
350
int main(int argc, char *argv[]){
338
351
  char *plugindir = NULL;
 
352
  char *pluginhelperdir = NULL;
339
353
  char *argfile = NULL;
340
354
  FILE *conffp;
341
 
  size_t d_name_len;
342
 
  DIR *dir = NULL;
343
 
  struct dirent *dirst;
 
355
  struct dirent **direntries = NULL;
344
356
  struct stat st;
345
357
  fd_set rfds_all;
346
358
  int ret, maxfd = 0;
354
366
                                      .sa_flags = SA_NOCLDSTOP };
355
367
  char **custom_argv = NULL;
356
368
  int custom_argc = 0;
 
369
  int dir_fd = -1;
357
370
  
358
371
  /* Establish a signal handler */
359
372
  sigemptyset(&sigchld_action.sa_mask);
404
417
      .doc = "Group ID the plugins will run as", .group = 3 },
405
418
    { .name = "debug", .key = 132,
406
419
      .doc = "Debug mode", .group = 4 },
 
420
    { .name = "plugin-helper-dir", .key = 133,
 
421
      .arg = "DIRECTORY",
 
422
      .doc = "Specify a different plugin helper directory",
 
423
      .group = 2 },
407
424
    /*
408
425
     * These reproduce what we would get without ARGP_NO_HELP
409
426
     */
416
433
    { .name = NULL }
417
434
  };
418
435
  
 
436
  __attribute__((nonnull(3)))
419
437
  error_t parse_opt(int key, char *arg, struct argp_state *state){
420
438
    errno = 0;
421
439
    switch(key){
422
440
      char *tmp;
423
 
      intmax_t tmpmax;
 
441
      intmax_t tmp_id;
424
442
    case 'g':                   /* --global-options */
425
443
      {
426
444
        char *plugin_option;
429
447
            break;
430
448
          }
431
449
        }
 
450
        errno = 0;
432
451
      }
433
452
      break;
434
453
    case 'G':                   /* --global-env */
435
 
      add_environment(getplugin(NULL), arg, true);
 
454
      if(add_environment(getplugin(NULL), arg, true)){
 
455
        errno = 0;
 
456
      }
436
457
      break;
437
458
    case 'o':                   /* --options-for */
438
459
      {
455
476
            break;
456
477
          }
457
478
        }
 
479
        errno = 0;
458
480
      }
459
481
      break;
460
482
    case 'E':                   /* --env-for */
472
494
          errno = EINVAL;
473
495
          break;
474
496
        }
475
 
        add_environment(getplugin(arg), envdef, true);
 
497
        if(add_environment(getplugin(arg), envdef, true)){
 
498
          errno = 0;
 
499
        }
476
500
      }
477
501
      break;
478
502
    case 'd':                   /* --disable */
480
504
        plugin *p = getplugin(arg);
481
505
        if(p != NULL){
482
506
          p->disabled = true;
 
507
          errno = 0;
483
508
        }
484
509
      }
485
510
      break;
488
513
        plugin *p = getplugin(arg);
489
514
        if(p != NULL){
490
515
          p->disabled = false;
 
516
          errno = 0;
491
517
        }
492
518
      }
493
519
      break;
494
520
    case 128:                   /* --plugin-dir */
495
521
      free(plugindir);
496
522
      plugindir = strdup(arg);
 
523
      if(plugindir != NULL){
 
524
        errno = 0;
 
525
      }
497
526
      break;
498
527
    case 129:                   /* --config-file */
499
528
      /* This is already done by parse_opt_config_file() */
500
529
      break;
501
530
    case 130:                   /* --userid */
502
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
531
      tmp_id = strtoimax(arg, &tmp, 10);
503
532
      if(errno != 0 or tmp == arg or *tmp != '\0'
504
 
         or tmpmax != (uid_t)tmpmax){
 
533
         or tmp_id != (uid_t)tmp_id){
505
534
        argp_error(state, "Bad user ID number: \"%s\", using %"
506
535
                   PRIdMAX, arg, (intmax_t)uid);
507
536
        break;
508
537
      }
509
 
      uid = (uid_t)tmpmax;
 
538
      uid = (uid_t)tmp_id;
 
539
      errno = 0;
510
540
      break;
511
541
    case 131:                   /* --groupid */
512
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
542
      tmp_id = strtoimax(arg, &tmp, 10);
513
543
      if(errno != 0 or tmp == arg or *tmp != '\0'
514
 
         or tmpmax != (gid_t)tmpmax){
 
544
         or tmp_id != (gid_t)tmp_id){
515
545
        argp_error(state, "Bad group ID number: \"%s\", using %"
516
546
                   PRIdMAX, arg, (intmax_t)gid);
517
547
        break;
518
548
      }
519
 
      gid = (gid_t)tmpmax;
 
549
      gid = (gid_t)tmp_id;
 
550
      errno = 0;
520
551
      break;
521
552
    case 132:                   /* --debug */
522
553
      debug = true;
523
554
      break;
 
555
    case 133:                   /* --plugin-helper-dir */
 
556
      free(pluginhelperdir);
 
557
      pluginhelperdir = strdup(arg);
 
558
      if(pluginhelperdir != NULL){
 
559
        errno = 0;
 
560
      }
 
561
      break;
524
562
      /*
525
563
       * These reproduce what we would get without ARGP_NO_HELP
526
564
       */
527
565
    case '?':                   /* --help */
528
566
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
567
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
568
      __builtin_unreachable();
530
569
    case -3:                    /* --usage */
531
570
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
532
571
      argp_state_help(state, state->out_stream,
533
572
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
573
      __builtin_unreachable();
534
574
    case 'V':                   /* --version */
535
575
      fprintf(state->out_stream, "%s\n", argp_program_version);
536
576
      exit(EXIT_SUCCESS);
546
586
      if(arg[0] == '\0'){
547
587
        break;
548
588
      }
 
589
#if __GNUC__ >= 7
 
590
      __attribute__((fallthrough));
 
591
#else
 
592
          /* FALLTHROUGH */
 
593
#endif
549
594
    default:
550
595
      return ARGP_ERR_UNKNOWN;
551
596
    }
570
615
    case 129:                   /* --config-file */
571
616
      free(argfile);
572
617
      argfile = strdup(arg);
 
618
      if(argfile != NULL){
 
619
        errno = 0;
 
620
      }
573
621
      break;
574
622
    case 130:                   /* --userid */
575
623
    case 131:                   /* --groupid */
576
624
    case 132:                   /* --debug */
 
625
    case 133:                   /* --plugin-helper-dir */
577
626
    case '?':                   /* --help */
578
627
    case -3:                    /* --usage */
579
628
    case 'V':                   /* --version */
658
707
        }
659
708
        
660
709
        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;
 
710
        {
 
711
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
712
                                    * ((size_t)custom_argc + 1));
 
713
          if(new_argv == NULL){
 
714
            error(0, errno, "realloc");
 
715
            exitstatus = EX_OSERR;
 
716
            free(new_arg);
 
717
            free(org_line);
 
718
            goto fallback;
 
719
          } else {
 
720
            custom_argv = new_argv;
 
721
          }
668
722
        }
669
723
        custom_argv[custom_argc-1] = new_arg;
670
724
        custom_argv[custom_argc] = NULL;
728
782
    goto fallback;
729
783
  }
730
784
  
 
785
  {
 
786
    char *pluginhelperenv;
 
787
    bool bret = true;
 
788
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
789
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
790
    if(ret != -1){
 
791
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
792
    }
 
793
    if(ret == -1 or not bret){
 
794
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
795
            " environment variable to \"%s\" for all plugins\n",
 
796
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
797
    }
 
798
    if(ret != -1){
 
799
      free(pluginhelperenv);
 
800
    }
 
801
  }
 
802
  
731
803
  if(debug){
732
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
804
    for(plugin *p = plugin_list; p != NULL; p = p->next){
733
805
      fprintf(stderr, "Plugin: %s has %d arguments\n",
734
806
              p->name ? p->name : "Global", p->argc - 1);
735
807
      for(char **a = p->argv; *a != NULL; a++){
742
814
    }
743
815
  }
744
816
  
745
 
  /* Strip permissions down to nobody */
746
 
  setgid(gid);
 
817
  if(getuid() == 0){
 
818
    /* Work around Debian bug #633582:
 
819
       <https://bugs.debian.org/633582> */
 
820
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
821
    if(plugindir_fd == -1){
 
822
      if(errno != ENOENT){
 
823
        error(0, errno, "open(\"" PDIR "\")");
 
824
      }
 
825
    } else {
 
826
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
827
      if(ret == -1){
 
828
        error(0, errno, "fstat");
 
829
      } else {
 
830
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
831
          ret = fchown(plugindir_fd, uid, gid);
 
832
          if(ret == -1){
 
833
            error(0, errno, "fchown");
 
834
          }
 
835
        }
 
836
      }
 
837
      close(plugindir_fd);
 
838
    }
 
839
  }
 
840
  
 
841
  /* Lower permissions */
 
842
  ret = setgid(gid);
747
843
  if(ret == -1){
748
844
    error(0, errno, "setgid");
749
845
  }
754
850
  
755
851
  /* Open plugin directory with close_on_exec flag */
756
852
  {
757
 
    int dir_fd = -1;
758
 
    if(plugindir == NULL){
759
 
      dir_fd = open(PDIR, O_RDONLY |
760
 
#ifdef O_CLOEXEC
761
 
                    O_CLOEXEC
762
 
#else  /* not O_CLOEXEC */
763
 
                    0
764
 
#endif  /* not O_CLOEXEC */
765
 
                    );
766
 
    } else {
767
 
      dir_fd = open(plugindir, O_RDONLY |
768
 
#ifdef O_CLOEXEC
769
 
                    O_CLOEXEC
770
 
#else  /* not O_CLOEXEC */
771
 
                    0
772
 
#endif  /* not O_CLOEXEC */
773
 
                    );
774
 
    }
 
853
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
854
#ifdef O_CLOEXEC
 
855
                  O_CLOEXEC
 
856
#else  /* not O_CLOEXEC */
 
857
                  0
 
858
#endif  /* not O_CLOEXEC */
 
859
                  );
775
860
    if(dir_fd == -1){
776
861
      error(0, errno, "Could not open plugin dir");
777
862
      exitstatus = EX_UNAVAILABLE;
783
868
    ret = set_cloexec_flag(dir_fd);
784
869
    if(ret < 0){
785
870
      error(0, errno, "set_cloexec_flag");
786
 
      TEMP_FAILURE_RETRY(close(dir_fd));
787
871
      exitstatus = EX_OSERR;
788
872
      goto fallback;
789
873
    }
790
874
#endif  /* O_CLOEXEC */
791
 
    
792
 
    dir = fdopendir(dir_fd);
793
 
    if(dir == NULL){
794
 
      error(0, errno, "Could not open plugin dir");
795
 
      TEMP_FAILURE_RETRY(close(dir_fd));
796
 
      exitstatus = EX_OSERR;
797
 
      goto fallback;
 
875
  }
 
876
  
 
877
  int good_name(const struct dirent * const dirent){
 
878
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
879
                                      "*.dpkg-old", "*.dpkg-bak",
 
880
                                      "*.dpkg-divert", NULL };
 
881
#ifdef __GNUC__
 
882
#pragma GCC diagnostic push
 
883
#pragma GCC diagnostic ignored "-Wcast-qual"
 
884
#endif
 
885
    for(const char **pat = (const char **)patterns;
 
886
        *pat != NULL; pat++){
 
887
#ifdef __GNUC__
 
888
#pragma GCC diagnostic pop
 
889
#endif
 
890
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
891
         != FNM_NOMATCH){
 
892
        if(debug){
 
893
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
894
                    " matching pattern %s\n", dirent->d_name, *pat);
 
895
        }
 
896
        return 0;
 
897
      }
798
898
    }
 
899
    return 1;
 
900
  }
 
901
  
 
902
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
903
                             alphasort);
 
904
  if(numplugins == -1){
 
905
    error(0, errno, "Could not scan plugin dir");
 
906
    direntries = NULL;
 
907
    exitstatus = EX_OSERR;
 
908
    goto fallback;
799
909
  }
800
910
  
801
911
  FD_ZERO(&rfds_all);
802
912
  
803
913
  /* Read and execute any executable in the plugin directory*/
804
 
  while(true){
805
 
    do {
806
 
      dirst = readdir(dir);
807
 
    } while(dirst == NULL and errno == EINTR);
808
 
    
809
 
    /* All directory entries have been processed */
810
 
    if(dirst == NULL){
811
 
      if(errno == EBADF){
812
 
        error(0, errno, "readdir");
813
 
        exitstatus = EX_IOERR;
814
 
        goto fallback;
815
 
      }
816
 
      break;
817
 
    }
818
 
    
819
 
    d_name_len = strlen(dirst->d_name);
820
 
    
821
 
    /* Ignore dotfiles, backup files and other junk */
822
 
    {
823
 
      bool bad_name = false;
824
 
      
825
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
826
 
      
827
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
828
 
                                           ".dpkg-old",
829
 
                                           ".dpkg-bak",
830
 
                                           ".dpkg-divert", NULL };
831
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
832
 
        size_t pre_len = strlen(*pre);
833
 
        if((d_name_len >= pre_len)
834
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
835
 
          if(debug){
836
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
837
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
838
 
          }
839
 
          bad_name = true;
840
 
          break;
841
 
        }
842
 
      }
843
 
      if(bad_name){
844
 
        continue;
845
 
      }
846
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
847
 
        size_t suf_len = strlen(*suf);
848
 
        if((d_name_len >= suf_len)
849
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
850
 
                == 0)){
851
 
          if(debug){
852
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
853
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
854
 
          }
855
 
          bad_name = true;
856
 
          break;
857
 
        }
858
 
      }
859
 
      
860
 
      if(bad_name){
861
 
        continue;
862
 
      }
863
 
    }
864
 
    
865
 
    char *filename;
866
 
    if(plugindir == NULL){
867
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
868
 
                                             dirst->d_name));
869
 
    } else {
870
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
871
 
                                             plugindir,
872
 
                                             dirst->d_name));
873
 
    }
874
 
    if(ret < 0){
875
 
      error(0, errno, "asprintf");
 
914
  for(int i = 0; i < numplugins; i++){
 
915
    
 
916
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
917
    if(plugin_fd == -1){
 
918
      error(0, errno, "Could not open plugin");
 
919
      free(direntries[i]);
876
920
      continue;
877
921
    }
878
 
    
879
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
922
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
880
923
    if(ret == -1){
881
924
      error(0, errno, "stat");
882
 
      free(filename);
 
925
      close(plugin_fd);
 
926
      free(direntries[i]);
883
927
      continue;
884
928
    }
885
929
    
886
930
    /* Ignore non-executable files */
887
931
    if(not S_ISREG(st.st_mode)
888
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
932
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
933
                                        X_OK, 0)) != 0)){
889
934
      if(debug){
890
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
891
 
                " with bad type or mode\n", filename);
 
935
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
936
                " with bad type or mode\n",
 
937
                plugindir != NULL ? plugindir : PDIR,
 
938
                direntries[i]->d_name);
892
939
      }
893
 
      free(filename);
 
940
      close(plugin_fd);
 
941
      free(direntries[i]);
894
942
      continue;
895
943
    }
896
944
    
897
 
    plugin *p = getplugin(dirst->d_name);
 
945
    plugin *p = getplugin(direntries[i]->d_name);
898
946
    if(p == NULL){
899
947
      error(0, errno, "getplugin");
900
 
      free(filename);
 
948
      close(plugin_fd);
 
949
      free(direntries[i]);
901
950
      continue;
902
951
    }
903
952
    if(p->disabled){
904
953
      if(debug){
905
954
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
906
 
                dirst->d_name);
 
955
                direntries[i]->d_name);
907
956
      }
908
 
      free(filename);
 
957
      close(plugin_fd);
 
958
      free(direntries[i]);
909
959
      continue;
910
960
    }
911
961
    {
925
975
        }
926
976
      }
927
977
    }
928
 
    /* If this plugin has any environment variables, we will call
929
 
       using execve and need to duplicate the environment from this
930
 
       process, too. */
 
978
    /* If this plugin has any environment variables, we need to
 
979
       duplicate the environment from this process, too. */
931
980
    if(p->environ[0] != NULL){
932
981
      for(char **e = environ; *e != NULL; e++){
933
982
        if(not add_environment(p, *e, false)){
937
986
    }
938
987
    
939
988
    int pipefd[2];
 
989
#ifndef O_CLOEXEC
940
990
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
991
#else  /* O_CLOEXEC */
 
992
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
993
#endif  /* O_CLOEXEC */
941
994
    if(ret == -1){
942
995
      error(0, errno, "pipe");
943
996
      exitstatus = EX_OSERR;
944
 
      goto fallback;
945
 
    }
 
997
      free(direntries[i]);
 
998
      goto fallback;
 
999
    }
 
1000
    if(pipefd[0] >= FD_SETSIZE){
 
1001
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1002
              FD_SETSIZE);
 
1003
      close(pipefd[0]);
 
1004
      close(pipefd[1]);
 
1005
      exitstatus = EX_OSERR;
 
1006
      free(direntries[i]);
 
1007
      goto fallback;
 
1008
    }
 
1009
#ifndef O_CLOEXEC
946
1010
    /* Ask OS to automatic close the pipe on exec */
947
1011
    ret = set_cloexec_flag(pipefd[0]);
948
1012
    if(ret < 0){
949
1013
      error(0, errno, "set_cloexec_flag");
 
1014
      close(pipefd[0]);
 
1015
      close(pipefd[1]);
950
1016
      exitstatus = EX_OSERR;
 
1017
      free(direntries[i]);
951
1018
      goto fallback;
952
1019
    }
953
1020
    ret = set_cloexec_flag(pipefd[1]);
954
1021
    if(ret < 0){
955
1022
      error(0, errno, "set_cloexec_flag");
 
1023
      close(pipefd[0]);
 
1024
      close(pipefd[1]);
956
1025
      exitstatus = EX_OSERR;
 
1026
      free(direntries[i]);
957
1027
      goto fallback;
958
1028
    }
 
1029
#endif  /* not O_CLOEXEC */
959
1030
    /* Block SIGCHLD until process is safely in process list */
960
1031
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
961
1032
                                              &sigchld_action.sa_mask,
963
1034
    if(ret < 0){
964
1035
      error(0, errno, "sigprocmask");
965
1036
      exitstatus = EX_OSERR;
 
1037
      free(direntries[i]);
966
1038
      goto fallback;
967
1039
    }
968
1040
    /* Starting a new process to be watched */
972
1044
    } while(pid == -1 and errno == EINTR);
973
1045
    if(pid == -1){
974
1046
      error(0, errno, "fork");
 
1047
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1048
                                     &sigchld_action.sa_mask, NULL));
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
975
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
976
1053
      goto fallback;
977
1054
    }
978
1055
    if(pid == 0){
994
1071
        _exit(EX_OSERR);
995
1072
      }
996
1073
      
997
 
      if(dirfd(dir) < 0){
998
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
999
 
           above and must now close it manually here. */
1000
 
        closedir(dir);
1001
 
      }
1002
 
      if(p->environ[0] == NULL){
1003
 
        if(execv(filename, p->argv) < 0){
1004
 
          error(0, errno, "execv for %s", filename);
1005
 
          _exit(EX_OSERR);
1006
 
        }
1007
 
      } else {
1008
 
        if(execve(filename, p->argv, p->environ) < 0){
1009
 
          error(0, errno, "execve for %s", filename);
1010
 
          _exit(EX_OSERR);
1011
 
        }
 
1074
      if(fexecve(plugin_fd, p->argv,
 
1075
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1076
        error(0, errno, "fexecve for %s/%s",
 
1077
              plugindir != NULL ? plugindir : PDIR,
 
1078
              direntries[i]->d_name);
 
1079
        _exit(EX_OSERR);
1012
1080
      }
1013
1081
      /* no return */
1014
1082
    }
1015
1083
    /* Parent process */
1016
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1017
 
                                             pipe */
1018
 
    free(filename);
1019
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1084
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1085
    close(plugin_fd);
 
1086
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1020
1087
    if(new_plugin == NULL){
1021
1088
      error(0, errno, "getplugin");
1022
1089
      ret = (int)(TEMP_FAILURE_RETRY
1026
1093
        error(0, errno, "sigprocmask");
1027
1094
      }
1028
1095
      exitstatus = EX_OSERR;
 
1096
      free(direntries[i]);
1029
1097
      goto fallback;
1030
1098
    }
 
1099
    free(direntries[i]);
1031
1100
    
1032
1101
    new_plugin->pid = pid;
1033
1102
    new_plugin->fd = pipefd[0];
1034
 
    
 
1103
 
 
1104
    if(debug){
 
1105
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1106
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1107
    }
 
1108
 
1035
1109
    /* Unblock SIGCHLD so signal handler can be run if this process
1036
1110
       has already completed */
1037
1111
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1043
1117
      goto fallback;
1044
1118
    }
1045
1119
    
1046
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1047
 
                                          -Wconversion */
 
1120
    FD_SET(new_plugin->fd, &rfds_all);
1048
1121
    
1049
1122
    if(maxfd < new_plugin->fd){
1050
1123
      maxfd = new_plugin->fd;
1051
1124
    }
1052
1125
  }
1053
1126
  
1054
 
  TEMP_FAILURE_RETRY(closedir(dir));
1055
 
  dir = NULL;
 
1127
  free(direntries);
 
1128
  direntries = NULL;
 
1129
  close(dir_fd);
 
1130
  dir_fd = -1;
1056
1131
  free_plugin(getplugin(NULL));
1057
1132
  
1058
1133
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1097
1172
                      (intmax_t) (proc->pid),
1098
1173
                      WTERMSIG(proc->status),
1099
1174
                      strsignal(WTERMSIG(proc->status)));
1100
 
            } else if(WCOREDUMP(proc->status)){
1101
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1102
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1103
1175
            }
1104
1176
          }
1105
1177
          
1106
1178
          /* Remove the plugin */
1107
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1108
 
                                          -Wconversion */
 
1179
          FD_CLR(proc->fd, &rfds_all);
1109
1180
          
1110
1181
          /* Block signal while modifying process_list */
1111
1182
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1151
1222
      }
1152
1223
      
1153
1224
      /* This process has not completed.  Does it have any output? */
1154
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1155
 
                                                         warning from
1156
 
                                                         -Wconversion */
 
1225
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1157
1226
        /* This process had nothing to say at this time */
1158
1227
        proc = proc->next;
1159
1228
        continue;
1160
1229
      }
1161
1230
      /* Before reading, make the process' data buffer large enough */
1162
1231
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1163
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1164
 
                               + (size_t) BUFFER_SIZE);
1165
 
        if(proc->buffer == NULL){
 
1232
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1233
                                   + (size_t) BUFFER_SIZE);
 
1234
        if(new_buffer == NULL){
1166
1235
          error(0, errno, "malloc");
1167
1236
          exitstatus = EX_OSERR;
1168
1237
          goto fallback;
1169
1238
        }
 
1239
        proc->buffer = new_buffer;
1170
1240
        proc->buffer_size += BUFFER_SIZE;
1171
1241
      }
1172
1242
      /* Read from the process */
1225
1295
    free(custom_argv);
1226
1296
  }
1227
1297
  
1228
 
  if(dir != NULL){
1229
 
    closedir(dir);
 
1298
  free(direntries);
 
1299
  
 
1300
  if(dir_fd != -1){
 
1301
    close(dir_fd);
1230
1302
  }
1231
1303
  
1232
1304
  /* Kill the processes */
1252
1324
  free_plugin_list();
1253
1325
  
1254
1326
  free(plugindir);
 
1327
  free(pluginhelperdir);
1255
1328
  free(argfile);
1256
1329
  
1257
1330
  return exitstatus;