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 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 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 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 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 61 perms posix_get_perms(const struct ::stat & st) noexcept { 62 return static_cast<perms>(st.st_mode) & perms::mask; 63 } 64 65 ::mode_t posix_convert_perms(perms prms) { 66 return static_cast< ::mode_t>(prms & perms::mask); 67 } 68 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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> 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__) 520 TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; } 521 TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; } 522 #else 523 TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; } 524 __attribute__((unused)) // Suppress warning 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 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 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 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> 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 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 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 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 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 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 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 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 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 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 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 873 file_status __status(const path& p, std::error_code *ec) { 874 return detail::posix_stat(p, ec); 875 } 876 877 file_status __symlink_status(const path& p, std::error_code *ec) { 878 return detail::posix_lstat(p, ec); 879 } 880 881 path __system_complete(const path& p, std::error_code *ec) { 882 if (ec) ec->clear(); 883 return absolute(p, current_path()); 884 } 885 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]. 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
