/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: 2014-07-25 22:44:20 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

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-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
 
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
16
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
17
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
16
 * General Public License for more details.
19
17
 * 
20
18
 * You should have received a copy of the GNU General Public License
21
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
19
 * along with this program.  If not, see
 
20
 * <http://www.gnu.org/licenses/>.
22
21
 * 
23
22
 * Contact the authors at <mandos@recompile.se>.
24
23
 */
26
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
27
26
                                   O_CLOEXEC, pipe2() */
28
27
#include <stddef.h>             /* size_t, NULL */
29
 
#include <stdlib.h>             /* malloc(), reallocarray(), realloc(),
30
 
                                   EXIT_SUCCESS, exit() */
 
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
 
29
                                   realloc() */
31
30
#include <stdbool.h>            /* bool, true, false */
32
31
#include <stdio.h>              /* fileno(), fprintf(),
33
32
                                   stderr, STDOUT_FILENO, fclose() */
38
37
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
38
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
39
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG() */
 
40
                                   WEXITSTATUS(), WTERMSIG(),
 
41
                                   WCOREDUMP() */
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() */
76
76
#define BUFFER_SIZE 256
77
77
 
78
78
#define PDIR "/lib/mandos/plugins.d"
79
 
#define PHDIR "/lib/mandos/plugin-helpers"
80
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
81
80
 
82
81
const char *argp_program_version = "plugin-runner " VERSION;
179
178
  /* Resize the pointed-to array to hold one more pointer */
180
179
  char **new_array = NULL;
181
180
  do {
182
 
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
183
 
    new_array = reallocarray(*array, (size_t)((*len) + 2),
184
 
                             sizeof(char *));
185
 
#else
186
 
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
187
 
      /* overflow */
188
 
      new_array = NULL;
189
 
      errno = ENOMEM;
190
 
    } else {
191
 
      new_array = realloc(*array, (size_t)((*len) + 2)
192
 
                          * sizeof(char *));
193
 
    }
194
 
#endif
 
181
    new_array = realloc(*array, sizeof(char *)
 
182
                        * (size_t) ((*len) + 2));
195
183
  } while(new_array == NULL and errno == EINTR);
196
184
  /* Malloc check */
197
185
  if(new_array == NULL){
324
312
__attribute__((nonnull))
325
313
static void free_plugin(plugin *plugin_node){
326
314
  
327
 
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
 
315
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
328
316
    free(*arg);
329
317
  }
330
 
  free(plugin_node->name);
331
318
  free(plugin_node->argv);
332
319
  for(char **env = plugin_node->environ; *env != NULL; env++){
333
320
    free(*env);
360
347
 
361
348
int main(int argc, char *argv[]){
362
349
  char *plugindir = NULL;
363
 
  char *pluginhelperdir = NULL;
364
350
  char *argfile = NULL;
365
351
  FILE *conffp;
366
352
  struct dirent **direntries = NULL;
428
414
      .doc = "Group ID the plugins will run as", .group = 3 },
429
415
    { .name = "debug", .key = 132,
430
416
      .doc = "Debug mode", .group = 4 },
431
 
    { .name = "plugin-helper-dir", .key = 133,
432
 
      .arg = "DIRECTORY",
433
 
      .doc = "Specify a different plugin helper directory",
434
 
      .group = 2 },
435
417
    /*
436
418
     * These reproduce what we would get without ARGP_NO_HELP
437
419
     */
563
545
    case 132:                   /* --debug */
564
546
      debug = true;
565
547
      break;
566
 
    case 133:                   /* --plugin-helper-dir */
567
 
      free(pluginhelperdir);
568
 
      pluginhelperdir = strdup(arg);
569
 
      if(pluginhelperdir != NULL){
570
 
        errno = 0;
571
 
      }
572
 
      break;
573
548
      /*
574
549
       * These reproduce what we would get without ARGP_NO_HELP
575
550
       */
576
551
    case '?':                   /* --help */
577
552
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
578
553
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
579
 
      __builtin_unreachable();
580
554
    case -3:                    /* --usage */
581
555
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
582
556
      argp_state_help(state, state->out_stream,
583
557
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
584
 
      __builtin_unreachable();
585
558
    case 'V':                   /* --version */
586
559
      fprintf(state->out_stream, "%s\n", argp_program_version);
587
560
      exit(EXIT_SUCCESS);
597
570
      if(arg[0] == '\0'){
598
571
        break;
599
572
      }
600
 
#if __GNUC__ >= 7
601
 
      __attribute__((fallthrough));
602
 
#else
603
 
          /* FALLTHROUGH */
604
 
#endif
605
573
    default:
606
574
      return ARGP_ERR_UNKNOWN;
607
575
    }
633
601
    case 130:                   /* --userid */
634
602
    case 131:                   /* --groupid */
635
603
    case 132:                   /* --debug */
636
 
    case 133:                   /* --plugin-helper-dir */
637
604
    case '?':                   /* --help */
638
605
    case -3:                    /* --usage */
639
606
    case 'V':                   /* --version */
719
686
        
720
687
        custom_argc += 1;
721
688
        {
722
 
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
723
 
          char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
724
 
                                         sizeof(char *));
725
 
#else
726
 
          char **new_argv = NULL;
727
 
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
728
 
            /* overflow */
729
 
            errno = ENOMEM;
730
 
          } else {
731
 
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
732
 
                               * sizeof(char *));
733
 
          }
734
 
#endif
 
689
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
690
                                    * ((unsigned int)
 
691
                                       custom_argc + 1));
735
692
          if(new_argv == NULL){
736
 
            error(0, errno, "reallocarray");
 
693
            error(0, errno, "realloc");
737
694
            exitstatus = EX_OSERR;
738
695
            free(new_arg);
739
696
            free(org_line);
804
761
    goto fallback;
805
762
  }
806
763
  
807
 
  {
808
 
    char *pluginhelperenv;
809
 
    bool bret = true;
810
 
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
811
 
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
812
 
    if(ret != -1){
813
 
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
814
 
    }
815
 
    if(ret == -1 or not bret){
816
 
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
817
 
            " environment variable to \"%s\" for all plugins\n",
818
 
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
819
 
    }
820
 
    if(ret != -1){
821
 
      free(pluginhelperenv);
822
 
    }
823
 
  }
824
 
  
825
764
  if(debug){
826
 
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
765
    for(plugin *p = plugin_list; p != NULL; p=p->next){
827
766
      fprintf(stderr, "Plugin: %s has %d arguments\n",
828
767
              p->name ? p->name : "Global", p->argc - 1);
829
768
      for(char **a = p->argv; *a != NULL; a++){
838
777
  
839
778
  if(getuid() == 0){
840
779
    /* Work around Debian bug #633582:
841
 
       <https://bugs.debian.org/633582> */
 
780
       <http://bugs.debian.org/633582> */
842
781
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
843
782
    if(plugindir_fd == -1){
844
783
      if(errno != ENOENT){
856
795
          }
857
796
        }
858
797
      }
859
 
      close(plugindir_fd);
 
798
      TEMP_FAILURE_RETRY(close(plugindir_fd));
860
799
    }
861
800
  }
862
801
  
921
860
    return 1;
922
861
  }
923
862
  
 
863
#ifdef __GLIBC__
 
864
#if __GLIBC_PREREQ(2, 15)
924
865
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
925
866
                             alphasort);
 
867
#else  /* not __GLIBC_PREREQ(2, 15) */
 
868
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
869
                           &direntries, good_name, alphasort);
 
870
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
871
#else   /* not __GLIBC__ */
 
872
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
873
                           &direntries, good_name, alphasort);
 
874
#endif  /* not __GLIBC__ */
926
875
  if(numplugins == -1){
927
876
    error(0, errno, "Could not scan plugin dir");
928
877
    direntries = NULL;
944
893
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
945
894
    if(ret == -1){
946
895
      error(0, errno, "stat");
947
 
      close(plugin_fd);
 
896
      TEMP_FAILURE_RETRY(close(plugin_fd));
948
897
      free(direntries[i]);
949
898
      continue;
950
899
    }
959
908
                plugindir != NULL ? plugindir : PDIR,
960
909
                direntries[i]->d_name);
961
910
      }
962
 
      close(plugin_fd);
 
911
      TEMP_FAILURE_RETRY(close(plugin_fd));
963
912
      free(direntries[i]);
964
913
      continue;
965
914
    }
967
916
    plugin *p = getplugin(direntries[i]->d_name);
968
917
    if(p == NULL){
969
918
      error(0, errno, "getplugin");
970
 
      close(plugin_fd);
 
919
      TEMP_FAILURE_RETRY(close(plugin_fd));
971
920
      free(direntries[i]);
972
921
      continue;
973
922
    }
976
925
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
977
926
                direntries[i]->d_name);
978
927
      }
979
 
      close(plugin_fd);
 
928
      TEMP_FAILURE_RETRY(close(plugin_fd));
980
929
      free(direntries[i]);
981
930
      continue;
982
931
    }
1022
971
    if(pipefd[0] >= FD_SETSIZE){
1023
972
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1024
973
              FD_SETSIZE);
1025
 
      close(pipefd[0]);
1026
 
      close(pipefd[1]);
 
974
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
975
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1027
976
      exitstatus = EX_OSERR;
1028
977
      free(direntries[i]);
1029
978
      goto fallback;
1033
982
    ret = set_cloexec_flag(pipefd[0]);
1034
983
    if(ret < 0){
1035
984
      error(0, errno, "set_cloexec_flag");
1036
 
      close(pipefd[0]);
1037
 
      close(pipefd[1]);
 
985
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
986
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1038
987
      exitstatus = EX_OSERR;
1039
988
      free(direntries[i]);
1040
989
      goto fallback;
1042
991
    ret = set_cloexec_flag(pipefd[1]);
1043
992
    if(ret < 0){
1044
993
      error(0, errno, "set_cloexec_flag");
1045
 
      close(pipefd[0]);
1046
 
      close(pipefd[1]);
 
994
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
995
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1047
996
      exitstatus = EX_OSERR;
1048
997
      free(direntries[i]);
1049
998
      goto fallback;
1068
1017
      error(0, errno, "fork");
1069
1018
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1070
1019
                                     &sigchld_action.sa_mask, NULL));
1071
 
      close(pipefd[0]);
1072
 
      close(pipefd[1]);
 
1020
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
1021
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1073
1022
      exitstatus = EX_OSERR;
1074
1023
      free(direntries[i]);
1075
1024
      goto fallback;
1103
1052
      /* no return */
1104
1053
    }
1105
1054
    /* Parent process */
1106
 
    close(pipefd[1]);           /* Close unused write end of pipe */
1107
 
    close(plugin_fd);
 
1055
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
 
1056
                                             pipe */
 
1057
    TEMP_FAILURE_RETRY(close(plugin_fd));
1108
1058
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1109
1059
    if(new_plugin == NULL){
1110
1060
      error(0, errno, "getplugin");
1122
1072
    
1123
1073
    new_plugin->pid = pid;
1124
1074
    new_plugin->fd = pipefd[0];
1125
 
 
1126
 
    if(debug){
1127
 
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1128
 
              new_plugin->name, (intmax_t) (new_plugin->pid));
1129
 
    }
1130
 
 
 
1075
    
1131
1076
    /* Unblock SIGCHLD so signal handler can be run if this process
1132
1077
       has already completed */
1133
1078
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1139
1084
      goto fallback;
1140
1085
    }
1141
1086
    
1142
 
    FD_SET(new_plugin->fd, &rfds_all);
 
1087
#if defined (__GNUC__) and defined (__GLIBC__)
 
1088
#if not __GLIBC_PREREQ(2, 16)
 
1089
#pragma GCC diagnostic push
 
1090
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1091
#endif
 
1092
#endif
 
1093
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
 
1094
                                          -Wconversion in GNU libc
 
1095
                                          before 2.16 */
 
1096
#if defined (__GNUC__) and defined (__GLIBC__)
 
1097
#if not __GLIBC_PREREQ(2, 16)
 
1098
#pragma GCC diagnostic pop
 
1099
#endif
 
1100
#endif
1143
1101
    
1144
1102
    if(maxfd < new_plugin->fd){
1145
1103
      maxfd = new_plugin->fd;
1148
1106
  
1149
1107
  free(direntries);
1150
1108
  direntries = NULL;
1151
 
  close(dir_fd);
 
1109
  TEMP_FAILURE_RETRY(close(dir_fd));
1152
1110
  dir_fd = -1;
1153
1111
  free_plugin(getplugin(NULL));
1154
1112
  
1194
1152
                      (intmax_t) (proc->pid),
1195
1153
                      WTERMSIG(proc->status),
1196
1154
                      strsignal(WTERMSIG(proc->status)));
 
1155
            } else if(WCOREDUMP(proc->status)){
 
1156
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
 
1157
                      " core\n", proc->name, (intmax_t) (proc->pid));
1197
1158
            }
1198
1159
          }
1199
1160
          
1200
1161
          /* Remove the plugin */
1201
 
          FD_CLR(proc->fd, &rfds_all);
 
1162
#if defined (__GNUC__) and defined (__GLIBC__)
 
1163
#if not __GLIBC_PREREQ(2, 16)
 
1164
#pragma GCC diagnostic push
 
1165
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1166
#endif
 
1167
#endif
 
1168
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
 
1169
                                          -Wconversion in GNU libc
 
1170
                                          before 2.16 */
 
1171
#if defined (__GNUC__) and defined (__GLIBC__)
 
1172
#if not __GLIBC_PREREQ(2, 16)
 
1173
#pragma GCC diagnostic pop
 
1174
#endif
 
1175
#endif
1202
1176
          
1203
1177
          /* Block signal while modifying process_list */
1204
1178
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1244
1218
      }
1245
1219
      
1246
1220
      /* This process has not completed.  Does it have any output? */
1247
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
 
1221
#if defined (__GNUC__) and defined (__GLIBC__)
 
1222
#if not __GLIBC_PREREQ(2, 16)
 
1223
#pragma GCC diagnostic push
 
1224
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1225
#endif
 
1226
#endif
 
1227
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
 
1228
                                                         warning from
 
1229
                                                         -Wconversion
 
1230
                                                         in GNU libc
 
1231
                                                         before
 
1232
                                                         2.16 */
 
1233
#if defined (__GNUC__) and defined (__GLIBC__)
 
1234
#if not __GLIBC_PREREQ(2, 16)
 
1235
#pragma GCC diagnostic pop
 
1236
#endif
 
1237
#endif
1248
1238
        /* This process had nothing to say at this time */
1249
1239
        proc = proc->next;
1250
1240
        continue;
1320
1310
  free(direntries);
1321
1311
  
1322
1312
  if(dir_fd != -1){
1323
 
    close(dir_fd);
 
1313
    TEMP_FAILURE_RETRY(close(dir_fd));
1324
1314
  }
1325
1315
  
1326
1316
  /* Kill the processes */
1346
1336
  free_plugin_list();
1347
1337
  
1348
1338
  free(plugindir);
1349
 
  free(pluginhelperdir);
1350
1339
  free(argfile);
1351
1340
  
1352
1341
  return exitstatus;