/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-08-05 21:14:05 UTC
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

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-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
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;
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 */
174
 
__attribute__((nonnull))
 
176
__attribute__((nonnull, warn_unused_result))
175
177
static bool add_to_char_array(const char *new, char ***array,
176
178
                              int *len){
177
179
  /* Resize the pointed-to array to hold one more pointer */
202
204
}
203
205
 
204
206
/* Add to a plugin's argument vector */
205
 
__attribute__((nonnull(2)))
 
207
__attribute__((nonnull(2), warn_unused_result))
206
208
static bool add_argument(plugin *p, const char *arg){
207
209
  if(p == NULL){
208
210
    return false;
211
213
}
212
214
 
213
215
/* Add to a plugin's environment */
214
 
__attribute__((nonnull(2)))
 
216
__attribute__((nonnull(2), warn_unused_result))
215
217
static bool add_environment(plugin *p, const char *def, bool replace){
216
218
  if(p == NULL){
217
219
    return false;
239
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
240
242
}
241
243
 
 
244
#ifndef O_CLOEXEC
242
245
/*
243
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
244
247
 * Descriptor Flags".
245
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
246
249
 */
 
250
__attribute__((warn_unused_result))
247
251
static int set_cloexec_flag(int fd){
248
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
249
253
  /* If reading the flags failed, return error indication now. */
254
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
255
259
                                       ret | FD_CLOEXEC));
256
260
}
 
261
#endif  /* not O_CLOEXEC */
257
262
 
258
263
 
259
264
/* Mark processes as completed when they exit, and save their exit
291
296
}
292
297
 
293
298
/* Prints out a password to stdout */
294
 
__attribute__((nonnull))
 
299
__attribute__((nonnull, warn_unused_result))
295
300
static bool print_out_password(const char *buffer, size_t length){
296
301
  ssize_t ret;
297
302
  for(size_t written = 0; written < length; written += (size_t)ret){
308
313
__attribute__((nonnull))
309
314
static void free_plugin(plugin *plugin_node){
310
315
  
311
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
316
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
312
317
    free(*arg);
313
318
  }
 
319
  free(plugin_node->name);
314
320
  free(plugin_node->argv);
315
321
  for(char **env = plugin_node->environ; *env != NULL; env++){
316
322
    free(*env);
343
349
 
344
350
int main(int argc, char *argv[]){
345
351
  char *plugindir = NULL;
 
352
  char *pluginhelperdir = NULL;
346
353
  char *argfile = NULL;
347
354
  FILE *conffp;
348
 
  size_t d_name_len;
349
 
  DIR *dir = NULL;
350
 
  struct dirent *dirst;
 
355
  struct dirent **direntries = NULL;
351
356
  struct stat st;
352
357
  fd_set rfds_all;
353
358
  int ret, maxfd = 0;
361
366
                                      .sa_flags = SA_NOCLDSTOP };
362
367
  char **custom_argv = NULL;
363
368
  int custom_argc = 0;
 
369
  int dir_fd = -1;
364
370
  
365
371
  /* Establish a signal handler */
366
372
  sigemptyset(&sigchld_action.sa_mask);
411
417
      .doc = "Group ID the plugins will run as", .group = 3 },
412
418
    { .name = "debug", .key = 132,
413
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 },
414
424
    /*
415
425
     * These reproduce what we would get without ARGP_NO_HELP
416
426
     */
437
447
            break;
438
448
          }
439
449
        }
 
450
        errno = 0;
440
451
      }
441
452
      break;
442
453
    case 'G':                   /* --global-env */
443
 
      add_environment(getplugin(NULL), arg, true);
 
454
      if(add_environment(getplugin(NULL), arg, true)){
 
455
        errno = 0;
 
456
      }
444
457
      break;
445
458
    case 'o':                   /* --options-for */
446
459
      {
463
476
            break;
464
477
          }
465
478
        }
 
479
        errno = 0;
466
480
      }
467
481
      break;
468
482
    case 'E':                   /* --env-for */
480
494
          errno = EINVAL;
481
495
          break;
482
496
        }
483
 
        add_environment(getplugin(arg), envdef, true);
 
497
        if(add_environment(getplugin(arg), envdef, true)){
 
498
          errno = 0;
 
499
        }
484
500
      }
485
501
      break;
486
502
    case 'd':                   /* --disable */
488
504
        plugin *p = getplugin(arg);
489
505
        if(p != NULL){
490
506
          p->disabled = true;
 
507
          errno = 0;
491
508
        }
492
509
      }
493
510
      break;
496
513
        plugin *p = getplugin(arg);
497
514
        if(p != NULL){
498
515
          p->disabled = false;
 
516
          errno = 0;
499
517
        }
500
518
      }
501
519
      break;
502
520
    case 128:                   /* --plugin-dir */
503
521
      free(plugindir);
504
522
      plugindir = strdup(arg);
 
523
      if(plugindir != NULL){
 
524
        errno = 0;
 
525
      }
505
526
      break;
506
527
    case 129:                   /* --config-file */
507
528
      /* This is already done by parse_opt_config_file() */
515
536
        break;
516
537
      }
517
538
      uid = (uid_t)tmp_id;
 
539
      errno = 0;
518
540
      break;
519
541
    case 131:                   /* --groupid */
520
542
      tmp_id = strtoimax(arg, &tmp, 10);
525
547
        break;
526
548
      }
527
549
      gid = (gid_t)tmp_id;
 
550
      errno = 0;
528
551
      break;
529
552
    case 132:                   /* --debug */
530
553
      debug = true;
531
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;
532
562
      /*
533
563
       * These reproduce what we would get without ARGP_NO_HELP
534
564
       */
535
565
    case '?':                   /* --help */
536
566
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
537
567
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
568
      __builtin_unreachable();
538
569
    case -3:                    /* --usage */
539
570
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
540
571
      argp_state_help(state, state->out_stream,
541
572
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
573
      __builtin_unreachable();
542
574
    case 'V':                   /* --version */
543
575
      fprintf(state->out_stream, "%s\n", argp_program_version);
544
576
      exit(EXIT_SUCCESS);
554
586
      if(arg[0] == '\0'){
555
587
        break;
556
588
      }
 
589
#if __GNUC__ >= 7
 
590
      __attribute__((fallthrough));
 
591
#else
 
592
          /* FALLTHROUGH */
 
593
#endif
557
594
    default:
558
595
      return ARGP_ERR_UNKNOWN;
559
596
    }
578
615
    case 129:                   /* --config-file */
579
616
      free(argfile);
580
617
      argfile = strdup(arg);
 
618
      if(argfile != NULL){
 
619
        errno = 0;
 
620
      }
581
621
      break;
582
622
    case 130:                   /* --userid */
583
623
    case 131:                   /* --groupid */
584
624
    case 132:                   /* --debug */
 
625
    case 133:                   /* --plugin-helper-dir */
585
626
    case '?':                   /* --help */
586
627
    case -3:                    /* --usage */
587
628
    case 'V':                   /* --version */
668
709
        custom_argc += 1;
669
710
        {
670
711
          char **new_argv = realloc(custom_argv, sizeof(char *)
671
 
                                    * ((unsigned int)
672
 
                                       custom_argc + 1));
 
712
                                    * ((size_t)custom_argc + 1));
673
713
          if(new_argv == NULL){
674
714
            error(0, errno, "realloc");
675
715
            exitstatus = EX_OSERR;
742
782
    goto fallback;
743
783
  }
744
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
  
745
803
  if(debug){
746
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
804
    for(plugin *p = plugin_list; p != NULL; p = p->next){
747
805
      fprintf(stderr, "Plugin: %s has %d arguments\n",
748
806
              p->name ? p->name : "Global", p->argc - 1);
749
807
      for(char **a = p->argv; *a != NULL; a++){
758
816
  
759
817
  if(getuid() == 0){
760
818
    /* Work around Debian bug #633582:
761
 
       <http://bugs.debian.org/633582> */
 
819
       <https://bugs.debian.org/633582> */
762
820
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
763
821
    if(plugindir_fd == -1){
764
 
      error(0, errno, "open");
 
822
      if(errno != ENOENT){
 
823
        error(0, errno, "open(\"" PDIR "\")");
 
824
      }
765
825
    } else {
766
826
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
767
827
      if(ret == -1){
774
834
          }
775
835
        }
776
836
      }
777
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
837
      close(plugindir_fd);
778
838
    }
779
839
  }
780
840
  
790
850
  
791
851
  /* Open plugin directory with close_on_exec flag */
792
852
  {
793
 
    int dir_fd = -1;
794
 
    if(plugindir == NULL){
795
 
      dir_fd = open(PDIR, O_RDONLY |
796
 
#ifdef O_CLOEXEC
797
 
                    O_CLOEXEC
798
 
#else  /* not O_CLOEXEC */
799
 
                    0
800
 
#endif  /* not O_CLOEXEC */
801
 
                    );
802
 
    } else {
803
 
      dir_fd = open(plugindir, O_RDONLY |
804
 
#ifdef O_CLOEXEC
805
 
                    O_CLOEXEC
806
 
#else  /* not O_CLOEXEC */
807
 
                    0
808
 
#endif  /* not O_CLOEXEC */
809
 
                    );
810
 
    }
 
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
                  );
811
860
    if(dir_fd == -1){
812
861
      error(0, errno, "Could not open plugin dir");
813
862
      exitstatus = EX_UNAVAILABLE;
819
868
    ret = set_cloexec_flag(dir_fd);
820
869
    if(ret < 0){
821
870
      error(0, errno, "set_cloexec_flag");
822
 
      TEMP_FAILURE_RETRY(close(dir_fd));
823
871
      exitstatus = EX_OSERR;
824
872
      goto fallback;
825
873
    }
826
874
#endif  /* O_CLOEXEC */
827
 
    
828
 
    dir = fdopendir(dir_fd);
829
 
    if(dir == NULL){
830
 
      error(0, errno, "Could not open plugin dir");
831
 
      TEMP_FAILURE_RETRY(close(dir_fd));
832
 
      exitstatus = EX_OSERR;
833
 
      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
      }
834
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;
835
909
  }
836
910
  
837
911
  FD_ZERO(&rfds_all);
838
912
  
839
913
  /* Read and execute any executable in the plugin directory*/
840
 
  while(true){
841
 
    do {
842
 
      dirst = readdir(dir);
843
 
    } while(dirst == NULL and errno == EINTR);
844
 
    
845
 
    /* All directory entries have been processed */
846
 
    if(dirst == NULL){
847
 
      if(errno == EBADF){
848
 
        error(0, errno, "readdir");
849
 
        exitstatus = EX_IOERR;
850
 
        goto fallback;
851
 
      }
852
 
      break;
853
 
    }
854
 
    
855
 
    d_name_len = strlen(dirst->d_name);
856
 
    
857
 
    /* Ignore dotfiles, backup files and other junk */
858
 
    {
859
 
      bool bad_name = false;
860
 
      
861
 
      const char * const bad_prefixes[] = { ".", "#", NULL };
862
 
      
863
 
      const char * const bad_suffixes[] = { "~", "#", ".dpkg-new",
864
 
                                           ".dpkg-old",
865
 
                                           ".dpkg-bak",
866
 
                                           ".dpkg-divert", NULL };
867
 
#ifdef __GNUC__
868
 
#pragma GCC diagnostic push
869
 
#pragma GCC diagnostic ignored "-Wcast-qual"
870
 
#endif
871
 
      for(const char **pre = (const char **)bad_prefixes;
872
 
          *pre != NULL; pre++){
873
 
#ifdef __GNUC__
874
 
#pragma GCC diagnostic pop
875
 
#endif
876
 
        size_t pre_len = strlen(*pre);
877
 
        if((d_name_len >= pre_len)
878
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
879
 
          if(debug){
880
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
881
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
882
 
          }
883
 
          bad_name = true;
884
 
          break;
885
 
        }
886
 
      }
887
 
      if(bad_name){
888
 
        continue;
889
 
      }
890
 
#ifdef __GNUC__
891
 
#pragma GCC diagnostic push
892
 
#pragma GCC diagnostic ignored "-Wcast-qual"
893
 
#endif
894
 
      for(const char **suf = (const char **)bad_suffixes;
895
 
          *suf != NULL; suf++){
896
 
#ifdef __GNUC__
897
 
#pragma GCC diagnostic pop
898
 
#endif
899
 
        size_t suf_len = strlen(*suf);
900
 
        if((d_name_len >= suf_len)
901
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
902
 
                == 0)){
903
 
          if(debug){
904
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
905
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
906
 
          }
907
 
          bad_name = true;
908
 
          break;
909
 
        }
910
 
      }
911
 
      
912
 
      if(bad_name){
913
 
        continue;
914
 
      }
915
 
    }
916
 
    
917
 
    char *filename;
918
 
    if(plugindir == NULL){
919
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
920
 
                                             dirst->d_name));
921
 
    } else {
922
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
923
 
                                             plugindir,
924
 
                                             dirst->d_name));
925
 
    }
926
 
    if(ret < 0){
927
 
      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]);
928
920
      continue;
929
921
    }
930
 
    
931
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
922
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
932
923
    if(ret == -1){
933
924
      error(0, errno, "stat");
934
 
      free(filename);
 
925
      close(plugin_fd);
 
926
      free(direntries[i]);
935
927
      continue;
936
928
    }
937
929
    
938
930
    /* Ignore non-executable files */
939
931
    if(not S_ISREG(st.st_mode)
940
 
       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)){
941
934
      if(debug){
942
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
943
 
                " 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);
944
939
      }
945
 
      free(filename);
 
940
      close(plugin_fd);
 
941
      free(direntries[i]);
946
942
      continue;
947
943
    }
948
944
    
949
 
    plugin *p = getplugin(dirst->d_name);
 
945
    plugin *p = getplugin(direntries[i]->d_name);
950
946
    if(p == NULL){
951
947
      error(0, errno, "getplugin");
952
 
      free(filename);
 
948
      close(plugin_fd);
 
949
      free(direntries[i]);
953
950
      continue;
954
951
    }
955
952
    if(p->disabled){
956
953
      if(debug){
957
954
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
958
 
                dirst->d_name);
 
955
                direntries[i]->d_name);
959
956
      }
960
 
      free(filename);
 
957
      close(plugin_fd);
 
958
      free(direntries[i]);
961
959
      continue;
962
960
    }
963
961
    {
977
975
        }
978
976
      }
979
977
    }
980
 
    /* If this plugin has any environment variables, we will call
981
 
       using execve and need to duplicate the environment from this
982
 
       process, too. */
 
978
    /* If this plugin has any environment variables, we need to
 
979
       duplicate the environment from this process, too. */
983
980
    if(p->environ[0] != NULL){
984
981
      for(char **e = environ; *e != NULL; e++){
985
982
        if(not add_environment(p, *e, false)){
989
986
    }
990
987
    
991
988
    int pipefd[2];
 
989
#ifndef O_CLOEXEC
992
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 */
993
994
    if(ret == -1){
994
995
      error(0, errno, "pipe");
995
996
      exitstatus = EX_OSERR;
996
 
      goto fallback;
997
 
    }
 
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
998
1010
    /* Ask OS to automatic close the pipe on exec */
999
1011
    ret = set_cloexec_flag(pipefd[0]);
1000
1012
    if(ret < 0){
1001
1013
      error(0, errno, "set_cloexec_flag");
 
1014
      close(pipefd[0]);
 
1015
      close(pipefd[1]);
1002
1016
      exitstatus = EX_OSERR;
 
1017
      free(direntries[i]);
1003
1018
      goto fallback;
1004
1019
    }
1005
1020
    ret = set_cloexec_flag(pipefd[1]);
1006
1021
    if(ret < 0){
1007
1022
      error(0, errno, "set_cloexec_flag");
 
1023
      close(pipefd[0]);
 
1024
      close(pipefd[1]);
1008
1025
      exitstatus = EX_OSERR;
 
1026
      free(direntries[i]);
1009
1027
      goto fallback;
1010
1028
    }
 
1029
#endif  /* not O_CLOEXEC */
1011
1030
    /* Block SIGCHLD until process is safely in process list */
1012
1031
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1013
1032
                                              &sigchld_action.sa_mask,
1015
1034
    if(ret < 0){
1016
1035
      error(0, errno, "sigprocmask");
1017
1036
      exitstatus = EX_OSERR;
 
1037
      free(direntries[i]);
1018
1038
      goto fallback;
1019
1039
    }
1020
1040
    /* Starting a new process to be watched */
1024
1044
    } while(pid == -1 and errno == EINTR);
1025
1045
    if(pid == -1){
1026
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]);
1027
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
1028
1053
      goto fallback;
1029
1054
    }
1030
1055
    if(pid == 0){
1046
1071
        _exit(EX_OSERR);
1047
1072
      }
1048
1073
      
1049
 
      if(dirfd(dir) < 0){
1050
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1051
 
           above and must now close it manually here. */
1052
 
        closedir(dir);
1053
 
      }
1054
 
      if(p->environ[0] == NULL){
1055
 
        if(execv(filename, p->argv) < 0){
1056
 
          error(0, errno, "execv for %s", filename);
1057
 
          _exit(EX_OSERR);
1058
 
        }
1059
 
      } else {
1060
 
        if(execve(filename, p->argv, p->environ) < 0){
1061
 
          error(0, errno, "execve for %s", filename);
1062
 
          _exit(EX_OSERR);
1063
 
        }
 
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);
1064
1080
      }
1065
1081
      /* no return */
1066
1082
    }
1067
1083
    /* Parent process */
1068
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1069
 
                                             pipe */
1070
 
    free(filename);
1071
 
    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);
1072
1087
    if(new_plugin == NULL){
1073
1088
      error(0, errno, "getplugin");
1074
1089
      ret = (int)(TEMP_FAILURE_RETRY
1078
1093
        error(0, errno, "sigprocmask");
1079
1094
      }
1080
1095
      exitstatus = EX_OSERR;
 
1096
      free(direntries[i]);
1081
1097
      goto fallback;
1082
1098
    }
 
1099
    free(direntries[i]);
1083
1100
    
1084
1101
    new_plugin->pid = pid;
1085
1102
    new_plugin->fd = pipefd[0];
1086
 
    
 
1103
 
 
1104
    if(debug){
 
1105
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1106
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1107
    }
 
1108
 
1087
1109
    /* Unblock SIGCHLD so signal handler can be run if this process
1088
1110
       has already completed */
1089
1111
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1095
1117
      goto fallback;
1096
1118
    }
1097
1119
    
1098
 
#if defined (__GNUC__) and defined (__GLIBC__)
1099
 
#if not __GLIBC_PREREQ(2, 16)
1100
 
#pragma GCC diagnostic push
1101
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1102
 
#endif
1103
 
#endif
1104
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1105
 
                                          -Wconversion in GNU libc
1106
 
                                          before 2.16 */
1107
 
#if defined (__GNUC__) and defined (__GLIBC__)
1108
 
#if not __GLIBC_PREREQ(2, 16)
1109
 
#pragma GCC diagnostic pop
1110
 
#endif
1111
 
#endif
 
1120
    FD_SET(new_plugin->fd, &rfds_all);
1112
1121
    
1113
1122
    if(maxfd < new_plugin->fd){
1114
1123
      maxfd = new_plugin->fd;
1115
1124
    }
1116
1125
  }
1117
1126
  
1118
 
  TEMP_FAILURE_RETRY(closedir(dir));
1119
 
  dir = NULL;
 
1127
  free(direntries);
 
1128
  direntries = NULL;
 
1129
  close(dir_fd);
 
1130
  dir_fd = -1;
1120
1131
  free_plugin(getplugin(NULL));
1121
1132
  
1122
1133
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1161
1172
                      (intmax_t) (proc->pid),
1162
1173
                      WTERMSIG(proc->status),
1163
1174
                      strsignal(WTERMSIG(proc->status)));
1164
 
            } else if(WCOREDUMP(proc->status)){
1165
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1166
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1167
1175
            }
1168
1176
          }
1169
1177
          
1170
1178
          /* Remove the plugin */
1171
 
#if defined (__GNUC__) and defined (__GLIBC__)
1172
 
#if not __GLIBC_PREREQ(2, 16)
1173
 
#pragma GCC diagnostic push
1174
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1175
 
#endif
1176
 
#endif
1177
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1178
 
                                          -Wconversion in GNU libc
1179
 
                                          before 2.16 */
1180
 
#if defined (__GNUC__) and defined (__GLIBC__)
1181
 
#if not __GLIBC_PREREQ(2, 16)
1182
 
#pragma GCC diagnostic pop
1183
 
#endif
1184
 
#endif
 
1179
          FD_CLR(proc->fd, &rfds_all);
1185
1180
          
1186
1181
          /* Block signal while modifying process_list */
1187
1182
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1227
1222
      }
1228
1223
      
1229
1224
      /* This process has not completed.  Does it have any output? */
1230
 
#if defined (__GNUC__) and defined (__GLIBC__)
1231
 
#if not __GLIBC_PREREQ(2, 16)
1232
 
#pragma GCC diagnostic push
1233
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1234
 
#endif
1235
 
#endif
1236
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1237
 
                                                         warning from
1238
 
                                                         -Wconversion
1239
 
                                                         in GNU libc
1240
 
                                                         before
1241
 
                                                         2.16 */
1242
 
#if defined (__GNUC__) and defined (__GLIBC__)
1243
 
#if not __GLIBC_PREREQ(2, 16)
1244
 
#pragma GCC diagnostic pop
1245
 
#endif
1246
 
#endif
 
1225
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1247
1226
        /* This process had nothing to say at this time */
1248
1227
        proc = proc->next;
1249
1228
        continue;
1316
1295
    free(custom_argv);
1317
1296
  }
1318
1297
  
1319
 
  if(dir != NULL){
1320
 
    closedir(dir);
 
1298
  free(direntries);
 
1299
  
 
1300
  if(dir_fd != -1){
 
1301
    close(dir_fd);
1321
1302
  }
1322
1303
  
1323
1304
  /* Kill the processes */
1343
1324
  free_plugin_list();
1344
1325
  
1345
1326
  free(plugindir);
 
1327
  free(pluginhelperdir);
1346
1328
  free(argfile);
1347
1329
  
1348
1330
  return exitstatus;