| 1 |
//===----------------------------------------------------------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
// REQUIRES: can-create-symlinks |
| 10 |
// UNSUPPORTED: c++03, c++11, c++14 |
| 11 |
// UNSUPPORTED: no-filesystem |
| 12 |
|
| 13 |
// Android's fchmodat seems broken on various OS versions -- see D140183. This |
| 14 |
// test probably passes on new-enough phones (not the emulator). |
| 15 |
// XFAIL: LIBCXX-ANDROID-FIXME && target={{i686|x86_64}}-{{.+}}-android{{.*}} |
| 16 |
// XFAIL: LIBCXX-ANDROID-FIXME && android-device-api={{21|22}} |
| 17 |
|
| 18 |
// <filesystem> |
| 19 |
|
| 20 |
// void permissions(const path& p, perms prms, |
| 21 |
// perm_options opts = perm_options::replace); |
| 22 |
// void permissions(const path& p, perms prms, std::error_code& ec) noexcept; |
| 23 |
// void permissions(const path& p, perms prms, perm_options opts, std::error_code); |
| 24 |
|
| 25 |
#include <filesystem> |
| 26 |
|
| 27 |
#include "test_macros.h" |
| 28 |
#include "filesystem_test_helper.h" |
| 29 |
namespace fs = std::filesystem; |
| 30 |
using namespace fs; |
| 31 |
|
| 32 |
using PR = fs::perms; |
| 33 |
|
| 34 |
static void test_signatures() |
| 35 |
{ |
| 36 |
const path p; ((void)p); |
| 37 |
const perms pr{}; ((void)pr); |
| 38 |
const perm_options opts{}; ((void)opts); |
| 39 |
std::error_code ec; ((void)ec); |
| 40 |
ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr)); |
| 41 |
ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts)); |
| 42 |
ASSERT_NOEXCEPT(fs::permissions(p, pr, ec)); |
| 43 |
LIBCPP_ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts, ec)); |
| 44 |
} |
| 45 |
|
| 46 |
static void test_error_reporting() |
| 47 |
{ |
| 48 |
auto checkThrow = [](path const& f, fs::perms opts, |
| 49 |
const std::error_code& ec) |
| 50 |
{ |
| 51 |
#ifndef TEST_HAS_NO_EXCEPTIONS |
| 52 |
try { |
| 53 |
fs::permissions(f, opts); |
| 54 |
return false; |
| 55 |
} catch (filesystem_error const& err) { |
| 56 |
return err.path1() == f |
| 57 |
&& err.path2() == "" |
| 58 |
&& err.code() == ec; |
| 59 |
} |
| 60 |
#else |
| 61 |
((void)f); ((void)opts); ((void)ec); |
| 62 |
return true; |
| 63 |
#endif |
| 64 |
}; |
| 65 |
|
| 66 |
scoped_test_env env; |
| 67 |
const path dne = env.make_env_path("dne"); |
| 68 |
const path dne_sym = env.create_symlink(dne, "dne_sym"); |
| 69 |
{ // !exists |
| 70 |
std::error_code ec = GetTestEC(); |
| 71 |
fs::permissions(dne, fs::perms{}, ec); |
| 72 |
assert(ec); |
| 73 |
assert(ec != GetTestEC()); |
| 74 |
assert(checkThrow(dne, fs::perms{}, ec)); |
| 75 |
} |
| 76 |
{ |
| 77 |
std::error_code ec = GetTestEC(); |
| 78 |
fs::permissions(dne_sym, fs::perms{}, ec); |
| 79 |
assert(ec); |
| 80 |
assert(ec != GetTestEC()); |
| 81 |
assert(checkThrow(dne_sym, fs::perms{}, ec)); |
| 82 |
} |
| 83 |
} |
| 84 |
|
| 85 |
static void basic_permissions_test() |
| 86 |
{ |
| 87 |
scoped_test_env env; |
| 88 |
const path file = env.create_file("file1", 42); |
| 89 |
const path dir = env.create_dir("dir1"); |
| 90 |
const path file_for_sym = env.create_file("file2", 42); |
| 91 |
const path sym = env.create_symlink(file_for_sym, "sym"); |
| 92 |
const perm_options AP = perm_options::add; |
| 93 |
const perm_options RP = perm_options::remove; |
| 94 |
const perm_options NF = perm_options::nofollow; |
| 95 |
struct TestCase { |
| 96 |
path p; |
| 97 |
perms set_perms; |
| 98 |
perms expected; |
| 99 |
perm_options opts; |
| 100 |
TestCase(path xp, perms xperms, perms xexpect, |
| 101 |
perm_options xopts = perm_options::replace) |
| 102 |
: p(xp), set_perms(xperms), expected(xexpect), opts(xopts) {} |
| 103 |
} cases[] = { |
| 104 |
// test file |
| 105 |
{file, perms::none, perms::none}, |
| 106 |
{file, perms::owner_all, perms::owner_all}, |
| 107 |
{file, perms::group_all, perms::owner_all | perms::group_all, AP}, |
| 108 |
{file, perms::group_all, perms::owner_all, RP}, |
| 109 |
// test directory |
| 110 |
{dir, perms::none, perms::none}, |
| 111 |
{dir, perms::owner_all, perms::owner_all}, |
| 112 |
{dir, perms::group_all, perms::owner_all | perms::group_all, AP}, |
| 113 |
{dir, perms::group_all, perms::owner_all, RP}, |
| 114 |
// test symlink without symlink_nofollow |
| 115 |
{sym, perms::none, perms::none}, |
| 116 |
{sym, perms::owner_all, perms::owner_all}, |
| 117 |
{sym, perms::group_all, perms::owner_all | perms::group_all, AP}, |
| 118 |
{sym, perms::group_all, perms::owner_all, RP}, |
| 119 |
// test non-symlink with symlink_nofollow. The last test on file/dir |
| 120 |
// will have set their permissions to perms::owner_all |
| 121 |
{file, perms::group_all, perms::owner_all | perms::group_all, AP | NF}, |
| 122 |
{dir, perms::group_all, perms::owner_all | perms::group_all, AP | NF} |
| 123 |
}; |
| 124 |
for (auto const& TC : cases) { |
| 125 |
assert(status(TC.p).permissions() != TC.expected); |
| 126 |
{ |
| 127 |
std::error_code ec = GetTestEC(); |
| 128 |
permissions(TC.p, TC.set_perms, TC.opts, ec); |
| 129 |
assert(!ec); |
| 130 |
auto pp = status(TC.p).permissions(); |
| 131 |
assert(pp == NormalizeExpectedPerms(TC.expected)); |
| 132 |
} |
| 133 |
if (TC.opts == perm_options::replace) { |
| 134 |
std::error_code ec = GetTestEC(); |
| 135 |
permissions(TC.p, TC.set_perms, ec); |
| 136 |
assert(!ec); |
| 137 |
auto pp = status(TC.p).permissions(); |
| 138 |
assert(pp == NormalizeExpectedPerms(TC.expected)); |
| 139 |
} |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
#ifndef _WIN32 |
| 144 |
// This test isn't currently meaningful on Windows; the Windows file |
| 145 |
// permissions visible via std::filesystem doesn't show any difference |
| 146 |
// between owner/group/others. |
| 147 |
static void test_no_resolve_symlink_on_symlink() |
| 148 |
{ |
| 149 |
scoped_test_env env; |
| 150 |
const path file = env.create_file("file", 42); |
| 151 |
const path sym = env.create_symlink(file, "sym"); |
| 152 |
const auto file_perms = status(file).permissions(); |
| 153 |
|
| 154 |
struct TestCase { |
| 155 |
perms set_perms; |
| 156 |
perms expected; // only expected on platform that support symlink perms. |
| 157 |
perm_options opts = perm_options::replace; |
| 158 |
TestCase(perms xperms, perms xexpect, |
| 159 |
perm_options xopts = perm_options::replace) |
| 160 |
: set_perms(xperms), expected(xexpect), opts(xopts) {} |
| 161 |
} cases[] = { |
| 162 |
{perms::owner_all, perms::owner_all}, |
| 163 |
{perms::group_all, perms::owner_all | perms::group_all, perm_options::add}, |
| 164 |
{perms::owner_all, perms::group_all, perm_options::remove}, |
| 165 |
}; |
| 166 |
for (auto const& TC : cases) { |
| 167 |
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(_AIX) |
| 168 |
// On OS X symlink permissions are supported. We should get an empty |
| 169 |
// error code and the expected permissions. |
| 170 |
const auto expected_link_perms = TC.expected; |
| 171 |
std::error_code expected_ec; |
| 172 |
#else |
| 173 |
// On linux symlink permissions are not supported. The error code should |
| 174 |
// be 'operation_not_supported' and the symlink permissions should be |
| 175 |
// unchanged. |
| 176 |
const auto expected_link_perms = symlink_status(sym).permissions(); |
| 177 |
std::error_code expected_ec = std::make_error_code(std::errc::operation_not_supported); |
| 178 |
#endif |
| 179 |
std::error_code ec = GetTestEC(); |
| 180 |
permissions(sym, TC.set_perms, TC.opts | perm_options::nofollow, ec); |
| 181 |
if (expected_ec) |
| 182 |
assert(ErrorIs(ec, static_cast<std::errc>(expected_ec.value()))); |
| 183 |
else |
| 184 |
assert(!ec); |
| 185 |
assert(status(file).permissions() == file_perms); |
| 186 |
assert(symlink_status(sym).permissions() == expected_link_perms); |
| 187 |
} |
| 188 |
} |
| 189 |
#endif // _WIN32 |
| 190 |
|
| 191 |
int main(int, char**) { |
| 192 |
test_signatures(); |
| 193 |
test_error_reporting(); |
| 194 |
basic_permissions_test(); |
| 195 |
#ifndef _WIN32 |
| 196 |
test_no_resolve_symlink_on_symlink(); |
| 197 |
#endif |
| 198 |
return 0; |
| 199 |
} |