1//===--------------------- filesystem/ops.cpp -----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "filesystem"
10#include "array"
11#include "iterator"
12#include "fstream"
13#include "random" /* for unique_path */
14#include "string_view"
15#include "type_traits"
16#include "vector"
17#include "cstdlib"
18#include "climits"
19
20#include "filesystem_common.h"
21
22#include <unistd.h>
23#include <sys/stat.h>
24#include <sys/statvfs.h>
25#include <time.h>
26#include <fcntl.h> /* values for fchmodat */
27
28#if defined(__linux__)
29#include <linux/version.h>
30#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33)
31#include <sys/sendfile.h>
32#define _LIBCPP_USE_SENDFILE
33#endif
34#elif defined(__APPLE__) || __has_include(<copyfile.h>)
35#include <copyfile.h>
36#define _LIBCPP_USE_COPYFILE
37#endif
38
39#if !defined(__APPLE__)
40#define _LIBCPP_USE_CLOCK_GETTIME
41#endif
42
43#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GETTIME)
44#include <sys/time.h> // for gettimeofday and timeval
45#endif // !defined(CLOCK_REALTIME)
46
47#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
48#pragma comment(lib, "rt")
49#endif
50
51#if defined(_LIBCPP_COMPILER_GCC)
52#if _GNUC_VER < 500
53#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
54#endif
55#endif
56
57_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
58
59namespace {
60namespace parser {
61
62using string_view_t = path::__string_view;
63using string_view_pair = pair<string_view_t, string_view_t>;
64using PosPtr = path::value_type const*;
65
66struct PathParser {
67 enum ParserState : unsigned char {
68 // Zero is a special sentinel value used by default constructed iterators.
69 PS_BeforeBegin = path::iterator::_BeforeBegin,
70 PS_InRootName = path::iterator::_InRootName,
71 PS_InRootDir = path::iterator::_InRootDir,
72 PS_InFilenames = path::iterator::_InFilenames,
73 PS_InTrailingSep = path::iterator::_InTrailingSep,
74 PS_AtEnd = path::iterator::_AtEnd
75 };
76
77 const string_view_t Path;
78 string_view_t RawEntry;
79 ParserState State;
80
81private:
82 PathParser(string_view_t P, ParserState State) noexcept : Path(P),
83 State(State) {}
84
85public:
86 PathParser(string_view_t P, string_view_t E, unsigned char S)
87 : Path(P), RawEntry(E), State(static_cast<ParserState>(S)) {
88 // S cannot be '0' or PS_BeforeBegin.
89 }
90
91 static PathParser CreateBegin(string_view_t P) noexcept {
92 PathParser PP(P, PS_BeforeBegin);
93 PP.increment();
94 return PP;
95 }
96
97 static PathParser CreateEnd(string_view_t P) noexcept {
98 PathParser PP(P, PS_AtEnd);
99 return PP;
100 }
101
102 PosPtr peek() const noexcept {
103 auto TkEnd = getNextTokenStartPos();
104 auto End = getAfterBack();
105 return TkEnd == End ? nullptr : TkEnd;
106 }
107
108 void increment() noexcept {
109 const PosPtr End = getAfterBack();
110 const PosPtr Start = getNextTokenStartPos();
111 if (Start == End)
112 return makeState(PS_AtEnd);
113
114 switch (State) {
115 case PS_BeforeBegin: {
116 PosPtr TkEnd = consumeSeparator(Start, End);
117 if (TkEnd)
118 return makeState(PS_InRootDir, Start, TkEnd);
119 else
120 return makeState(PS_InFilenames, Start, consumeName(Start, End));
121 }
122 case PS_InRootDir:
123 return makeState(PS_InFilenames, Start, consumeName(Start, End));
124
125 case PS_InFilenames: {
126 PosPtr SepEnd = consumeSeparator(Start, End);
127 if (SepEnd != End) {
128 PosPtr TkEnd = consumeName(SepEnd, End);
129 if (TkEnd)
130 return makeState(PS_InFilenames, SepEnd, TkEnd);
131 }
132 return makeState(PS_InTrailingSep, Start, SepEnd);
133 }
134
135 case PS_InTrailingSep:
136 return makeState(PS_AtEnd);
137
138 case PS_InRootName:
139 case PS_AtEnd:
140 _LIBCPP_UNREACHABLE();
141 }
142 }
143
144 void decrement() noexcept {
145 const PosPtr REnd = getBeforeFront();
146 const PosPtr RStart = getCurrentTokenStartPos() - 1;
147 if (RStart == REnd) // we're decrementing the begin
148 return makeState(PS_BeforeBegin);
149
150 switch (State) {
151 case PS_AtEnd: {
152 // Try to consume a trailing separator or root directory first.
153 if (PosPtr SepEnd = consumeSeparator(RStart, REnd)) {
154 if (SepEnd == REnd)
155 return makeState(PS_InRootDir, Path.data(), RStart + 1);
156 return makeState(PS_InTrailingSep, SepEnd + 1, RStart + 1);
157 } else {
158 PosPtr TkStart = consumeName(RStart, REnd);
159 return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
160 }
161 }
162 case PS_InTrailingSep:
163 return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1,
164 RStart + 1);
165 case PS_InFilenames: {
166 PosPtr SepEnd = consumeSeparator(RStart, REnd);
167 if (SepEnd == REnd)
168 return makeState(PS_InRootDir, Path.data(), RStart + 1);
169 PosPtr TkEnd = consumeName(SepEnd, REnd);
170 return makeState(PS_InFilenames, TkEnd + 1, SepEnd + 1);
171 }
172 case PS_InRootDir:
173 // return makeState(PS_InRootName, Path.data(), RStart + 1);
174 case PS_InRootName:
175 case PS_BeforeBegin:
176 _LIBCPP_UNREACHABLE();
177 }
178 }
179
180 /// \brief Return a view with the "preferred representation" of the current
181 /// element. For example trailing separators are represented as a '.'
182 string_view_t operator*() const noexcept {
183 switch (State) {
184 case PS_BeforeBegin:
185 case PS_AtEnd:
186 return "";
187 case PS_InRootDir:
188 return "/";
189 case PS_InTrailingSep:
190 return "";
191 case PS_InRootName:
192 case PS_InFilenames:
193 return RawEntry;
194 }
195 _LIBCPP_UNREACHABLE();
196 }
197
198 explicit operator bool() const noexcept {
199 return State != PS_BeforeBegin && State != PS_AtEnd;
200 }
201
202 PathParser& operator++() noexcept {
203 increment();
204 return *this;
205 }
206
207 PathParser& operator--() noexcept {
208 decrement();
209 return *this;
210 }
211
212 bool atEnd() const noexcept {
213 return State == PS_AtEnd;
214 }
215
216 bool inRootDir() const noexcept {
217 return State == PS_InRootDir;
218 }
219
220 bool inRootName() const noexcept {
221 return State == PS_InRootName;
222 }
223
224 bool inRootPath() const noexcept {
225 return inRootName() || inRootDir();
226 }
227
228private:
229 void makeState(ParserState NewState, PosPtr Start, PosPtr End) noexcept {
230 State = NewState;
231 RawEntry = string_view_t(Start, End - Start);
232 }
233 void makeState(ParserState NewState) noexcept {
234 State = NewState;
235 RawEntry = {};
236 }
237
238 PosPtr getAfterBack() const noexcept { return Path.data() + Path.size(); }
239
240 PosPtr getBeforeFront() const noexcept { return Path.data() - 1; }
241
242 /// \brief Return a pointer to the first character after the currently
243 /// lexed element.
244 PosPtr getNextTokenStartPos() const noexcept {
245 switch (State) {
246 case PS_BeforeBegin:
247 return Path.data();
248 case PS_InRootName:
249 case PS_InRootDir:
250 case PS_InFilenames:
251 return &RawEntry.back() + 1;
252 case PS_InTrailingSep:
253 case PS_AtEnd:
254 return getAfterBack();
255 }
256 _LIBCPP_UNREACHABLE();
257 }
258
259 /// \brief Return a pointer to the first character in the currently lexed
260 /// element.
261 PosPtr getCurrentTokenStartPos() const noexcept {
262 switch (State) {
263 case PS_BeforeBegin:
264 case PS_InRootName:
265 return &Path.front();
266 case PS_InRootDir:
267 case PS_InFilenames:
268 case PS_InTrailingSep:
269 return &RawEntry.front();
270 case PS_AtEnd:
271 return &Path.back() + 1;
272 }
273 _LIBCPP_UNREACHABLE();
274 }
275
276 PosPtr consumeSeparator(PosPtr P, PosPtr End) const noexcept {
277 if (P == End || *P != '/')
278 return nullptr;
279 const int Inc = P < End ? 1 : -1;
280 P += Inc;
281 while (P != End && *P == '/')
282 P += Inc;
283 return P;
284 }
285
286 PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
287 if (P == End || *P == '/')
288 return nullptr;
289 const int Inc = P < End ? 1 : -1;
290 P += Inc;
291 while (P != End && *P != '/')
292 P += Inc;
293 return P;
294 }
295};
296
297string_view_pair separate_filename(string_view_t const& s) {
298 if (s == "." || s == ".." || s.empty())
299 return string_view_pair{s, ""};
300 auto pos = s.find_last_of('.');
301 if (pos == string_view_t::npos || pos == 0)
302 return string_view_pair{s, string_view_t{}};
303 return string_view_pair{s.substr(0, pos), s.substr(pos)};
304}
305
306string_view_t createView(PosPtr S, PosPtr E) noexcept {
307 return {S, static_cast<size_t>(E - S) + 1};
308}
309
310} // namespace parser
311} // namespace
312
313// POSIX HELPERS
314
315namespace detail {
316namespace {
317
318using value_type = path::value_type;
319using string_type = path::string_type;
320
321struct FileDescriptor {
322 const path& name;
323 int fd = -1;
324 StatT m_stat;
325 file_status m_status;
326
327 template <class... Args>
328 static FileDescriptor create(const path* p, error_code& ec, Args... args) {
329 ec.clear();
330 int fd;
331 if ((fd = ::open(p->c_str(), args...)) == -1) {
332 ec = capture_errno();
333 return FileDescriptor{p};
334 }
335 return FileDescriptor(p, fd);
336 }
337
338 template <class... Args>
339 static FileDescriptor create_with_status(const path* p, error_code& ec,
340 Args... args) {
341 FileDescriptor fd = create(p, ec, args...);
342 if (!ec)
343 fd.refresh_status(ec);
344
345 return fd;
346 }
347
348 file_status get_status() const { return m_status; }
349 StatT const& get_stat() const { return m_stat; }
350
351 bool status_known() const { return _VSTD_FS::status_known(m_status); }
352
353 file_status refresh_status(error_code& ec);
354
355 void close() noexcept {
356 if (fd != -1)
357 ::close(fd);
358 fd = -1;
359 }
360
361 FileDescriptor(FileDescriptor&& other)
362 : name(other.name), fd(other.fd), m_stat(other.m_stat),
363 m_status(other.m_status) {
364 other.fd = -1;
365 other.m_status = file_status{};
366 }
367
368 ~FileDescriptor() { close(); }
369
370 FileDescriptor(FileDescriptor const&) = delete;
371 FileDescriptor& operator=(FileDescriptor const&) = delete;
372
373private:
374 explicit FileDescriptor(const path* p, int fd = -1) : name(*p), fd(fd) {}
375};
376
377perms posix_get_perms(const StatT& st) noexcept {
378 return static_cast<perms>(st.st_mode) & perms::mask;
379}
380
381::mode_t posix_convert_perms(perms prms) {
382 return static_cast< ::mode_t>(prms & perms::mask);
383}
384
385file_status create_file_status(error_code& m_ec, path const& p,
386 const StatT& path_stat, error_code* ec) {
387 if (ec)
388 *ec = m_ec;
389 if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
390 return file_status(file_type::not_found);
391 } else if (m_ec) {
392 ErrorHandler<void> err("posix_stat", ec, &p);
393 err.report(m_ec, "failed to determine attributes for the specified path");
394 return file_status(file_type::none);
395 }
396 // else
397
398 file_status fs_tmp;
399 auto const mode = path_stat.st_mode;
400 if (S_ISLNK(mode))
401 fs_tmp.type(file_type::symlink);
402 else if (S_ISREG(mode))
403 fs_tmp.type(file_type::regular);
404 else if (S_ISDIR(mode))
405 fs_tmp.type(file_type::directory);
406 else if (S_ISBLK(mode))
407 fs_tmp.type(file_type::block);
408 else if (S_ISCHR(mode))
409 fs_tmp.type(file_type::character);
410 else if (S_ISFIFO(mode))
411 fs_tmp.type(file_type::fifo);
412 else if (S_ISSOCK(mode))
413 fs_tmp.type(file_type::socket);
414 else
415 fs_tmp.type(file_type::unknown);
416
417 fs_tmp.permissions(detail::posix_get_perms(path_stat));
418 return fs_tmp;
419}
420
421file_status posix_stat(path const& p, StatT& path_stat, error_code* ec) {
422 error_code m_ec;
423 if (::stat(p.c_str(), &path_stat) == -1)
424 m_ec = detail::capture_errno();
425 return create_file_status(m_ec, p, path_stat, ec);
426}
427
428file_status posix_stat(path const& p, error_code* ec) {
429 StatT path_stat;
430 return posix_stat(p, path_stat, ec);
431}
432
433file_status posix_lstat(path const& p, StatT& path_stat, error_code* ec) {
434 error_code m_ec;
435 if (::lstat(p.c_str(), &path_stat) == -1)
436 m_ec = detail::capture_errno();
437 return create_file_status(m_ec, p, path_stat, ec);
438}
439
440file_status posix_lstat(path const& p, error_code* ec) {
441 StatT path_stat;
442 return posix_lstat(p, path_stat, ec);
443}
444
445// http://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html
446bool posix_ftruncate(const FileDescriptor& fd, off_t to_size, error_code& ec) {
447 if (::ftruncate(fd.fd, to_size) == -1) {
448 ec = capture_errno();
449 return true;
450 }
451 ec.clear();
452 return false;
453}
454
455bool posix_fchmod(const FileDescriptor& fd, const StatT& st, error_code& ec) {
456 if (::fchmod(fd.fd, st.st_mode) == -1) {
457 ec = capture_errno();
458 return true;
459 }
460 ec.clear();
461 return false;
462}
463
464bool stat_equivalent(const StatT& st1, const StatT& st2) {
465 return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
466}
467
468file_status FileDescriptor::refresh_status(error_code& ec) {
469 // FD must be open and good.
470 m_status = file_status{};
471 m_stat = {};
472 error_code m_ec;
473 if (::fstat(fd, &m_stat) == -1)
474 m_ec = capture_errno();
475 m_status = create_file_status(m_ec, name, m_stat, &ec);
476 return m_status;
477}
478} // namespace
479} // end namespace detail
480
481using detail::capture_errno;
482using detail::ErrorHandler;
483using detail::StatT;
484using detail::TimeSpec;
485using parser::createView;
486using parser::PathParser;
487using parser::string_view_t;
488
489const bool _FilesystemClock::is_steady;
490
491_FilesystemClock::time_point _FilesystemClock::now() noexcept {
492 typedef chrono::duration<rep> __secs;
493#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
494 typedef chrono::duration<rep, nano> __nsecs;
495 struct timespec tp;
496 if (0 != clock_gettime(CLOCK_REALTIME, &tp))
497 __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
498 return time_point(__secs(tp.tv_sec) +
499 chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
500#else
501 typedef chrono::duration<rep, micro> __microsecs;
502 timeval tv;
503 gettimeofday(&tv, 0);
504 return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
505#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
506}
507
508filesystem_error::~filesystem_error() {}
509
510void filesystem_error::__create_what(int __num_paths) {
511 const char* derived_what = system_error::what();
512 __storage_->__what_ = [&]() -> string {
513 const char* p1 = path1().native().empty() ? "\"\"" : path1().c_str();
514 const char* p2 = path2().native().empty() ? "\"\"" : path2().c_str();
515 switch (__num_paths) {
516 default:
517 return detail::format_string("filesystem error: %s", derived_what);
518 case 1:
519 return detail::format_string("filesystem error: %s [%s]", derived_what,
520 p1);
521 case 2:
522 return detail::format_string("filesystem error: %s [%s] [%s]",
523 derived_what, p1, p2);
524 }
525 }();
526}
527
528static path __do_absolute(const path& p, path* cwd, error_code* ec) {
529 if (ec)
530 ec->clear();
531 if (p.is_absolute())
532 return p;
533 *cwd = __current_path(ec);
534 if (ec && *ec)
535 return {};
536 return (*cwd) / p;
537}
538
539path __absolute(const path& p, error_code* ec) {
540 path cwd;
541 return __do_absolute(p, &cwd, ec);
542}
543
544path __canonical(path const& orig_p, error_code* ec) {
545 path cwd;
546 ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
547
548 path p = __do_absolute(orig_p, &cwd, ec);
549#if _POSIX_VERSION >= 200112
550 std::unique_ptr<char, decltype(&::free)>
551 hold(::realpath(p.c_str(), nullptr), &::free);
552 if (hold.get() == nullptr)
553 return err.report(capture_errno());
554 return {hold.get()};
555#else
556 char buff[PATH_MAX + 1];
557 char* ret;
558 if ((ret = ::realpath(p.c_str(), buff)) == nullptr)
559 return err.report(capture_errno());
560 return {ret};
561#endif
562}
563
564void __copy(const path& from, const path& to, copy_options options,
565 error_code* ec) {
566 ErrorHandler<void> err("copy", ec, &from, &to);
567
568 const bool sym_status = bool(
569 options & (copy_options::create_symlinks | copy_options::skip_symlinks));
570
571 const bool sym_status2 = bool(options & copy_options::copy_symlinks);
572
573 error_code m_ec1;
574 StatT f_st = {};
575 const file_status f = sym_status || sym_status2
576 ? detail::posix_lstat(from, f_st, &m_ec1)
577 : detail::posix_stat(from, f_st, &m_ec1);
578 if (m_ec1)
579 return err.report(m_ec1);
580
581 StatT t_st = {};
582 const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec1)
583 : detail::posix_stat(to, t_st, &m_ec1);
584
585 if (not status_known(t))
586 return err.report(m_ec1);
587
588 if (!exists(f) || is_other(f) || is_other(t) ||
589 (is_directory(f) && is_regular_file(t)) ||
590 detail::stat_equivalent(f_st, t_st)) {
591 return err.report(errc::function_not_supported);
592 }
593
594 if (ec)
595 ec->clear();
596
597 if (is_symlink(f)) {
598 if (bool(copy_options::skip_symlinks & options)) {
599 // do nothing
600 } else if (not exists(t)) {
601 __copy_symlink(from, to, ec);
602 } else {
603 return err.report(errc::file_exists);
604 }
605 return;
606 } else if (is_regular_file(f)) {
607 if (bool(copy_options::directories_only & options)) {
608 // do nothing
609 } else if (bool(copy_options::create_symlinks & options)) {
610 __create_symlink(from, to, ec);
611 } else if (bool(copy_options::create_hard_links & options)) {
612 __create_hard_link(from, to, ec);
613 } else if (is_directory(t)) {
614 __copy_file(from, to / from.filename(), options, ec);
615 } else {
616 __copy_file(from, to, options, ec);
617 }
618 return;
619 } else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
620 return err.report(errc::is_a_directory);
621 } else if (is_directory(f) && (bool(copy_options::recursive & options) ||
622 copy_options::none == options)) {
623
624 if (!exists(t)) {
625 // create directory to with attributes from 'from'.
626 __create_directory(to, from, ec);
627 if (ec && *ec) {
628 return;
629 }
630 }
631 directory_iterator it =
632 ec ? directory_iterator(from, *ec) : directory_iterator(from);
633 if (ec && *ec) {
634 return;
635 }
636 error_code m_ec2;
637 for (; it != directory_iterator(); it.increment(m_ec2)) {
638 if (m_ec2) {
639 return err.report(m_ec2);
640 }
641 __copy(it->path(), to / it->path().filename(),
642 options | copy_options::__in_recursive_copy, ec);
643 if (ec && *ec) {
644 return;
645 }
646 }
647 }
648}
649
650namespace detail {
651namespace {
652
653#ifdef _LIBCPP_USE_SENDFILE
654bool copy_file_impl_sendfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
655 error_code& ec) {
656
657 size_t count = read_fd.get_stat().st_size;
658 do {
659 ssize_t res;
660 if ((res = ::sendfile(write_fd.fd, read_fd.fd, nullptr, count)) == -1) {
661 ec = capture_errno();
662 return false;
663 }
664 count -= res;
665 } while (count > 0);
666
667 ec.clear();
668
669 return true;
670}
671#elif defined(_LIBCPP_USE_COPYFILE)
672bool copy_file_impl_copyfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
673 error_code& ec) {
674 struct CopyFileState {
675 copyfile_state_t state;
676 CopyFileState() { state = copyfile_state_alloc(); }
677 ~CopyFileState() { copyfile_state_free(state); }
678
679 private:
680 CopyFileState(CopyFileState const&) = delete;
681 CopyFileState& operator=(CopyFileState const&) = delete;
682 };
683
684 CopyFileState cfs;
685 if (fcopyfile(read_fd.fd, write_fd.fd, cfs.state, COPYFILE_DATA) < 0) {
686 ec = capture_errno();
687 return false;
688 }
689
690 ec.clear();
691 return true;
692}
693#endif
694
695// Note: This function isn't guarded by ifdef's even though it may be unused
696// in order to assure it still compiles.
697__attribute__((unused)) bool copy_file_impl_default(FileDescriptor& read_fd,
698 FileDescriptor& write_fd,
699 error_code& ec) {
700 ifstream in;
701 in.__open(read_fd.fd, ios::binary);
702 if (!in.is_open()) {
703 // This assumes that __open didn't reset the error code.
704 ec = capture_errno();
705 return false;
706 }
707 ofstream out;
708 out.__open(write_fd.fd, ios::binary);
709 if (!out.is_open()) {
710 ec = capture_errno();
711 return false;
712 }
713
714 if (in.good() && out.good()) {
715 using InIt = istreambuf_iterator<char>;
716 using OutIt = ostreambuf_iterator<char>;
717 InIt bin(in);
718 InIt ein;
719 OutIt bout(out);
720 copy(bin, ein, bout);
721 }
722 if (out.fail() || in.fail()) {
723 ec = make_error_code(errc::io_error);
724 return false;
725 }
726
727 ec.clear();
728 return true;
729}
730
731bool copy_file_impl(FileDescriptor& from, FileDescriptor& to, error_code& ec) {
732#if defined(_LIBCPP_USE_SENDFILE)
733 return copy_file_impl_sendfile(from, to, ec);
734#elif defined(_LIBCPP_USE_COPYFILE)
735 return copy_file_impl_copyfile(from, to, ec);
736#else
737 return copy_file_impl_default(from, to, ec);
738#endif
739}
740
741} // namespace
742} // namespace detail
743
744bool __copy_file(const path& from, const path& to, copy_options options,
745 error_code* ec) {
746 using detail::FileDescriptor;
747 ErrorHandler<bool> err("copy_file", ec, &to, &from);
748
749 error_code m_ec;
750 FileDescriptor from_fd =
751 FileDescriptor::create_with_status(&from, m_ec, O_RDONLY | O_NONBLOCK);
752 if (m_ec)
753 return err.report(m_ec);
754
755 auto from_st = from_fd.get_status();
756 StatT const& from_stat = from_fd.get_stat();
757 if (!is_regular_file(from_st)) {
758 if (not m_ec)
759 m_ec = make_error_code(errc::not_supported);
760 return err.report(m_ec);
761 }
762
763 const bool skip_existing = bool(copy_options::skip_existing & options);
764 const bool update_existing = bool(copy_options::update_existing & options);
765 const bool overwrite_existing =
766 bool(copy_options::overwrite_existing & options);
767
768 StatT to_stat_path;
769 file_status to_st = detail::posix_stat(to, to_stat_path, &m_ec);
770 if (!status_known(to_st))
771 return err.report(m_ec);
772
773 const bool to_exists = exists(to_st);
774 if (to_exists && !is_regular_file(to_st))
775 return err.report(errc::not_supported);
776
777 if (to_exists && detail::stat_equivalent(from_stat, to_stat_path))
778 return err.report(errc::file_exists);
779
780 if (to_exists && skip_existing)
781 return false;
782
783 bool ShouldCopy = [&]() {
784 if (to_exists && update_existing) {
785 auto from_time = detail::extract_mtime(from_stat);
786 auto to_time = detail::extract_mtime(to_stat_path);
787 if (from_time.tv_sec < to_time.tv_sec)
788 return false;
789 if (from_time.tv_sec == to_time.tv_sec &&
790 from_time.tv_nsec <= to_time.tv_nsec)
791 return false;
792 return true;
793 }
794 if (!to_exists || overwrite_existing)
795 return true;
796 return err.report(errc::file_exists);
797 }();
798 if (!ShouldCopy)
799 return false;
800
801 // Don't truncate right away. We may not be opening the file we originally
802 // looked at; we'll check this later.
803 int to_open_flags = O_WRONLY;
804 if (!to_exists)
805 to_open_flags |= O_CREAT;
806 FileDescriptor to_fd = FileDescriptor::create_with_status(
807 &to, m_ec, to_open_flags, from_stat.st_mode);
808 if (m_ec)
809 return err.report(m_ec);
810
811 if (to_exists) {
812 // Check that the file we initially stat'ed is equivalent to the one
813 // we opened.
814 // FIXME: report this better.
815 if (!detail::stat_equivalent(to_stat_path, to_fd.get_stat()))
816 return err.report(errc::bad_file_descriptor);
817
818 // Set the permissions and truncate the file we opened.
819 if (detail::posix_fchmod(to_fd, from_stat, m_ec))
820 return err.report(m_ec);
821 if (detail::posix_ftruncate(to_fd, 0, m_ec))
822 return err.report(m_ec);
823 }
824
825 if (!copy_file_impl(from_fd, to_fd, m_ec)) {
826 // FIXME: Remove the dest file if we failed, and it didn't exist previously.
827 return err.report(m_ec);
828 }
829
830 return true;
831}
832
833void __copy_symlink(const path& existing_symlink, const path& new_symlink,
834 error_code* ec) {
835 const path real_path(__read_symlink(existing_symlink, ec));
836 if (ec && *ec) {
837 return;
838 }
839 // NOTE: proposal says you should detect if you should call
840 // create_symlink or create_directory_symlink. I don't think this
841 // is needed with POSIX
842 __create_symlink(real_path, new_symlink, ec);
843}
844
845bool __create_directories(const path& p, error_code* ec) {
846 ErrorHandler<bool> err("create_directories", ec, &p);
847
848 error_code m_ec;
849 auto const st = detail::posix_stat(p, &m_ec);
850 if (!status_known(st))
851 return err.report(m_ec);
852 else if (is_directory(st))
853 return false;
854 else if (exists(st))
855 return err.report(errc::file_exists);
856
857 const path parent = p.parent_path();
858 if (!parent.empty()) {
859 const file_status parent_st = status(parent, m_ec);
860 if (not status_known(parent_st))
861 return err.report(m_ec);
862 if (not exists(parent_st)) {
863 __create_directories(parent, ec);
864 if (ec && *ec) {
865 return false;
866 }
867 }
868 }
869 return __create_directory(p, ec);
870}
871
872bool __create_directory(const path& p, error_code* ec) {
873 ErrorHandler<bool> err("create_directory", ec, &p);
874
875 if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
876 return true;
877 if (errno != EEXIST)
878 err.report(capture_errno());
879 return false;
880}
881
882bool __create_directory(path const& p, path const& attributes, error_code* ec) {
883 ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
884
885 StatT attr_stat;
886 error_code mec;
887 auto st = detail::posix_stat(attributes, attr_stat, &mec);
888 if (!status_known(st))
889 return err.report(mec);
890 if (!is_directory(st))
891 return err.report(errc::not_a_directory,
892 "the specified attribute path is invalid");
893
894 if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
895 return true;
896 if (errno != EEXIST)
897 err.report(capture_errno());
898 return false;
899}
900
901void __create_directory_symlink(path const& from, path const& to,
902 error_code* ec) {
903 ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
904 if (::symlink(from.c_str(), to.c_str()) != 0)
905 return err.report(capture_errno());
906}
907
908void __create_hard_link(const path& from, const path& to, error_code* ec) {
909 ErrorHandler<void> err("create_hard_link", ec, &from, &to);
910 if (::link(from.c_str(), to.c_str()) == -1)
911 return err.report(capture_errno());
912}
913
914void __create_symlink(path const& from, path const& to, error_code* ec) {
915 ErrorHandler<void> err("create_symlink", ec, &from, &to);
916 if (::symlink(from.c_str(), to.c_str()) == -1)
917 return err.report(capture_errno());
918}
919
920path __current_path(error_code* ec) {
921 ErrorHandler<path> err("current_path", ec);
922
923 auto size = ::pathconf(".", _PC_PATH_MAX);
924 _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
925
926 auto buff = unique_ptr<char[]>(new char[size + 1]);
927 char* ret;
928 if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr)
929 return err.report(capture_errno(), "call to getcwd failed");
930
931 return {buff.get()};
932}
933
934void __current_path(const path& p, error_code* ec) {
935 ErrorHandler<void> err("current_path", ec, &p);
936 if (::chdir(p.c_str()) == -1)
937 err.report(capture_errno());
938}
939
940bool __equivalent(const path& p1, const path& p2, error_code* ec) {
941 ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
942
943 error_code ec1, ec2;
944 StatT st1 = {}, st2 = {};
945 auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
946 if (!exists(s1))
947 return err.report(errc::not_supported);
948 auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
949 if (!exists(s2))
950 return err.report(errc::not_supported);
951
952 return detail::stat_equivalent(st1, st2);
953}
954
955uintmax_t __file_size(const path& p, error_code* ec) {
956 ErrorHandler<uintmax_t> err("file_size", ec, &p);
957
958 error_code m_ec;
959 StatT st;
960 file_status fst = detail::posix_stat(p, st, &m_ec);
961 if (!exists(fst) || !is_regular_file(fst)) {
962 errc error_kind =
963 is_directory(fst) ? errc::is_a_directory : errc::not_supported;
964 if (!m_ec)
965 m_ec = make_error_code(error_kind);
966 return err.report(m_ec);
967 }
968 // is_regular_file(p) == true
969 return static_cast<uintmax_t>(st.st_size);
970}
971
972uintmax_t __hard_link_count(const path& p, error_code* ec) {
973 ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
974
975 error_code m_ec;
976 StatT st;
977 detail::posix_stat(p, st, &m_ec);
978 if (m_ec)
979 return err.report(m_ec);
980 return static_cast<uintmax_t>(st.st_nlink);
981}
982
983bool __fs_is_empty(const path& p, error_code* ec) {
984 ErrorHandler<bool> err("is_empty", ec, &p);
985
986 error_code m_ec;
987 StatT pst;
988 auto st = detail::posix_stat(p, pst, &m_ec);
989 if (m_ec)
990 return err.report(m_ec);
991 else if (!is_directory(st) && !is_regular_file(st))
992 return err.report(errc::not_supported);
993 else if (is_directory(st)) {
994 auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
995 if (ec && *ec)
996 return false;
997 return it == directory_iterator{};
998 } else if (is_regular_file(st))
999 return static_cast<uintmax_t>(pst.st_size) == 0;
1000
1001 _LIBCPP_UNREACHABLE();
1002}
1003
1004static file_time_type __extract_last_write_time(const path& p, const StatT& st,
1005 error_code* ec) {
1006 using detail::fs_time;
1007 ErrorHandler<file_time_type> err("last_write_time", ec, &p);
1008
1009 auto ts = detail::extract_mtime(st);
1010 if (!fs_time::is_representable(ts))
1011 return err.report(errc::value_too_large);
1012
1013 return fs_time::convert_from_timespec(ts);
1014}
1015
1016file_time_type __last_write_time(const path& p, error_code* ec) {
1017 using namespace chrono;
1018 ErrorHandler<file_time_type> err("last_write_time", ec, &p);
1019
1020 error_code m_ec;
1021 StatT st;
1022 detail::posix_stat(p, st, &m_ec);
1023 if (m_ec)
1024 return err.report(m_ec);
1025 return __extract_last_write_time(p, st, ec);
1026}
1027
1028void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {
1029 using detail::fs_time;
1030 ErrorHandler<void> err("last_write_time", ec, &p);
1031
1032 error_code m_ec;
1033 array<TimeSpec, 2> tbuf;
1034#if !defined(_LIBCPP_USE_UTIMENSAT)
1035 // This implementation has a race condition between determining the
1036 // last access time and attempting to set it to the same value using
1037 // ::utimes
1038 StatT st;
1039 file_status fst = detail::posix_stat(p, st, &m_ec);
1040 if (m_ec)
1041 return err.report(m_ec);
1042 tbuf[0] = detail::extract_atime(st);
1043#else
1044 tbuf[0].tv_sec = 0;
1045 tbuf[0].tv_nsec = UTIME_OMIT;
1046#endif
1047 if (!fs_time::convert_to_timespec(tbuf[1], new_time))
1048 return err.report(errc::value_too_large);
1049
1050 detail::set_file_times(p, tbuf, m_ec);
1051 if (m_ec)
1052 return err.report(m_ec);
1053}
1054
1055void __permissions(const path& p, perms prms, perm_options opts,
1056 error_code* ec) {
1057 ErrorHandler<void> err("permissions", ec, &p);
1058
1059 auto has_opt = [&](perm_options o) { return bool(o & opts); };
1060 const bool resolve_symlinks = !has_opt(perm_options::nofollow);
1061 const bool add_perms = has_opt(perm_options::add);
1062 const bool remove_perms = has_opt(perm_options::remove);
1063 _LIBCPP_ASSERT(
1064 (add_perms + remove_perms + has_opt(perm_options::replace)) == 1,
1065 "One and only one of the perm_options constants replace, add, or remove "
1066 "is present in opts");
1067
1068 bool set_sym_perms = false;
1069 prms &= perms::mask;
1070 if (!resolve_symlinks || (add_perms || remove_perms)) {
1071 error_code m_ec;
1072 file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
1073 : detail::posix_lstat(p, &m_ec);
1074 set_sym_perms = is_symlink(st);
1075 if (m_ec)
1076 return err.report(m_ec);
1077 _LIBCPP_ASSERT(st.permissions() != perms::unknown,
1078 "Permissions unexpectedly unknown");
1079 if (add_perms)
1080 prms |= st.permissions();
1081 else if (remove_perms)
1082 prms = st.permissions() & ~prms;
1083 }
1084 const auto real_perms = detail::posix_convert_perms(prms);
1085
1086#if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
1087 const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
1088 if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
1089 return err.report(capture_errno());
1090 }
1091#else
1092 if (set_sym_perms)
1093 return err.report(errc::operation_not_supported);
1094 if (::chmod(p.c_str(), real_perms) == -1) {
1095 return err.report(capture_errno());
1096 }
1097#endif
1098}
1099
1100path __read_symlink(const path& p, error_code* ec) {
1101 ErrorHandler<path> err("read_symlink", ec, &p);
1102
1103#ifdef PATH_MAX
1104 struct NullDeleter { void operator()(void*) const {} };
1105 const size_t size = PATH_MAX + 1;
1106 char stack_buff[size];
1107 auto buff = std::unique_ptr<char[], NullDeleter>(stack_buff);
1108#else
1109 StatT sb;
1110 if (::lstat(p.c_str(), &sb) == -1) {
1111 return err.report(capture_errno());
1112 }
1113 const size_t size = sb.st_size + 1;
1114 auto buff = unique_ptr<char[]>(new char[size]);
1115#endif
1116 ::ssize_t ret;
1117 if ((ret = ::readlink(p.c_str(), buff.get(), size)) == -1)
1118 return err.report(capture_errno());
1119 _LIBCPP_ASSERT(ret > 0, "TODO");
1120 if (static_cast<size_t>(ret) >= size)
1121 return err.report(errc::value_too_large);
1122 buff[ret] = 0;
1123 return {buff.get()};
1124}
1125
1126bool __remove(const path& p, error_code* ec) {
1127 ErrorHandler<bool> err("remove", ec, &p);
1128 if (::remove(p.c_str()) == -1) {
1129 if (errno != ENOENT)
1130 err.report(capture_errno());
1131 return false;
1132 }
1133 return true;
1134}
1135
1136namespace {
1137
1138uintmax_t remove_all_impl(path const& p, error_code& ec) {
1139 const auto npos = static_cast<uintmax_t>(-1);
1140 const file_status st = __symlink_status(p, &ec);
1141 if (ec)
1142 return npos;
1143 uintmax_t count = 1;
1144 if (is_directory(st)) {
1145 for (directory_iterator it(p, ec); !ec && it != directory_iterator();
1146 it.increment(ec)) {
1147 auto other_count = remove_all_impl(it->path(), ec);
1148 if (ec)
1149 return npos;
1150 count += other_count;
1151 }
1152 if (ec)
1153 return npos;
1154 }
1155 if (!__remove(p, &ec))
1156 return npos;
1157 return count;
1158}
1159
1160} // end namespace
1161
1162uintmax_t __remove_all(const path& p, error_code* ec) {
1163 ErrorHandler<uintmax_t> err("remove_all", ec, &p);
1164
1165 error_code mec;
1166 auto count = remove_all_impl(p, mec);
1167 if (mec) {
1168 if (mec == errc::no_such_file_or_directory)
1169 return 0;
1170 return err.report(mec);
1171 }
1172 return count;
1173}
1174
1175void __rename(const path& from, const path& to, error_code* ec) {
1176 ErrorHandler<void> err("rename", ec, &from, &to);
1177 if (::rename(from.c_str(), to.c_str()) == -1)
1178 err.report(capture_errno());
1179}
1180
1181void __resize_file(const path& p, uintmax_t size, error_code* ec) {
1182 ErrorHandler<void> err("resize_file", ec, &p);
1183 if (::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
1184 return err.report(capture_errno());
1185}
1186
1187space_info __space(const path& p, error_code* ec) {
1188 ErrorHandler<void> err("space", ec, &p);
1189 space_info si;
1190 struct statvfs m_svfs = {};
1191 if (::statvfs(p.c_str(), &m_svfs) == -1) {
1192 err.report(capture_errno());
1193 si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
1194 return si;
1195 }
1196 // Multiply with overflow checking.
1197 auto do_mult = [&](uintmax_t& out, uintmax_t other) {
1198 out = other * m_svfs.f_frsize;
1199 if (other == 0 || out / other != m_svfs.f_frsize)
1200 out = static_cast<uintmax_t>(-1);
1201 };
1202 do_mult(si.capacity, m_svfs.f_blocks);
1203 do_mult(si.free, m_svfs.f_bfree);
1204 do_mult(si.available, m_svfs.f_bavail);
1205 return si;
1206}
1207
1208file_status __status(const path& p, error_code* ec) {
1209 return detail::posix_stat(p, ec);
1210}
1211
1212file_status __symlink_status(const path& p, error_code* ec) {
1213 return detail::posix_lstat(p, ec);
1214}
1215
1216path __temp_directory_path(error_code* ec) {
1217 ErrorHandler<path> err("temp_directory_path", ec);
1218
1219 const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
1220 const char* ret = nullptr;
1221
1222 for (auto& ep : env_paths)
1223 if ((ret = getenv(ep)))
1224 break;
1225 if (ret == nullptr)
1226 ret = "/tmp";
1227
1228 path p(ret);
1229 error_code m_ec;
1230 file_status st = detail::posix_stat(p, &m_ec);
1231 if (!status_known(st))
1232 return err.report(m_ec, "cannot access path \"%s\"", p);
1233
1234 if (!exists(st) || !is_directory(st))
1235 return err.report(errc::not_a_directory, "path \"%s\" is not a directory",
1236 p);
1237
1238 return p;
1239}
1240
1241path __weakly_canonical(const path& p, error_code* ec) {
1242 ErrorHandler<path> err("weakly_canonical", ec, &p);
1243
1244 if (p.empty())
1245 return __canonical("", ec);
1246
1247 path result;
1248 path tmp;
1249 tmp.__reserve(p.native().size());
1250 auto PP = PathParser::CreateEnd(p.native());
1251 --PP;
1252 vector<string_view_t> DNEParts;
1253
1254 while (PP.State != PathParser::PS_BeforeBegin) {
1255 tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
1256 error_code m_ec;
1257 file_status st = __status(tmp, &m_ec);
1258 if (!status_known(st)) {
1259 return err.report(m_ec);
1260 } else if (exists(st)) {
1261 result = __canonical(tmp, ec);
1262 break;
1263 }
1264 DNEParts.push_back(*PP);
1265 --PP;
1266 }
1267 if (PP.State == PathParser::PS_BeforeBegin)
1268 result = __canonical("", ec);
1269 if (ec)
1270 ec->clear();
1271 if (DNEParts.empty())
1272 return result;
1273 for (auto It = DNEParts.rbegin(); It != DNEParts.rend(); ++It)
1274 result /= *It;
1275 return result.lexically_normal();
1276}
1277
1278///////////////////////////////////////////////////////////////////////////////
1279// path definitions
1280///////////////////////////////////////////////////////////////////////////////
1281
1282constexpr path::value_type path::preferred_separator;
1283
1284path& path::replace_extension(path const& replacement) {
1285 path p = extension();
1286 if (not p.empty()) {
1287 __pn_.erase(__pn_.size() - p.native().size());
1288 }
1289 if (!replacement.empty()) {
1290 if (replacement.native()[0] != '.') {
1291 __pn_ += ".";
1292 }
1293 __pn_.append(replacement.__pn_);
1294 }
1295 return *this;
1296}
1297
1298///////////////////////////////////////////////////////////////////////////////
1299// path.decompose
1300
1301string_view_t path::__root_name() const {
1302 auto PP = PathParser::CreateBegin(__pn_);
1303 if (PP.State == PathParser::PS_InRootName)
1304 return *PP;
1305 return {};
1306}
1307
1308string_view_t path::__root_directory() const {
1309 auto PP = PathParser::CreateBegin(__pn_);
1310 if (PP.State == PathParser::PS_InRootName)
1311 ++PP;
1312 if (PP.State == PathParser::PS_InRootDir)
1313 return *PP;
1314 return {};
1315}
1316
1317string_view_t path::__root_path_raw() const {
1318 auto PP = PathParser::CreateBegin(__pn_);
1319 if (PP.State == PathParser::PS_InRootName) {
1320 auto NextCh = PP.peek();
1321 if (NextCh && *NextCh == '/') {
1322 ++PP;
1323 return createView(__pn_.data(), &PP.RawEntry.back());
1324 }
1325 return PP.RawEntry;
1326 }
1327 if (PP.State == PathParser::PS_InRootDir)
1328 return *PP;
1329 return {};
1330}
1331
1332static bool ConsumeRootName(PathParser *PP) {
1333 static_assert(PathParser::PS_BeforeBegin == 1 &&
1334 PathParser::PS_InRootName == 2,
1335 "Values for enums are incorrect");
1336 while (PP->State <= PathParser::PS_InRootName)
1337 ++(*PP);
1338 return PP->State == PathParser::PS_AtEnd;
1339}
1340
1341static bool ConsumeRootDir(PathParser* PP) {
1342 static_assert(PathParser::PS_BeforeBegin == 1 &&
1343 PathParser::PS_InRootName == 2 &&
1344 PathParser::PS_InRootDir == 3, "Values for enums are incorrect");
1345 while (PP->State <= PathParser::PS_InRootDir)
1346 ++(*PP);
1347 return PP->State == PathParser::PS_AtEnd;
1348}
1349
1350string_view_t path::__relative_path() const {
1351 auto PP = PathParser::CreateBegin(__pn_);
1352 if (ConsumeRootDir(&PP))
1353 return {};
1354 return createView(PP.RawEntry.data(), &__pn_.back());
1355}
1356
1357string_view_t path::__parent_path() const {
1358 if (empty())
1359 return {};
1360 // Determine if we have a root path but not a relative path. In that case
1361 // return *this.
1362 {
1363 auto PP = PathParser::CreateBegin(__pn_);
1364 if (ConsumeRootDir(&PP))
1365 return __pn_;
1366 }
1367 // Otherwise remove a single element from the end of the path, and return
1368 // a string representing that path
1369 {
1370 auto PP = PathParser::CreateEnd(__pn_);
1371 --PP;
1372 if (PP.RawEntry.data() == __pn_.data())
1373 return {};
1374 --PP;
1375 return createView(__pn_.data(), &PP.RawEntry.back());
1376 }
1377}
1378
1379string_view_t path::__filename() const {
1380 if (empty())
1381 return {};
1382 {
1383 PathParser PP = PathParser::CreateBegin(__pn_);
1384 if (ConsumeRootDir(&PP))
1385 return {};
1386 }
1387 return *(--PathParser::CreateEnd(__pn_));
1388}
1389
1390string_view_t path::__stem() const {
1391 return parser::separate_filename(__filename()).first;
1392}
1393
1394string_view_t path::__extension() const {
1395 return parser::separate_filename(__filename()).second;
1396}
1397
1398////////////////////////////////////////////////////////////////////////////
1399// path.gen
1400
1401enum PathPartKind : unsigned char {
1402 PK_None,
1403 PK_RootSep,
1404 PK_Filename,
1405 PK_Dot,
1406 PK_DotDot,
1407 PK_TrailingSep
1408};
1409
1410static PathPartKind ClassifyPathPart(string_view_t Part) {
1411 if (Part.empty())
1412 return PK_TrailingSep;
1413 if (Part == ".")
1414 return PK_Dot;
1415 if (Part == "..")
1416 return PK_DotDot;
1417 if (Part == "/")
1418 return PK_RootSep;
1419 return PK_Filename;
1420}
1421
1422path path::lexically_normal() const {
1423 if (__pn_.empty())
1424 return *this;
1425
1426 using PartKindPair = pair<string_view_t, PathPartKind>;
1427 vector<PartKindPair> Parts;
1428 // Guess as to how many elements the path has to avoid reallocating.
1429 Parts.reserve(32);
1430
1431 // Track the total size of the parts as we collect them. This allows the
1432 // resulting path to reserve the correct amount of memory.
1433 size_t NewPathSize = 0;
1434 auto AddPart = [&](PathPartKind K, string_view_t P) {
1435 NewPathSize += P.size();
1436 Parts.emplace_back(P, K);
1437 };
1438 auto LastPartKind = [&]() {
1439 if (Parts.empty())
1440 return PK_None;
1441 return Parts.back().second;
1442 };
1443
1444 bool MaybeNeedTrailingSep = false;
1445 // Build a stack containing the remaining elements of the path, popping off
1446 // elements which occur before a '..' entry.
1447 for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
1448 auto Part = *PP;
1449 PathPartKind Kind = ClassifyPathPart(Part);
1450 switch (Kind) {
1451 case PK_Filename:
1452 case PK_RootSep: {
1453 // Add all non-dot and non-dot-dot elements to the stack of elements.
1454 AddPart(Kind, Part);
1455 MaybeNeedTrailingSep = false;
1456 break;
1457 }
1458 case PK_DotDot: {
1459 // Only push a ".." element if there are no elements preceding the "..",
1460 // or if the preceding element is itself "..".
1461 auto LastKind = LastPartKind();
1462 if (LastKind == PK_Filename) {
1463 NewPathSize -= Parts.back().first.size();
1464 Parts.pop_back();
1465 } else if (LastKind != PK_RootSep)
1466 AddPart(PK_DotDot, "..");
1467 MaybeNeedTrailingSep = LastKind == PK_Filename;
1468 break;
1469 }
1470 case PK_Dot:
1471 case PK_TrailingSep: {
1472 MaybeNeedTrailingSep = true;
1473 break;
1474 }
1475 case PK_None:
1476 _LIBCPP_UNREACHABLE();
1477 }
1478 }
1479 // [fs.path.generic]p6.8: If the path is empty, add a dot.
1480 if (Parts.empty())
1481 return ".";
1482
1483 // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
1484 // trailing directory-separator.
1485 bool NeedTrailingSep = MaybeNeedTrailingSep && LastPartKind() == PK_Filename;
1486
1487 path Result;
1488 Result.__pn_.reserve(Parts.size() + NewPathSize + NeedTrailingSep);
1489 for (auto& PK : Parts)
1490 Result /= PK.first;
1491
1492 if (NeedTrailingSep)
1493 Result /= "";
1494
1495 return Result;
1496}
1497
1498static int DetermineLexicalElementCount(PathParser PP) {
1499 int Count = 0;
1500 for (; PP; ++PP) {
1501 auto Elem = *PP;
1502 if (Elem == "..")
1503 --Count;
1504 else if (Elem != "." && Elem != "")
1505 ++Count;
1506 }
1507 return Count;
1508}
1509
1510path path::lexically_relative(const path& base) const {
1511 { // perform root-name/root-directory mismatch checks
1512 auto PP = PathParser::CreateBegin(__pn_);
1513 auto PPBase = PathParser::CreateBegin(base.__pn_);
1514 auto CheckIterMismatchAtBase = [&]() {
1515 return PP.State != PPBase.State &&
1516 (PP.inRootPath() || PPBase.inRootPath());
1517 };
1518 if (PP.inRootName() && PPBase.inRootName()) {
1519 if (*PP != *PPBase)
1520 return {};
1521 } else if (CheckIterMismatchAtBase())
1522 return {};
1523
1524 if (PP.inRootPath())
1525 ++PP;
1526 if (PPBase.inRootPath())
1527 ++PPBase;
1528 if (CheckIterMismatchAtBase())
1529 return {};
1530 }
1531
1532 // Find the first mismatching element
1533 auto PP = PathParser::CreateBegin(__pn_);
1534 auto PPBase = PathParser::CreateBegin(base.__pn_);
1535 while (PP && PPBase && PP.State == PPBase.State && *PP == *PPBase) {
1536 ++PP;
1537 ++PPBase;
1538 }
1539
1540 // If there is no mismatch, return ".".
1541 if (!PP && !PPBase)
1542 return ".";
1543
1544 // Otherwise, determine the number of elements, 'n', which are not dot or
1545 // dot-dot minus the number of dot-dot elements.
1546 int ElemCount = DetermineLexicalElementCount(PPBase);
1547 if (ElemCount < 0)
1548 return {};
1549
1550 // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
1551 if (ElemCount == 0 && (PP.atEnd() || *PP == ""))
1552 return ".";
1553
1554 // return a path constructed with 'n' dot-dot elements, followed by the the
1555 // elements of '*this' after the mismatch.
1556 path Result;
1557 // FIXME: Reserve enough room in Result that it won't have to re-allocate.
1558 while (ElemCount--)
1559 Result /= "..";
1560 for (; PP; ++PP)
1561 Result /= *PP;
1562 return Result;
1563}
1564
1565////////////////////////////////////////////////////////////////////////////
1566// path.comparisons
1567static int CompareRootName(PathParser *LHS, PathParser *RHS) {
1568 if (!LHS->inRootName() && !RHS->inRootName())
1569 return 0;
1570
1571 auto GetRootName = [](PathParser *Parser) -> string_view_t {
1572 return Parser->inRootName() ? **Parser : "";
1573 };
1574 int res = GetRootName(LHS).compare(GetRootName(RHS));
1575 ConsumeRootName(LHS);
1576 ConsumeRootName(RHS);
1577 return res;
1578}
1579
1580static int CompareRootDir(PathParser *LHS, PathParser *RHS) {
1581 if (!LHS->inRootDir() && RHS->inRootDir())
1582 return -1;
1583 else if (LHS->inRootDir() && !RHS->inRootDir())
1584 return 1;
1585 else {
1586 ConsumeRootDir(LHS);
1587 ConsumeRootDir(RHS);
1588 return 0;
1589 }
1590}
1591
1592static int CompareRelative(PathParser *LHSPtr, PathParser *RHSPtr) {
1593 auto &LHS = *LHSPtr;
1594 auto &RHS = *RHSPtr;
1595
1596 int res;
1597 while (LHS && RHS) {
1598 if ((res = (*LHS).compare(*RHS)) != 0)
1599 return res;
1600 ++LHS;
1601 ++RHS;
1602 }
1603 return 0;
1604}
1605
1606static int CompareEndState(PathParser *LHS, PathParser *RHS) {
1607 if (LHS->atEnd() && !RHS->atEnd())
1608 return -1;
1609 else if (!LHS->atEnd() && RHS->atEnd())
1610 return 1;
1611 return 0;
1612}
1613
1614int path::__compare(string_view_t __s) const {
1615 auto LHS = PathParser::CreateBegin(__pn_);
1616 auto RHS = PathParser::CreateBegin(__s);
1617 int res;
1618
1619 if ((res = CompareRootName(&LHS, &RHS)) != 0)
1620 return res;
1621
1622 if ((res = CompareRootDir(&LHS, &RHS)) != 0)
1623 return res;
1624
1625 if ((res = CompareRelative(&LHS, &RHS)) != 0)
1626 return res;
1627
1628 return CompareEndState(&LHS, &RHS);
1629}
1630
1631////////////////////////////////////////////////////////////////////////////
1632// path.nonmembers
1633size_t hash_value(const path& __p) noexcept {
1634 auto PP = PathParser::CreateBegin(__p.native());
1635 size_t hash_value = 0;
1636 hash<string_view_t> hasher;
1637 while (PP) {
1638 hash_value = __hash_combine(hash_value, hasher(*PP));
1639 ++PP;
1640 }
1641 return hash_value;
1642}
1643
1644////////////////////////////////////////////////////////////////////////////
1645// path.itr
1646path::iterator path::begin() const {
1647 auto PP = PathParser::CreateBegin(__pn_);
1648 iterator it;
1649 it.__path_ptr_ = this;
1650 it.__state_ = static_cast<path::iterator::_ParserState>(PP.State);
1651 it.__entry_ = PP.RawEntry;
1652 it.__stashed_elem_.__assign_view(*PP);
1653 return it;
1654}
1655
1656path::iterator path::end() const {
1657 iterator it{};
1658 it.__state_ = path::iterator::_AtEnd;
1659 it.__path_ptr_ = this;
1660 return it;
1661}
1662
1663path::iterator& path::iterator::__increment() {
1664 PathParser PP(__path_ptr_->native(), __entry_, __state_);
1665 ++PP;
1666 __state_ = static_cast<_ParserState>(PP.State);
1667 __entry_ = PP.RawEntry;
1668 __stashed_elem_.__assign_view(*PP);
1669 return *this;
1670}
1671
1672path::iterator& path::iterator::__decrement() {
1673 PathParser PP(__path_ptr_->native(), __entry_, __state_);
1674 --PP;
1675 __state_ = static_cast<_ParserState>(PP.State);
1676 __entry_ = PP.RawEntry;
1677 __stashed_elem_.__assign_view(*PP);
1678 return *this;
1679}
1680
1681///////////////////////////////////////////////////////////////////////////////
1682// directory entry definitions
1683///////////////////////////////////////////////////////////////////////////////
1684
1685#ifndef _LIBCPP_WIN32API
1686error_code directory_entry::__do_refresh() noexcept {
1687 __data_.__reset();
1688 error_code failure_ec;
1689
1690 StatT full_st;
1691 file_status st = detail::posix_lstat(__p_, full_st, &failure_ec);
1692 if (!status_known(st)) {
1693 __data_.__reset();
1694 return failure_ec;
1695 }
1696
1697 if (!_VSTD_FS::exists(st) || !_VSTD_FS::is_symlink(st)) {
1698 __data_.__cache_type_ = directory_entry::_RefreshNonSymlink;
1699 __data_.__type_ = st.type();
1700 __data_.__non_sym_perms_ = st.permissions();
1701 } else { // we have a symlink
1702 __data_.__sym_perms_ = st.permissions();
1703 // Get the information about the linked entity.
1704 // Ignore errors from stat, since we don't want errors regarding symlink
1705 // resolution to be reported to the user.
1706 error_code ignored_ec;
1707 st = detail::posix_stat(__p_, full_st, &ignored_ec);
1708
1709 __data_.__type_ = st.type();
1710 __data_.__non_sym_perms_ = st.permissions();
1711
1712 // If we failed to resolve the link, then only partially populate the
1713 // cache.
1714 if (!status_known(st)) {
1715 __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
1716 return error_code{};
1717 }
1718 // Otherwise, we resolved the link, potentially as not existing.
1719 // That's OK.
1720 __data_.__cache_type_ = directory_entry::_RefreshSymlink;
1721 }
1722
1723 if (_VSTD_FS::is_regular_file(st))
1724 __data_.__size_ = static_cast<uintmax_t>(full_st.st_size);
1725
1726 if (_VSTD_FS::exists(st)) {
1727 __data_.__nlink_ = static_cast<uintmax_t>(full_st.st_nlink);
1728
1729 // Attempt to extract the mtime, and fail if it's not representable using
1730 // file_time_type. For now we ignore the error, as we'll report it when
1731 // the value is actually used.
1732 error_code ignored_ec;
1733 __data_.__write_time_ =
1734 __extract_last_write_time(__p_, full_st, &ignored_ec);
1735 }
1736
1737 return failure_ec;
1738}
1739#else
1740error_code directory_entry::__do_refresh() noexcept {
1741 __data_.__reset();
1742 error_code failure_ec;
1743
1744 file_status st = _VSTD_FS::symlink_status(__p_, failure_ec);
1745 if (!status_known(st)) {
1746 __data_.__reset();
1747 return failure_ec;
1748 }
1749
1750 if (!_VSTD_FS::exists(st) || !_VSTD_FS::is_symlink(st)) {
1751 __data_.__cache_type_ = directory_entry::_RefreshNonSymlink;
1752 __data_.__type_ = st.type();
1753 __data_.__non_sym_perms_ = st.permissions();
1754 } else { // we have a symlink
1755 __data_.__sym_perms_ = st.permissions();
1756 // Get the information about the linked entity.
1757 // Ignore errors from stat, since we don't want errors regarding symlink
1758 // resolution to be reported to the user.
1759 error_code ignored_ec;
1760 st = _VSTD_FS::status(__p_, ignored_ec);
1761
1762 __data_.__type_ = st.type();
1763 __data_.__non_sym_perms_ = st.permissions();
1764
1765 // If we failed to resolve the link, then only partially populate the
1766 // cache.
1767 if (!status_known(st)) {
1768 __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
1769 return error_code{};
1770 }
1771 __data_.__cache_type_ = directory_entry::_RefreshSymlink;
1772 }
1773
1774 // FIXME: This is currently broken, and the implementation only a placeholder.
1775 // We need to cache last_write_time, file_size, and hard_link_count here before
1776 // the implementation actually works.
1777
1778 return failure_ec;
1779}
1780#endif
1781
1782_LIBCPP_END_NAMESPACE_FILESYSTEM
1783