• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--------------------- filesystem/ops.cpp -----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "experimental/filesystem"
11 #include "iterator"
12 #include "fstream"
13 #include "type_traits"
14 #include "random"  /* for unique_path */
15 #include "cstdlib"
16 #include "climits"
17 
18 #include <unistd.h>
19 #include <sys/stat.h>
20 #include <sys/statvfs.h>
21 #include <fcntl.h>  /* values for fchmodat */
22 #if !defined(UTIME_OMIT)
23 #include <sys/time.h> // for ::utimes as used in __last_write_time
24 #endif
25 
26 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
27 
~filesystem_error()28 filesystem_error::~filesystem_error() {}
29 
30 
31 //                       POSIX HELPERS
32 
33 namespace detail { namespace  {
34 
35 using value_type = path::value_type;
36 using string_type = path::string_type;
37 
capture_errno()38 inline std::error_code capture_errno() {
39   _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
40   return std::error_code(errno, std::generic_category());
41 }
42 
set_or_throw(std::error_code const & m_ec,std::error_code * ec,const char * msg,path const & p={},path const & p2={})43 void set_or_throw(std::error_code const& m_ec, std::error_code* ec,
44                   const char* msg, path const& p = {}, path const& p2 = {})
45 {
46     if (ec) {
47         *ec = m_ec;
48     } else {
49         string msg_s("std::experimental::filesystem::");
50         msg_s += msg;
51         __throw_filesystem_error(msg_s, p, p2, m_ec);
52     }
53 }
54 
set_or_throw(std::error_code * ec,const char * msg,path const & p={},path const & p2={})55 void set_or_throw(std::error_code* ec, const char* msg,
56                   path const& p = {}, path const& p2 = {})
57 {
58     return set_or_throw(capture_errno(), ec, msg, p, p2);
59 }
60 
posix_get_perms(const struct::stat & st)61 perms posix_get_perms(const struct ::stat & st) noexcept {
62     return static_cast<perms>(st.st_mode) & perms::mask;
63 }
64 
posix_convert_perms(perms prms)65 ::mode_t posix_convert_perms(perms prms) {
66     return static_cast< ::mode_t>(prms & perms::mask);
67 }
68 
create_file_status(std::error_code & m_ec,path const & p,struct::stat & path_stat,std::error_code * ec)69 file_status create_file_status(std::error_code& m_ec, path const& p,
70                                struct ::stat& path_stat,
71                                std::error_code* ec)
72 {
73     if (ec) *ec = m_ec;
74     if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
75         return file_status(file_type::not_found);
76     }
77     else if (m_ec) {
78         set_or_throw(m_ec, ec, "posix_stat", p);
79         return file_status(file_type::none);
80     }
81     // else
82 
83     file_status fs_tmp;
84     auto const mode = path_stat.st_mode;
85     if      (S_ISLNK(mode))  fs_tmp.type(file_type::symlink);
86     else if (S_ISREG(mode))  fs_tmp.type(file_type::regular);
87     else if (S_ISDIR(mode))  fs_tmp.type(file_type::directory);
88     else if (S_ISBLK(mode))  fs_tmp.type(file_type::block);
89     else if (S_ISCHR(mode))  fs_tmp.type(file_type::character);
90     else if (S_ISFIFO(mode)) fs_tmp.type(file_type::fifo);
91     else if (S_ISSOCK(mode)) fs_tmp.type(file_type::socket);
92     else                     fs_tmp.type(file_type::unknown);
93 
94     fs_tmp.permissions(detail::posix_get_perms(path_stat));
95     return fs_tmp;
96 }
97 
posix_stat(path const & p,struct::stat & path_stat,std::error_code * ec)98 file_status posix_stat(path const & p, struct ::stat& path_stat,
99                        std::error_code* ec)
100 {
101     std::error_code m_ec;
102     if (::stat(p.c_str(), &path_stat) == -1)
103         m_ec = detail::capture_errno();
104     return create_file_status(m_ec, p, path_stat, ec);
105 }
106 
posix_stat(path const & p,std::error_code * ec)107 file_status posix_stat(path const & p, std::error_code* ec) {
108     struct ::stat path_stat;
109     return posix_stat(p, path_stat, ec);
110 }
111 
posix_lstat(path const & p,struct::stat & path_stat,std::error_code * ec)112 file_status posix_lstat(path const & p, struct ::stat & path_stat,
113                         std::error_code* ec)
114 {
115     std::error_code m_ec;
116     if (::lstat(p.c_str(), &path_stat) == -1)
117         m_ec = detail::capture_errno();
118     return create_file_status(m_ec, p, path_stat, ec);
119 }
120 
posix_lstat(path const & p,std::error_code * ec)121 file_status posix_lstat(path const & p, std::error_code* ec) {
122     struct ::stat path_stat;
123     return posix_lstat(p, path_stat, ec);
124 }
125 
stat_equivalent(struct::stat & st1,struct::stat & st2)126 bool stat_equivalent(struct ::stat& st1, struct ::stat& st2) {
127     return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
128 }
129 
130 //                           DETAIL::MISC
131 
132 
copy_file_impl(const path & from,const path & to,perms from_perms,std::error_code * ec)133 bool copy_file_impl(const path& from, const path& to, perms from_perms,
134                     std::error_code *ec)
135 {
136     std::ifstream in(from.c_str(), std::ios::binary);
137     std::ofstream out(to.c_str(),  std::ios::binary);
138 
139     if (in.good() && out.good()) {
140         using InIt = std::istreambuf_iterator<char>;
141         using OutIt = std::ostreambuf_iterator<char>;
142         InIt bin(in);
143         InIt ein;
144         OutIt bout(out);
145         std::copy(bin, ein, bout);
146     }
147     if (out.fail() || in.fail()) {
148         set_or_throw(make_error_code(errc::operation_not_permitted),
149                      ec, "copy_file", from, to);
150         return false;
151     }
152     __permissions(to, from_perms, ec);
153     // TODO what if permissions fails?
154     return true;
155 }
156 
157 }} // end namespace detail
158 
159 using detail::set_or_throw;
160 
__canonical(path const & orig_p,const path & base,std::error_code * ec)161 path __canonical(path const & orig_p, const path& base, std::error_code *ec)
162 {
163     path p = absolute(orig_p, base);
164     char buff[PATH_MAX + 1];
165     char *ret;
166     if ((ret = ::realpath(p.c_str(), buff)) == nullptr) {
167         set_or_throw(ec, "canonical", orig_p, base);
168         return {};
169     }
170     if (ec) ec->clear();
171     return {ret};
172 }
173 
__copy(const path & from,const path & to,copy_options options,std::error_code * ec)174 void __copy(const path& from, const path& to, copy_options options,
175             std::error_code *ec)
176 {
177     const bool sym_status = bool(options &
178         (copy_options::create_symlinks | copy_options::skip_symlinks));
179 
180     const bool sym_status2 = bool(options &
181         copy_options::copy_symlinks);
182 
183     std::error_code m_ec;
184     struct ::stat f_st = {};
185     const file_status f = sym_status || sym_status2
186                                      ? detail::posix_lstat(from, f_st, &m_ec)
187                                      : detail::posix_stat(from,  f_st, &m_ec);
188     if (m_ec)
189         return set_or_throw(m_ec, ec, "copy", from, to);
190 
191     struct ::stat t_st = {};
192     const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec)
193                                      : detail::posix_stat(to, t_st, &m_ec);
194 
195     if (not status_known(t))
196         return set_or_throw(m_ec, ec, "copy", from, to);
197 
198     if (!exists(f) || is_other(f) || is_other(t)
199         || (is_directory(f) && is_regular_file(t))
200         || detail::stat_equivalent(f_st, t_st))
201     {
202         return set_or_throw(make_error_code(errc::function_not_supported),
203                             ec, "copy", from, to);
204     }
205 
206     if (ec) ec->clear();
207 
208     if (is_symlink(f)) {
209         if (bool(copy_options::skip_symlinks & options)) {
210             // do nothing
211         } else if (not exists(t)) {
212             __copy_symlink(from, to, ec);
213         } else {
214             set_or_throw(make_error_code(errc::file_exists),
215                          ec, "copy", from, to);
216         }
217         return;
218     }
219     else if (is_regular_file(f)) {
220         if (bool(copy_options::directories_only & options)) {
221             // do nothing
222         }
223         else if (bool(copy_options::create_symlinks & options)) {
224             __create_symlink(from, to, ec);
225         }
226         else if (bool(copy_options::create_hard_links & options)) {
227             __create_hard_link(from, to, ec);
228         }
229         else if (is_directory(t)) {
230             __copy_file(from, to / from.filename(), options, ec);
231         } else {
232             __copy_file(from, to, options, ec);
233         }
234         return;
235     }
236     else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
237         return set_or_throw(make_error_code(errc::is_a_directory), ec, "copy");
238     }
239     else if (is_directory(f) && (bool(copy_options::recursive & options) ||
240              copy_options::none == options)) {
241 
242         if (!exists(t)) {
243             // create directory to with attributes from 'from'.
244             __create_directory(to, from, ec);
245             if (ec && *ec) { return; }
246         }
247         directory_iterator it = ec ? directory_iterator(from, *ec)
248                                    : directory_iterator(from);
249         if (ec && *ec) { return; }
250         std::error_code m_ec;
251         for (; it != directory_iterator(); it.increment(m_ec)) {
252             if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to);
253             __copy(it->path(), to / it->path().filename(),
254                    options | copy_options::__in_recursive_copy, ec);
255             if (ec && *ec) { return; }
256         }
257     }
258 }
259 
260 
__copy_file(const path & from,const path & to,copy_options options,std::error_code * ec)261 bool __copy_file(const path& from, const path& to, copy_options options,
262                  std::error_code *ec)
263 {
264     if (ec) ec->clear();
265 
266     std::error_code m_ec;
267     auto from_st = detail::posix_stat(from, &m_ec);
268     if (not is_regular_file(from_st)) {
269         if (not m_ec)
270             m_ec = make_error_code(errc::not_supported);
271         set_or_throw(m_ec, ec, "copy_file", from, to);
272         return false;
273     }
274 
275     auto to_st = detail::posix_stat(to, &m_ec);
276     if (!status_known(to_st)) {
277         set_or_throw(m_ec, ec, "copy_file", from, to);
278         return false;
279     }
280 
281     const bool to_exists = exists(to_st);
282     if (to_exists && !is_regular_file(to_st)) {
283         set_or_throw(make_error_code(errc::not_supported), ec, "copy_file", from, to);
284         return false;
285     }
286     if (to_exists && bool(copy_options::skip_existing & options)) {
287         return false;
288     }
289     else if (to_exists && bool(copy_options::update_existing & options)) {
290         auto from_time = __last_write_time(from, ec);
291         if (ec && *ec) { return false; }
292         auto to_time = __last_write_time(to, ec);
293         if (ec && *ec) { return false; }
294         if (from_time <= to_time) {
295             return false;
296         }
297         return detail::copy_file_impl(from, to, from_st.permissions(), ec);
298     }
299     else if (!to_exists || bool(copy_options::overwrite_existing & options)) {
300         return detail::copy_file_impl(from, to, from_st.permissions(), ec);
301     }
302     else {
303         set_or_throw(make_error_code(errc::file_exists), ec, "copy", from, to);
304         return false;
305     }
306 
307     _LIBCPP_UNREACHABLE();
308 }
309 
__copy_symlink(const path & existing_symlink,const path & new_symlink,std::error_code * ec)310 void __copy_symlink(const path& existing_symlink, const path& new_symlink,
311                     std::error_code *ec)
312 {
313     const path real_path(__read_symlink(existing_symlink, ec));
314     if (ec && *ec) { return; }
315     // NOTE: proposal says you should detect if you should call
316     // create_symlink or create_directory_symlink. I don't think this
317     // is needed with POSIX
318     __create_symlink(real_path, new_symlink, ec);
319 }
320 
321 
__create_directories(const path & p,std::error_code * ec)322 bool __create_directories(const path& p, std::error_code *ec)
323 {
324     std::error_code m_ec;
325     auto const st = detail::posix_stat(p, &m_ec);
326     if (!status_known(st)) {
327         set_or_throw(m_ec, ec, "create_directories", p);
328         return false;
329     }
330     else if (is_directory(st)) {
331         if (ec) ec->clear();
332         return false;
333     }
334     else if (exists(st)) {
335         set_or_throw(make_error_code(errc::file_exists),
336                      ec, "create_directories", p);
337         return false;
338     }
339 
340     const path parent = p.parent_path();
341     if (!parent.empty()) {
342         const file_status parent_st = status(parent, m_ec);
343         if (not status_known(parent_st)) {
344             set_or_throw(m_ec, ec, "create_directories", p);
345             return false;
346         }
347         if (not exists(parent_st)) {
348             __create_directories(parent, ec);
349             if (ec && *ec) { return false; }
350         }
351     }
352     return __create_directory(p, ec);
353 }
354 
__create_directory(const path & p,std::error_code * ec)355 bool __create_directory(const path& p, std::error_code *ec)
356 {
357     if (ec) ec->clear();
358     if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
359         return true;
360     if (errno != EEXIST || !is_directory(p))
361         set_or_throw(ec, "create_directory", p);
362     return false;
363 }
364 
__create_directory(path const & p,path const & attributes,std::error_code * ec)365 bool __create_directory(path const & p, path const & attributes,
366                         std::error_code *ec)
367 {
368     struct ::stat attr_stat;
369     std::error_code mec;
370     auto st = detail::posix_stat(attributes, attr_stat, &mec);
371     if (!status_known(st)) {
372         set_or_throw(mec, ec, "create_directory", p, attributes);
373         return false;
374     }
375     if (ec) ec->clear();
376     if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
377         return true;
378     if (errno != EEXIST || !is_directory(p))
379         set_or_throw(ec, "create_directory", p, attributes);
380     return false;
381 }
382 
__create_directory_symlink(path const & from,path const & to,std::error_code * ec)383 void __create_directory_symlink(path const & from, path const & to,
384                                 std::error_code *ec){
385     if (::symlink(from.c_str(), to.c_str()) != 0)
386         set_or_throw(ec, "create_directory_symlink", from, to);
387     else if (ec)
388         ec->clear();
389 }
390 
__create_hard_link(const path & from,const path & to,std::error_code * ec)391 void __create_hard_link(const path& from, const path& to, std::error_code *ec){
392     if (::link(from.c_str(), to.c_str()) == -1)
393         set_or_throw(ec, "create_hard_link", from, to);
394     else if (ec)
395         ec->clear();
396 }
397 
__create_symlink(path const & from,path const & to,std::error_code * ec)398 void __create_symlink(path const & from, path const & to, std::error_code *ec) {
399 
400     if (::symlink(from.c_str(), to.c_str()) == -1)
401         set_or_throw(ec, "create_symlink", from, to);
402     else if (ec)
403         ec->clear();
404 }
405 
__current_path(std::error_code * ec)406 path __current_path(std::error_code *ec) {
407     auto size = ::pathconf(".", _PC_PATH_MAX);
408     _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
409 
410     auto buff = std::unique_ptr<char[]>(new char[size + 1]);
411     char* ret;
412     if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr) {
413         set_or_throw(ec, "current_path");
414         return {};
415     }
416     if (ec) ec->clear();
417     return {buff.get()};
418 }
419 
__current_path(const path & p,std::error_code * ec)420 void __current_path(const path& p, std::error_code *ec) {
421     if (::chdir(p.c_str()) == -1)
422         set_or_throw(ec, "current_path", p);
423     else if (ec)
424         ec->clear();
425 }
426 
__equivalent(const path & p1,const path & p2,std::error_code * ec)427 bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
428 {
429     std::error_code ec1, ec2;
430     struct ::stat st1 = {};
431     struct ::stat st2 = {};
432     auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
433     auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
434 
435     if ((!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))) {
436         set_or_throw(make_error_code(errc::not_supported), ec,
437                      "equivalent", p1, p2);
438         return false;
439     }
440     if (ec) ec->clear();
441     return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
442 }
443 
444 
__file_size(const path & p,std::error_code * ec)445 std::uintmax_t __file_size(const path& p, std::error_code *ec)
446 {
447     std::error_code m_ec;
448     struct ::stat st;
449     file_status fst = detail::posix_stat(p, st, &m_ec);
450     if (!exists(fst) || !is_regular_file(fst)) {
451         if (!m_ec)
452             m_ec = make_error_code(errc::not_supported);
453         set_or_throw(m_ec, ec, "file_size", p);
454         return static_cast<uintmax_t>(-1);
455     }
456     // is_regular_file(p) == true
457     if (ec) ec->clear();
458     return static_cast<std::uintmax_t>(st.st_size);
459 }
460 
__hard_link_count(const path & p,std::error_code * ec)461 std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
462 {
463     std::error_code m_ec;
464     struct ::stat st;
465     detail::posix_stat(p, st, &m_ec);
466     if (m_ec) {
467         set_or_throw(m_ec, ec, "hard_link_count", p);
468         return static_cast<std::uintmax_t>(-1);
469     }
470     if (ec) ec->clear();
471     return static_cast<std::uintmax_t>(st.st_nlink);
472 }
473 
474 
__fs_is_empty(const path & p,std::error_code * ec)475 bool __fs_is_empty(const path& p, std::error_code *ec)
476 {
477     if (ec) ec->clear();
478     std::error_code m_ec;
479     struct ::stat pst;
480     auto st = detail::posix_stat(p, pst, &m_ec);
481     if (m_ec) {
482         set_or_throw(m_ec, ec, "is_empty", p);
483         return false;
484     }
485     else if (!is_directory(st) && !is_regular_file(st)) {
486         m_ec = make_error_code(errc::not_supported);
487         set_or_throw(m_ec, ec, "is_empty");
488         return false;
489     }
490     else if (is_directory(st)) {
491         auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
492         if (ec && *ec)
493             return false;
494         return it == directory_iterator{};
495     }
496     else if (is_regular_file(st))
497         return static_cast<std::uintmax_t>(pst.st_size) == 0;
498 
499     _LIBCPP_UNREACHABLE();
500 }
501 
502 
503 namespace detail { namespace {
504 
505 using namespace std::chrono;
506 
507 template <class CType, class ChronoType>
checked_set(CType * out,ChronoType time)508 bool checked_set(CType* out, ChronoType time) {
509     using Lim = numeric_limits<CType>;
510     if (time > Lim::max() || time < Lim::min())
511         return false;
512     *out = static_cast<CType>(time);
513     return true;
514 }
515 
516 using TimeSpec = struct ::timespec;
517 using StatT = struct ::stat;
518 
519 #if defined(__APPLE__)
extract_mtime(StatT const & st)520 TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
extract_atime(StatT const & st)521 TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
522 #else
extract_mtime(StatT const & st)523 TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
524 __attribute__((unused)) // Suppress warning
extract_atime(StatT const & st)525 TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
526 #endif
527 
528 constexpr auto max_seconds = duration_cast<seconds>(
529     file_time_type::duration::max()).count();
530 
531 constexpr auto max_nsec = duration_cast<nanoseconds>(
532     file_time_type::duration::max() - seconds(max_seconds)).count();
533 
534 constexpr auto min_seconds = duration_cast<seconds>(
535     file_time_type::duration::min()).count();
536 
537 constexpr auto min_nsec_timespec = duration_cast<nanoseconds>(
538     (file_time_type::duration::min() - seconds(min_seconds)) + seconds(1)).count();
539 
540 // Static assert that these values properly round trip.
541 static_assert((seconds(min_seconds) + duration_cast<microseconds>(nanoseconds(min_nsec_timespec)))
542                   - duration_cast<microseconds>(seconds(1))
543                   == file_time_type::duration::min(), "");
544 
545 constexpr auto max_time_t = numeric_limits<time_t>::max();
546 constexpr auto min_time_t = numeric_limits<time_t>::min();
547 
548 #if !defined(__LP64__) && defined(__clang__)
549 #pragma clang diagnostic push
550 #pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
551 #endif
552 
553 _LIBCPP_CONSTEXPR_AFTER_CXX11
is_representable(TimeSpec const & tm)554 bool is_representable(TimeSpec const& tm) {
555   if (tm.tv_sec >= 0) {
556     return (tm.tv_sec < max_seconds) ||
557         (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
558   } else if (tm.tv_sec == (min_seconds - 1)) {
559      return tm.tv_nsec >= min_nsec_timespec;
560   } else {
561     return (tm.tv_sec >= min_seconds);
562   }
563 }
564 #ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
565 #if defined(__LP64__)
566 static_assert(is_representable({max_seconds, max_nsec}), "");
567 static_assert(!is_representable({max_seconds + 1, 0}), "");
568 static_assert(!is_representable({max_seconds, max_nsec + 1}), "");
569 static_assert(!is_representable({max_time_t, 0}), "");
570 static_assert(is_representable({min_seconds, 0}), "");
571 static_assert(is_representable({min_seconds - 1, min_nsec_timespec}), "");
572 static_assert(is_representable({min_seconds - 1, min_nsec_timespec + 1}), "");
573 static_assert(!is_representable({min_seconds - 1, min_nsec_timespec - 1}), "");
574 static_assert(!is_representable({min_time_t, 999999999}), "");
575 #else
576 static_assert(is_representable({max_time_t, 999999999}), "");
577 static_assert(is_representable({max_time_t, 1000000000}), "");
578 static_assert(is_representable({min_time_t, 0}), "");
579 #endif
580 #endif
581 
582 _LIBCPP_CONSTEXPR_AFTER_CXX11
is_representable(file_time_type const & tm)583 bool is_representable(file_time_type const& tm) {
584   auto secs = duration_cast<seconds>(tm.time_since_epoch());
585   auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
586   if (nsecs.count() < 0) {
587     secs = secs +  seconds(1);
588     nsecs = nsecs + seconds(1);
589   }
590   using TLim = numeric_limits<time_t>;
591   if (secs.count() >= 0)
592     return secs.count() <= TLim::max();
593   return secs.count() >= TLim::min();
594 }
595 #ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
596 #if defined(__LP64__)
597 static_assert(is_representable(file_time_type::max()), "");
598 static_assert(is_representable(file_time_type::min()), "");
599 #else
600 static_assert(!is_representable(file_time_type::max()), "");
601 static_assert(!is_representable(file_time_type::min()), "");
602 static_assert(is_representable(file_time_type(seconds(max_time_t))), "");
603 static_assert(is_representable(file_time_type(seconds(min_time_t))), "");
604 #endif
605 #endif
606 
607 _LIBCPP_CONSTEXPR_AFTER_CXX11
convert_timespec(TimeSpec const & tm)608 file_time_type convert_timespec(TimeSpec const& tm) {
609   auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
610   if (tm.tv_sec >= 0) {
611     auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
612     return file_time_type(Dur);
613   } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() == 0) {
614     return file_time_type(seconds(tm.tv_sec));
615   } else { // tm.tv_sec < 0
616     auto adj_subsec = duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
617     auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
618     return file_time_type(Dur);
619   }
620 }
621 #ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
622 #if defined(__LP64__)
623 static_assert(convert_timespec({max_seconds, max_nsec}) == file_time_type::max(), "");
624 static_assert(convert_timespec({max_seconds, max_nsec - 1}) < file_time_type::max(), "");
625 static_assert(convert_timespec({max_seconds - 1, 999999999}) < file_time_type::max(), "");
626 static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec}) == file_time_type::min(), "");
627 static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec + 1}) > file_time_type::min(), "");
628 static_assert(convert_timespec({min_seconds , 0}) > file_time_type::min(), "");
629 #else
630 // FIXME add tests for 32 bit builds
631 #endif
632 #endif
633 
634 #if !defined(__LP64__) && defined(__clang__)
635 #pragma clang diagnostic pop
636 #endif
637 
638 template <class SubSecDurT, class SubSecT>
set_times_checked(time_t * sec_out,SubSecT * subsec_out,file_time_type tp)639 bool set_times_checked(time_t* sec_out, SubSecT* subsec_out, file_time_type tp) {
640     using namespace chrono;
641     auto dur = tp.time_since_epoch();
642     auto sec_dur = duration_cast<seconds>(dur);
643     auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
644     // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
645     if (subsec_dur.count() < 0) {
646         if (sec_dur.count() > min_seconds) {
647             sec_dur -= seconds(1);
648             subsec_dur += seconds(1);
649         } else {
650             subsec_dur = SubSecDurT::zero();
651         }
652     }
653     return checked_set(sec_out, sec_dur.count())
654         && checked_set(subsec_out, subsec_dur.count());
655 }
656 
657 }} // end namespace detail
658 
__last_write_time(const path & p,std::error_code * ec)659 file_time_type __last_write_time(const path& p, std::error_code *ec)
660 {
661     using namespace ::std::chrono;
662     std::error_code m_ec;
663     struct ::stat st;
664     detail::posix_stat(p, st, &m_ec);
665     if (m_ec) {
666         set_or_throw(m_ec, ec, "last_write_time", p);
667         return file_time_type::min();
668     }
669     if (ec) ec->clear();
670     auto ts = detail::extract_mtime(st);
671     if (!detail::is_representable(ts)) {
672         set_or_throw(error_code(EOVERFLOW, generic_category()), ec,
673                      "last_write_time", p);
674         return file_time_type::min();
675     }
676     return detail::convert_timespec(ts);
677 }
678 
__last_write_time(const path & p,file_time_type new_time,std::error_code * ec)679 void __last_write_time(const path& p, file_time_type new_time,
680                        std::error_code *ec)
681 {
682     using namespace std::chrono;
683     std::error_code m_ec;
684 
685     // We can use the presence of UTIME_OMIT to detect platforms that do not
686     // provide utimensat.
687 #if !defined(UTIME_OMIT)
688     // This implementation has a race condition between determining the
689     // last access time and attempting to set it to the same value using
690     // ::utimes
691     struct ::stat st;
692     file_status fst = detail::posix_stat(p, st, &m_ec);
693     if (m_ec && !status_known(fst)) {
694         set_or_throw(m_ec, ec, "last_write_time", p);
695         return;
696     }
697     auto atime = detail::extract_atime(st);
698     struct ::timeval tbuf[2];
699     tbuf[0].tv_sec = atime.tv_sec;
700     tbuf[0].tv_usec = duration_cast<microseconds>(nanoseconds(atime.tv_nsec)).count();
701     const bool overflowed = !detail::set_times_checked<microseconds>(
702         &tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
703 
704     if (overflowed) {
705         set_or_throw(make_error_code(errc::invalid_argument), ec,
706                      "last_write_time", p);
707         return;
708     }
709     if (::utimes(p.c_str(), tbuf) == -1) {
710         m_ec = detail::capture_errno();
711     }
712 #else
713     struct ::timespec tbuf[2];
714     tbuf[0].tv_sec = 0;
715     tbuf[0].tv_nsec = UTIME_OMIT;
716 
717     const bool overflowed = !detail::set_times_checked<nanoseconds>(
718         &tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
719     if (overflowed) {
720         set_or_throw(make_error_code(errc::invalid_argument),
721             ec, "last_write_time", p);
722         return;
723     }
724     if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
725         m_ec = detail::capture_errno();
726     }
727 #endif
728     if (m_ec)
729         set_or_throw(m_ec, ec, "last_write_time", p);
730     else if (ec)
731         ec->clear();
732 }
733 
734 
__permissions(const path & p,perms prms,std::error_code * ec)735 void __permissions(const path& p, perms prms, std::error_code *ec)
736 {
737 
738     const bool resolve_symlinks = !bool(perms::symlink_nofollow & prms);
739     const bool add_perms = bool(perms::add_perms & prms);
740     const bool remove_perms = bool(perms::remove_perms & prms);
741     _LIBCPP_ASSERT(!(add_perms && remove_perms),
742                    "Both add_perms and remove_perms are set");
743 
744     bool set_sym_perms = false;
745     prms &= perms::mask;
746     if (!resolve_symlinks || (add_perms || remove_perms)) {
747         std::error_code m_ec;
748         file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
749                                           : detail::posix_lstat(p, &m_ec);
750         set_sym_perms = is_symlink(st);
751         if (m_ec) return set_or_throw(m_ec, ec, "permissions", p);
752         _LIBCPP_ASSERT(st.permissions() != perms::unknown,
753                        "Permissions unexpectedly unknown");
754         if (add_perms)
755             prms |= st.permissions();
756         else if (remove_perms)
757            prms = st.permissions() & ~prms;
758     }
759     const auto real_perms = detail::posix_convert_perms(prms);
760 
761 # if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
762     const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
763     if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
764         return set_or_throw(ec, "permissions", p);
765     }
766 # else
767     if (set_sym_perms)
768         return set_or_throw(make_error_code(errc::operation_not_supported),
769                             ec, "permissions", p);
770     if (::chmod(p.c_str(), real_perms) == -1) {
771         return set_or_throw(ec, "permissions", p);
772     }
773 # endif
774     if (ec) ec->clear();
775 }
776 
777 
__read_symlink(const path & p,std::error_code * ec)778 path __read_symlink(const path& p, std::error_code *ec) {
779     char buff[PATH_MAX + 1];
780     std::error_code m_ec;
781     ::ssize_t ret;
782     if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
783         set_or_throw(ec, "read_symlink", p);
784         return {};
785     }
786     _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
787     _LIBCPP_ASSERT(ret > 0, "TODO");
788     if (ec) ec->clear();
789     buff[ret] = 0;
790     return {buff};
791 }
792 
793 
__remove(const path & p,std::error_code * ec)794 bool __remove(const path& p, std::error_code *ec) {
795     if (ec) ec->clear();
796     if (::remove(p.c_str()) == -1) {
797         set_or_throw(ec, "remove", p);
798         return false;
799     }
800     return true;
801 }
802 
803 namespace {
804 
remove_all_impl(path const & p,std::error_code & ec)805 std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
806 {
807     const auto npos = static_cast<std::uintmax_t>(-1);
808     const file_status st = __symlink_status(p, &ec);
809     if (ec) return npos;
810      std::uintmax_t count = 1;
811     if (is_directory(st)) {
812         for (directory_iterator it(p, ec); !ec && it != directory_iterator();
813              it.increment(ec)) {
814             auto other_count = remove_all_impl(it->path(), ec);
815             if (ec) return npos;
816             count += other_count;
817         }
818         if (ec) return npos;
819     }
820     if (!__remove(p, &ec)) return npos;
821     return count;
822 }
823 
824 } // end namespace
825 
__remove_all(const path & p,std::error_code * ec)826 std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
827     std::error_code mec;
828     auto count = remove_all_impl(p, mec);
829     if (mec) {
830         set_or_throw(mec, ec, "remove_all", p);
831         return static_cast<std::uintmax_t>(-1);
832     }
833     if (ec) ec->clear();
834     return count;
835 }
836 
__rename(const path & from,const path & to,std::error_code * ec)837 void __rename(const path& from, const path& to, std::error_code *ec) {
838     if (::rename(from.c_str(), to.c_str()) == -1)
839         set_or_throw(ec, "rename", from, to);
840     else if (ec)
841         ec->clear();
842 }
843 
__resize_file(const path & p,std::uintmax_t size,std::error_code * ec)844 void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
845     if (::truncate(p.c_str(), static_cast<long>(size)) == -1)
846         set_or_throw(ec, "resize_file", p);
847     else if (ec)
848         ec->clear();
849 }
850 
__space(const path & p,std::error_code * ec)851 space_info __space(const path& p, std::error_code *ec) {
852     space_info si;
853     struct statvfs m_svfs = {};
854     if (::statvfs(p.c_str(), &m_svfs) == -1)  {
855         set_or_throw(ec, "space", p);
856         si.capacity = si.free = si.available =
857             static_cast<std::uintmax_t>(-1);
858         return si;
859     }
860     if (ec) ec->clear();
861     // Multiply with overflow checking.
862     auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
863       out = other * m_svfs.f_frsize;
864       if (other == 0 || out / other != m_svfs.f_frsize)
865           out = static_cast<std::uintmax_t>(-1);
866     };
867     do_mult(si.capacity, m_svfs.f_blocks);
868     do_mult(si.free, m_svfs.f_bfree);
869     do_mult(si.available, m_svfs.f_bavail);
870     return si;
871 }
872 
__status(const path & p,std::error_code * ec)873 file_status __status(const path& p, std::error_code *ec) {
874     return detail::posix_stat(p, ec);
875 }
876 
__symlink_status(const path & p,std::error_code * ec)877 file_status __symlink_status(const path& p, std::error_code *ec) {
878     return detail::posix_lstat(p, ec);
879 }
880 
__system_complete(const path & p,std::error_code * ec)881 path __system_complete(const path& p, std::error_code *ec) {
882     if (ec) ec->clear();
883     return absolute(p, current_path());
884 }
885 
__temp_directory_path(std::error_code * ec)886 path __temp_directory_path(std::error_code* ec) {
887   const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
888   const char* ret = nullptr;
889 
890   for (auto& ep : env_paths)
891     if ((ret = std::getenv(ep)))
892       break;
893   if (ret == nullptr)
894     ret = "/tmp";
895 
896   path p(ret);
897   std::error_code m_ec;
898   if (!exists(p, m_ec) || !is_directory(p, m_ec)) {
899     if (!m_ec || m_ec == make_error_code(errc::no_such_file_or_directory))
900       m_ec = make_error_code(errc::not_a_directory);
901     set_or_throw(m_ec, ec, "temp_directory_path");
902     return {};
903   }
904 
905   if (ec)
906     ec->clear();
907   return p;
908 }
909 
910 // An absolute path is composed according to the table in [fs.op.absolute].
absolute(const path & p,const path & base)911 path absolute(const path& p, const path& base) {
912     auto root_name = p.root_name();
913     auto root_dir = p.root_directory();
914 
915     if (!root_name.empty() && !root_dir.empty())
916       return p;
917 
918     auto abs_base = base.is_absolute() ? base : absolute(base);
919 
920     /* !has_root_name && !has_root_dir */
921     if (root_name.empty() && root_dir.empty())
922     {
923       return abs_base / p;
924     }
925     else if (!root_name.empty()) /* has_root_name && !has_root_dir */
926     {
927       return  root_name / abs_base.root_directory()
928               /
929               abs_base.relative_path() / p.relative_path();
930     }
931     else /* !has_root_name && has_root_dir */
932     {
933       if (abs_base.has_root_name())
934         return abs_base.root_name() / p;
935       // else p is absolute,  return outside of block
936     }
937     return p;
938 }
939 
940 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
941