/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-03-18 22:29:25 UTC
  • Revision ID: teddy@recompile.se-20190318222925-jvhek84dgcfgj6g3
mandos-ctl: Refactor tests

* mandos-ctl: Where the clients names "foo" and "barbar" do not refer
              to the actual mock clients in the TestCommand class,
              change all occurrences of these names to "client1" and
              "client2" (or just "client" when only one is used) .
              Also change all test doubles to use correct terminology;
              some things called mocks are actually stubs or spies,
              and rename all true mocks to have "mock" in their names.
              Also eliminate duplicate values in tests; derive values
              from previously defined values whenever possible.

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-2014 Teddy Hogeborn
6
 
 * Copyright © 2008-2014 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
 */
37
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS(), WTERMSIG(),
41
 
                                   WCOREDUMP() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
42
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
43
43
#include <iso646.h>             /* and, or, not */
44
44
#include <dirent.h>             /* struct dirent, scandirat() */
564
564
    case '?':                   /* --help */
565
565
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
566
566
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
567
      __builtin_unreachable();
567
568
    case -3:                    /* --usage */
568
569
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
569
570
      argp_state_help(state, state->out_stream,
570
571
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
572
      __builtin_unreachable();
571
573
    case 'V':                   /* --version */
572
574
      fprintf(state->out_stream, "%s\n", argp_program_version);
573
575
      exit(EXIT_SUCCESS);
583
585
      if(arg[0] == '\0'){
584
586
        break;
585
587
      }
 
588
      /* FALLTHROUGH */
586
589
    default:
587
590
      return ARGP_ERR_UNKNOWN;
588
591
    }
701
704
        custom_argc += 1;
702
705
        {
703
706
          char **new_argv = realloc(custom_argv, sizeof(char *)
704
 
                                    * ((unsigned int)
705
 
                                       custom_argc + 1));
 
707
                                    * ((size_t)custom_argc + 1));
706
708
          if(new_argv == NULL){
707
709
            error(0, errno, "realloc");
708
710
            exitstatus = EX_OSERR;
794
796
  }
795
797
  
796
798
  if(debug){
797
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
799
    for(plugin *p = plugin_list; p != NULL; p = p->next){
798
800
      fprintf(stderr, "Plugin: %s has %d arguments\n",
799
801
              p->name ? p->name : "Global", p->argc - 1);
800
802
      for(char **a = p->argv; *a != NULL; a++){
809
811
  
810
812
  if(getuid() == 0){
811
813
    /* Work around Debian bug #633582:
812
 
       <http://bugs.debian.org/633582> */
 
814
       <https://bugs.debian.org/633582> */
813
815
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
816
    if(plugindir_fd == -1){
815
817
      if(errno != ENOENT){
827
829
          }
828
830
        }
829
831
      }
830
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
832
      close(plugindir_fd);
831
833
    }
832
834
  }
833
835
  
892
894
    return 1;
893
895
  }
894
896
  
895
 
#ifdef __GLIBC__
896
 
#if __GLIBC_PREREQ(2, 15)
897
897
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
898
898
                             alphasort);
899
 
#else  /* not __GLIBC_PREREQ(2, 15) */
900
 
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
901
 
                           &direntries, good_name, alphasort);
902
 
#endif  /* not __GLIBC_PREREQ(2, 15) */
903
 
#else   /* not __GLIBC__ */
904
 
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
905
 
                           &direntries, good_name, alphasort);
906
 
#endif  /* not __GLIBC__ */
907
899
  if(numplugins == -1){
908
900
    error(0, errno, "Could not scan plugin dir");
909
901
    direntries = NULL;
925
917
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
926
918
    if(ret == -1){
927
919
      error(0, errno, "stat");
928
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
920
      close(plugin_fd);
929
921
      free(direntries[i]);
930
922
      continue;
931
923
    }
940
932
                plugindir != NULL ? plugindir : PDIR,
941
933
                direntries[i]->d_name);
942
934
      }
943
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
935
      close(plugin_fd);
944
936
      free(direntries[i]);
945
937
      continue;
946
938
    }
948
940
    plugin *p = getplugin(direntries[i]->d_name);
949
941
    if(p == NULL){
950
942
      error(0, errno, "getplugin");
951
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
943
      close(plugin_fd);
952
944
      free(direntries[i]);
953
945
      continue;
954
946
    }
957
949
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
958
950
                direntries[i]->d_name);
959
951
      }
960
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
952
      close(plugin_fd);
961
953
      free(direntries[i]);
962
954
      continue;
963
955
    }
1003
995
    if(pipefd[0] >= FD_SETSIZE){
1004
996
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1005
997
              FD_SETSIZE);
1006
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1007
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
998
      close(pipefd[0]);
 
999
      close(pipefd[1]);
1008
1000
      exitstatus = EX_OSERR;
1009
1001
      free(direntries[i]);
1010
1002
      goto fallback;
1014
1006
    ret = set_cloexec_flag(pipefd[0]);
1015
1007
    if(ret < 0){
1016
1008
      error(0, errno, "set_cloexec_flag");
1017
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1018
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1009
      close(pipefd[0]);
 
1010
      close(pipefd[1]);
1019
1011
      exitstatus = EX_OSERR;
1020
1012
      free(direntries[i]);
1021
1013
      goto fallback;
1023
1015
    ret = set_cloexec_flag(pipefd[1]);
1024
1016
    if(ret < 0){
1025
1017
      error(0, errno, "set_cloexec_flag");
1026
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1027
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1018
      close(pipefd[0]);
 
1019
      close(pipefd[1]);
1028
1020
      exitstatus = EX_OSERR;
1029
1021
      free(direntries[i]);
1030
1022
      goto fallback;
1049
1041
      error(0, errno, "fork");
1050
1042
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1051
1043
                                     &sigchld_action.sa_mask, NULL));
1052
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1053
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1044
      close(pipefd[0]);
 
1045
      close(pipefd[1]);
1054
1046
      exitstatus = EX_OSERR;
1055
1047
      free(direntries[i]);
1056
1048
      goto fallback;
1084
1076
      /* no return */
1085
1077
    }
1086
1078
    /* Parent process */
1087
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1088
 
                                             pipe */
1089
 
    TEMP_FAILURE_RETRY(close(plugin_fd));
 
1079
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1080
    close(plugin_fd);
1090
1081
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1091
1082
    if(new_plugin == NULL){
1092
1083
      error(0, errno, "getplugin");
1104
1095
    
1105
1096
    new_plugin->pid = pid;
1106
1097
    new_plugin->fd = pipefd[0];
1107
 
    
 
1098
 
 
1099
    if(debug){
 
1100
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1101
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1102
    }
 
1103
 
1108
1104
    /* Unblock SIGCHLD so signal handler can be run if this process
1109
1105
       has already completed */
1110
1106
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1116
1112
      goto fallback;
1117
1113
    }
1118
1114
    
1119
 
#if defined (__GNUC__) and defined (__GLIBC__)
1120
 
#if not __GLIBC_PREREQ(2, 16)
1121
 
#pragma GCC diagnostic push
1122
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1123
 
#endif
1124
 
#endif
1125
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1126
 
                                          -Wconversion in GNU libc
1127
 
                                          before 2.16 */
1128
 
#if defined (__GNUC__) and defined (__GLIBC__)
1129
 
#if not __GLIBC_PREREQ(2, 16)
1130
 
#pragma GCC diagnostic pop
1131
 
#endif
1132
 
#endif
 
1115
    FD_SET(new_plugin->fd, &rfds_all);
1133
1116
    
1134
1117
    if(maxfd < new_plugin->fd){
1135
1118
      maxfd = new_plugin->fd;
1138
1121
  
1139
1122
  free(direntries);
1140
1123
  direntries = NULL;
1141
 
  TEMP_FAILURE_RETRY(close(dir_fd));
 
1124
  close(dir_fd);
1142
1125
  dir_fd = -1;
1143
1126
  free_plugin(getplugin(NULL));
1144
1127
  
1184
1167
                      (intmax_t) (proc->pid),
1185
1168
                      WTERMSIG(proc->status),
1186
1169
                      strsignal(WTERMSIG(proc->status)));
1187
 
            } else if(WCOREDUMP(proc->status)){
1188
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1189
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1190
1170
            }
1191
1171
          }
1192
1172
          
1193
1173
          /* Remove the plugin */
1194
 
#if defined (__GNUC__) and defined (__GLIBC__)
1195
 
#if not __GLIBC_PREREQ(2, 16)
1196
 
#pragma GCC diagnostic push
1197
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1198
 
#endif
1199
 
#endif
1200
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1201
 
                                          -Wconversion in GNU libc
1202
 
                                          before 2.16 */
1203
 
#if defined (__GNUC__) and defined (__GLIBC__)
1204
 
#if not __GLIBC_PREREQ(2, 16)
1205
 
#pragma GCC diagnostic pop
1206
 
#endif
1207
 
#endif
 
1174
          FD_CLR(proc->fd, &rfds_all);
1208
1175
          
1209
1176
          /* Block signal while modifying process_list */
1210
1177
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1250
1217
      }
1251
1218
      
1252
1219
      /* This process has not completed.  Does it have any output? */
1253
 
#if defined (__GNUC__) and defined (__GLIBC__)
1254
 
#if not __GLIBC_PREREQ(2, 16)
1255
 
#pragma GCC diagnostic push
1256
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1257
 
#endif
1258
 
#endif
1259
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1260
 
                                                         warning from
1261
 
                                                         -Wconversion
1262
 
                                                         in GNU libc
1263
 
                                                         before
1264
 
                                                         2.16 */
1265
 
#if defined (__GNUC__) and defined (__GLIBC__)
1266
 
#if not __GLIBC_PREREQ(2, 16)
1267
 
#pragma GCC diagnostic pop
1268
 
#endif
1269
 
#endif
 
1220
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1270
1221
        /* This process had nothing to say at this time */
1271
1222
        proc = proc->next;
1272
1223
        continue;
1342
1293
  free(direntries);
1343
1294
  
1344
1295
  if(dir_fd != -1){
1345
 
    TEMP_FAILURE_RETRY(close(dir_fd));
 
1296
    close(dir_fd);
1346
1297
  }
1347
1298
  
1348
1299
  /* Kill the processes */