/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

  • Committer: Teddy Hogeborn
  • Date: 2014-03-23 22:12:57 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 311.
  • Revision ID: teddy@recompile.se-20140323221257-9lkufevfdn4kwoq6
Use openat() etc. in plugin-runner.  Also one less useless warning.

* plugin-runner.c (main): Only print warning about failure to work
                          around Debian bug #633582 if the plugin
                          directory actually exists.  Use openat(),
                          fstat(), faccessat(), and eliminate
                          asprintf().

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
23
23
 */
24
24
 
25
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
                                   O_CLOEXEC */
27
27
#include <stddef.h>             /* size_t, NULL */
28
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
29
                                   realloc() */
30
30
#include <stdbool.h>            /* bool, true, false */
31
31
#include <stdio.h>              /* fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
 
32
                                   stderr, STDOUT_FILENO, fclose() */
 
33
#include <sys/types.h>          /* DIR, fdopendir(), fstat(), struct
34
34
                                   stat, waitpid(), WIFEXITED(),
35
35
                                   WEXITSTATUS(), wait(), pid_t,
36
36
                                   uid_t, gid_t, getuid(), getgid(),
40
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
41
                                   WEXITSTATUS(), WTERMSIG(),
42
42
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
43
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
44
44
#include <iso646.h>             /* and, or, not */
45
45
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
46
46
                                   readdir(), closedir(), dirfd() */
47
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
48
 
                                   fcntl(), setuid(), setgid(),
49
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
50
 
                                   access(), pipe(), fork(), close()
51
 
                                   dup2(), STDOUT_FILENO, _exit(),
52
 
                                   execve(), write(), read(),
53
 
                                   close() */
 
47
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
 
48
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
 
49
                                   struct stat, fstat(), close(),
 
50
                                   setgid(), setuid(), S_ISREG(),
 
51
                                   faccessat() pipe(), fork(),
 
52
                                   _exit(), dup2(), fexecve(), read()
 
53
                                */
54
54
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
 
55
                                   FD_CLOEXEC, openat() */
 
56
#include <string.h>             /* strsep, strlen(), strsignal(),
 
57
                                   strcmp(), strncmp() */
58
58
#include <errno.h>              /* errno */
59
59
#include <argp.h>               /* struct argp_option, struct
60
60
                                   argp_state, struct argp,
363
363
                                      .sa_flags = SA_NOCLDSTOP };
364
364
  char **custom_argv = NULL;
365
365
  int custom_argc = 0;
 
366
  int dir_fd;
366
367
  
367
368
  /* Establish a signal handler */
368
369
  sigemptyset(&sigchld_action.sa_mask);
779
780
       <http://bugs.debian.org/633582> */
780
781
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
781
782
    if(plugindir_fd == -1){
782
 
      error(0, errno, "open(\"" PDIR "\")");
 
783
      if(errno != ENOENT){
 
784
        error(0, errno, "open(\"" PDIR "\")");
 
785
      }
783
786
    } else {
784
787
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
785
788
      if(ret == -1){
808
811
  
809
812
  /* Open plugin directory with close_on_exec flag */
810
813
  {
811
 
    int dir_fd = -1;
812
 
    if(plugindir == NULL){
813
 
      dir_fd = open(PDIR, O_RDONLY |
814
 
#ifdef O_CLOEXEC
815
 
                    O_CLOEXEC
816
 
#else  /* not O_CLOEXEC */
817
 
                    0
818
 
#endif  /* not O_CLOEXEC */
819
 
                    );
820
 
    } else {
821
 
      dir_fd = open(plugindir, O_RDONLY |
822
 
#ifdef O_CLOEXEC
823
 
                    O_CLOEXEC
824
 
#else  /* not O_CLOEXEC */
825
 
                    0
826
 
#endif  /* not O_CLOEXEC */
827
 
                    );
828
 
    }
 
814
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
815
#ifdef O_CLOEXEC
 
816
                  O_CLOEXEC
 
817
#else  /* not O_CLOEXEC */
 
818
                  0
 
819
#endif  /* not O_CLOEXEC */
 
820
                  );
829
821
    if(dir_fd == -1){
830
822
      error(0, errno, "Could not open plugin dir");
831
823
      exitstatus = EX_UNAVAILABLE;
932
924
      }
933
925
    }
934
926
    
935
 
    char *filename;
936
 
    if(plugindir == NULL){
937
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
938
 
                                             dirst->d_name));
939
 
    } else {
940
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
941
 
                                             plugindir,
942
 
                                             dirst->d_name));
 
927
    int plugin_fd = openat(dir_fd, dirst->d_name, O_RDONLY |
 
928
#ifdef O_CLOEXEC
 
929
                            O_CLOEXEC
 
930
#else  /* not O_CLOEXEC */
 
931
                            0
 
932
#endif  /* not O_CLOEXEC */
 
933
                            );
 
934
    if(plugin_fd == -1){
 
935
      error(0, errno, "Could not open plugin");
 
936
      continue;
943
937
    }
 
938
#ifndef O_CLOEXEC
 
939
  /* Set the FD_CLOEXEC flag on the plugin FD */
 
940
    ret = set_cloexec_flag(plugin_fd);
944
941
    if(ret < 0){
945
 
      error(0, errno, "asprintf");
 
942
      error(0, errno, "set_cloexec_flag");
 
943
      TEMP_FAILURE_RETRY(close(plugin_fd));
946
944
      continue;
947
945
    }
948
 
    
949
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
946
#endif  /* O_CLOEXEC */
 
947
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
950
948
    if(ret == -1){
951
949
      error(0, errno, "stat");
952
 
      free(filename);
 
950
      TEMP_FAILURE_RETRY(close(plugin_fd));
953
951
      continue;
954
952
    }
955
953
    
956
954
    /* Ignore non-executable files */
957
955
    if(not S_ISREG(st.st_mode)
958
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
956
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, dirst->d_name, X_OK,
 
957
                                        0)) != 0)){
959
958
      if(debug){
960
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
961
 
                " with bad type or mode\n", filename);
 
959
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
960
                " with bad type or mode\n",
 
961
                plugindir != NULL ? plugindir : PDIR, dirst->d_name);
962
962
      }
963
 
      free(filename);
 
963
      TEMP_FAILURE_RETRY(close(plugin_fd));
964
964
      continue;
965
965
    }
966
966
    
967
967
    plugin *p = getplugin(dirst->d_name);
968
968
    if(p == NULL){
969
969
      error(0, errno, "getplugin");
970
 
      free(filename);
 
970
      TEMP_FAILURE_RETRY(close(plugin_fd));
971
971
      continue;
972
972
    }
973
973
    if(p->disabled){
975
975
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
976
976
                dirst->d_name);
977
977
      }
978
 
      free(filename);
 
978
      TEMP_FAILURE_RETRY(close(plugin_fd));
979
979
      continue;
980
980
    }
981
981
    {
995
995
        }
996
996
      }
997
997
    }
998
 
    /* If this plugin has any environment variables, we will call
999
 
       using execve and need to duplicate the environment from this
1000
 
       process, too. */
 
998
    /* If this plugin has any environment variables, we need to
 
999
       duplicate the environment from this process, too. */
1001
1000
    if(p->environ[0] != NULL){
1002
1001
      for(char **e = environ; *e != NULL; e++){
1003
1002
        if(not add_environment(p, *e, false)){
1069
1068
           above and must now close it manually here. */
1070
1069
        closedir(dir);
1071
1070
      }
1072
 
      if(execve(filename, p->argv,
 
1071
      if(fexecve(plugin_fd, p->argv,
1073
1072
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
1074
 
        error(0, errno, "execve for %s", filename);
 
1073
        error(0, errno, "fexecve for %s/%s",
 
1074
              plugindir != NULL ? plugindir : PDIR, dirst->d_name);
1075
1075
        _exit(EX_OSERR);
1076
1076
      }
1077
1077
      /* no return */
1079
1079
    /* Parent process */
1080
1080
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1081
1081
                                             pipe */
1082
 
    free(filename);
 
1082
    TEMP_FAILURE_RETRY(close(plugin_fd));
1083
1083
    plugin *new_plugin = getplugin(dirst->d_name);
1084
1084
    if(new_plugin == NULL){
1085
1085
      error(0, errno, "getplugin");