/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-02 22:16:53 UTC
  • Revision ID: teddy@recompile.se-20190802221653-ic1iko9hbefzwsk7
Fix bug in server Debian package: Fails to start on first install

There has been a very long-standing bug where installation of the
server (the "mandos" Debian package) would fail to start the server
properly right after installation.  It would work on manual (re)start
after installation, or after reboot, and even after package purge and
reinstall, it would then work the first time.  The problem, it turns
out, is when the new "_mandos" user (and corresponding group) is
created, the D-Bus server is not reloaded, and is therefore not aware
of that user, and does not recognize the user and group name in the
/etc/dbus-1/system.d/mandos.conf file.  The Mandos server, when it
tries to start and access the D-Bus, is then not permitted to connect
to its D-Bus bus name, and disables D-Bus use as a fallback measure;
i.e. the server works, but it is not controllable via D-Bus commands
(via mandos-ctl or mandos-monitor).  The next time the D-Bus daemon is
reloaded for any reason, the new user & group would become visible to
the D-Bus daemon and after that, any restart of the Mandos server
would succeed and it would bind to its D-Bus name properly, and
thereby be visible and controllable by mandos-ctl & mandos-monitor.
This was mostly invisible when using sysvinit, but systemd makes the
problem visible since the systemd service file for the Mandos server
is configured to not consider the Mandos server "started" until the
D-Bus name has been bound; this makes the starting of the service wait
for 90 seconds and then fail with a timeout error.

Fixing this should also make the Debian CI autopkgtest tests work.

* debian/mandos.postinst (configure): After creating (or renaming)
                                      user & group, reload D-Bus
                                      daemon (if present).

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() */
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;
312
313
__attribute__((nonnull))
313
314
static void free_plugin(plugin *plugin_node){
314
315
  
315
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
316
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
316
317
    free(*arg);
317
318
  }
 
319
  free(plugin_node->name);
318
320
  free(plugin_node->argv);
319
321
  for(char **env = plugin_node->environ; *env != NULL; env++){
320
322
    free(*env);
347
349
 
348
350
int main(int argc, char *argv[]){
349
351
  char *plugindir = NULL;
 
352
  char *pluginhelperdir = NULL;
350
353
  char *argfile = NULL;
351
354
  FILE *conffp;
352
355
  struct dirent **direntries = NULL;
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
  
860
899
    return 1;
861
900
  }
862
901
  
863
 
#ifdef __GLIBC__
864
 
#if __GLIBC_PREREQ(2, 15)
865
902
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
866
903
                             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__ */
875
904
  if(numplugins == -1){
876
905
    error(0, errno, "Could not scan plugin dir");
877
906
    direntries = NULL;
893
922
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
894
923
    if(ret == -1){
895
924
      error(0, errno, "stat");
896
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
925
      close(plugin_fd);
897
926
      free(direntries[i]);
898
927
      continue;
899
928
    }
908
937
                plugindir != NULL ? plugindir : PDIR,
909
938
                direntries[i]->d_name);
910
939
      }
911
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
940
      close(plugin_fd);
912
941
      free(direntries[i]);
913
942
      continue;
914
943
    }
916
945
    plugin *p = getplugin(direntries[i]->d_name);
917
946
    if(p == NULL){
918
947
      error(0, errno, "getplugin");
919
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
948
      close(plugin_fd);
920
949
      free(direntries[i]);
921
950
      continue;
922
951
    }
925
954
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
926
955
                direntries[i]->d_name);
927
956
      }
928
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
957
      close(plugin_fd);
929
958
      free(direntries[i]);
930
959
      continue;
931
960
    }
971
1000
    if(pipefd[0] >= FD_SETSIZE){
972
1001
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
973
1002
              FD_SETSIZE);
974
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
975
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1003
      close(pipefd[0]);
 
1004
      close(pipefd[1]);
976
1005
      exitstatus = EX_OSERR;
977
1006
      free(direntries[i]);
978
1007
      goto fallback;
982
1011
    ret = set_cloexec_flag(pipefd[0]);
983
1012
    if(ret < 0){
984
1013
      error(0, errno, "set_cloexec_flag");
985
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
986
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1014
      close(pipefd[0]);
 
1015
      close(pipefd[1]);
987
1016
      exitstatus = EX_OSERR;
988
1017
      free(direntries[i]);
989
1018
      goto fallback;
991
1020
    ret = set_cloexec_flag(pipefd[1]);
992
1021
    if(ret < 0){
993
1022
      error(0, errno, "set_cloexec_flag");
994
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
995
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1023
      close(pipefd[0]);
 
1024
      close(pipefd[1]);
996
1025
      exitstatus = EX_OSERR;
997
1026
      free(direntries[i]);
998
1027
      goto fallback;
1017
1046
      error(0, errno, "fork");
1018
1047
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1019
1048
                                     &sigchld_action.sa_mask, NULL));
1020
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1021
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
1022
1051
      exitstatus = EX_OSERR;
1023
1052
      free(direntries[i]);
1024
1053
      goto fallback;
1052
1081
      /* no return */
1053
1082
    }
1054
1083
    /* Parent process */
1055
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1056
 
                                             pipe */
1057
 
    TEMP_FAILURE_RETRY(close(plugin_fd));
 
1084
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1085
    close(plugin_fd);
1058
1086
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1059
1087
    if(new_plugin == NULL){
1060
1088
      error(0, errno, "getplugin");
1072
1100
    
1073
1101
    new_plugin->pid = pid;
1074
1102
    new_plugin->fd = pipefd[0];
1075
 
    
 
1103
 
 
1104
    if(debug){
 
1105
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1106
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1107
    }
 
1108
 
1076
1109
    /* Unblock SIGCHLD so signal handler can be run if this process
1077
1110
       has already completed */
1078
1111
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1084
1117
      goto fallback;
1085
1118
    }
1086
1119
    
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
 
1120
    FD_SET(new_plugin->fd, &rfds_all);
1101
1121
    
1102
1122
    if(maxfd < new_plugin->fd){
1103
1123
      maxfd = new_plugin->fd;
1106
1126
  
1107
1127
  free(direntries);
1108
1128
  direntries = NULL;
1109
 
  TEMP_FAILURE_RETRY(close(dir_fd));
 
1129
  close(dir_fd);
1110
1130
  dir_fd = -1;
1111
1131
  free_plugin(getplugin(NULL));
1112
1132
  
1152
1172
                      (intmax_t) (proc->pid),
1153
1173
                      WTERMSIG(proc->status),
1154
1174
                      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));
1158
1175
            }
1159
1176
          }
1160
1177
          
1161
1178
          /* Remove the plugin */
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
 
1179
          FD_CLR(proc->fd, &rfds_all);
1176
1180
          
1177
1181
          /* Block signal while modifying process_list */
1178
1182
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1218
1222
      }
1219
1223
      
1220
1224
      /* This process has not completed.  Does it have any output? */
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
 
1225
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1238
1226
        /* This process had nothing to say at this time */
1239
1227
        proc = proc->next;
1240
1228
        continue;
1310
1298
  free(direntries);
1311
1299
  
1312
1300
  if(dir_fd != -1){
1313
 
    TEMP_FAILURE_RETRY(close(dir_fd));
 
1301
    close(dir_fd);
1314
1302
  }
1315
1303
  
1316
1304
  /* Kill the processes */
1336
1324
  free_plugin_list();
1337
1325
  
1338
1326
  free(plugindir);
 
1327
  free(pluginhelperdir);
1339
1328
  free(argfile);
1340
1329
  
1341
1330
  return exitstatus;