/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: 2015-05-23 20:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 756.
  • Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.

For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished".  This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found.  One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD.  To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous).  In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.

This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.

DBUS-API (CheckerCompleted): Change the second value provided by this
                             D-Bus signal from the raw wait(2) status
                             to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
                               multiprocessing.Process (starting a
                               separate process).
(Client.last_checker signal): New attribute for signal which
                              terminated last checker.  Like
                              last_checker_status, only not accessible
                              via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
                           to get returncode; set last_checker_signal.
                           Return False so gobject does not call this
                           callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
                        instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument.        Call
                               Client.checker_callback early to have
                               it set last_checker_status and
                               last_checker_signal; use those.  Change
                               second value provided to D-Bus signal
                               CheckerCompleted to use
                               last_checker_signal if checker was
                               terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
                                        "condition" argument.  Use it
                                        accordingly.  Remove dead code
                                        (os.WCOREDUMP case).

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2008-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
 */
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;
313
312
__attribute__((nonnull))
314
313
static void free_plugin(plugin *plugin_node){
315
314
  
316
 
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
 
315
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
317
316
    free(*arg);
318
317
  }
319
 
  free(plugin_node->name);
320
318
  free(plugin_node->argv);
321
319
  for(char **env = plugin_node->environ; *env != NULL; env++){
322
320
    free(*env);
349
347
 
350
348
int main(int argc, char *argv[]){
351
349
  char *plugindir = NULL;
352
 
  char *pluginhelperdir = NULL;
353
350
  char *argfile = NULL;
354
351
  FILE *conffp;
355
352
  struct dirent **direntries = NULL;
417
414
      .doc = "Group ID the plugins will run as", .group = 3 },
418
415
    { .name = "debug", .key = 132,
419
416
      .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 },
424
417
    /*
425
418
     * These reproduce what we would get without ARGP_NO_HELP
426
419
     */
552
545
    case 132:                   /* --debug */
553
546
      debug = true;
554
547
      break;
555
 
    case 133:                   /* --plugin-helper-dir */
556
 
      free(pluginhelperdir);
557
 
      pluginhelperdir = strdup(arg);
558
 
      if(pluginhelperdir != NULL){
559
 
        errno = 0;
560
 
      }
561
 
      break;
562
548
      /*
563
549
       * These reproduce what we would get without ARGP_NO_HELP
564
550
       */
565
551
    case '?':                   /* --help */
566
552
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
567
553
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
568
 
      __builtin_unreachable();
569
554
    case -3:                    /* --usage */
570
555
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
571
556
      argp_state_help(state, state->out_stream,
572
557
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
573
 
      __builtin_unreachable();
574
558
    case 'V':                   /* --version */
575
559
      fprintf(state->out_stream, "%s\n", argp_program_version);
576
560
      exit(EXIT_SUCCESS);
586
570
      if(arg[0] == '\0'){
587
571
        break;
588
572
      }
589
 
      /* FALLTHROUGH */
590
573
    default:
591
574
      return ARGP_ERR_UNKNOWN;
592
575
    }
618
601
    case 130:                   /* --userid */
619
602
    case 131:                   /* --groupid */
620
603
    case 132:                   /* --debug */
621
 
    case 133:                   /* --plugin-helper-dir */
622
604
    case '?':                   /* --help */
623
605
    case -3:                    /* --usage */
624
606
    case 'V':                   /* --version */
705
687
        custom_argc += 1;
706
688
        {
707
689
          char **new_argv = realloc(custom_argv, sizeof(char *)
708
 
                                    * ((size_t)custom_argc + 1));
 
690
                                    * ((unsigned int)
 
691
                                       custom_argc + 1));
709
692
          if(new_argv == NULL){
710
693
            error(0, errno, "realloc");
711
694
            exitstatus = EX_OSERR;
778
761
    goto fallback;
779
762
  }
780
763
  
781
 
  {
782
 
    char *pluginhelperenv;
783
 
    bool bret = true;
784
 
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
785
 
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
786
 
    if(ret != -1){
787
 
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
788
 
    }
789
 
    if(ret == -1 or not bret){
790
 
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
791
 
            " environment variable to \"%s\" for all plugins\n",
792
 
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
793
 
    }
794
 
    if(ret != -1){
795
 
      free(pluginhelperenv);
796
 
    }
797
 
  }
798
 
  
799
764
  if(debug){
800
 
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
765
    for(plugin *p = plugin_list; p != NULL; p=p->next){
801
766
      fprintf(stderr, "Plugin: %s has %d arguments\n",
802
767
              p->name ? p->name : "Global", p->argc - 1);
803
768
      for(char **a = p->argv; *a != NULL; a++){
812
777
  
813
778
  if(getuid() == 0){
814
779
    /* Work around Debian bug #633582:
815
 
       <https://bugs.debian.org/633582> */
 
780
       <http://bugs.debian.org/633582> */
816
781
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
817
782
    if(plugindir_fd == -1){
818
783
      if(errno != ENOENT){
830
795
          }
831
796
        }
832
797
      }
833
 
      close(plugindir_fd);
 
798
      TEMP_FAILURE_RETRY(close(plugindir_fd));
834
799
    }
835
800
  }
836
801
  
895
860
    return 1;
896
861
  }
897
862
  
 
863
#ifdef __GLIBC__
 
864
#if __GLIBC_PREREQ(2, 15)
898
865
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
899
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__ */
900
875
  if(numplugins == -1){
901
876
    error(0, errno, "Could not scan plugin dir");
902
877
    direntries = NULL;
918
893
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
919
894
    if(ret == -1){
920
895
      error(0, errno, "stat");
921
 
      close(plugin_fd);
 
896
      TEMP_FAILURE_RETRY(close(plugin_fd));
922
897
      free(direntries[i]);
923
898
      continue;
924
899
    }
933
908
                plugindir != NULL ? plugindir : PDIR,
934
909
                direntries[i]->d_name);
935
910
      }
936
 
      close(plugin_fd);
 
911
      TEMP_FAILURE_RETRY(close(plugin_fd));
937
912
      free(direntries[i]);
938
913
      continue;
939
914
    }
941
916
    plugin *p = getplugin(direntries[i]->d_name);
942
917
    if(p == NULL){
943
918
      error(0, errno, "getplugin");
944
 
      close(plugin_fd);
 
919
      TEMP_FAILURE_RETRY(close(plugin_fd));
945
920
      free(direntries[i]);
946
921
      continue;
947
922
    }
950
925
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
951
926
                direntries[i]->d_name);
952
927
      }
953
 
      close(plugin_fd);
 
928
      TEMP_FAILURE_RETRY(close(plugin_fd));
954
929
      free(direntries[i]);
955
930
      continue;
956
931
    }
996
971
    if(pipefd[0] >= FD_SETSIZE){
997
972
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
998
973
              FD_SETSIZE);
999
 
      close(pipefd[0]);
1000
 
      close(pipefd[1]);
 
974
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
975
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1001
976
      exitstatus = EX_OSERR;
1002
977
      free(direntries[i]);
1003
978
      goto fallback;
1007
982
    ret = set_cloexec_flag(pipefd[0]);
1008
983
    if(ret < 0){
1009
984
      error(0, errno, "set_cloexec_flag");
1010
 
      close(pipefd[0]);
1011
 
      close(pipefd[1]);
 
985
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
986
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1012
987
      exitstatus = EX_OSERR;
1013
988
      free(direntries[i]);
1014
989
      goto fallback;
1016
991
    ret = set_cloexec_flag(pipefd[1]);
1017
992
    if(ret < 0){
1018
993
      error(0, errno, "set_cloexec_flag");
1019
 
      close(pipefd[0]);
1020
 
      close(pipefd[1]);
 
994
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
995
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1021
996
      exitstatus = EX_OSERR;
1022
997
      free(direntries[i]);
1023
998
      goto fallback;
1042
1017
      error(0, errno, "fork");
1043
1018
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1044
1019
                                     &sigchld_action.sa_mask, NULL));
1045
 
      close(pipefd[0]);
1046
 
      close(pipefd[1]);
 
1020
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
1021
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1047
1022
      exitstatus = EX_OSERR;
1048
1023
      free(direntries[i]);
1049
1024
      goto fallback;
1077
1052
      /* no return */
1078
1053
    }
1079
1054
    /* Parent process */
1080
 
    close(pipefd[1]);           /* Close unused write end of pipe */
1081
 
    close(plugin_fd);
 
1055
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
 
1056
                                             pipe */
 
1057
    TEMP_FAILURE_RETRY(close(plugin_fd));
1082
1058
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1083
1059
    if(new_plugin == NULL){
1084
1060
      error(0, errno, "getplugin");
1096
1072
    
1097
1073
    new_plugin->pid = pid;
1098
1074
    new_plugin->fd = pipefd[0];
1099
 
 
1100
 
    if(debug){
1101
 
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1102
 
              new_plugin->name, (intmax_t) (new_plugin->pid));
1103
 
    }
1104
 
 
 
1075
    
1105
1076
    /* Unblock SIGCHLD so signal handler can be run if this process
1106
1077
       has already completed */
1107
1078
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1113
1084
      goto fallback;
1114
1085
    }
1115
1086
    
1116
 
    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
1117
1101
    
1118
1102
    if(maxfd < new_plugin->fd){
1119
1103
      maxfd = new_plugin->fd;
1122
1106
  
1123
1107
  free(direntries);
1124
1108
  direntries = NULL;
1125
 
  close(dir_fd);
 
1109
  TEMP_FAILURE_RETRY(close(dir_fd));
1126
1110
  dir_fd = -1;
1127
1111
  free_plugin(getplugin(NULL));
1128
1112
  
1168
1152
                      (intmax_t) (proc->pid),
1169
1153
                      WTERMSIG(proc->status),
1170
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));
1171
1158
            }
1172
1159
          }
1173
1160
          
1174
1161
          /* Remove the plugin */
1175
 
          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
1176
1176
          
1177
1177
          /* Block signal while modifying process_list */
1178
1178
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1218
1218
      }
1219
1219
      
1220
1220
      /* This process has not completed.  Does it have any output? */
1221
 
      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
1222
1238
        /* This process had nothing to say at this time */
1223
1239
        proc = proc->next;
1224
1240
        continue;
1294
1310
  free(direntries);
1295
1311
  
1296
1312
  if(dir_fd != -1){
1297
 
    close(dir_fd);
 
1313
    TEMP_FAILURE_RETRY(close(dir_fd));
1298
1314
  }
1299
1315
  
1300
1316
  /* Kill the processes */
1320
1336
  free_plugin_list();
1321
1337
  
1322
1338
  free(plugindir);
1323
 
  free(pluginhelperdir);
1324
1339
  free(argfile);
1325
1340
  
1326
1341
  return exitstatus;