/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:
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
 
                                   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
33
                                   stderr, STDOUT_FILENO, fclose() */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), fstat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
 
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() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
43
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() */
 
44
#include <dirent.h>             /* struct dirent, scandirat() */
47
45
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
48
46
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
49
47
                                   struct stat, fstat(), close(),
50
48
                                   setgid(), setuid(), S_ISREG(),
51
 
                                   faccessat() pipe(), fork(),
 
49
                                   faccessat() pipe2(), fork(),
52
50
                                   _exit(), dup2(), fexecve(), read()
53
51
                                */
54
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC, openat() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
56
55
#include <string.h>             /* strsep, strlen(), strsignal(),
57
56
                                   strcmp(), strncmp() */
58
57
#include <errno.h>              /* errno */
77
76
#define BUFFER_SIZE 256
78
77
 
79
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
80
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
81
81
 
82
82
const char *argp_program_version = "plugin-runner " VERSION;
241
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
242
242
}
243
243
 
 
244
#ifndef O_CLOEXEC
244
245
/*
245
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
246
247
 * Descriptor Flags".
257
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
258
259
                                       ret | FD_CLOEXEC));
259
260
}
 
261
#endif  /* not O_CLOEXEC */
260
262
 
261
263
 
262
264
/* Mark processes as completed when they exit, and save their exit
311
313
__attribute__((nonnull))
312
314
static void free_plugin(plugin *plugin_node){
313
315
  
314
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
316
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
315
317
    free(*arg);
316
318
  }
 
319
  free(plugin_node->name);
317
320
  free(plugin_node->argv);
318
321
  for(char **env = plugin_node->environ; *env != NULL; env++){
319
322
    free(*env);
346
349
 
347
350
int main(int argc, char *argv[]){
348
351
  char *plugindir = NULL;
 
352
  char *pluginhelperdir = NULL;
349
353
  char *argfile = NULL;
350
354
  FILE *conffp;
351
 
  DIR *dir = NULL;
352
 
  struct dirent *dirst;
 
355
  struct dirent **direntries = NULL;
353
356
  struct stat st;
354
357
  fd_set rfds_all;
355
358
  int ret, maxfd = 0;
363
366
                                      .sa_flags = SA_NOCLDSTOP };
364
367
  char **custom_argv = NULL;
365
368
  int custom_argc = 0;
366
 
  int dir_fd;
 
369
  int dir_fd = -1;
367
370
  
368
371
  /* Establish a signal handler */
369
372
  sigemptyset(&sigchld_action.sa_mask);
414
417
      .doc = "Group ID the plugins will run as", .group = 3 },
415
418
    { .name = "debug", .key = 132,
416
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 },
417
424
    /*
418
425
     * These reproduce what we would get without ARGP_NO_HELP
419
426
     */
545
552
    case 132:                   /* --debug */
546
553
      debug = true;
547
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;
548
562
      /*
549
563
       * These reproduce what we would get without ARGP_NO_HELP
550
564
       */
551
565
    case '?':                   /* --help */
552
566
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
553
567
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
568
      __builtin_unreachable();
554
569
    case -3:                    /* --usage */
555
570
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
556
571
      argp_state_help(state, state->out_stream,
557
572
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
573
      __builtin_unreachable();
558
574
    case 'V':                   /* --version */
559
575
      fprintf(state->out_stream, "%s\n", argp_program_version);
560
576
      exit(EXIT_SUCCESS);
570
586
      if(arg[0] == '\0'){
571
587
        break;
572
588
      }
 
589
#if __GNUC__ >= 7
 
590
      __attribute__((fallthrough));
 
591
#else
 
592
          /* FALLTHROUGH */
 
593
#endif
573
594
    default:
574
595
      return ARGP_ERR_UNKNOWN;
575
596
    }
601
622
    case 130:                   /* --userid */
602
623
    case 131:                   /* --groupid */
603
624
    case 132:                   /* --debug */
 
625
    case 133:                   /* --plugin-helper-dir */
604
626
    case '?':                   /* --help */
605
627
    case -3:                    /* --usage */
606
628
    case 'V':                   /* --version */
687
709
        custom_argc += 1;
688
710
        {
689
711
          char **new_argv = realloc(custom_argv, sizeof(char *)
690
 
                                    * ((unsigned int)
691
 
                                       custom_argc + 1));
 
712
                                    * ((size_t)custom_argc + 1));
692
713
          if(new_argv == NULL){
693
714
            error(0, errno, "realloc");
694
715
            exitstatus = EX_OSERR;
761
782
    goto fallback;
762
783
  }
763
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
  
764
803
  if(debug){
765
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
804
    for(plugin *p = plugin_list; p != NULL; p = p->next){
766
805
      fprintf(stderr, "Plugin: %s has %d arguments\n",
767
806
              p->name ? p->name : "Global", p->argc - 1);
768
807
      for(char **a = p->argv; *a != NULL; a++){
777
816
  
778
817
  if(getuid() == 0){
779
818
    /* Work around Debian bug #633582:
780
 
       <http://bugs.debian.org/633582> */
 
819
       <https://bugs.debian.org/633582> */
781
820
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
782
821
    if(plugindir_fd == -1){
783
822
      if(errno != ENOENT){
795
834
          }
796
835
        }
797
836
      }
798
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
837
      close(plugindir_fd);
799
838
    }
800
839
  }
801
840
  
829
868
    ret = set_cloexec_flag(dir_fd);
830
869
    if(ret < 0){
831
870
      error(0, errno, "set_cloexec_flag");
832
 
      TEMP_FAILURE_RETRY(close(dir_fd));
833
871
      exitstatus = EX_OSERR;
834
872
      goto fallback;
835
873
    }
836
874
#endif  /* O_CLOEXEC */
837
 
    
838
 
    dir = fdopendir(dir_fd);
839
 
    if(dir == NULL){
840
 
      error(0, errno, "Could not open plugin dir");
841
 
      TEMP_FAILURE_RETRY(close(dir_fd));
842
 
      exitstatus = EX_OSERR;
843
 
      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
      }
844
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;
845
909
  }
846
910
  
847
911
  FD_ZERO(&rfds_all);
848
912
  
849
913
  /* Read and execute any executable in the plugin directory*/
850
 
  while(true){
851
 
    do {
852
 
      dirst = readdir(dir);
853
 
    } while(dirst == NULL and errno == EINTR);
854
 
    
855
 
    /* All directory entries have been processed */
856
 
    if(dirst == NULL){
857
 
      if(errno == EBADF){
858
 
        error(0, errno, "readdir");
859
 
        exitstatus = EX_IOERR;
860
 
        goto fallback;
861
 
      }
862
 
      break;
863
 
    }
864
 
    
865
 
    /* Ignore dotfiles, backup files and other junk */
866
 
    {
867
 
      bool bad_name = false;
868
 
      const char * const patterns[] = { ".*", "#*#", "*~",
869
 
                                        "*.dpkg-new", "*.dpkg-old",
870
 
                                        "*.dpkg-bak", "*.dpkg-divert",
871
 
                                        NULL };
872
 
#ifdef __GNUC__
873
 
#pragma GCC diagnostic push
874
 
#pragma GCC diagnostic ignored "-Wcast-qual"
875
 
#endif
876
 
      for(const char **pat = (const char **)patterns;
877
 
          *pat != NULL; pat++){
878
 
#ifdef __GNUC__
879
 
#pragma GCC diagnostic pop
880
 
#endif
881
 
        if(fnmatch(*pat, dirst->d_name,
882
 
                   FNM_FILE_NAME | FNM_PERIOD) != FNM_NOMATCH){
883
 
          if(debug){
884
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
885
 
                    " matching pattern %s\n", dirst->d_name, *pat);
886
 
          }
887
 
          bad_name = true;
888
 
          break;
889
 
        }
890
 
      }
891
 
      if(bad_name){
892
 
        continue;
893
 
      }
894
 
    }
895
 
    
896
 
    int plugin_fd = openat(dir_fd, dirst->d_name, O_RDONLY |
897
 
#ifdef O_CLOEXEC
898
 
                            O_CLOEXEC
899
 
#else  /* not O_CLOEXEC */
900
 
                            0
901
 
#endif  /* not O_CLOEXEC */
902
 
                            );
 
914
  for(int i = 0; i < numplugins; i++){
 
915
    
 
916
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
903
917
    if(plugin_fd == -1){
904
918
      error(0, errno, "Could not open plugin");
905
 
      continue;
906
 
    }
907
 
#ifndef O_CLOEXEC
908
 
  /* Set the FD_CLOEXEC flag on the plugin FD */
909
 
    ret = set_cloexec_flag(plugin_fd);
910
 
    if(ret < 0){
911
 
      error(0, errno, "set_cloexec_flag");
912
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
913
 
      continue;
914
 
    }
915
 
#endif  /* O_CLOEXEC */
 
919
      free(direntries[i]);
 
920
      continue;
 
921
    }
916
922
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
917
923
    if(ret == -1){
918
924
      error(0, errno, "stat");
919
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
925
      close(plugin_fd);
 
926
      free(direntries[i]);
920
927
      continue;
921
928
    }
922
929
    
923
930
    /* Ignore non-executable files */
924
931
    if(not S_ISREG(st.st_mode)
925
 
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, dirst->d_name, X_OK,
926
 
                                        0)) != 0)){
 
932
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
933
                                        X_OK, 0)) != 0)){
927
934
      if(debug){
928
935
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
929
936
                " with bad type or mode\n",
930
 
                plugindir != NULL ? plugindir : PDIR, dirst->d_name);
 
937
                plugindir != NULL ? plugindir : PDIR,
 
938
                direntries[i]->d_name);
931
939
      }
932
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
940
      close(plugin_fd);
 
941
      free(direntries[i]);
933
942
      continue;
934
943
    }
935
944
    
936
 
    plugin *p = getplugin(dirst->d_name);
 
945
    plugin *p = getplugin(direntries[i]->d_name);
937
946
    if(p == NULL){
938
947
      error(0, errno, "getplugin");
939
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
948
      close(plugin_fd);
 
949
      free(direntries[i]);
940
950
      continue;
941
951
    }
942
952
    if(p->disabled){
943
953
      if(debug){
944
954
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
945
 
                dirst->d_name);
 
955
                direntries[i]->d_name);
946
956
      }
947
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
957
      close(plugin_fd);
 
958
      free(direntries[i]);
948
959
      continue;
949
960
    }
950
961
    {
975
986
    }
976
987
    
977
988
    int pipefd[2];
 
989
#ifndef O_CLOEXEC
978
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 */
979
994
    if(ret == -1){
980
995
      error(0, errno, "pipe");
981
996
      exitstatus = EX_OSERR;
982
 
      goto fallback;
983
 
    }
 
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
984
1010
    /* Ask OS to automatic close the pipe on exec */
985
1011
    ret = set_cloexec_flag(pipefd[0]);
986
1012
    if(ret < 0){
987
1013
      error(0, errno, "set_cloexec_flag");
 
1014
      close(pipefd[0]);
 
1015
      close(pipefd[1]);
988
1016
      exitstatus = EX_OSERR;
 
1017
      free(direntries[i]);
989
1018
      goto fallback;
990
1019
    }
991
1020
    ret = set_cloexec_flag(pipefd[1]);
992
1021
    if(ret < 0){
993
1022
      error(0, errno, "set_cloexec_flag");
 
1023
      close(pipefd[0]);
 
1024
      close(pipefd[1]);
994
1025
      exitstatus = EX_OSERR;
 
1026
      free(direntries[i]);
995
1027
      goto fallback;
996
1028
    }
 
1029
#endif  /* not O_CLOEXEC */
997
1030
    /* Block SIGCHLD until process is safely in process list */
998
1031
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
999
1032
                                              &sigchld_action.sa_mask,
1001
1034
    if(ret < 0){
1002
1035
      error(0, errno, "sigprocmask");
1003
1036
      exitstatus = EX_OSERR;
 
1037
      free(direntries[i]);
1004
1038
      goto fallback;
1005
1039
    }
1006
1040
    /* Starting a new process to be watched */
1010
1044
    } while(pid == -1 and errno == EINTR);
1011
1045
    if(pid == -1){
1012
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]);
1013
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
1014
1053
      goto fallback;
1015
1054
    }
1016
1055
    if(pid == 0){
1032
1071
        _exit(EX_OSERR);
1033
1072
      }
1034
1073
      
1035
 
      if(dirfd(dir) < 0){
1036
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1037
 
           above and must now close it manually here. */
1038
 
        closedir(dir);
1039
 
      }
1040
1074
      if(fexecve(plugin_fd, p->argv,
1041
1075
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
1042
1076
        error(0, errno, "fexecve for %s/%s",
1043
 
              plugindir != NULL ? plugindir : PDIR, dirst->d_name);
 
1077
              plugindir != NULL ? plugindir : PDIR,
 
1078
              direntries[i]->d_name);
1044
1079
        _exit(EX_OSERR);
1045
1080
      }
1046
1081
      /* no return */
1047
1082
    }
1048
1083
    /* Parent process */
1049
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1050
 
                                             pipe */
1051
 
    TEMP_FAILURE_RETRY(close(plugin_fd));
1052
 
    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);
1053
1087
    if(new_plugin == NULL){
1054
1088
      error(0, errno, "getplugin");
1055
1089
      ret = (int)(TEMP_FAILURE_RETRY
1059
1093
        error(0, errno, "sigprocmask");
1060
1094
      }
1061
1095
      exitstatus = EX_OSERR;
 
1096
      free(direntries[i]);
1062
1097
      goto fallback;
1063
1098
    }
 
1099
    free(direntries[i]);
1064
1100
    
1065
1101
    new_plugin->pid = pid;
1066
1102
    new_plugin->fd = pipefd[0];
1067
 
    
 
1103
 
 
1104
    if(debug){
 
1105
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1106
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1107
    }
 
1108
 
1068
1109
    /* Unblock SIGCHLD so signal handler can be run if this process
1069
1110
       has already completed */
1070
1111
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1076
1117
      goto fallback;
1077
1118
    }
1078
1119
    
1079
 
#if defined (__GNUC__) and defined (__GLIBC__)
1080
 
#if not __GLIBC_PREREQ(2, 16)
1081
 
#pragma GCC diagnostic push
1082
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1083
 
#endif
1084
 
#endif
1085
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1086
 
                                          -Wconversion in GNU libc
1087
 
                                          before 2.16 */
1088
 
#if defined (__GNUC__) and defined (__GLIBC__)
1089
 
#if not __GLIBC_PREREQ(2, 16)
1090
 
#pragma GCC diagnostic pop
1091
 
#endif
1092
 
#endif
 
1120
    FD_SET(new_plugin->fd, &rfds_all);
1093
1121
    
1094
1122
    if(maxfd < new_plugin->fd){
1095
1123
      maxfd = new_plugin->fd;
1096
1124
    }
1097
1125
  }
1098
1126
  
1099
 
  TEMP_FAILURE_RETRY(closedir(dir));
1100
 
  dir = NULL;
 
1127
  free(direntries);
 
1128
  direntries = NULL;
 
1129
  close(dir_fd);
 
1130
  dir_fd = -1;
1101
1131
  free_plugin(getplugin(NULL));
1102
1132
  
1103
1133
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1142
1172
                      (intmax_t) (proc->pid),
1143
1173
                      WTERMSIG(proc->status),
1144
1174
                      strsignal(WTERMSIG(proc->status)));
1145
 
            } else if(WCOREDUMP(proc->status)){
1146
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1147
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1148
1175
            }
1149
1176
          }
1150
1177
          
1151
1178
          /* Remove the plugin */
1152
 
#if defined (__GNUC__) and defined (__GLIBC__)
1153
 
#if not __GLIBC_PREREQ(2, 16)
1154
 
#pragma GCC diagnostic push
1155
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1156
 
#endif
1157
 
#endif
1158
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1159
 
                                          -Wconversion in GNU libc
1160
 
                                          before 2.16 */
1161
 
#if defined (__GNUC__) and defined (__GLIBC__)
1162
 
#if not __GLIBC_PREREQ(2, 16)
1163
 
#pragma GCC diagnostic pop
1164
 
#endif
1165
 
#endif
 
1179
          FD_CLR(proc->fd, &rfds_all);
1166
1180
          
1167
1181
          /* Block signal while modifying process_list */
1168
1182
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1208
1222
      }
1209
1223
      
1210
1224
      /* This process has not completed.  Does it have any output? */
1211
 
#if defined (__GNUC__) and defined (__GLIBC__)
1212
 
#if not __GLIBC_PREREQ(2, 16)
1213
 
#pragma GCC diagnostic push
1214
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1215
 
#endif
1216
 
#endif
1217
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1218
 
                                                         warning from
1219
 
                                                         -Wconversion
1220
 
                                                         in GNU libc
1221
 
                                                         before
1222
 
                                                         2.16 */
1223
 
#if defined (__GNUC__) and defined (__GLIBC__)
1224
 
#if not __GLIBC_PREREQ(2, 16)
1225
 
#pragma GCC diagnostic pop
1226
 
#endif
1227
 
#endif
 
1225
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1228
1226
        /* This process had nothing to say at this time */
1229
1227
        proc = proc->next;
1230
1228
        continue;
1297
1295
    free(custom_argv);
1298
1296
  }
1299
1297
  
1300
 
  if(dir != NULL){
1301
 
    closedir(dir);
 
1298
  free(direntries);
 
1299
  
 
1300
  if(dir_fd != -1){
 
1301
    close(dir_fd);
1302
1302
  }
1303
1303
  
1304
1304
  /* Kill the processes */
1324
1324
  free_plugin_list();
1325
1325
  
1326
1326
  free(plugindir);
 
1327
  free(pluginhelperdir);
1327
1328
  free(argfile);
1328
1329
  
1329
1330
  return exitstatus;