/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-02-10 03:50:20 UTC
  • Revision ID: teddy@recompile.se-20190210035020-nttr1tybgwwixueu
Show debconf note about new TLS key IDs

If mandos-client did not see TLS keys and had to create them, or if
mandos sees GnuTLS version 3.6.6 or later, show an important notice on
package installation about the importance of adding the new key_id
options to clients.conf on the Mandos server.

* debian/control (Package: mandos, Package: mandos-client): Depend on
                                                            debconf.
* debian/mandos-client.lintian-overrides: Override warnings.
* debian/mandos-client.postinst (create_keys): Show notice if new TLS
                                               key files were created.
* debian/mandos-client.templates: New.
* debian/mandos.lintian-overrides: Override warnings.
* debian/mandos.postinst (configure): If GnuTLS 3.6.6 or later is
                                      detected, show an important
                                      notice (once) about the new
                                      key_id option required in
                                      clients.conf.
* debian/mandos.templates: New.

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-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() */
583
583
      if(arg[0] == '\0'){
584
584
        break;
585
585
      }
 
586
      /* FALLTHROUGH */
586
587
    default:
587
588
      return ARGP_ERR_UNKNOWN;
588
589
    }
701
702
        custom_argc += 1;
702
703
        {
703
704
          char **new_argv = realloc(custom_argv, sizeof(char *)
704
 
                                    * ((unsigned int)
705
 
                                       custom_argc + 1));
 
705
                                    * ((size_t)custom_argc + 1));
706
706
          if(new_argv == NULL){
707
707
            error(0, errno, "realloc");
708
708
            exitstatus = EX_OSERR;
794
794
  }
795
795
  
796
796
  if(debug){
797
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
797
    for(plugin *p = plugin_list; p != NULL; p = p->next){
798
798
      fprintf(stderr, "Plugin: %s has %d arguments\n",
799
799
              p->name ? p->name : "Global", p->argc - 1);
800
800
      for(char **a = p->argv; *a != NULL; a++){
809
809
  
810
810
  if(getuid() == 0){
811
811
    /* Work around Debian bug #633582:
812
 
       <http://bugs.debian.org/633582> */
 
812
       <https://bugs.debian.org/633582> */
813
813
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
814
    if(plugindir_fd == -1){
815
815
      if(errno != ENOENT){
827
827
          }
828
828
        }
829
829
      }
830
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
830
      close(plugindir_fd);
831
831
    }
832
832
  }
833
833
  
892
892
    return 1;
893
893
  }
894
894
  
895
 
#ifdef __GLIBC__
896
 
#if __GLIBC_PREREQ(2, 15)
897
895
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
898
896
                             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
897
  if(numplugins == -1){
908
898
    error(0, errno, "Could not scan plugin dir");
909
899
    direntries = NULL;
925
915
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
926
916
    if(ret == -1){
927
917
      error(0, errno, "stat");
928
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
918
      close(plugin_fd);
929
919
      free(direntries[i]);
930
920
      continue;
931
921
    }
940
930
                plugindir != NULL ? plugindir : PDIR,
941
931
                direntries[i]->d_name);
942
932
      }
943
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
933
      close(plugin_fd);
944
934
      free(direntries[i]);
945
935
      continue;
946
936
    }
948
938
    plugin *p = getplugin(direntries[i]->d_name);
949
939
    if(p == NULL){
950
940
      error(0, errno, "getplugin");
951
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
941
      close(plugin_fd);
952
942
      free(direntries[i]);
953
943
      continue;
954
944
    }
957
947
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
958
948
                direntries[i]->d_name);
959
949
      }
960
 
      TEMP_FAILURE_RETRY(close(plugin_fd));
 
950
      close(plugin_fd);
961
951
      free(direntries[i]);
962
952
      continue;
963
953
    }
1003
993
    if(pipefd[0] >= FD_SETSIZE){
1004
994
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1005
995
              FD_SETSIZE);
1006
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1007
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
996
      close(pipefd[0]);
 
997
      close(pipefd[1]);
1008
998
      exitstatus = EX_OSERR;
1009
999
      free(direntries[i]);
1010
1000
      goto fallback;
1014
1004
    ret = set_cloexec_flag(pipefd[0]);
1015
1005
    if(ret < 0){
1016
1006
      error(0, errno, "set_cloexec_flag");
1017
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1018
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1007
      close(pipefd[0]);
 
1008
      close(pipefd[1]);
1019
1009
      exitstatus = EX_OSERR;
1020
1010
      free(direntries[i]);
1021
1011
      goto fallback;
1023
1013
    ret = set_cloexec_flag(pipefd[1]);
1024
1014
    if(ret < 0){
1025
1015
      error(0, errno, "set_cloexec_flag");
1026
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1027
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1016
      close(pipefd[0]);
 
1017
      close(pipefd[1]);
1028
1018
      exitstatus = EX_OSERR;
1029
1019
      free(direntries[i]);
1030
1020
      goto fallback;
1049
1039
      error(0, errno, "fork");
1050
1040
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1051
1041
                                     &sigchld_action.sa_mask, NULL));
1052
 
      TEMP_FAILURE_RETRY(close(pipefd[0]));
1053
 
      TEMP_FAILURE_RETRY(close(pipefd[1]));
 
1042
      close(pipefd[0]);
 
1043
      close(pipefd[1]);
1054
1044
      exitstatus = EX_OSERR;
1055
1045
      free(direntries[i]);
1056
1046
      goto fallback;
1084
1074
      /* no return */
1085
1075
    }
1086
1076
    /* Parent process */
1087
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1088
 
                                             pipe */
1089
 
    TEMP_FAILURE_RETRY(close(plugin_fd));
 
1077
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1078
    close(plugin_fd);
1090
1079
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1091
1080
    if(new_plugin == NULL){
1092
1081
      error(0, errno, "getplugin");
1104
1093
    
1105
1094
    new_plugin->pid = pid;
1106
1095
    new_plugin->fd = pipefd[0];
1107
 
    
 
1096
 
 
1097
    if(debug){
 
1098
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1099
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1100
    }
 
1101
 
1108
1102
    /* Unblock SIGCHLD so signal handler can be run if this process
1109
1103
       has already completed */
1110
1104
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1116
1110
      goto fallback;
1117
1111
    }
1118
1112
    
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
 
1113
    FD_SET(new_plugin->fd, &rfds_all);
1133
1114
    
1134
1115
    if(maxfd < new_plugin->fd){
1135
1116
      maxfd = new_plugin->fd;
1138
1119
  
1139
1120
  free(direntries);
1140
1121
  direntries = NULL;
1141
 
  TEMP_FAILURE_RETRY(close(dir_fd));
 
1122
  close(dir_fd);
1142
1123
  dir_fd = -1;
1143
1124
  free_plugin(getplugin(NULL));
1144
1125
  
1184
1165
                      (intmax_t) (proc->pid),
1185
1166
                      WTERMSIG(proc->status),
1186
1167
                      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
1168
            }
1191
1169
          }
1192
1170
          
1193
1171
          /* 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
 
1172
          FD_CLR(proc->fd, &rfds_all);
1208
1173
          
1209
1174
          /* Block signal while modifying process_list */
1210
1175
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1250
1215
      }
1251
1216
      
1252
1217
      /* 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
 
1218
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1270
1219
        /* This process had nothing to say at this time */
1271
1220
        proc = proc->next;
1272
1221
        continue;
1342
1291
  free(direntries);
1343
1292
  
1344
1293
  if(dir_fd != -1){
1345
 
    TEMP_FAILURE_RETRY(close(dir_fd));
 
1294
    close(dir_fd);
1346
1295
  }
1347
1296
  
1348
1297
  /* Kill the processes */