123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794 |
- //===--------------------- filesystem/ops.cpp -----------------------------===//
- //
- // The LLVM Compiler Infrastructure
- //
- // This file is dual licensed under the MIT and the University of Illinois Open
- // Source Licenses. See LICENSE.TXT for details.
- //
- //===----------------------------------------------------------------------===//
- #include "experimental/filesystem"
- #include "iterator"
- #include "fstream"
- #include "type_traits"
- #include "random" /* for unique_path */
- #include "cstdlib"
- #include "climits"
- #include <unistd.h>
- #include <sys/stat.h>
- #include <sys/statvfs.h>
- #include <fcntl.h> /* values for fchmodat */
- #if !defined(UTIME_OMIT)
- #include <sys/time.h> // for ::utimes as used in __last_write_time
- #endif
- _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
- filesystem_error::~filesystem_error() {}
- // POSIX HELPERS
- namespace detail { namespace {
- using value_type = path::value_type;
- using string_type = path::string_type;
- inline std::error_code capture_errno() {
- _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
- std::error_code m_ec(errno, std::generic_category());
- return m_ec;
- }
- void set_or_throw(std::error_code const& m_ec, std::error_code* ec,
- const char* msg, path const& p = {}, path const& p2 = {})
- {
- if (ec) {
- *ec = m_ec;
- } else {
- string msg_s("std::experimental::filesystem::");
- msg_s += msg;
- __libcpp_throw(filesystem_error(msg_s, p, p2, m_ec));
- }
- }
- void set_or_throw(std::error_code* ec, const char* msg,
- path const& p = {}, path const& p2 = {})
- {
- return set_or_throw(capture_errno(), ec, msg, p, p2);
- }
- perms posix_get_perms(const struct ::stat & st) noexcept {
- return static_cast<perms>(st.st_mode) & perms::mask;
- }
- ::mode_t posix_convert_perms(perms prms) {
- return static_cast< ::mode_t>(prms & perms::mask);
- }
- file_status create_file_status(std::error_code& m_ec, path const& p,
- struct ::stat& path_stat,
- std::error_code* ec)
- {
- if (ec) *ec = m_ec;
- if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
- return file_status(file_type::not_found);
- }
- else if (m_ec) {
- set_or_throw(m_ec, ec, "posix_stat", p);
- return file_status(file_type::none);
- }
- // else
- file_status fs_tmp;
- auto const mode = path_stat.st_mode;
- if (S_ISLNK(mode)) fs_tmp.type(file_type::symlink);
- else if (S_ISREG(mode)) fs_tmp.type(file_type::regular);
- else if (S_ISDIR(mode)) fs_tmp.type(file_type::directory);
- else if (S_ISBLK(mode)) fs_tmp.type(file_type::block);
- else if (S_ISCHR(mode)) fs_tmp.type(file_type::character);
- else if (S_ISFIFO(mode)) fs_tmp.type(file_type::fifo);
- else if (S_ISSOCK(mode)) fs_tmp.type(file_type::socket);
- else fs_tmp.type(file_type::unknown);
- fs_tmp.permissions(detail::posix_get_perms(path_stat));
- return fs_tmp;
- }
- file_status posix_stat(path const & p, struct ::stat& path_stat,
- std::error_code* ec)
- {
- std::error_code m_ec;
- if (::stat(p.c_str(), &path_stat) == -1)
- m_ec = detail::capture_errno();
- return create_file_status(m_ec, p, path_stat, ec);
- }
- file_status posix_stat(path const & p, std::error_code* ec) {
- struct ::stat path_stat;
- return posix_stat(p, path_stat, ec);
- }
- file_status posix_lstat(path const & p, struct ::stat & path_stat,
- std::error_code* ec)
- {
- std::error_code m_ec;
- if (::lstat(p.c_str(), &path_stat) == -1)
- m_ec = detail::capture_errno();
- return create_file_status(m_ec, p, path_stat, ec);
- }
- file_status posix_lstat(path const & p, std::error_code* ec) {
- struct ::stat path_stat;
- return posix_lstat(p, path_stat, ec);
- }
- bool stat_equivalent(struct ::stat& st1, struct ::stat& st2) {
- return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
- }
- // DETAIL::MISC
- bool copy_file_impl(const path& from, const path& to, perms from_perms,
- std::error_code *ec)
- {
- std::ifstream in(from.c_str(), std::ios::binary);
- std::ofstream out(to.c_str(), std::ios::binary);
- if (in.good() && out.good()) {
- using InIt = std::istreambuf_iterator<char>;
- using OutIt = std::ostreambuf_iterator<char>;
- InIt bin(in);
- InIt ein;
- OutIt bout(out);
- std::copy(bin, ein, bout);
- }
- if (out.fail() || in.fail()) {
- set_or_throw(make_error_code(errc::operation_not_permitted),
- ec, "copy_file", from, to);
- return false;
- }
- __permissions(to, from_perms, ec);
- // TODO what if permissions fails?
- return true;
- }
- }} // end namespace detail
- using detail::set_or_throw;
- 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};
- }
- void __copy(const path& from, const path& to, copy_options options,
- std::error_code *ec)
- {
- const bool sym_status = bool(options &
- (copy_options::create_symlinks | copy_options::skip_symlinks));
- const bool sym_status2 = bool(options &
- copy_options::copy_symlinks);
- std::error_code m_ec;
- struct ::stat f_st = {};
- const file_status f = sym_status || sym_status2
- ? detail::posix_lstat(from, f_st, &m_ec)
- : detail::posix_stat(from, f_st, &m_ec);
- if (m_ec)
- return set_or_throw(m_ec, ec, "copy", from, to);
- struct ::stat t_st = {};
- const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec)
- : detail::posix_stat(to, t_st, &m_ec);
- if (not status_known(t))
- return set_or_throw(m_ec, ec, "copy", from, to);
- if (!exists(f) || is_other(f) || is_other(t)
- || (is_directory(f) && is_regular_file(t))
- || detail::stat_equivalent(f_st, t_st))
- {
- return set_or_throw(make_error_code(errc::function_not_supported),
- ec, "copy", from, to);
- }
- if (ec) ec->clear();
- if (is_symlink(f)) {
- if (bool(copy_options::skip_symlinks & options)) {
- // do nothing
- } else if (not exists(t)) {
- __copy_symlink(from, to, ec);
- } else {
- set_or_throw(make_error_code(errc::file_exists),
- ec, "copy", from, to);
- }
- return;
- }
- else if (is_regular_file(f)) {
- if (bool(copy_options::directories_only & options)) {
- // do nothing
- }
- else if (bool(copy_options::create_symlinks & options)) {
- __create_symlink(from, to, ec);
- }
- else if (bool(copy_options::create_hard_links & options)) {
- __create_hard_link(from, to, ec);
- }
- else if (is_directory(t)) {
- __copy_file(from, to / from.filename(), options, ec);
- } else {
- __copy_file(from, to, options, ec);
- }
- return;
- }
- else if (is_directory(f)) {
- if (not bool(copy_options::recursive & options) &&
- bool(copy_options::__in_recursive_copy & options))
- {
- return;
- }
- if (!exists(t)) {
- // create directory to with attributes from 'from'.
- __create_directory(to, from, ec);
- if (ec && *ec) { return; }
- }
- directory_iterator it = ec ? directory_iterator(from, *ec)
- : directory_iterator(from);
- if (ec && *ec) { return; }
- std::error_code m_ec;
- for (; it != directory_iterator(); it.increment(m_ec)) {
- if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to);
- __copy(it->path(), to / it->path().filename(),
- options | copy_options::__in_recursive_copy, ec);
- if (ec && *ec) { return; }
- }
- }
- }
- bool __copy_file(const path& from, const path& to, copy_options options,
- std::error_code *ec)
- {
- if (ec) ec->clear();
- std::error_code m_ec;
- auto from_st = detail::posix_stat(from, &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;
- }
- auto to_st = detail::posix_stat(to, &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 && 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", from, to);
- return false;
- }
- }
- void __copy_symlink(const path& existing_symlink, const path& new_symlink,
- std::error_code *ec)
- {
- const path real_path(__read_symlink(existing_symlink, ec));
- if (ec && *ec) { return; }
- // NOTE: proposal says you should detect if you should call
- // create_symlink or create_directory_symlink. I don't think this
- // is needed with POSIX
- __create_symlink(real_path, new_symlink, ec);
- }
- 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 __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;
- }
- 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;
- }
- void __create_directory_symlink(path const & from, path const & to,
- std::error_code *ec){
- if (::symlink(from.c_str(), to.c_str()) != 0)
- set_or_throw(ec, "create_directory_symlink", from, to);
- else if (ec)
- ec->clear();
- }
- void __create_hard_link(const path& from, const path& to, std::error_code *ec){
- if (::link(from.c_str(), to.c_str()) == -1)
- set_or_throw(ec, "create_hard_link", from, to);
- 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();
- }
- 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()};
- }
- 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();
- }
- 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);
- }
- 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 __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);
- }
- 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;
- }
- namespace detail { namespace {
- template <class CType, class ChronoType>
- bool checked_set(CType* out, ChronoType time) {
- using Lim = numeric_limits<CType>;
- if (time > Lim::max() || time < Lim::min())
- return false;
- *out = static_cast<CType>(time);
- return true;
- }
- constexpr long long min_seconds = file_time_type::duration::min().count()
- / file_time_type::period::den;
- template <class SubSecDurT, class SubSecT>
- bool set_times_checked(time_t* sec_out, SubSecT* subsec_out, file_time_type tp) {
- using namespace chrono;
- auto dur = tp.time_since_epoch();
- auto sec_dur = duration_cast<seconds>(dur);
- auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
- // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
- if (subsec_dur.count() < 0) {
- if (sec_dur.count() > min_seconds) {
- sec_dur -= seconds(1);
- subsec_dur += seconds(1);
- } else {
- subsec_dur = SubSecDurT::zero();
- }
- }
- return checked_set(sec_out, sec_dur.count())
- && checked_set(subsec_out, subsec_dur.count());
- }
- }} // end namespace detail
- 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);
- }
- 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 __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();
- }
- 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};
- }
- 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;
- }
- namespace {
- std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
- {
- const auto npos = static_cast<std::uintmax_t>(-1);
- const file_status st = __symlink_status(p, &ec);
- if (ec) return npos;
- std::uintmax_t count = 1;
- if (is_directory(st)) {
- for (directory_iterator it(p, ec); !ec && it != directory_iterator();
- it.increment(ec)) {
- auto other_count = remove_all_impl(it->path(), ec);
- if (ec) return npos;
- count += other_count;
- }
- if (ec) return npos;
- }
- if (!__remove(p, &ec)) return npos;
- return count;
- }
- } // end namespace
- 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 __rename(const path& from, const path& to, std::error_code *ec) {
- if (::rename(from.c_str(), to.c_str()) == -1)
- set_or_throw(ec, "rename", from, to);
- else if (ec)
- ec->clear();
- }
- void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
- if (::truncate(p.c_str(), static_cast<long>(size)) == -1)
- set_or_throw(ec, "resize_file", p);
- else if (ec)
- ec->clear();
- }
- 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;
- }
- file_status __status(const path& p, std::error_code *ec) {
- return detail::posix_stat(p, ec);
- }
- file_status __symlink_status(const path& p, std::error_code *ec) {
- return detail::posix_lstat(p, ec);
- }
- path __system_complete(const path& p, std::error_code *ec) {
- if (ec) ec->clear();
- return absolute(p, current_path());
- }
- 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 {};
- }
- // An absolute path is composed according to the table in [fs.op.absolute].
- path absolute(const path& p, const path& base) {
- auto root_name = p.root_name();
- auto root_dir = p.root_directory();
- if (!root_name.empty() && !root_dir.empty())
- return p;
- auto abs_base = base.is_absolute() ? base : absolute(base);
- /* !has_root_name && !has_root_dir */
- if (root_name.empty() && root_dir.empty())
- {
- return abs_base / p;
- }
- else if (!root_name.empty()) /* has_root_name && !has_root_dir */
- {
- return root_name / abs_base.root_directory()
- /
- abs_base.relative_path() / p.relative_path();
- }
- else /* !has_root_name && has_root_dir */
- {
- if (abs_base.has_root_name())
- return abs_base.root_name() / p;
- // else p is absolute, return outside of block
- }
- return p;
- }
- _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
|