blob: ed5e9f7d5cf5606a2d017cf83d2355dc14e6a949 [file] [log] [blame]
// Filesystem operations -*- C++ -*-
// Copyright (C) 2014-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#ifndef _GLIBCXX_USE_CXX11_ABI
# define _GLIBCXX_USE_CXX11_ABI 1
# define NEED_DO_COPY_FILE
# define NEED_DO_SPACE
#endif
#ifndef _GNU_SOURCE
// Cygwin needs this for secure_getenv
# define _GNU_SOURCE 1
#endif
#include <bits/largefile-config.h>
#include <filesystem>
#include <functional>
#include <ostream>
#include <stack>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h> // PATH_MAX
#ifdef _GLIBCXX_HAVE_FCNTL_H
# include <fcntl.h> // AT_FDCWD, AT_SYMLINK_NOFOLLOW
#endif
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
# include <sys/stat.h> // stat, utimensat, fchmodat
#endif
#ifdef _GLIBCXX_HAVE_SYS_STATVFS_H
# include <sys/statvfs.h> // statvfs
#endif
#if !_GLIBCXX_USE_UTIMENSAT && _GLIBCXX_HAVE_UTIME_H
# include <utime.h> // utime
#endif
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
# include <windows.h>
#endif
#define _GLIBCXX_BEGIN_NAMESPACE_FILESYSTEM namespace filesystem {
#define _GLIBCXX_END_NAMESPACE_FILESYSTEM }
#include "../filesystem/ops-common.h"
#pragma GCC diagnostic ignored "-Wunused-parameter"
namespace fs = std::filesystem;
namespace posix = std::filesystem::__gnu_posix;
fs::path
fs::absolute(const path& p)
{
error_code ec;
path ret = absolute(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot make absolute path", p,
ec));
return ret;
}
fs::path
fs::absolute(const path& p, error_code& ec)
{
path ret;
if (p.empty())
{
ec = make_error_code(std::errc::invalid_argument);
return ret;
}
ec.clear();
if (p.is_absolute())
{
ret = p;
return ret;
}
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
// s must remain null-terminated
wstring_view s = p.native();
if (p.has_root_directory()) // implies !p.has_root_name()
{
// GetFullPathNameW("//") gives unwanted result (PR 88884).
// If there are multiple directory separators at the start,
// skip all but the last of them.
const auto pos = s.find_first_not_of(L"/\\");
__glibcxx_assert(pos != 0);
s.remove_prefix(std::min(s.length(), pos) - 1);
}
uint32_t len = 1024;
wstring buf;
do
{
buf.resize(len);
len = GetFullPathNameW(s.data(), len, buf.data(), nullptr);
}
while (len > buf.size());
if (len == 0)
ec = __last_system_error();
else
{
buf.resize(len);
ret = std::move(buf);
}
#else
ret = current_path(ec);
ret /= p;
#endif
return ret;
}
namespace
{
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
inline bool is_dot(wchar_t c) { return c == L'.'; }
#else
inline bool is_dot(char c) { return c == '.'; }
#endif
inline bool is_dot(const fs::path& path)
{
const auto& filename = path.native();
return filename.size() == 1 && is_dot(filename[0]);
}
inline bool is_dotdot(const fs::path& path)
{
const auto& filename = path.native();
return filename.size() == 2 && is_dot(filename[0]) && is_dot(filename[1]);
}
struct free_as_in_malloc
{
void operator()(void* p) const { ::free(p); }
};
using char_ptr = std::unique_ptr<fs::path::value_type[], free_as_in_malloc>;
}
fs::path
fs::canonical(const path& p, error_code& ec)
{
path result;
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
const path pa = absolute(p.lexically_normal(), ec);
#else
const path pa = absolute(p, ec);
#endif
if (ec)
return result;
#ifdef _GLIBCXX_USE_REALPATH
char_ptr buf{ nullptr };
# if _XOPEN_VERSION < 700
// Not safe to call realpath(path, NULL)
using char_type = fs::path::value_type;
buf.reset( (char_type*)::malloc(PATH_MAX * sizeof(char_type)) );
# endif
if (char* rp = ::realpath(pa.c_str(), buf.get()))
{
if (buf == nullptr)
buf.reset(rp);
result.assign(rp);
ec.clear();
return result;
}
if (errno != ENAMETOOLONG)
{
ec.assign(errno, std::generic_category());
return result;
}
#endif
if (!exists(pa, ec))
{
if (!ec)
ec = make_error_code(std::errc::no_such_file_or_directory);
return result;
}
// else: we know there are (currently) no unresolvable symlink loops
result = pa.root_path();
deque<path> cmpts;
for (auto& f : pa.relative_path())
cmpts.push_back(f);
int max_allowed_symlinks = 40;
while (!cmpts.empty() && !ec)
{
path f = std::move(cmpts.front());
cmpts.pop_front();
if (f.empty())
{
// ignore empty element
}
else if (is_dot(f))
{
if (!is_directory(result, ec) && !ec)
ec.assign(ENOTDIR, std::generic_category());
}
else if (is_dotdot(f))
{
auto parent = result.parent_path();
if (parent.empty())
result = pa.root_path();
else
result.swap(parent);
}
else
{
result /= f;
if (is_symlink(result, ec))
{
path link = read_symlink(result, ec);
if (!ec)
{
if (--max_allowed_symlinks == 0)
ec.assign(ELOOP, std::generic_category());
else
{
if (link.is_absolute())
{
result = link.root_path();
link = link.relative_path();
}
else
result = result.parent_path();
cmpts.insert(cmpts.begin(), link.begin(), link.end());
}
}
}
}
}
if (ec || !exists(result, ec))
result.clear();
return result;
}
fs::path
fs::canonical(const path& p)
{
error_code ec;
path res = canonical(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot make canonical path",
p, ec));
return res;
}
void
fs::copy(const path& from, const path& to, copy_options options)
{
error_code ec;
copy(from, to, options, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy", from, to, ec));
}
namespace std::filesystem
{
// Need this as there's no 'perm_options::none' enumerator.
static inline bool is_set(fs::perm_options obj, fs::perm_options bits)
{
return (obj & bits) != fs::perm_options{};
}
}
namespace
{
struct internal_file_clock : fs::__file_clock
{
using __file_clock::_S_to_sys;
using __file_clock::_S_from_sys;
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
static fs::file_time_type
from_stat(const fs::stat_type& st, std::error_code& ec) noexcept
{
const auto sys_time = fs::file_time(st, ec);
if (sys_time == sys_time.min())
return fs::file_time_type::min();
return _S_from_sys(sys_time);
}
#endif
};
}
void
fs::copy(const path& from, const path& to, copy_options options,
error_code& ec)
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
const bool skip_symlinks = is_set(options, copy_options::skip_symlinks);
const bool create_symlinks = is_set(options, copy_options::create_symlinks);
const bool copy_symlinks = is_set(options, copy_options::copy_symlinks);
const bool use_lstat = create_symlinks || skip_symlinks;
file_status f, t;
stat_type from_st, to_st;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2681. filesystem::copy() cannot copy symlinks
if (use_lstat || copy_symlinks
? posix::lstat(from.c_str(), &from_st)
: posix::stat(from.c_str(), &from_st))
{
ec.assign(errno, std::generic_category());
return;
}
if (use_lstat
? posix::lstat(to.c_str(), &to_st)
: posix::stat(to.c_str(), &to_st))
{
if (!is_not_found_errno(errno))
{
ec.assign(errno, std::generic_category());
return;
}
t = file_status{file_type::not_found};
}
else
t = make_file_status(to_st);
f = make_file_status(from_st);
if (exists(t) && !is_other(t) && !is_other(f)
&& to_st.st_dev == from_st.st_dev && to_st.st_ino == from_st.st_ino)
{
ec = std::make_error_code(std::errc::file_exists);
return;
}
if (is_other(f) || is_other(t))
{
ec = std::make_error_code(std::errc::invalid_argument);
return;
}
if (is_directory(f) && is_regular_file(t))
{
ec = std::make_error_code(std::errc::is_a_directory);
return;
}
if (is_symlink(f))
{
if (skip_symlinks)
ec.clear();
else if (!exists(t) && copy_symlinks)
copy_symlink(from, to, ec);
else
// Not clear what should be done here.
// "Otherwise report an error as specified in Error reporting (7)."
ec = std::make_error_code(std::errc::invalid_argument);
}
else if (is_regular_file(f))
{
if (is_set(options, copy_options::directories_only))
ec.clear();
else if (create_symlinks)
create_symlink(from, to, ec);
else if (is_set(options, copy_options::create_hard_links))
create_hard_link(from, to, ec);
else if (is_directory(t))
do_copy_file(from.c_str(), (to / from.filename()).c_str(),
copy_file_options(options), &from_st, nullptr, ec);
else
{
auto ptr = exists(t) ? &to_st : &from_st;
do_copy_file(from.c_str(), to.c_str(), copy_file_options(options),
&from_st, ptr, ec);
}
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2682. filesystem::copy() won't create a symlink to a directory
else if (is_directory(f) && create_symlinks)
ec = std::make_error_code(errc::is_a_directory);
else if (is_directory(f) && (is_set(options, copy_options::recursive)
|| options == copy_options::none))
{
if (!exists(t))
if (!create_directory(to, from, ec))
return;
// set an unused bit in options to disable further recursion
if (!is_set(options, copy_options::recursive))
options |= static_cast<copy_options>(4096);
for (const directory_entry& x : directory_iterator(from, ec))
{
copy(x.path(), to/x.path().filename(), options, ec);
if (ec)
return;
}
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2683. filesystem::copy() says "no effects"
else
ec.clear();
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
}
bool
fs::copy_file(const path& from, const path& to, copy_options option)
{
error_code ec;
bool result = copy_file(from, to, option, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy file", from, to,
ec));
return result;
}
bool
fs::copy_file(const path& from, const path& to, copy_options options,
error_code& ec)
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
return do_copy_file(from.c_str(), to.c_str(), copy_file_options(options),
nullptr, nullptr, ec);
#else
ec = std::make_error_code(std::errc::function_not_supported);
return false;
#endif
}
void
fs::copy_symlink(const path& existing_symlink, const path& new_symlink)
{
error_code ec;
copy_symlink(existing_symlink, new_symlink, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy symlink",
existing_symlink, new_symlink, ec));
}
void
fs::copy_symlink(const path& existing_symlink, const path& new_symlink,
error_code& ec) noexcept
{
auto p = read_symlink(existing_symlink, ec);
if (ec)
return;
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
if (is_directory(p))
{
create_directory_symlink(p, new_symlink, ec);
return;
}
#endif
create_symlink(p, new_symlink, ec);
}
bool
fs::create_directories(const path& p)
{
error_code ec;
bool result = create_directories(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directories", p,
ec));
return result;
}
bool
fs::create_directories(const path& p, error_code& ec)
{
if (p.empty())
{
ec = std::make_error_code(errc::invalid_argument);
return false;
}
file_status st = status(p, ec);
if (is_directory(st))
return false;
else if (ec && !status_known(st))
return false;
else if (exists(st))
{
if (!ec)
ec = std::make_error_code(std::errc::not_a_directory);
return false;
}
__glibcxx_assert(st.type() == file_type::not_found);
// !exists(p) so there must be at least one non-existent component in p.
std::stack<path> missing;
path pp = p;
// Strip any trailing slash
if (pp.has_relative_path() && !pp.has_filename())
pp = pp.parent_path();
do
{
const auto& filename = pp.filename();
if (is_dot(filename) || is_dotdot(filename))
pp = pp.parent_path();
else
{
missing.push(std::move(pp));
if (missing.size() > 1000) // sanity check
{
ec = std::make_error_code(std::errc::filename_too_long);
return false;
}
pp = missing.top().parent_path();
}
if (pp.empty())
break;
st = status(pp, ec);
if (exists(st))
{
if (ec)
return false;
if (!is_directory(st))
{
ec = std::make_error_code(std::errc::not_a_directory);
return false;
}
}
if (ec && exists(st))
return false;
}
while (st.type() == file_type::not_found);
__glibcxx_assert(!missing.empty());
bool created;
do
{
const path& top = missing.top();
created = create_directory(top, ec);
if (ec)
return false;
missing.pop();
}
while (!missing.empty());
return created;
}
namespace
{
bool
create_dir(const fs::path& p, fs::perms perm, std::error_code& ec)
{
bool created = false;
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
posix::mode_t mode = static_cast<std::underlying_type_t<fs::perms>>(perm);
if (posix::mkdir(p.c_str(), mode))
{
const int err = errno;
if (err != EEXIST || !is_directory(p, ec))
ec.assign(err, std::generic_category());
}
else
{
ec.clear();
created = true;
}
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
return created;
}
} // namespace
bool
fs::create_directory(const path& p)
{
error_code ec;
bool result = create_directory(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory", p,
ec));
return result;
}
bool
fs::create_directory(const path& p, error_code& ec) noexcept
{
return create_dir(p, perms::all, ec);
}
bool
fs::create_directory(const path& p, const path& attributes)
{
error_code ec;
bool result = create_directory(p, attributes, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory", p,
ec));
return result;
}
bool
fs::create_directory(const path& p, const path& attributes,
error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
stat_type st;
if (posix::stat(attributes.c_str(), &st))
{
ec.assign(errno, std::generic_category());
return false;
}
return create_dir(p, static_cast<perms>(st.st_mode), ec);
#else
ec = std::make_error_code(std::errc::function_not_supported);
return false;
#endif
}
void
fs::create_directory_symlink(const path& to, const path& new_symlink)
{
error_code ec;
create_directory_symlink(to, new_symlink, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory symlink",
to, new_symlink, ec));
}
void
fs::create_directory_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept
{
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
ec = std::make_error_code(std::errc::function_not_supported);
#else
create_symlink(to, new_symlink, ec);
#endif
}
void
fs::create_hard_link(const path& to, const path& new_hard_link)
{
error_code ec;
create_hard_link(to, new_hard_link, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create hard link",
to, new_hard_link, ec));
}
void
fs::create_hard_link(const path& to, const path& new_hard_link,
error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_LINK
if (::link(to.c_str(), new_hard_link.c_str()))
ec.assign(errno, std::generic_category());
else
ec.clear();
#elif defined _GLIBCXX_FILESYSTEM_IS_WINDOWS
if (CreateHardLinkW(new_hard_link.c_str(), to.c_str(), NULL))
ec.clear();
else
ec = __last_system_error();
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
}
void
fs::create_symlink(const path& to, const path& new_symlink)
{
error_code ec;
create_symlink(to, new_symlink, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create symlink",
to, new_symlink, ec));
}
void
fs::create_symlink(const path& to, const path& new_symlink,
error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYMLINK
if (::symlink(to.c_str(), new_symlink.c_str()))
ec.assign(errno, std::generic_category());
else
ec.clear();
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
}
fs::path
fs::current_path()
{
error_code ec;
path p = current_path(ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get current path", ec));
return p;
}
fs::path
fs::current_path(error_code& ec)
{
path p;
#ifdef _GLIBCXX_HAVE_UNISTD_H
#if defined __GLIBC__ || defined _GLIBCXX_FILESYSTEM_IS_WINDOWS
if (char_ptr cwd = char_ptr{posix::getcwd(nullptr, 0)})
{
p.assign(cwd.get());
ec.clear();
}
else
ec.assign(errno, std::generic_category());
#else
#ifdef _PC_PATH_MAX
long path_max = pathconf(".", _PC_PATH_MAX);
size_t size;
if (path_max == -1)
size = 1024;
else if (path_max > 10240)
size = 10240;
else
size = path_max;
#elif defined(PATH_MAX)
size_t size = PATH_MAX;
#else
size_t size = 1024;
#endif
for (char_ptr buf; p.empty(); size *= 2)
{
using char_type = fs::path::value_type;
buf.reset((char_type*)malloc(size * sizeof(char_type)));
if (buf)
{
if (getcwd(buf.get(), size))
{
p.assign(buf.get());
ec.clear();
}
else if (errno != ERANGE)
{
ec.assign(errno, std::generic_category());
return {};
}
}
else
{
ec = std::make_error_code(std::errc::not_enough_memory);
return {};
}
}
#endif // __GLIBC__
#else // _GLIBCXX_HAVE_UNISTD_H
ec = std::make_error_code(std::errc::function_not_supported);
#endif
return p;
}
void
fs::current_path(const path& p)
{
error_code ec;
current_path(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set current path", ec));
}
void
fs::current_path(const path& p, error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_UNISTD_H
if (posix::chdir(p.c_str()))
ec.assign(errno, std::generic_category());
else
ec.clear();
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
}
bool
fs::equivalent(const path& p1, const path& p2)
{
error_code ec;
auto result = equivalent(p1, p2, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check file equivalence",
p1, p2, ec));
return result;
}
bool
fs::equivalent(const path& p1, const path& p2, error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
int err = 0;
file_status s1, s2;
stat_type st1, st2;
if (posix::stat(p1.c_str(), &st1) == 0)
s1 = make_file_status(st1);
else if (is_not_found_errno(errno))
s1.type(file_type::not_found);
else
err = errno;
if (posix::stat(p2.c_str(), &st2) == 0)
s2 = make_file_status(st2);
else if (is_not_found_errno(errno))
s2.type(file_type::not_found);
else
err = errno;
if (exists(s1) && exists(s2))
{
if (is_other(s1) && is_other(s2))
{
ec = std::__unsupported();
return false;
}
ec.clear();
if (is_other(s1) || is_other(s2))
return false;
#if _GLIBCXX_FILESYSTEM_IS_WINDOWS
// st_ino is not set, so can't be used to distinguish files
if (st1.st_mode != st2.st_mode || st1.st_dev != st2.st_dev)
return false;
struct auto_handle {
explicit auto_handle(const path& p_)
: handle(CreateFileW(p_.c_str(), 0,
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0))
{ }
~auto_handle()
{ if (*this) CloseHandle(handle); }
explicit operator bool() const
{ return handle != INVALID_HANDLE_VALUE; }
bool get_info()
{ return GetFileInformationByHandle(handle, &info); }
HANDLE handle;
BY_HANDLE_FILE_INFORMATION info;
};
auto_handle h1(p1);
auto_handle h2(p2);
if (!h1 || !h2)
{
if (!h1 && !h2)
ec = __last_system_error();
return false;
}
if (!h1.get_info() || !h2.get_info())
{
ec = __last_system_error();
return false;
}
return h1.info.dwVolumeSerialNumber == h2.info.dwVolumeSerialNumber
&& h1.info.nFileIndexHigh == h2.info.nFileIndexHigh
&& h1.info.nFileIndexLow == h2.info.nFileIndexLow;
#else
return st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino;
#endif
}
else if (!exists(s1) && !exists(s2))
ec = std::make_error_code(std::errc::no_such_file_or_directory);
else if (err)
ec.assign(err, std::generic_category());
else
ec.clear();
return false;
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
return false;
}
std::uintmax_t
fs::file_size(const path& p)
{
error_code ec;
auto sz = file_size(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get file size", p, ec));
return sz;
}
namespace
{
template<typename Accessor, typename T>
inline T
do_stat(const fs::path& p, std::error_code& ec, Accessor f, T deflt)
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
posix::stat_type st;
if (posix::stat(p.c_str(), &st))
{
ec.assign(errno, std::generic_category());
return deflt;
}
ec.clear();
return f(st);
#else
ec = std::make_error_code(std::errc::function_not_supported);
return deflt;
#endif
}
}
std::uintmax_t
fs::file_size(const path& p, error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
struct S
{
S(const stat_type& st) : type(make_file_type(st)), size(st.st_size) { }
S() : type(file_type::not_found) { }
file_type type;
uintmax_t size;
};
auto s = do_stat(p, ec, [](const auto& st) { return S{st}; }, S{});
if (s.type == file_type::regular)
return s.size;
if (!ec)
{
if (s.type == file_type::directory)
ec = std::make_error_code(std::errc::is_a_directory);
else
ec = std::__unsupported();
}
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
return -1;
}
std::uintmax_t
fs::hard_link_count(const path& p)
{
error_code ec;
auto count = hard_link_count(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get link count", p, ec));
return count;
}
std::uintmax_t
fs::hard_link_count(const path& p, error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
return do_stat(p, ec, std::mem_fn(&stat_type::st_nlink),
static_cast<uintmax_t>(-1));
#else
ec = std::make_error_code(std::errc::function_not_supported);
return static_cast<uintmax_t>(-1);
#endif
}
bool
fs::is_empty(const path& p)
{
error_code ec;
bool e = is_empty(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check if file is empty",
p, ec));
return e;
}
bool
fs::is_empty(const path& p, error_code& ec)
{
auto s = status(p, ec);
if (ec)
return false;
bool empty = fs::is_directory(s)
? fs::directory_iterator(p, ec) == fs::directory_iterator()
: fs::file_size(p, ec) == 0;
return ec ? false : empty;
}
fs::file_time_type
fs::last_write_time(const path& p)
{
error_code ec;
auto t = last_write_time(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get file time", p, ec));
return t;
}
fs::file_time_type
fs::last_write_time(const path& p, error_code& ec) noexcept
{
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
return do_stat(p, ec,
[&ec](const auto& st) {
return internal_file_clock::from_stat(st, ec);
},
file_time_type::min());
#else
ec = std::make_error_code(std::errc::function_not_supported);
return file_time_type::min();
#endif
}
void
fs::last_write_time(const path& p, file_time_type new_time)
{
error_code ec;
last_write_time(p, new_time, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set file time", p, ec));
}
void
fs::last_write_time(const path& p,
file_time_type new_time, error_code& ec) noexcept
{
auto d = internal_file_clock::_S_to_sys(new_time).time_since_epoch();
auto s = chrono::duration_cast<chrono::seconds>(d);
#if _GLIBCXX_USE_UTIMENSAT
auto ns = chrono::duration_cast<chrono::nanoseconds>(d - s);
if (ns < ns.zero()) // tv_nsec must be non-negative and less than 10e9.
{
--s;
ns += chrono::seconds(1);
}
struct ::timespec ts[2];
ts[0].tv_sec = 0;
ts[0].tv_nsec = UTIME_OMIT;
ts[1].tv_sec = static_cast<std::time_t>(s.count());
ts[1].tv_nsec = static_cast<long>(ns.count());
if (::utimensat(AT_FDCWD, p.c_str(), ts, 0))
ec.assign(errno, std::generic_category());
else
ec.clear();
#elif _GLIBCXX_USE_UTIME && _GLIBCXX_HAVE_SYS_STAT_H
posix::utimbuf times;
times.modtime = s.count();
times.actime = do_stat(p, ec, [](const auto& st) { return st.st_atime; },
times.modtime);
if (posix::utime(p.c_str(), &times))
ec.assign(errno, std::generic_category());
else
ec.clear();
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
}
void
fs::permissions(const path& p, perms prms, perm_options opts)
{
error_code ec;
permissions(p, prms, opts, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set permissions", p, ec));
}
void
fs::permissions(const path& p, perms prms, perm_options opts,
error_code& ec) noexcept
{
const bool replace = is_set(opts, perm_options::replace);
const bool add = is_set(opts, perm_options::add);
const bool remove = is_set(opts, perm_options::remove);
const bool nofollow = is_set(opts, perm_options::nofollow);
if (((int)replace + (int)add + (int)remove) != 1)
{
ec = std::make_error_code(std::errc::invalid_argument);
return;
}
prms &= perms::mask;
file_status st;
if (add || remove || nofollow)
{
st = nofollow ? symlink_status(p, ec) : status(p, ec);
if (ec)
return;
auto curr = st.permissions();
if (add)
prms |= curr;
else if (remove)
prms = curr & ~prms;
}
int err = 0;
#if _GLIBCXX_USE_FCHMODAT
const int flag = (nofollow && is_symlink(st)) ? AT_SYMLINK_NOFOLLOW : 0;
if (::fchmodat(AT_FDCWD, p.c_str(), static_cast<mode_t>(prms), flag))
err = errno;
#else
if (nofollow && is_symlink(st))
ec = std::__unsupported();
else if (posix::chmod(p.c_str(), static_cast<posix::mode_t>(prms)))
err = errno;
#endif
if (err)
ec.assign(err, std::generic_category());
else
ec.clear();
}
fs::path
fs::proximate(const path& p, const path& base)
{
return weakly_canonical(p).lexically_proximate(weakly_canonical(base));
}
fs::path
fs::proximate(const path& p, const path& base, error_code& ec)
{
path result;
const auto p2 = weakly_canonical(p, ec);
if (!ec)
{
const auto base2 = weakly_canonical(base, ec);
if (!ec)
result = p2.lexically_proximate(base2);
}
return result;
}
fs::path
fs::read_symlink(const path& p)
{
error_code ec;
path tgt = read_symlink(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("read_symlink", p, ec));
return tgt;
}
fs::path fs::read_symlink(const path& p, error_code& ec)
{
path result;
#if defined(_GLIBCXX_HAVE_READLINK) && defined(_GLIBCXX_HAVE_SYS_STAT_H)
stat_type st;
if (posix::lstat(p.c_str(), &st))
{
ec.assign(errno, std::generic_category());
return result;
}
else if (!fs::is_symlink(make_file_status(st)))
{
ec.assign(EINVAL, std::generic_category());
return result;
}
std::string buf(st.st_size ? st.st_size + 1 : 128, '\0');
do
{
ssize_t len = ::readlink(p.c_str(), buf.data(), buf.size());
if (len == -1)
{
ec.assign(errno, std::generic_category());
return result;
}
else if (len == (ssize_t)buf.size())
{
if (buf.size() > 4096)
{
ec.assign(ENAMETOOLONG, std::generic_category());
return result;
}
buf.resize(buf.size() * 2);
}
else
{
buf.resize(len);
result.assign(buf);
ec.clear();
break;
}
}
while (true);
#else
ec = std::make_error_code(std::errc::function_not_supported);
#endif
return result;
}
fs::path
fs::relative(const path& p, const path& base)
{
return weakly_canonical(p).lexically_relative(weakly_canonical(base));
}
fs::path
fs::relative(const path& p, const path& base, error_code& ec)
{
auto result = weakly_canonical(p, ec);
fs::path cbase;
if (!ec)
cbase = weakly_canonical(base, ec);
if (!ec)
result = result.lexically_relative(cbase);
if (ec)
result.clear();
return result;
}
bool
fs::remove(const path& p)
{
error_code ec;
const bool result = fs::remove(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot remove", p, ec));
return result;
}
bool
fs::remove(const path& p, error_code& ec) noexcept
{
#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
auto st = symlink_status(p, ec);
if (exists(st))
{
if ((is_directory(p, ec) && RemoveDirectoryW(p.c_str()))
|| DeleteFileW(p.c_str()))
{
ec.clear();
return true;
}
else if (!ec)
ec = __last_system_error();
}
else if (status_known(st))
ec.clear();
#else
if (::remove(p.c_str()) == 0)
{
ec.clear();
return true;
}
else if (errno == ENOENT)
ec.clear();
else
ec.assign(errno, std::generic_category());
#endif
return false;
}
std::uintmax_t
fs::remove_all(const path& p)
{
error_code ec;
uintmax_t count = 0;
recursive_directory_iterator dir(p, directory_options{64|128}, ec);
switch (ec.value()) // N.B. assumes ec.category() == std::generic_category()
{
case 0:
// Iterate over the directory removing everything.
{
const recursive_directory_iterator end;
while (dir != end)
{
dir.__erase(); // throws on error
++count;
}
}
// Directory is empty now, will remove it below.
break;
case ENOENT:
// Our work here is done.
return 0;
case ENOTDIR:
case ELOOP:
// Not a directory, will remove below.
break;
default:
// An error occurred.
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot remove all", p, ec));
}
// Remove p itself, which is either a non-directory or is now empty.
return count + fs::remove(p);
}
std::uintmax_t
fs::remove_all(const path& p, error_code& ec)
{
uintmax_t count = 0;
recursive_directory_iterator dir(p, directory_options{64|128}, ec);
switch (ec.value()) // N.B. assumes ec.category() == std::generic_category()
{
case 0:
// Iterate over the directory removing everything.
{
const recursive_directory_iterator end;
while (dir != end)
{
dir.__erase(&ec);
if (ec)
return -1;
++count;
}
}
// Directory is empty now, will remove it below.
break;
case ENOENT:
// Our work here is done.
ec.clear();
return 0;
case ENOTDIR:
case ELOOP:
// Not a directory, will remove below.
break;
default:
// An error occurred.
return -1;
}
// Remove p itself, which is either a non-directory or is now empty.
if (int last = fs::remove(p, ec); !ec)
return count + last;
return -1;
}
void
fs::rename(const path& from, const path& to)
{
error_code ec;
rename(from, to, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot rename", from, to, ec));
}
void
fs::rename(const path& from, const path& to, error_code& ec) noexcept
{
#if _GLIBCXX_FILESYSTEM_IS_WINDOWS
const auto to_status = fs::status(to, ec);
if (to_status.type() == file_type::not_found)
ec.clear();
else if (ec)
return;
if (fs::exists(to_status))
{
const auto from_status = fs::status(from, ec);
if (ec)
return;
if (fs::is_directory(to_status))
{
if (!fs::is_directory(from_status))
{
// Cannot rename a non-directory over an existing directory.
ec = std::make_error_code(std::errc::is_a_directory);
return;
}
}
else if (fs::is_directory(from_status))
{
// Cannot rename a directory over an existing non-directory.
ec = std::make_error_code(std::errc::not_a_directory);
return;
}
}
#endif
if (posix::rename(from.c_str(), to.c_str()))
ec.assign(errno, std::generic_category());
else
ec.clear();
}
void
fs::resize_file(const path& p, uintmax_t size)
{
error_code ec;
resize_file(p, size, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot resize file", p, ec));
}
void
fs::resize_file(const path& p, uintmax_t size, error_code& ec) noexcept
{
if (size > static_cast<uintmax_t>(std::numeric_limits<posix::off_t>::max()))
ec.assign(EINVAL, std::generic_category());
else if (posix::truncate(p.c_str(), size))
ec.assign(errno, std::generic_category());
else
ec.clear();
}
fs::space_info
fs::space(const path& p)
{
error_code ec;
space_info s = space(p, ec);
if (ec)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get free space", p, ec));
return s;
}
fs::space_info
fs::space(const path& p, error_code& ec) noexcept
{
space_info info = {
static_cast<uintmax_t>(-1),
static_cast<uintmax_t>(-1),
static_cast<uintmax_t>(-1)
};
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
#if _GLIBCXX_FILESYSTEM_IS_WINDOWS
path dir = absolute(p);
dir.remove_filename();
auto str = dir.c_str();
#else
auto str = p.c_str();
#endif
do_space(str, info.capacity, info.free, info.available, ec);
#endif // _GLIBCXX_HAVE_SYS_STAT_H
return info;
}
#ifdef _GLIBCXX_HAVE_SYS_STAT_H
fs::file_status
fs::status(const fs::path& p, error_code& ec) noexcept
{
file_status status;
auto str = p.c_str();
#if _GLIBCXX_FILESYSTEM_IS_WINDOWS
// stat() fails if there's a trailing slash (PR 88881)
path p2;
if (p.has_relative_path() && !p.has_filename())
{
__try
{
p2 = p.parent_path();
str = p2.c_str();
}
__catch(const bad_alloc&)
{
ec = std::make_error_code(std::errc::not_enough_memory);
return status;
}
str = p2.c_str();
}
#endif
stat_type st;
if (posix::stat(str, &st))
{
int err = errno;
ec.assign(err, std::generic_category());
if (is_not_found_errno(err))
status.type(file_type::not_found);
#ifdef EOVERFLOW
else if (err == EOVERFLOW)
status.type(file_type::unknown);
#endif
}
else
{
status = make_file_status(st);
ec.clear();
}
return status;
}
fs::file_status
fs::symlink_status(const fs::path& p, std::error_code& ec) noexcept
{
file_status status;
auto str = p.c_str();
#if _GLIBCXX_FILESYSTEM_IS_WINDOWS
// stat() fails if there's a trailing slash (PR 88881)
path p2;
if (p.has_relative_path() && !p.has_filename())
{
__try
{
p2 = p.parent_path();
str = p2.c_str();
}
__catch(const bad_alloc&)
{
ec = std::make_error_code(std::errc::not_enough_memory);
return status;
}
str = p2.c_str();
}
#endif
stat_type st;
if (posix::lstat(str, &st))
{
int err = errno;
ec.assign(err, std::generic_category());
if (is_not_found_errno(err))
status.type(file_type::not_found);
}
else
{
status = make_file_status(st);
ec.clear();
}
return status;
}
#endif
fs::file_status
fs::status(const fs::path& p)
{
std::error_code ec;
auto result = status(p, ec);
if (result.type() == file_type::none)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("status", p, ec));
return result;
}
fs::file_status
fs::symlink_status(const fs::path& p)
{
std::error_code ec;
auto result = symlink_status(p, ec);
if (result.type() == file_type::none)
_GLIBCXX_THROW_OR_ABORT(filesystem_error("symlink_status", p, ec));
return result;
}
fs::path
fs::temp_directory_path()
{
error_code ec;
path p = fs::get_temp_directory_from_env(ec);
if (!ec)
{
auto st = status(p, ec);
if (!ec && !is_directory(st))
ec = std::make_error_code(std::errc::not_a_directory);
}
if (ec)
{
if (p.empty())
_GLIBCXX_THROW_OR_ABORT(filesystem_error("temp_directory_path", ec));
else
_GLIBCXX_THROW_OR_ABORT(filesystem_error("temp_directory_path", p, ec));
}
return p;
}
fs::path
fs::temp_directory_path(error_code& ec)
{
path p = fs::get_temp_directory_from_env(ec);
if (!ec)
{
auto st = status(p, ec);
if (ec)
p.clear();
else if (!is_directory(st))
{
p.clear();
ec = std::make_error_code(std::errc::not_a_directory);
}
}
return p;
}
fs::path
fs::weakly_canonical(const path& p)
{
path result;
if (exists(status(p)))
return canonical(p);
path tmp;
auto iter = p.begin(), end = p.end();
// find leading elements of p that exist:
while (iter != end)
{
tmp = result / *iter;
if (exists(status(tmp)))
swap(result, tmp);
else
break;
++iter;
}
// canonicalize:
if (!result.empty())
result = canonical(result);
// append the non-existing elements:
while (iter != end)
result /= *iter++;
// normalize:
return result.lexically_normal();
}
fs::path
fs::weakly_canonical(const path& p, error_code& ec)
{
path result;
file_status st = status(p, ec);
if (exists(st))
return canonical(p, ec);
else if (status_known(st))
ec.clear();
else
return result;
path tmp;
auto iter = p.begin(), end = p.end();
// find leading elements of p that exist:
while (iter != end)
{
tmp = result / *iter;
st = status(tmp, ec);
if (exists(st))
swap(result, tmp);
else
{
if (status_known(st))
ec.clear();
break;
}
++iter;
}
// canonicalize:
if (!ec && !result.empty())
result = canonical(result, ec);
if (ec)
result.clear();
else
{
// append the non-existing elements:
while (iter != end)
result /= *iter++;
// normalize:
result = result.lexically_normal();
}
return result;
}