bool __fs_is_empty(const path& p, std::error_code *ec)
{
if (ec) ec->clear();
std::error_code m_ec;
struct ::stat pst;
auto st = detail::posix_stat(p, pst, &m_ec);
if (m_ec) {
set_or_throw(m_ec, ec, "is_empty", p);
return false;
}
else if (!is_directory(st) && !is_regular_file(st)) {
m_ec = make_error_code(errc::not_supported);
set_or_throw(m_ec, ec, "is_empty");
return false;
}
else if (is_directory(st)) {
auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
if (ec && *ec)
return false;
return it == directory_iterator{};
}
else if (is_regular_file(st))
return static_cast<std::uintmax_t>(pst.st_size) == 0;
_LIBCPP_UNREACHABLE();
}
bool __create_directories(const path& p, std::error_code *ec)
{
std::error_code m_ec;
auto const st = detail::posix_stat(p, &m_ec);
if (!status_known(st)) {
set_or_throw(m_ec, ec, "create_directories", p);
return false;
}
else if (is_directory(st)) {
if (ec) ec->clear();
return false;
}
else if (exists(st)) {
set_or_throw(make_error_code(errc::file_exists),
ec, "create_directories", p);
return false;
}
const path parent = p.parent_path();
if (!parent.empty()) {
const file_status parent_st = status(parent, m_ec);
if (not status_known(parent_st)) {
set_or_throw(m_ec, ec, "create_directories", p);
return false;
}
if (not exists(parent_st)) {
__create_directories(parent, ec);
if (ec && *ec) { return false; }
}
}
return __create_directory(p, ec);
}
bool __copy_file(const path& from, const path& to, copy_options options,
std::error_code *ec)
{
using StatT = struct ::stat;
if (ec)
ec->clear();
std::error_code m_ec;
StatT from_stat;
auto from_st = detail::posix_stat(from, from_stat, &m_ec);
if (not is_regular_file(from_st)) {
if (not m_ec)
m_ec = make_error_code(errc::not_supported);
set_or_throw(m_ec, ec, "copy_file", from, to);
return false;
}
StatT to_stat;
auto to_st = detail::posix_stat(to, to_stat, &m_ec);
if (!status_known(to_st)) {
set_or_throw(m_ec, ec, "copy_file", from, to);
return false;
}
const bool to_exists = exists(to_st);
if (to_exists && !is_regular_file(to_st)) {
set_or_throw(make_error_code(errc::not_supported), ec, "copy_file", from, to);
return false;
}
if (to_exists && detail::stat_equivalent(from_stat, to_stat)) {
set_or_throw(make_error_code(errc::file_exists), ec, "copy_file", from,
to);
return false;
}
if (to_exists && bool(copy_options::skip_existing & options)) {
return false;
}
else if (to_exists && bool(copy_options::update_existing & options)) {
auto from_time = __last_write_time(from, ec);
if (ec && *ec) { return false; }
auto to_time = __last_write_time(to, ec);
if (ec && *ec) { return false; }
if (from_time <= to_time) {
return false;
}
return detail::copy_file_impl(from, to, from_st.permissions(), ec);
}
else if (!to_exists || bool(copy_options::overwrite_existing & options)) {
return detail::copy_file_impl(from, to, from_st.permissions(), ec);
}
else {
set_or_throw(make_error_code(errc::file_exists), ec, "copy_file", from,
to);
return false;
}
_LIBCPP_UNREACHABLE();
}
void __last_write_time(const path& p, file_time_type new_time,
std::error_code *ec)
{
using namespace std::chrono;
std::error_code m_ec;
// We can use the presence of UTIME_OMIT to detect platforms that do not
// provide utimensat.
#if !defined(UTIME_OMIT)
// This implementation has a race condition between determining the
// last access time and attempting to set it to the same value using
// ::utimes
struct ::stat st;
file_status fst = detail::posix_stat(p, st, &m_ec);
if (m_ec && !status_known(fst)) {
set_or_throw(m_ec, ec, "last_write_time", p);
return;
}
struct ::timeval tbuf[2];
tbuf[0].tv_sec = st.st_atime;
tbuf[0].tv_usec = 0;
const bool overflowed = !detail::set_times_checked<microseconds>(
&tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
if (overflowed) {
set_or_throw(make_error_code(errc::invalid_argument), ec,
"last_write_time", p);
return;
}
if (::utimes(p.c_str(), tbuf) == -1) {
m_ec = detail::capture_errno();
}
#else
struct ::timespec tbuf[2];
tbuf[0].tv_sec = 0;
tbuf[0].tv_nsec = UTIME_OMIT;
const bool overflowed = !detail::set_times_checked<nanoseconds>(
&tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
if (overflowed) {
set_or_throw(make_error_code(errc::invalid_argument),
ec, "last_write_time", p);
return;
}
if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
m_ec = detail::capture_errno();
}
#endif
if (m_ec)
set_or_throw(m_ec, ec, "last_write_time", p);
else if (ec)
ec->clear();
}
void __last_write_time(const path& p, file_time_type new_time,
std::error_code *ec)
{
using namespace std::chrono;
std::error_code m_ec;
#if !defined(_LIBCXX_USE_UTIMENSAT)
// This implementation has a race condition between determining the
// last access time and attempting to set it to the same value using
// ::utimes
struct ::stat st;
file_status fst = detail::posix_stat(p, st, &m_ec);
if (m_ec && !status_known(fst)) {
set_or_throw(m_ec, ec, "last_write_time", p);
return;
}
auto atime = detail::extract_atime(st);
struct ::timeval tbuf[2];
tbuf[0].tv_sec = atime.tv_sec;
tbuf[0].tv_usec = duration_cast<microseconds>(nanoseconds(atime.tv_nsec)).count();
const bool overflowed = !FSTime::set_times_checked<microseconds>(
&tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
if (overflowed) {
set_or_throw(make_error_code(errc::invalid_argument), ec,
"last_write_time", p);
return;
}
if (::utimes(p.c_str(), tbuf) == -1) {
m_ec = detail::capture_errno();
}
#else
struct ::timespec tbuf[2];
tbuf[0].tv_sec = 0;
tbuf[0].tv_nsec = UTIME_OMIT;
const bool overflowed = !FSTime::set_times_checked<nanoseconds>(
&tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
if (overflowed) {
set_or_throw(make_error_code(errc::invalid_argument),
ec, "last_write_time", p);
return;
}
if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
m_ec = detail::capture_errno();
}
#endif
if (m_ec)
set_or_throw(m_ec, ec, "last_write_time", p);
else if (ec)
ec->clear();
}
void __create_symlink(path const & from, path const & to, std::error_code *ec) {
if (::symlink(from.c_str(), to.c_str()) == -1)
set_or_throw(ec, "create_symlink", from, to);
else if (ec)
ec->clear();
}
bool __create_directory(path const & p, path const & attributes,
std::error_code *ec)
{
struct ::stat attr_stat;
std::error_code mec;
auto st = detail::posix_stat(attributes, attr_stat, &mec);
if (!status_known(st)) {
set_or_throw(mec, ec, "create_directory", p, attributes);
return false;
}
if (ec) ec->clear();
if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
return true;
if (errno != EEXIST || !is_directory(p))
set_or_throw(ec, "create_directory", p, attributes);
return false;
}
bool __remove(const path& p, std::error_code *ec) {
if (ec) ec->clear();
if (::remove(p.c_str()) == -1) {
set_or_throw(ec, "remove", p);
return false;
}
return true;
}
bool __create_directory(const path& p, std::error_code *ec)
{
if (ec) ec->clear();
if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
return true;
if (errno != EEXIST || !is_directory(p))
set_or_throw(ec, "create_directory", p);
return false;
}
file_time_type __last_write_time(const path& p, std::error_code *ec)
{
using namespace ::std::chrono;
std::error_code m_ec;
struct ::stat st;
detail::posix_stat(p, st, &m_ec);
if (m_ec) {
set_or_throw(m_ec, ec, "last_write_time", p);
return file_time_type::min();
}
if (ec) ec->clear();
auto ts = detail::extract_mtime(st);
if (!FSTime::is_representable(ts)) {
set_or_throw(error_code(EOVERFLOW, generic_category()), ec,
"last_write_time", p);
return file_time_type::min();
}
return FSTime::convert_timespec(ts);
}
std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
std::error_code mec;
auto count = remove_all_impl(p, mec);
if (mec) {
set_or_throw(mec, ec, "remove_all", p);
return static_cast<std::uintmax_t>(-1);
}
if (ec) ec->clear();
return count;
}
void __permissions(const path& p, perms prms, std::error_code *ec)
{
const bool resolve_symlinks = !bool(perms::symlink_nofollow & prms);
const bool add_perms = bool(perms::add_perms & prms);
const bool remove_perms = bool(perms::remove_perms & prms);
_LIBCPP_ASSERT(!(add_perms && remove_perms),
"Both add_perms and remove_perms are set");
bool set_sym_perms = false;
prms &= perms::mask;
if (!resolve_symlinks || (add_perms || remove_perms)) {
std::error_code m_ec;
file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
: detail::posix_lstat(p, &m_ec);
set_sym_perms = is_symlink(st);
if (m_ec) return set_or_throw(m_ec, ec, "permissions", p);
_LIBCPP_ASSERT(st.permissions() != perms::unknown,
"Permissions unexpectedly unknown");
if (add_perms)
prms |= st.permissions();
else if (remove_perms)
prms = st.permissions() & ~prms;
}
const auto real_perms = detail::posix_convert_perms(prms);
# if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
return set_or_throw(ec, "permissions", p);
}
# else
if (set_sym_perms)
return set_or_throw(make_error_code(errc::operation_not_supported),
ec, "permissions", p);
if (::chmod(p.c_str(), real_perms) == -1) {
return set_or_throw(ec, "permissions", p);
}
# endif
if (ec) ec->clear();
}
file_time_type __last_write_time(const path& p, std::error_code *ec)
{
std::error_code m_ec;
struct ::stat st;
detail::posix_stat(p, st, &m_ec);
if (m_ec) {
set_or_throw(m_ec, ec, "last_write_time", p);
return file_time_type::min();
}
if (ec) ec->clear();
return file_time_type::clock::from_time_t(st.st_mtime);
}
std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
{
std::error_code m_ec;
struct ::stat st;
detail::posix_stat(p, st, &m_ec);
if (m_ec) {
set_or_throw(m_ec, ec, "hard_link_count", p);
return static_cast<std::uintmax_t>(-1);
}
if (ec) ec->clear();
return static_cast<std::uintmax_t>(st.st_nlink);
}
path __canonical(path const & orig_p, const path& base, std::error_code *ec)
{
path p = absolute(orig_p, base);
char buff[PATH_MAX + 1];
char *ret;
if ((ret = ::realpath(p.c_str(), buff)) == nullptr) {
set_or_throw(ec, "canonical", orig_p, base);
return {};
}
if (ec) ec->clear();
return {ret};
}
directory_iterator::directory_iterator(const path& p, error_code *ec,
directory_options opts)
{
std::error_code m_ec;
__imp_ = make_shared<__dir_stream>(p, opts, m_ec);
if (ec) *ec = m_ec;
if (!__imp_->good()) {
__imp_.reset();
if (m_ec)
set_or_throw(m_ec, ec,
"directory_iterator::directory_iterator(...)", p);
}
}
path __current_path(std::error_code *ec) {
auto size = ::pathconf(".", _PC_PATH_MAX);
_LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
auto buff = std::unique_ptr<char[]>(new char[size + 1]);
char* ret;
if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr) {
set_or_throw(ec, "current_path");
return {};
}
if (ec) ec->clear();
return {buff.get()};
}
bool __fs_is_empty(const path& p, std::error_code *ec)
{
if (ec) ec->clear();
std::error_code m_ec;
struct ::stat pst;
auto st = detail::posix_stat(p, pst, &m_ec);
if (is_directory(st))
return directory_iterator(p) == directory_iterator{};
else if (is_regular_file(st))
return static_cast<std::uintmax_t>(pst.st_size) == 0;
// else
set_or_throw(m_ec, ec, "is_empty", p);
return false;
}
path __read_symlink(const path& p, std::error_code *ec) {
char buff[PATH_MAX + 1];
std::error_code m_ec;
::ssize_t ret;
if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
set_or_throw(ec, "read_symlink", p);
return {};
}
_LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
_LIBCPP_ASSERT(ret > 0, "TODO");
if (ec) ec->clear();
buff[ret] = 0;
return {buff};
}
directory_iterator& directory_iterator::__increment(error_code *ec)
{
_LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
std::error_code m_ec;
if (!__imp_->advance(m_ec)) {
__imp_.reset();
if (m_ec)
set_or_throw(m_ec, ec, "directory_iterator::operator++()");
} else {
if (ec) ec->clear();
}
return *this;
}
recursive_directory_iterator::recursive_directory_iterator(const path& p,
directory_options opt, error_code *ec)
: __imp_(nullptr), __rec_(true)
{
if (ec) ec->clear();
std::error_code m_ec;
__dir_stream new_s(p, opt, m_ec);
if (m_ec) set_or_throw(m_ec, ec, "recursive_directory_iterator", p);
if (m_ec || !new_s.good()) return;
__imp_ = _VSTD::make_shared<__shared_imp>();
__imp_->__options_ = opt;
__imp_->__stack_.push(_VSTD::move(new_s));
}
void recursive_directory_iterator::__advance(error_code* ec) {
// REQUIRES: ec must be cleared before calling this function.
const directory_iterator end_it;
auto& stack = __imp_->__stack_;
std::error_code m_ec;
while (stack.size() > 0) {
if (stack.top().advance(m_ec))
return;
if (m_ec) break;
stack.pop();
}
__imp_.reset();
if (m_ec)
set_or_throw(m_ec, ec, "recursive_directory_iterator::operator++()");
}
std::uintmax_t __file_size(const path& p, std::error_code *ec)
{
std::error_code m_ec;
struct ::stat st;
file_status fst = detail::posix_stat(p, st, &m_ec);
if (!exists(fst) || !is_regular_file(fst)) {
if (!m_ec)
m_ec = make_error_code(errc::not_supported);
set_or_throw(m_ec, ec, "file_size", p);
return static_cast<uintmax_t>(-1);
}
// is_regular_file(p) == true
if (ec) ec->clear();
return static_cast<std::uintmax_t>(st.st_size);
}
std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
if (ec) ec->clear();
std::error_code mec;
auto count = remove_all_impl(p, mec);
if (mec) {
if (mec == errc::no_such_file_or_directory) {
return 0;
} else {
set_or_throw(mec, ec, "remove_all", p);
return static_cast<std::uintmax_t>(-1);
}
}
return count;
}
bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
{
std::error_code ec1, ec2;
struct ::stat st1 = {};
struct ::stat st2 = {};
auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
if ((!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))) {
set_or_throw(make_error_code(errc::not_supported), ec,
"equivalent", p1, p2);
return false;
}
if (ec) ec->clear();
return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
}
path __temp_directory_path(std::error_code *ec) {
const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
const char* ret = nullptr;
for (auto & ep : env_paths) {
if ((ret = std::getenv(ep)))
break;
}
path p(ret ? ret : "/tmp");
std::error_code m_ec;
if (is_directory(p, m_ec)) {
if (ec) ec->clear();
return p;
}
if (!m_ec || m_ec == make_error_code(errc::no_such_file_or_directory))
m_ec = make_error_code(errc::not_a_directory);
set_or_throw(m_ec, ec, "temp_directory_path");
return {};
}
bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
{
auto make_unsupported_error = [&]() {
set_or_throw(make_error_code(errc::not_supported), ec,
"equivalent", p1, p2);
return false;
};
std::error_code ec1, ec2;
struct ::stat st1 = {};
struct ::stat st2 = {};
auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
if (!exists(s1))
return make_unsupported_error();
auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
if (!exists(s2))
return make_unsupported_error();
if (ec) ec->clear();
return detail::stat_equivalent(st1, st2);
}
space_info __space(const path& p, std::error_code *ec) {
space_info si;
struct statvfs m_svfs = {};
if (::statvfs(p.c_str(), &m_svfs) == -1) {
set_or_throw(ec, "space", p);
si.capacity = si.free = si.available =
static_cast<std::uintmax_t>(-1);
return si;
}
if (ec) ec->clear();
// Multiply with overflow checking.
auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
out = other * m_svfs.f_frsize;
if (out / other != m_svfs.f_frsize || other == 0)
out = static_cast<std::uintmax_t>(-1);
};
do_mult(si.capacity, m_svfs.f_blocks);
do_mult(si.free, m_svfs.f_bfree);
do_mult(si.available, m_svfs.f_bavail);
return si;
}
bool recursive_directory_iterator::__try_recursion(error_code *ec) {
bool rec_sym =
bool(options() & directory_options::follow_directory_symlink);
auto& curr_it = __imp_->__stack_.top();
if (is_directory(curr_it.__entry_.status()) &&
(!is_symlink(curr_it.__entry_.symlink_status()) || rec_sym))
{
std::error_code m_ec;
__dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
if (new_it.good()) {
__imp_->__stack_.push(_VSTD::move(new_it));
return true;
}
if (m_ec) {
__imp_.reset();
set_or_throw(m_ec, ec,
"recursive_directory_iterator::operator++()");
}
}
return false;
}
void __current_path(const path& p, std::error_code *ec) {
if (::chdir(p.c_str()) == -1)
set_or_throw(ec, "current_path", p);
else if (ec)
ec->clear();
}