/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugin-runner.c

* mandos-clients.conf.xml (OPTIONS): Moved up "extended_timeout" to
                                     order options alphabetically.
* clients.conf: Language change in comment.

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,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
 
5
 * Copyright © 2008-2010 Teddy Hogeborn
 
6
 * Copyright © 2008-2010 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
28
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
29
                                   realloc() */
30
30
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, fileno(), fprintf(),
 
31
#include <stdio.h>              /* fileno(), fprintf(),
32
32
                                   stderr, STDOUT_FILENO */
33
33
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
34
                                   stat, waitpid(), WIFEXITED(),
70
70
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
71
71
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
72
72
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
73
#include <errno.h>              /* errno */
 
74
#include <error.h>              /* error() */
73
75
 
74
76
#define BUFFER_SIZE 256
75
77
 
266
268
        /* No child processes */
267
269
        break;
268
270
      }
269
 
      perror("waitpid");
 
271
      error(0, errno, "waitpid");
270
272
    }
271
273
    
272
274
    /* A child exited, find it in process_list */
357
359
  sigemptyset(&sigchld_action.sa_mask);
358
360
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
359
361
  if(ret == -1){
360
 
    perror("sigaddset");
 
362
    error(0, errno, "sigaddset");
361
363
    exitstatus = EX_OSERR;
362
364
    goto fallback;
363
365
  }
364
366
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
365
367
  if(ret == -1){
366
 
    perror("sigaction");
 
368
    error(0, errno, "sigaction");
367
369
    exitstatus = EX_OSERR;
368
370
    goto fallback;
369
371
  }
599
601
  case ENOMEM:
600
602
  default:
601
603
    errno = ret;
602
 
    perror("argp_parse");
 
604
    error(0, errno, "argp_parse");
603
605
    exitstatus = EX_OSERR;
604
606
    goto fallback;
605
607
  case EINVAL:
626
628
    custom_argc = 1;
627
629
    custom_argv = malloc(sizeof(char*) * 2);
628
630
    if(custom_argv == NULL){
629
 
      perror("malloc");
 
631
      error(0, errno, "malloc");
630
632
      exitstatus = EX_OSERR;
631
633
      goto fallback;
632
634
    }
649
651
        }
650
652
        new_arg = strdup(p);
651
653
        if(new_arg == NULL){
652
 
          perror("strdup");
 
654
          error(0, errno, "strdup");
653
655
          exitstatus = EX_OSERR;
654
656
          free(org_line);
655
657
          goto fallback;
659
661
        custom_argv = realloc(custom_argv, sizeof(char *)
660
662
                              * ((unsigned int) custom_argc + 1));
661
663
        if(custom_argv == NULL){
662
 
          perror("realloc");
 
664
          error(0, errno, "realloc");
663
665
          exitstatus = EX_OSERR;
664
666
          free(org_line);
665
667
          goto fallback;
672
674
      ret = fclose(conffp);
673
675
    } while(ret == EOF and errno == EINTR);
674
676
    if(ret == EOF){
675
 
      perror("fclose");
 
677
      error(0, errno, "fclose");
676
678
      exitstatus = EX_IOERR;
677
679
      goto fallback;
678
680
    }
681
683
    /* Check for harmful errors and go to fallback. Other errors might
682
684
       not affect opening plugins */
683
685
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
684
 
      perror("fopen");
 
686
      error(0, errno, "fopen");
685
687
      exitstatus = EX_OSERR;
686
688
      goto fallback;
687
689
    }
698
700
    case ENOMEM:
699
701
    default:
700
702
      errno = ret;
701
 
      perror("argp_parse");
 
703
      error(0, errno, "argp_parse");
702
704
      exitstatus = EX_OSERR;
703
705
      goto fallback;
704
706
    case EINVAL:
718
720
  case ENOMEM:
719
721
  default:
720
722
    errno = ret;
721
 
    perror("argp_parse");
 
723
    error(0, errno, "argp_parse");
722
724
    exitstatus = EX_OSERR;
723
725
    goto fallback;
724
726
  case EINVAL:
740
742
    }
741
743
  }
742
744
  
743
 
  /* Strip permissions down to nobody */
 
745
  {
 
746
    /* Work around Debian bug #633582:
 
747
       <http://bugs.debian.org/633582> */
 
748
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
749
    if(plugindir_fd == -1){
 
750
      error(0, errno, "open");
 
751
    } else {
 
752
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
753
      if(ret == -1){
 
754
        error(0, errno, "fstat");
 
755
      } else {
 
756
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
757
          ret = fchown(plugindir_fd, uid, gid);
 
758
          if(ret == -1){
 
759
            error(0, errno, "fchown");
 
760
          }
 
761
        }
 
762
      }
 
763
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
764
    }
 
765
  }
 
766
  
 
767
  /* Lower permissions */
744
768
  setgid(gid);
745
769
  if(ret == -1){
746
 
    perror("setgid");
 
770
    error(0, errno, "setgid");
747
771
  }
748
772
  ret = setuid(uid);
749
773
  if(ret == -1){
750
 
    perror("setuid");
 
774
    error(0, errno, "setuid");
751
775
  }
752
776
  
753
777
  /* Open plugin directory with close_on_exec flag */
771
795
                    );
772
796
    }
773
797
    if(dir_fd == -1){
774
 
      perror("Could not open plugin dir");
 
798
      error(0, errno, "Could not open plugin dir");
775
799
      exitstatus = EX_UNAVAILABLE;
776
800
      goto fallback;
777
801
    }
780
804
  /* Set the FD_CLOEXEC flag on the directory */
781
805
    ret = set_cloexec_flag(dir_fd);
782
806
    if(ret < 0){
783
 
      perror("set_cloexec_flag");
 
807
      error(0, errno, "set_cloexec_flag");
784
808
      TEMP_FAILURE_RETRY(close(dir_fd));
785
809
      exitstatus = EX_OSERR;
786
810
      goto fallback;
789
813
    
790
814
    dir = fdopendir(dir_fd);
791
815
    if(dir == NULL){
792
 
      perror("Could not open plugin dir");
 
816
      error(0, errno, "Could not open plugin dir");
793
817
      TEMP_FAILURE_RETRY(close(dir_fd));
794
818
      exitstatus = EX_OSERR;
795
819
      goto fallback;
807
831
    /* All directory entries have been processed */
808
832
    if(dirst == NULL){
809
833
      if(errno == EBADF){
810
 
        perror("readdir");
 
834
        error(0, errno, "readdir");
811
835
        exitstatus = EX_IOERR;
812
836
        goto fallback;
813
837
      }
870
894
                                             dirst->d_name));
871
895
    }
872
896
    if(ret < 0){
873
 
      perror("asprintf");
 
897
      error(0, errno, "asprintf");
874
898
      continue;
875
899
    }
876
900
    
877
901
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
878
902
    if(ret == -1){
879
 
      perror("stat");
 
903
      error(0, errno, "stat");
880
904
      free(filename);
881
905
      continue;
882
906
    }
894
918
    
895
919
    plugin *p = getplugin(dirst->d_name);
896
920
    if(p == NULL){
897
 
      perror("getplugin");
 
921
      error(0, errno, "getplugin");
898
922
      free(filename);
899
923
      continue;
900
924
    }
912
936
      if(g != NULL){
913
937
        for(char **a = g->argv + 1; *a != NULL; a++){
914
938
          if(not add_argument(p, *a)){
915
 
            perror("add_argument");
 
939
            error(0, errno, "add_argument");
916
940
          }
917
941
        }
918
942
        /* Add global environment variables */
919
943
        for(char **e = g->environ; *e != NULL; e++){
920
944
          if(not add_environment(p, *e, false)){
921
 
            perror("add_environment");
 
945
            error(0, errno, "add_environment");
922
946
          }
923
947
        }
924
948
      }
929
953
    if(p->environ[0] != NULL){
930
954
      for(char **e = environ; *e != NULL; e++){
931
955
        if(not add_environment(p, *e, false)){
932
 
          perror("add_environment");
 
956
          error(0, errno, "add_environment");
933
957
        }
934
958
      }
935
959
    }
937
961
    int pipefd[2];
938
962
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
939
963
    if(ret == -1){
940
 
      perror("pipe");
 
964
      error(0, errno, "pipe");
941
965
      exitstatus = EX_OSERR;
942
966
      goto fallback;
943
967
    }
944
968
    /* Ask OS to automatic close the pipe on exec */
945
969
    ret = set_cloexec_flag(pipefd[0]);
946
970
    if(ret < 0){
947
 
      perror("set_cloexec_flag");
 
971
      error(0, errno, "set_cloexec_flag");
948
972
      exitstatus = EX_OSERR;
949
973
      goto fallback;
950
974
    }
951
975
    ret = set_cloexec_flag(pipefd[1]);
952
976
    if(ret < 0){
953
 
      perror("set_cloexec_flag");
 
977
      error(0, errno, "set_cloexec_flag");
954
978
      exitstatus = EX_OSERR;
955
979
      goto fallback;
956
980
    }
959
983
                                              &sigchld_action.sa_mask,
960
984
                                              NULL));
961
985
    if(ret < 0){
962
 
      perror("sigprocmask");
 
986
      error(0, errno, "sigprocmask");
963
987
      exitstatus = EX_OSERR;
964
988
      goto fallback;
965
989
    }
969
993
      pid = fork();
970
994
    } while(pid == -1 and errno == EINTR);
971
995
    if(pid == -1){
972
 
      perror("fork");
 
996
      error(0, errno, "fork");
973
997
      exitstatus = EX_OSERR;
974
998
      goto fallback;
975
999
    }
977
1001
      /* this is the child process */
978
1002
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
979
1003
      if(ret < 0){
980
 
        perror("sigaction");
 
1004
        error(0, errno, "sigaction");
981
1005
        _exit(EX_OSERR);
982
1006
      }
983
1007
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
984
1008
      if(ret < 0){
985
 
        perror("sigprocmask");
 
1009
        error(0, errno, "sigprocmask");
986
1010
        _exit(EX_OSERR);
987
1011
      }
988
1012
      
989
1013
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
990
1014
      if(ret == -1){
991
 
        perror("dup2");
 
1015
        error(0, errno, "dup2");
992
1016
        _exit(EX_OSERR);
993
1017
      }
994
1018
      
999
1023
      }
1000
1024
      if(p->environ[0] == NULL){
1001
1025
        if(execv(filename, p->argv) < 0){
1002
 
          perror("execv");
 
1026
          error(0, errno, "execv for %s", filename);
1003
1027
          _exit(EX_OSERR);
1004
1028
        }
1005
1029
      } else {
1006
1030
        if(execve(filename, p->argv, p->environ) < 0){
1007
 
          perror("execve");
 
1031
          error(0, errno, "execve for %s", filename);
1008
1032
          _exit(EX_OSERR);
1009
1033
        }
1010
1034
      }
1016
1040
    free(filename);
1017
1041
    plugin *new_plugin = getplugin(dirst->d_name);
1018
1042
    if(new_plugin == NULL){
1019
 
      perror("getplugin");
 
1043
      error(0, errno, "getplugin");
1020
1044
      ret = (int)(TEMP_FAILURE_RETRY
1021
1045
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1022
1046
                               NULL)));
1023
1047
      if(ret < 0){
1024
 
        perror("sigprocmask");
 
1048
        error(0, errno, "sigprocmask");
1025
1049
      }
1026
1050
      exitstatus = EX_OSERR;
1027
1051
      goto fallback;
1036
1060
                                              &sigchld_action.sa_mask,
1037
1061
                                              NULL));
1038
1062
    if(ret < 0){
1039
 
      perror("sigprocmask");
 
1063
      error(0, errno, "sigprocmask");
1040
1064
      exitstatus = EX_OSERR;
1041
1065
      goto fallback;
1042
1066
    }
1069
1093
    fd_set rfds = rfds_all;
1070
1094
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1071
1095
    if(select_ret == -1 and errno != EINTR){
1072
 
      perror("select");
 
1096
      error(0, errno, "select");
1073
1097
      exitstatus = EX_OSERR;
1074
1098
      goto fallback;
1075
1099
    }
1111
1135
                                         &sigchld_action.sa_mask,
1112
1136
                                         NULL));
1113
1137
          if(ret < 0){
1114
 
            perror("sigprocmask");
 
1138
            error(0, errno, "sigprocmask");
1115
1139
            exitstatus = EX_OSERR;
1116
1140
            goto fallback;
1117
1141
          }
1125
1149
                      (sigprocmask(SIG_UNBLOCK,
1126
1150
                                   &sigchld_action.sa_mask, NULL)));
1127
1151
          if(ret < 0){
1128
 
            perror("sigprocmask");
 
1152
            error(0, errno, "sigprocmask");
1129
1153
            exitstatus = EX_OSERR;
1130
1154
            goto fallback;
1131
1155
          }
1142
1166
        bool bret = print_out_password(proc->buffer,
1143
1167
                                       proc->buffer_length);
1144
1168
        if(not bret){
1145
 
          perror("print_out_password");
 
1169
          error(0, errno, "print_out_password");
1146
1170
          exitstatus = EX_IOERR;
1147
1171
        }
1148
1172
        goto fallback;
1161
1185
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1162
1186
                               + (size_t) BUFFER_SIZE);
1163
1187
        if(proc->buffer == NULL){
1164
 
          perror("malloc");
 
1188
          error(0, errno, "malloc");
1165
1189
          exitstatus = EX_OSERR;
1166
1190
          goto fallback;
1167
1191
        }
1204
1228
    }
1205
1229
    bret = print_out_password(passwordbuffer, len);
1206
1230
    if(not bret){
1207
 
      perror("print_out_password");
 
1231
      error(0, errno, "print_out_password");
1208
1232
      exitstatus = EX_IOERR;
1209
1233
    }
1210
1234
  }
1212
1236
  /* Restore old signal handler */
1213
1237
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1214
1238
  if(ret == -1){
1215
 
    perror("sigaction");
 
1239
    error(0, errno, "sigaction");
1216
1240
    exitstatus = EX_OSERR;
1217
1241
  }
1218
1242
  
1234
1258
      ret = kill(p->pid, SIGTERM);
1235
1259
      if(ret == -1 and errno != ESRCH){
1236
1260
        /* Set-uid proccesses might not get closed */
1237
 
        perror("kill");
 
1261
        error(0, errno, "kill");
1238
1262
      }
1239
1263
    }
1240
1264
  }
1244
1268
    ret = wait(NULL);
1245
1269
  } while(ret >= 0);
1246
1270
  if(errno != ECHILD){
1247
 
    perror("wait");
 
1271
    error(0, errno, "wait");
1248
1272
  }
1249
1273
  
1250
1274
  free_plugin_list();