gvisor/test/syscalls/linux/access.cc

// Copyright 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include "gtest/gtest.h"
#include "test/util/capability_util.h"
#include "test/util/fs_util.h"
#include "test/util/temp_path.h"
#include "test/util/test_util.h"

using ::testing::Ge;

namespace gvisor {
namespace testing {

namespace {

class AccessTest : public ::testing::Test {
 public:
  std::string CreateTempFile(int perm) {
    const std::string path = NewTempAbsPath();
    const int fd = open(path.c_str(), O_CREAT | O_RDONLY, perm);
    TEST_PCHECK(fd > 0);
    TEST_PCHECK(close(fd) == 0);
    return path;
  }

 protected:
  // SetUp creates various configurations of files.
  void SetUp() override {
    // Move to the temporary directory. This allows us to reason more easily
    // about absolute and relative paths.
    ASSERT_THAT(chdir(GetAbsoluteTestTmpdir().c_str()), SyscallSucceeds());

    // Create an empty file, standard permissions.
    relfile_ = NewTempRelPath();
    int fd;
    ASSERT_THAT(fd = open(relfile_.c_str(), O_CREAT | O_TRUNC, 0644),
                SyscallSucceedsWithValue(Ge(0)));
    ASSERT_THAT(close(fd), SyscallSucceeds());
    absfile_ = GetAbsoluteTestTmpdir() + "/" + relfile_;

    // Create an empty directory, no writable permissions.
    absdir_ = NewTempAbsPath();
    reldir_ = JoinPath(Basename(absdir_), "");
    ASSERT_THAT(mkdir(reldir_.c_str(), 0555), SyscallSucceeds());

    // This file doesn't exist.
    relnone_ = NewTempRelPath();
    absnone_ = GetAbsoluteTestTmpdir() + "/" + relnone_;
  }

  // TearDown unlinks created files.
  void TearDown() override {
    ASSERT_THAT(unlink(absfile_.c_str()), SyscallSucceeds());
    ASSERT_THAT(rmdir(absdir_.c_str()), SyscallSucceeds());
  }

  std::string relfile_;
  std::string reldir_;

  std::string absfile_;
  std::string absdir_;

  std::string relnone_;
  std::string absnone_;
};

TEST_F(AccessTest, RelativeFile) {
  EXPECT_THAT(access(relfile_.c_str(), R_OK), SyscallSucceeds());
}

TEST_F(AccessTest, RelativeDir) {
  EXPECT_THAT(access(reldir_.c_str(), R_OK | X_OK), SyscallSucceeds());
}

TEST_F(AccessTest, AbsFile) {
  EXPECT_THAT(access(absfile_.c_str(), R_OK), SyscallSucceeds());
}

TEST_F(AccessTest, AbsDir) {
  EXPECT_THAT(access(absdir_.c_str(), R_OK | X_OK), SyscallSucceeds());
}

TEST_F(AccessTest, RelDoesNotExist) {
  EXPECT_THAT(access(relnone_.c_str(), R_OK), SyscallFailsWithErrno(ENOENT));
}

TEST_F(AccessTest, AbsDoesNotExist) {
  EXPECT_THAT(access(absnone_.c_str(), R_OK), SyscallFailsWithErrno(ENOENT));
}

TEST_F(AccessTest, InvalidMode) {
  EXPECT_THAT(access(relfile_.c_str(), 0xffffffff),
              SyscallFailsWithErrno(EINVAL));
}

TEST_F(AccessTest, NoPerms) {
  // Drop capabilities that allow us to override permissions. We must drop
  // PERMITTED because access() checks those instead of EFFECTIVE.
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_OVERRIDE));
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_READ_SEARCH));

  EXPECT_THAT(access(absdir_.c_str(), W_OK), SyscallFailsWithErrno(EACCES));
}

TEST_F(AccessTest, InvalidName) {
  EXPECT_THAT(access(reinterpret_cast<char*>(0x1234), W_OK),
              SyscallFailsWithErrno(EFAULT));
}

TEST_F(AccessTest, UsrReadOnly) {
  // Drop capabilities that allow us to override permissions. We must drop
  // PERMITTED because access() checks those instead of EFFECTIVE.
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_OVERRIDE));
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_READ_SEARCH));

  const std::string filename = CreateTempFile(0400);
  EXPECT_THAT(access(filename.c_str(), R_OK), SyscallSucceeds());
  EXPECT_THAT(access(filename.c_str(), W_OK), SyscallFailsWithErrno(EACCES));
  EXPECT_THAT(access(filename.c_str(), X_OK), SyscallFailsWithErrno(EACCES));
  EXPECT_THAT(unlink(filename.c_str()), SyscallSucceeds());
}

TEST_F(AccessTest, UsrReadExec) {
  // Drop capabilities that allow us to override permissions. We must drop
  // PERMITTED because access() checks those instead of EFFECTIVE.
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_OVERRIDE));
  ASSERT_NO_ERRNO(DropPermittedCapability(CAP_DAC_READ_SEARCH));

  const std::string filename = CreateTempFile(0500);
  EXPECT_THAT(access(filename.c_str(), R_OK | X_OK), SyscallSucceeds());
  EXPECT_THAT(access(filename.c_str(), W_OK), SyscallFailsWithErrno(EACCES));
  EXPECT_THAT(unlink(filename.c_str()), SyscallSucceeds());
}

TEST_F(AccessTest, UsrReadWrite) {
  const std::string filename = CreateTempFile(0600);
  EXPECT_THAT(access(filename.c_str(), R_OK | W_OK), SyscallSucceeds());
  EXPECT_THAT(access(filename.c_str(), X_OK), SyscallFailsWithErrno(EACCES));
  EXPECT_THAT(unlink(filename.c_str()), SyscallSucceeds());
}

TEST_F(AccessTest, UsrReadWriteExec) {
  const std::string filename = CreateTempFile(0700);
  EXPECT_THAT(access(filename.c_str(), R_OK | W_OK | X_OK), SyscallSucceeds());
  EXPECT_THAT(unlink(filename.c_str()), SyscallSucceeds());
}

}  // namespace

}  // namespace testing
}  // namespace gvisor