libstdc++-v3/src/filesystem/std-ops.cc

   1 // Filesystem operations -*- C++ -*-
   2
   3 // Copyright (C) 2014-2017 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 #ifndef _GLIBCXX_USE_CXX11_ABI
  26 # define _GLIBCXX_USE_CXX11_ABI 1
  27 # define NEED_DO_COPY_FILE
  28 #endif
  29
  30 #include <filesystem>
  31 #include <experimental/filesystem>
  32 #include <functional>
  33 #include <ostream>
  34 #include <stack>
  35 #include <ext/stdio_filebuf.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <errno.h>
  39 #include <limits.h>  // PATH_MAX
  40 #ifdef _GLIBCXX_HAVE_FCNTL_H
  41 # include <fcntl.h>  // AT_FDCWD, AT_SYMLINK_NOFOLLOW
  42 #endif
  43 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
  44 #  include <sys/stat.h>   // stat, utimensat, fchmodat
  45 #endif
  46 #ifdef _GLIBCXX_HAVE_SYS_STATVFS_H
  47 # include <sys/statvfs.h> // statvfs
  48 #endif
  49 #ifdef _GLIBCXX_USE_SENDFILE
  50 # include <sys/sendfile.h> // sendfile
  51 #endif
  52 #if !_GLIBCXX_USE_UTIMENSAT && _GLIBCXX_HAVE_UTIME_H
  53 # include <utime.h> // utime
  54 #endif
  55
  56 #define _GLIBCXX_BEGIN_NAMESPACE_FILESYSTEM namespace filesystem {
  57 #define _GLIBCXX_END_NAMESPACE_FILESYSTEM }
  58 #include "ops-common.h"
  59
  60 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
  61 # undef utime
  62 # define utime _wutime
  63 # undef chmod
  64 # define chmod _wchmod
  65 #endif
  66
  67 namespace fs = std::filesystem;
  68
  69 fs::path
  70 fs::absolute(const path& p)
  71 {
  72 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
  73   error_code ec;
  74   path ret = absolute(p, ec);
  75   if (ec)
  76     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot make absolute path", p,
  77         std::make_error_code(errc::not_supported)));
  78   return ret;
  79 #else
  80   return current_path() / p;
  81 #endif
  82 }
  83
  84 fs::path
  85 fs::absolute(const path& p, error_code& ec)
  86 {
  87 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
  88   ec = std::make_error_code(errc::not_supported);
  89   return {};
  90 #else
  91   ec.clear();
  92   return current_path() / p;
  93 #endif
  94 }
  95
  96 namespace
  97 {
  98 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
  99   inline bool is_dot(wchar_t c) { return c == L'.'; }
 100 #else
 101   inline bool is_dot(char c) { return c == '.'; }
 102 #endif
 103
 104   inline bool is_dot(const fs::path& path)
 105   {
 106     const auto& filename = path.native();
 107     return filename.size() == 1 && is_dot(filename[0]);
 108   }
 109
 110   inline bool is_dotdot(const fs::path& path)
 111   {
 112     const auto& filename = path.native();
 113     return filename.size() == 2 && is_dot(filename[0]) && is_dot(filename[1]);
 114   }
 115
 116   struct free_as_in_malloc
 117   {
 118     void operator()(void* p) const { ::free(p); }
 119   };
 120
 121   using char_ptr = std::unique_ptr<char[], free_as_in_malloc>;
 122 }
 123
 124 fs::path
 125 fs::canonical(const path& p, error_code& ec)
 126 {
 127   path result;
 128   const path pa = absolute(p, ec);
 129   if (ec)
 130     return result;
 131
 132 #ifdef _GLIBCXX_USE_REALPATH
 133   char_ptr buf{ nullptr };
 134 # if _XOPEN_VERSION < 700
 135   // Not safe to call realpath(path, NULL)
 136   buf.reset( (char*)::malloc(PATH_MAX) );
 137 # endif
 138   if (char* rp = ::realpath(pa.c_str(), buf.get()))
 139     {
 140       if (buf == nullptr)
 141         buf.reset(rp);
 142       result.assign(rp);
 143       ec.clear();
 144       return result;
 145     }
 146   if (errno != ENAMETOOLONG)
 147     {
 148       ec.assign(errno, std::generic_category());
 149       return result;
 150     }
 151 #endif
 152
 153   if (!exists(pa, ec))
 154     {
 155       if (!ec)
 156         ec = make_error_code(std::errc::no_such_file_or_directory);
 157       return result;
 158     }
 159   // else: we know there are (currently) no unresolvable symlink loops
 160
 161   result = pa.root_path();
 162
 163   deque<path> cmpts;
 164   for (auto& f : pa.relative_path())
 165     cmpts.push_back(f);
 166
 167   int max_allowed_symlinks = 40;
 168
 169   while (!cmpts.empty() && !ec)
 170     {
 171       path f = std::move(cmpts.front());
 172       cmpts.pop_front();
 173
 174       if (f.empty())
 175         {
 176           // ignore empty element
 177         }
 178       else if (is_dot(f))
 179         {
 180           if (!is_directory(result, ec) && !ec)
 181             ec.assign(ENOTDIR, std::generic_category());
 182         }
 183       else if (is_dotdot(f))
 184         {
 185           auto parent = result.parent_path();
 186           if (parent.empty())
 187             result = pa.root_path();
 188           else
 189             result.swap(parent);
 190         }
 191       else
 192         {
 193           result /= f;
 194
 195           if (is_symlink(result, ec))
 196             {
 197               path link = read_symlink(result, ec);
 198               if (!ec)
 199                 {
 200                   if (--max_allowed_symlinks == 0)
 201                     ec.assign(ELOOP, std::generic_category());
 202                   else
 203                     {
 204                       if (link.is_absolute())
 205                         {
 206                           result = link.root_path();
 207                           link = link.relative_path();
 208                         }
 209                       else
 210                         result = result.parent_path();
 211
 212                       cmpts.insert(cmpts.begin(), link.begin(), link.end());
 213                     }
 214                 }
 215             }
 216         }
 217     }
 218
 219   if (ec || !exists(result, ec))
 220     result.clear();
 221
 222   return result;
 223 }
 224
 225 fs::path
 226 fs::canonical(const path& p)
 227 {
 228   error_code ec;
 229   path res = canonical(p, ec);
 230   if (ec)
 231     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot make canonical path",
 232                                              p, ec));
 233   return res;
 234 }
 235
 236 void
 237 fs::copy(const path& from, const path& to, copy_options options)
 238 {
 239   error_code ec;
 240   copy(from, to, options, ec);
 241   if (ec)
 242     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy", from, to, ec));
 243 }
 244
 245 namespace std::filesystem
 246 {
 247   // Need this as there's no 'perm_options::none' enumerator.
 248   inline bool is_set(fs::perm_options obj, fs::perm_options bits)
 249   {
 250     return (obj & bits) != fs::perm_options{};
 251   }
 252 }
 253
 254 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 255 #ifdef NEED_DO_COPY_FILE
 256 bool
 257 fs::do_copy_file(const char* from, const char* to,
 258                  copy_options_existing_file options,
 259                  stat_type* from_st, stat_type* to_st,
 260                  std::error_code& ec) noexcept
 261 {
 262   stat_type st1, st2;
 263   fs::file_status t, f;
 264
 265   if (to_st == nullptr)
 266     {
 267       if (::stat(to, &st1))
 268         {
 269           const int err = errno;
 270           if (!is_not_found_errno(err))
 271             {
 272               ec.assign(err, std::generic_category());
 273               return false;
 274             }
 275         }
 276       else
 277         to_st = &st1;
 278     }
 279   else if (to_st == from_st)
 280     to_st = nullptr;
 281
 282   if (to_st == nullptr)
 283     t = fs::file_status{fs::file_type::not_found};
 284   else
 285     t = make_file_status(*to_st);
 286
 287   if (from_st == nullptr)
 288     {
 289       if (::stat(from, &st2))
 290         {
 291           ec.assign(errno, std::generic_category());
 292           return false;
 293         }
 294       else
 295         from_st = &st2;
 296     }
 297   f = make_file_status(*from_st);
 298   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 299   // 2712. copy_file() has a number of unspecified error conditions
 300   if (!is_regular_file(f))
 301     {
 302       ec = std::make_error_code(std::errc::not_supported);
 303       return false;
 304     }
 305
 306   if (exists(t))
 307     {
 308       if (!is_regular_file(t))
 309         {
 310           ec = std::make_error_code(std::errc::not_supported);
 311           return false;
 312         }
 313
 314       if (to_st->st_dev == from_st->st_dev
 315           && to_st->st_ino == from_st->st_ino)
 316         {
 317           ec = std::make_error_code(std::errc::file_exists);
 318           return false;
 319         }
 320
 321       if (options.skip)
 322         {
 323           ec.clear();
 324           return false;
 325         }
 326       else if (options.update)
 327         {
 328           const auto from_mtime = file_time(*from_st, ec);
 329           if (ec)
 330             return false;
 331           if ((from_mtime <= file_time(*to_st, ec)) || ec)
 332             return false;
 333         }
 334       else if (!options.overwrite)
 335         {
 336           ec = std::make_error_code(std::errc::file_exists);
 337           return false;
 338         }
 339       else if (!is_regular_file(t))
 340         {
 341           ec = std::make_error_code(std::errc::not_supported);
 342           return false;
 343         }
 344     }
 345
 346   struct CloseFD {
 347     ~CloseFD() { if (fd != -1) ::close(fd); }
 348     bool close() { return ::close(std::exchange(fd, -1)) == 0; }
 349     int fd;
 350   };
 351
 352   CloseFD in = { ::open(from, O_RDONLY) };
 353   if (in.fd == -1)
 354     {
 355       ec.assign(errno, std::generic_category());
 356       return false;
 357     }
 358   int oflag = O_WRONLY|O_CREAT;
 359   if (options.overwrite || options.update)
 360     oflag |= O_TRUNC;
 361   else
 362     oflag |= O_EXCL;
 363   CloseFD out = { ::open(to, oflag, S_IWUSR) };
 364   if (out.fd == -1)
 365     {
 366       if (errno == EEXIST && options.skip)
 367         ec.clear();
 368       else
 369         ec.assign(errno, std::generic_category());
 370       return false;
 371     }
 372
 373 #ifdef _GLIBCXX_USE_FCHMOD
 374   if (::fchmod(out.fd, from_st->st_mode))
 375 #elif defined _GLIBCXX_USE_FCHMODAT
 376   if (::fchmodat(AT_FDCWD, to, from_st->st_mode, 0))
 377 #else
 378   if (::chmod(to, from_st->st_mode))
 379 #endif
 380     {
 381       ec.assign(errno, std::generic_category());
 382       return false;
 383     }
 384
 385 #ifdef _GLIBCXX_USE_SENDFILE
 386   off_t offset = 0;
 387   const auto n = ::sendfile(out.fd, in.fd, &offset, from_st->st_size);
 388   if (n < 0 && (errno == ENOSYS || errno == EINVAL))
 389     {
 390 #endif // _GLIBCXX_USE_SENDFILE
 391       __gnu_cxx::stdio_filebuf<char> sbin(in.fd, std::ios::in);
 392       __gnu_cxx::stdio_filebuf<char> sbout(out.fd, std::ios::out);
 393       if (sbin.is_open())
 394         in.fd = -1;
 395       if (sbout.is_open())
 396         out.fd = -1;
 397       if (from_st->st_size && !(std::ostream(&sbout) << &sbin))
 398         {
 399           ec = std::make_error_code(std::errc::io_error);
 400           return false;
 401         }
 402       if (!sbout.close() || !sbin.close())
 403         {
 404           ec.assign(errno, std::generic_category());
 405           return false;
 406         }
 407
 408       ec.clear();
 409       return true;
 410
 411 #ifdef _GLIBCXX_USE_SENDFILE
 412     }
 413   if (n != from_st->st_size)
 414     {
 415       ec.assign(errno, std::generic_category());
 416       return false;
 417     }
 418   if (!out.close() || !in.close())
 419     {
 420       ec.assign(errno, std::generic_category());
 421       return false;
 422     }
 423
 424   ec.clear();
 425   return true;
 426 #endif // _GLIBCXX_USE_SENDFILE
 427 }
 428 #endif // NEED_DO_COPY_FILE
 429 #endif // _GLIBCXX_HAVE_SYS_STAT_H
 430
 431 void
 432 fs::copy(const path& from, const path& to, copy_options options,
 433          error_code& ec) noexcept
 434 {
 435   const bool skip_symlinks = is_set(options, copy_options::skip_symlinks);
 436   const bool create_symlinks = is_set(options, copy_options::create_symlinks);
 437   const bool copy_symlinks = is_set(options, copy_options::copy_symlinks);
 438   const bool use_lstat = create_symlinks || skip_symlinks;
 439
 440   file_status f, t;
 441   stat_type from_st, to_st;
 442   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 443   // 2681. filesystem::copy() cannot copy symlinks
 444   if (use_lstat || copy_symlinks
 445       ? ::lstat(from.c_str(), &from_st)
 446       : ::stat(from.c_str(), &from_st))
 447     {
 448       ec.assign(errno, std::generic_category());
 449       return;
 450     }
 451   if (use_lstat
 452       ? ::lstat(to.c_str(), &to_st)
 453       : ::stat(to.c_str(), &to_st))
 454     {
 455       if (!is_not_found_errno(errno))
 456         {
 457           ec.assign(errno, std::generic_category());
 458           return;
 459         }
 460       t = file_status{file_type::not_found};
 461     }
 462   else
 463     t = make_file_status(to_st);
 464   f = make_file_status(from_st);
 465
 466   if (exists(t) && !is_other(t) && !is_other(f)
 467       && to_st.st_dev == from_st.st_dev && to_st.st_ino == from_st.st_ino)
 468     {
 469       ec = std::make_error_code(std::errc::file_exists);
 470       return;
 471     }
 472   if (is_other(f) || is_other(t))
 473     {
 474       ec = std::make_error_code(std::errc::not_supported);
 475       return;
 476     }
 477   if (is_directory(f) && is_regular_file(t))
 478     {
 479       ec = std::make_error_code(std::errc::is_a_directory);
 480       return;
 481     }
 482
 483   if (is_symlink(f))
 484     {
 485       if (skip_symlinks)
 486         ec.clear();
 487       else if (!exists(t) && copy_symlinks)
 488         copy_symlink(from, to, ec);
 489       else
 490         // Not clear what should be done here.
 491         // "Otherwise report an error as specified in Error reporting (7)."
 492         ec = std::make_error_code(std::errc::invalid_argument);
 493     }
 494   else if (is_regular_file(f))
 495     {
 496       if (is_set(options, copy_options::directories_only))
 497         ec.clear();
 498       else if (create_symlinks)
 499         create_symlink(from, to, ec);
 500       else if (is_set(options, copy_options::create_hard_links))
 501         create_hard_link(from, to, ec);
 502       else if (is_directory(t))
 503         do_copy_file(from.c_str(), (to / from.filename()).c_str(),
 504                      copy_file_options(options), &from_st, nullptr, ec);
 505       else
 506         {
 507           auto ptr = exists(t) ? &to_st : &from_st;
 508           do_copy_file(from.c_str(), to.c_str(), copy_file_options(options),
 509                        &from_st, ptr, ec);
 510         }
 511     }
 512   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 513   // 2682. filesystem::copy() won't create a symlink to a directory
 514   else if (is_directory(f) && create_symlinks)
 515     ec = std::make_error_code(errc::is_a_directory);
 516   else if (is_directory(f) && (is_set(options, copy_options::recursive)
 517                                || options == copy_options::none))
 518     {
 519       if (!exists(t))
 520         if (!create_directory(to, from, ec))
 521           return;
 522       // set an unused bit in options to disable further recursion
 523       if (!is_set(options, copy_options::recursive))
 524         options |= static_cast<copy_options>(4096);
 525       for (const directory_entry& x : directory_iterator(from))
 526         copy(x.path(), to/x.path().filename(), options, ec);
 527     }
 528   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 529   // 2683. filesystem::copy() says "no effects"
 530   else
 531     ec.clear();
 532 }
 533
 534 bool
 535 fs::copy_file(const path& from, const path& to, copy_options option)
 536 {
 537   error_code ec;
 538   bool result = copy_file(from, to, option, ec);
 539   if (ec)
 540     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy file", from, to,
 541                                              ec));
 542   return result;
 543 }
 544
 545 bool
 546 fs::copy_file(const path& from, const path& to, copy_options options,
 547               error_code& ec) noexcept
 548 {
 549 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 550   return do_copy_file(from.c_str(), to.c_str(), copy_file_options(options),
 551                       nullptr, nullptr, ec);
 552 #else
 553   ec = std::make_error_code(std::errc::not_supported);
 554   return false;
 555 #endif
 556 }
 557
 558
 559 void
 560 fs::copy_symlink(const path& existing_symlink, const path& new_symlink)
 561 {
 562   error_code ec;
 563   copy_symlink(existing_symlink, new_symlink, ec);
 564   if (ec)
 565     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot copy symlink",
 566           existing_symlink, new_symlink, ec));
 567 }
 568
 569 void
 570 fs::copy_symlink(const path& existing_symlink, const path& new_symlink,
 571                  error_code& ec) noexcept
 572 {
 573   auto p = read_symlink(existing_symlink, ec);
 574   if (ec)
 575     return;
 576 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 577   if (is_directory(p))
 578     {
 579       create_directory_symlink(p, new_symlink, ec);
 580       return;
 581     }
 582 #endif
 583   create_symlink(p, new_symlink, ec);
 584 }
 585
 586
 587 bool
 588 fs::create_directories(const path& p)
 589 {
 590   error_code ec;
 591   bool result = create_directories(p, ec);
 592   if (ec)
 593     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directories", p,
 594                                              ec));
 595   return result;
 596 }
 597
 598 bool
 599 fs::create_directories(const path& p, error_code& ec) noexcept
 600 {
 601   if (p.empty())
 602     {
 603       ec = std::make_error_code(errc::invalid_argument);
 604       return false;
 605     }
 606   std::stack<path> missing;
 607   path pp = p;
 608
 609   while (pp.has_filename() && status(pp, ec).type() == file_type::not_found)
 610     {
 611       ec.clear();
 612       const auto& filename = pp.filename();
 613       if (!is_dot(filename) && !is_dotdot(filename))
 614         missing.push(pp);
 615       pp = pp.parent_path();
 616
 617       if (missing.size() > 1000) // sanity check
 618         {
 619           ec = std::make_error_code(std::errc::filename_too_long);
 620           return false;
 621         }
 622     }
 623
 624   if (ec || missing.empty())
 625     return false;
 626
 627   do
 628     {
 629       const path& top = missing.top();
 630       create_directory(top, ec);
 631       if (ec && is_directory(top))
 632         ec.clear();
 633       missing.pop();
 634     }
 635   while (!missing.empty() && !ec);
 636
 637   return missing.empty();
 638 }
 639
 640 namespace
 641 {
 642   bool
 643   create_dir(const fs::path& p, fs::perms perm, std::error_code& ec)
 644   {
 645     bool created = false;
 646 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 647     ::mode_t mode = static_cast<std::underlying_type_t<fs::perms>>(perm);
 648     if (::mkdir(p.c_str(), mode))
 649       {
 650         const int err = errno;
 651         if (err != EEXIST || !is_directory(p))
 652           ec.assign(err, std::generic_category());
 653         else
 654           ec.clear();
 655       }
 656     else
 657       {
 658         ec.clear();
 659         created = true;
 660       }
 661 #else
 662     ec = std::make_error_code(std::errc::not_supported);
 663 #endif
 664     return created;
 665   }
 666 } // namespace
 667
 668 bool
 669 fs::create_directory(const path& p)
 670 {
 671   error_code ec;
 672   bool result = create_directory(p, ec);
 673   if (ec)
 674     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory", p,
 675           ec));
 676   return result;
 677 }
 678
 679 bool
 680 fs::create_directory(const path& p, error_code& ec) noexcept
 681 {
 682   return create_dir(p, perms::all, ec);
 683 }
 684
 685
 686 bool
 687 fs::create_directory(const path& p, const path& attributes)
 688 {
 689   error_code ec;
 690   bool result = create_directory(p, attributes, ec);
 691   if (ec)
 692     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory", p,
 693           ec));
 694   return result;
 695 }
 696
 697 bool
 698 fs::create_directory(const path& p, const path& attributes,
 699                      error_code& ec) noexcept
 700 {
 701 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 702   stat_type st;
 703   if (::stat(attributes.c_str(), &st))
 704     {
 705       ec.assign(errno, std::generic_category());
 706       return false;
 707     }
 708   return create_dir(p, static_cast<perms>(st.st_mode), ec);
 709 #else
 710   ec = std::make_error_code(std::errc::not_supported);
 711   return false;
 712 #endif
 713 }
 714
 715
 716 void
 717 fs::create_directory_symlink(const path& to, const path& new_symlink)
 718 {
 719   error_code ec;
 720   create_directory_symlink(to, new_symlink, ec);
 721   if (ec)
 722     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create directory symlink",
 723           to, new_symlink, ec));
 724 }
 725
 726 void
 727 fs::create_directory_symlink(const path& to, const path& new_symlink,
 728                              error_code& ec) noexcept
 729 {
 730 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 731   ec = std::make_error_code(std::errc::not_supported);
 732 #else
 733   create_symlink(to, new_symlink, ec);
 734 #endif
 735 }
 736
 737
 738 void
 739 fs::create_hard_link(const path& to, const path& new_hard_link)
 740 {
 741   error_code ec;
 742   create_hard_link(to, new_hard_link, ec);
 743   if (ec)
 744     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create hard link",
 745           to, new_hard_link, ec));
 746 }
 747
 748 void
 749 fs::create_hard_link(const path& to, const path& new_hard_link,
 750                      error_code& ec) noexcept
 751 {
 752 #ifdef _GLIBCXX_HAVE_UNISTD_H
 753   if (::link(to.c_str(), new_hard_link.c_str()))
 754     ec.assign(errno, std::generic_category());
 755   else
 756     ec.clear();
 757 #else
 758   ec = std::make_error_code(std::errc::not_supported);
 759 #endif
 760 }
 761
 762 void
 763 fs::create_symlink(const path& to, const path& new_symlink)
 764 {
 765   error_code ec;
 766   create_symlink(to, new_symlink, ec);
 767   if (ec)
 768     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot create symlink",
 769           to, new_symlink, ec));
 770 }
 771
 772 void
 773 fs::create_symlink(const path& to, const path& new_symlink,
 774                    error_code& ec) noexcept
 775 {
 776 #ifdef _GLIBCXX_HAVE_UNISTD_H
 777   if (::symlink(to.c_str(), new_symlink.c_str()))
 778     ec.assign(errno, std::generic_category());
 779   else
 780     ec.clear();
 781 #else
 782   ec = std::make_error_code(std::errc::not_supported);
 783 #endif
 784 }
 785
 786
 787 fs::path
 788 fs::current_path()
 789 {
 790   error_code ec;
 791   path p = current_path(ec);
 792   if (ec)
 793     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get current path", ec));
 794   return p;
 795 }
 796
 797 fs::path
 798 fs::current_path(error_code& ec)
 799 {
 800   path p;
 801 #ifdef _GLIBCXX_HAVE_UNISTD_H
 802 #ifdef __GLIBC__
 803   if (char_ptr cwd = char_ptr{::getcwd(nullptr, 0)})
 804     {
 805       p.assign(cwd.get());
 806       ec.clear();
 807     }
 808   else
 809     ec.assign(errno, std::generic_category());
 810 #else
 811   long path_max = pathconf(".", _PC_PATH_MAX);
 812   size_t size;
 813   if (path_max == -1)
 814       size = 1024;
 815   else if (path_max > 10240)
 816       size = 10240;
 817   else
 818       size = path_max;
 819   for (char_ptr buf; p.empty(); size *= 2)
 820     {
 821       buf.reset((char*)malloc(size));
 822       if (buf)
 823         {
 824           if (getcwd(buf.get(), size))
 825             {
 826               p.assign(buf.get());
 827               ec.clear();
 828             }
 829           else if (errno != ERANGE)
 830             {
 831               ec.assign(errno, std::generic_category());
 832               return {};
 833             }
 834         }
 835       else
 836         {
 837           ec = std::make_error_code(std::errc::not_enough_memory);
 838           return {};
 839         }
 840     }
 841 #endif  // __GLIBC__
 842 #else   // _GLIBCXX_HAVE_UNISTD_H
 843   ec = std::make_error_code(std::errc::not_supported);
 844 #endif
 845   return p;
 846 }
 847
 848 void
 849 fs::current_path(const path& p)
 850 {
 851   error_code ec;
 852   current_path(p, ec);
 853   if (ec)
 854     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set current path", ec));
 855 }
 856
 857 void
 858 fs::current_path(const path& p, error_code& ec) noexcept
 859 {
 860 #ifdef _GLIBCXX_HAVE_UNISTD_H
 861   if (::chdir(p.c_str()))
 862     ec.assign(errno, std::generic_category());
 863   else
 864     ec.clear();
 865 #else
 866   ec = std::make_error_code(std::errc::not_supported);
 867 #endif
 868 }
 869
 870 bool
 871 fs::equivalent(const path& p1, const path& p2)
 872 {
 873   error_code ec;
 874   auto result = equivalent(p1, p2, ec);
 875   if (ec)
 876     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check file equivalence",
 877           p1, p2, ec));
 878   return result;
 879 }
 880
 881 bool
 882 fs::equivalent(const path& p1, const path& p2, error_code& ec) noexcept
 883 {
 884 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 885   int err = 0;
 886   file_status s1, s2;
 887   stat_type st1, st2;
 888   if (::stat(p1.c_str(), &st1) == 0)
 889     s1 = make_file_status(st1);
 890   else if (is_not_found_errno(errno))
 891     s1.type(file_type::not_found);
 892   else
 893     err = errno;
 894
 895   if (::stat(p2.c_str(), &st2) == 0)
 896     s2 = make_file_status(st2);
 897   else if (is_not_found_errno(errno))
 898     s2.type(file_type::not_found);
 899   else
 900     err = errno;
 901
 902   if (exists(s1) && exists(s2))
 903     {
 904       if (is_other(s1) && is_other(s2))
 905         {
 906           ec = std::make_error_code(std::errc::not_supported);
 907           return false;
 908         }
 909       ec.clear();
 910       if (is_other(s1) || is_other(s2))
 911         return false;
 912       return st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino;
 913     }
 914   else if (!exists(s1) && !exists(s2))
 915     ec = std::make_error_code(std::errc::no_such_file_or_directory);
 916   else if (err)
 917     ec.assign(err, std::generic_category());
 918   else
 919     ec.clear();
 920   return false;
 921 #else
 922   ec = std::make_error_code(std::errc::not_supported);
 923 #endif
 924   return false;
 925 }
 926
 927 std::uintmax_t
 928 fs::file_size(const path& p)
 929 {
 930   error_code ec;
 931   auto sz = file_size(p, ec);
 932   if (ec)
 933     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get file size", p, ec));
 934   return sz;
 935 }
 936
 937 namespace
 938 {
 939   template<typename Accessor, typename T>
 940     inline T
 941     do_stat(const fs::path& p, std::error_code& ec, Accessor f, T deflt)
 942     {
 943 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
 944       fs::stat_type st;
 945       if (::stat(p.c_str(), &st))
 946         {
 947           ec.assign(errno, std::generic_category());
 948           return deflt;
 949         }
 950       ec.clear();
 951       return f(st);
 952 #else
 953       ec = std::make_error_code(std::errc::not_supported);
 954       return deflt;
 955 #endif
 956     }
 957 }
 958
 959 std::uintmax_t
 960 fs::file_size(const path& p, error_code& ec) noexcept
 961 {
 962   struct S
 963   {
 964     S(const stat_type& st) : type(make_file_type(st)), size(st.st_size) { }
 965     S() : type(file_type::not_found) { }
 966     file_type type;
 967     size_t size;
 968   };
 969   auto s = do_stat(p, ec, [](const auto& st) { return S{st}; }, S{});
 970   if (s.type == file_type::regular)
 971     return s.size;
 972   if (!ec)
 973     {
 974       if (s.type == file_type::directory)
 975         ec = std::make_error_code(std::errc::is_a_directory);
 976       else
 977         ec = std::make_error_code(std::errc::not_supported);
 978     }
 979   return -1;
 980 }
 981
 982 std::uintmax_t
 983 fs::hard_link_count(const path& p)
 984 {
 985   error_code ec;
 986   auto count = hard_link_count(p, ec);
 987   if (ec)
 988     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get link count", p, ec));
 989   return count;
 990 }
 991
 992 std::uintmax_t
 993 fs::hard_link_count(const path& p, error_code& ec) noexcept
 994 {
 995   return do_stat(p, ec, std::mem_fn(&stat::st_nlink),
 996                  static_cast<uintmax_t>(-1));
 997 }
 998
 999 bool
1000 fs::is_empty(const path& p)
1001 {
1002   error_code ec;
1003   bool e = is_empty(p, ec);
1004   if (ec)
1005     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check if file is empty",
1006                                              p, ec));
1007   return e;
1008 }
1009
1010 bool
1011 fs::is_empty(const path& p, error_code& ec) noexcept
1012 {
1013   auto s = status(p, ec);
1014   if (ec)
1015     return false;
1016   bool empty = fs::is_directory(s)
1017     ? fs::directory_iterator(p, ec) == fs::directory_iterator()
1018     : fs::file_size(p, ec) == 0;
1019   return ec ? false : empty;
1020 }
1021
1022 fs::file_time_type
1023 fs::last_write_time(const path& p)
1024 {
1025   error_code ec;
1026   auto t = last_write_time(p, ec);
1027   if (ec)
1028     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get file time", p, ec));
1029   return t;
1030 }
1031
1032 fs::file_time_type
1033 fs::last_write_time(const path& p, error_code& ec) noexcept
1034 {
1035   return do_stat(p, ec, [&ec](const auto& st) { return file_time(st, ec); },
1036                  file_time_type::min());
1037 }
1038
1039 void
1040 fs::last_write_time(const path& p, file_time_type new_time)
1041 {
1042   error_code ec;
1043   last_write_time(p, new_time, ec);
1044   if (ec)
1045     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set file time", p, ec));
1046 }
1047
1048 void
1049 fs::last_write_time(const path& p __attribute__((__unused__)),
1050                     file_time_type new_time, error_code& ec) noexcept
1051 {
1052   auto d = new_time.time_since_epoch();
1053   auto s = chrono::duration_cast<chrono::seconds>(d);
1054 #if _GLIBCXX_USE_UTIMENSAT
1055   auto ns = chrono::duration_cast<chrono::nanoseconds>(d - s);
1056   if (ns < ns.zero()) // tv_nsec must be non-negative and less than 10e9.
1057     {
1058       --s;
1059       ns += chrono::seconds(1);
1060     }
1061   struct ::timespec ts[2];
1062   ts[0].tv_sec = 0;
1063   ts[0].tv_nsec = UTIME_OMIT;
1064   ts[1].tv_sec = static_cast<std::time_t>(s.count());
1065   ts[1].tv_nsec = static_cast<long>(ns.count());
1066   if (::utimensat(AT_FDCWD, p.c_str(), ts, 0))
1067     ec.assign(errno, std::generic_category());
1068   else
1069     ec.clear();
1070 #elif _GLIBCXX_HAVE_UTIME_H
1071   ::utimbuf times;
1072   times.modtime = s.count();
1073   times.actime = do_stat(p, ec, [](const auto& st) { return st.st_atime; },
1074                          times.modtime);
1075   if (::utime(p.c_str(), &times))
1076     ec.assign(errno, std::generic_category());
1077   else
1078     ec.clear();
1079 #else
1080   ec = std::make_error_code(std::errc::not_supported);
1081 #endif
1082 }
1083
1084 void
1085 fs::permissions(const path& p, perms prms, perm_options opts)
1086 {
1087   error_code ec;
1088   permissions(p, prms, opts, ec);
1089   if (ec)
1090     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set permissions", p, ec));
1091 }
1092
1093 void
1094 fs::permissions(const path& p, perms prms, perm_options opts,
1095                 error_code& ec) noexcept
1096 {
1097   const bool replace = is_set(opts, perm_options::replace);
1098   const bool add = is_set(opts, perm_options::add);
1099   const bool remove = is_set(opts, perm_options::remove);
1100   const bool nofollow = is_set(opts, perm_options::nofollow);
1101   if (((int)replace + (int)add + (int)remove) != 1)
1102     {
1103       ec = std::make_error_code(std::errc::invalid_argument);
1104       return;
1105     }
1106
1107   prms &= perms::mask;
1108
1109   file_status st;
1110   if (add || remove || nofollow)
1111     {
1112       st = nofollow ? symlink_status(p, ec) : status(p, ec);
1113       if (ec)
1114         return;
1115       auto curr = st.permissions();
1116       if (add)
1117         prms |= curr;
1118       else if (remove)
1119         prms = curr & ~prms;
1120     }
1121
1122   int err = 0;
1123 #if _GLIBCXX_USE_FCHMODAT
1124   const int flag = (nofollow && is_symlink(st)) ? AT_SYMLINK_NOFOLLOW : 0;
1125   if (::fchmodat(AT_FDCWD, p.c_str(), static_cast<mode_t>(prms), flag))
1126     err = errno;
1127 #else
1128   if (nofollow && is_symlink(st))
1129     ec = std::make_error_code(std::errc::operation_not_supported);
1130   else if (::chmod(p.c_str(), static_cast<mode_t>(prms)))
1131     err = errno;
1132 #endif
1133
1134   if (err)
1135     ec.assign(err, std::generic_category());
1136   else
1137     ec.clear();
1138 }
1139
1140 fs::path
1141 fs::proximate(const path& p, const path& base)
1142 {
1143   return weakly_canonical(p).lexically_proximate(weakly_canonical(base));
1144 }
1145
1146 fs::path
1147 fs::proximate(const path& p, const path& base, error_code& ec)
1148 {
1149   path result;
1150   const auto p2 = weakly_canonical(p, ec);
1151   if (!ec)
1152     {
1153       const auto base2 = weakly_canonical(base, ec);
1154       if (!ec)
1155         result = p2.lexically_proximate(base2);
1156     }
1157   return result;
1158 }
1159
1160 fs::path
1161 fs::read_symlink(const path& p)
1162 {
1163   error_code ec;
1164   path tgt = read_symlink(p, ec);
1165   if (ec)
1166     _GLIBCXX_THROW_OR_ABORT(filesystem_error("read_symlink", p, ec));
1167   return tgt;
1168 }
1169
1170 fs::path fs::read_symlink(const path& p, error_code& ec)
1171 {
1172   path result;
1173 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
1174   stat_type st;
1175   if (::lstat(p.c_str(), &st))
1176     {
1177       ec.assign(errno, std::generic_category());
1178       return result;
1179     }
1180   std::string buf(st.st_size ? st.st_size + 1 : 128, '\0');
1181   do
1182     {
1183       ssize_t len = ::readlink(p.c_str(), buf.data(), buf.size());
1184       if (len == -1)
1185         {
1186           ec.assign(errno, std::generic_category());
1187           return result;
1188         }
1189       else if (len == (ssize_t)buf.size())
1190         {
1191           if (buf.size() > 4096)
1192             {
1193               ec.assign(ENAMETOOLONG, std::generic_category());
1194               return result;
1195             }
1196           buf.resize(buf.size() * 2);
1197         }
1198       else
1199         {
1200           buf.resize(len);
1201           result.assign(buf);
1202           ec.clear();
1203           break;
1204         }
1205     }
1206   while (true);
1207 #else
1208   ec = std::make_error_code(std::errc::not_supported);
1209 #endif
1210   return result;
1211 }
1212
1213 fs::path
1214 fs::relative(const path& p, const path& base)
1215 {
1216   return weakly_canonical(p).lexically_relative(weakly_canonical(base));
1217 }
1218
1219 fs::path
1220 fs::relative(const path& p, const path& base, error_code& ec)
1221 {
1222   auto result = weakly_canonical(p, ec);
1223   fs::path cbase;
1224   if (!ec)
1225     cbase = weakly_canonical(base, ec);
1226   if (!ec)
1227     result = result.lexically_relative(cbase);
1228   if (ec)
1229     result.clear();
1230   return result;
1231 }
1232
1233 bool
1234 fs::remove(const path& p)
1235 {
1236   error_code ec;
1237   bool result = fs::remove(p, ec);
1238   if (ec)
1239     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot remove", p, ec));
1240   return result;
1241 }
1242
1243 bool
1244 fs::remove(const path& p, error_code& ec) noexcept
1245 {
1246   if (exists(symlink_status(p, ec)))
1247     {
1248       if (::remove(p.c_str()) == 0)
1249         {
1250           ec.clear();
1251           return true;
1252         }
1253       else
1254         ec.assign(errno, std::generic_category());
1255     }
1256   return false;
1257 }
1258
1259
1260 std::uintmax_t
1261 fs::remove_all(const path& p)
1262 {
1263   error_code ec;
1264   bool result = remove_all(p, ec);
1265   if (ec)
1266     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot remove all", p, ec));
1267   return result;
1268 }
1269
1270 std::uintmax_t
1271 fs::remove_all(const path& p, error_code& ec) noexcept
1272 {
1273   auto fs = symlink_status(p, ec);
1274   uintmax_t count = 0;
1275   if (!ec && fs.type() == file_type::directory)
1276     for (directory_iterator d(p, ec), end; !ec && d != end; ++d)
1277       count += fs::remove_all(d->path(), ec);
1278   if (ec)
1279     return -1;
1280   return fs::remove(p, ec) ? ++count : -1;  // fs:remove() calls ec.clear()
1281 }
1282
1283 void
1284 fs::rename(const path& from, const path& to)
1285 {
1286   error_code ec;
1287   rename(from, to, ec);
1288   if (ec)
1289     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot rename", from, to, ec));
1290 }
1291
1292 void
1293 fs::rename(const path& from, const path& to, error_code& ec) noexcept
1294 {
1295   if (::rename(from.c_str(), to.c_str()))
1296     ec.assign(errno, std::generic_category());
1297   else
1298     ec.clear();
1299 }
1300
1301 void
1302 fs::resize_file(const path& p, uintmax_t size)
1303 {
1304   error_code ec;
1305   resize_file(p, size, ec);
1306   if (ec)
1307     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot resize file", p, ec));
1308 }
1309
1310 void
1311 fs::resize_file(const path& p, uintmax_t size, error_code& ec) noexcept
1312 {
1313 #ifdef _GLIBCXX_HAVE_UNISTD_H
1314   if (size > static_cast<uintmax_t>(std::numeric_limits<off_t>::max()))
1315     ec.assign(EINVAL, std::generic_category());
1316   else if (::truncate(p.c_str(), size))
1317     ec.assign(errno, std::generic_category());
1318   else
1319     ec.clear();
1320 #else
1321   ec = std::make_error_code(std::errc::not_supported);
1322 #endif
1323 }
1324
1325
1326 fs::space_info
1327 fs::space(const path& p)
1328 {
1329   error_code ec;
1330   space_info s = space(p, ec);
1331   if (ec)
1332     _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot get free space", p, ec));
1333   return s;
1334 }
1335
1336 fs::space_info
1337 fs::space(const path& p, error_code& ec) noexcept
1338 {
1339   space_info info = {
1340     static_cast<uintmax_t>(-1),
1341     static_cast<uintmax_t>(-1),
1342     static_cast<uintmax_t>(-1)
1343   };
1344 #ifdef _GLIBCXX_HAVE_SYS_STATVFS_H
1345   struct ::statvfs f;
1346   if (::statvfs(p.c_str(), &f))
1347       ec.assign(errno, std::generic_category());
1348   else
1349     {
1350       info = space_info{
1351         f.f_blocks * f.f_frsize,
1352         f.f_bfree * f.f_frsize,
1353         f.f_bavail * f.f_frsize
1354       };
1355       ec.clear();
1356     }
1357 #else
1358   ec = std::make_error_code(std::errc::not_supported);
1359 #endif
1360   return info;
1361 }
1362
1363 #ifdef _GLIBCXX_HAVE_SYS_STAT_H
1364 fs::file_status
1365 fs::status(const fs::path& p, error_code& ec) noexcept
1366 {
1367   file_status status;
1368   stat_type st;
1369   if (::stat(p.c_str(), &st))
1370     {
1371       int err = errno;
1372       ec.assign(err, std::generic_category());
1373       if (is_not_found_errno(err))
1374         status.type(file_type::not_found);
1375 #ifdef EOVERFLOW
1376       else if (err == EOVERFLOW)
1377         status.type(file_type::unknown);
1378 #endif
1379     }
1380   else
1381     {
1382       status = make_file_status(st);
1383       ec.clear();
1384     }
1385   return status;
1386 }
1387
1388 fs::file_status
1389 fs::symlink_status(const fs::path& p, std::error_code& ec) noexcept
1390 {
1391   file_status status;
1392   stat_type st;
1393   if (::lstat(p.c_str(), &st))
1394     {
1395       int err = errno;
1396       ec.assign(err, std::generic_category());
1397       if (is_not_found_errno(err))
1398         status.type(file_type::not_found);
1399     }
1400   else
1401     {
1402       status = make_file_status(st);
1403       ec.clear();
1404     }
1405   return status;
1406 }
1407 #endif
1408
1409 fs::file_status
1410 fs::status(const fs::path& p)
1411 {
1412   std::error_code ec;
1413   auto result = status(p, ec);
1414   if (result.type() == file_type::none)
1415     _GLIBCXX_THROW_OR_ABORT(filesystem_error("status", p, ec));
1416   return result;
1417 }
1418
1419 fs::file_status
1420 fs::symlink_status(const fs::path& p)
1421 {
1422   std::error_code ec;
1423   auto result = symlink_status(p, ec);
1424   if (result.type() == file_type::none)
1425     _GLIBCXX_THROW_OR_ABORT(filesystem_error("symlink_status", p, ec));
1426   return result;
1427 }
1428
1429 fs::path fs::temp_directory_path()
1430 {
1431   error_code ec;
1432   path tmp = temp_directory_path(ec);
1433   if (ec)
1434     _GLIBCXX_THROW_OR_ABORT(filesystem_error("temp_directory_path", ec));
1435   return tmp;
1436 }
1437
1438 fs::path fs::temp_directory_path(error_code& ec)
1439 {
1440 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1441   ec = std::make_error_code(std::errc::not_supported);
1442   return {}; // TODO
1443 #else
1444   const char* tmpdir = nullptr;
1445   const char* env[] = { "TMPDIR", "TMP", "TEMP", "TEMPDIR", nullptr };
1446   for (auto e = env; tmpdir == nullptr && *e != nullptr; ++e)
1447     tmpdir = ::getenv(*e);
1448   path p = tmpdir ? tmpdir : "/tmp";
1449   auto st = status(p, ec);
1450   if (!ec)
1451     {
1452       if (is_directory(st))
1453         {
1454           ec.clear();
1455           return p;
1456         }
1457       else
1458         ec = std::make_error_code(std::errc::not_a_directory);
1459     }
1460   return {};
1461 #endif
1462 }
1463
1464 fs::path
1465 fs::weakly_canonical(const path& p)
1466 {
1467   path result;
1468   if (exists(status(p)))
1469     return canonical(p);
1470
1471   path tmp;
1472   auto iter = p.begin(), end = p.end();
1473   // find leading elements of p that exist:
1474   while (iter != end)
1475     {
1476       tmp = result / *iter;
1477       if (exists(status(tmp)))
1478         swap(result, tmp);
1479       else
1480         break;
1481       ++iter;
1482     }
1483   // canonicalize:
1484   result = canonical(result);
1485   // append the non-existing elements:
1486   while (iter != end)
1487     result /= *iter++;
1488   // normalize:
1489   return result.lexically_normal();
1490 }
1491
1492 fs::path
1493 fs::weakly_canonical(const path& p, error_code& ec)
1494 {
1495   path result;
1496   file_status st = status(p, ec);
1497   if (exists(st))
1498     return canonical(p, ec);
1499   else if (status_known(st))
1500     ec.clear();
1501   else
1502     return result;
1503
1504   path tmp;
1505   auto iter = p.begin(), end = p.end();
1506   // find leading elements of p that exist:
1507   while (iter != end)
1508     {
1509       tmp = result / *iter;
1510       st = status(tmp, ec);
1511       if (exists(st))
1512         swap(result, tmp);
1513       else
1514         {
1515           if (status_known(st))
1516             ec.clear();
1517           break;
1518         }
1519       ++iter;
1520     }
1521   // canonicalize:
1522   if (!ec)
1523     result = canonical(result, ec);
1524   if (ec)
1525     result.clear();
1526   else
1527     {
1528       // append the non-existing elements:
1529       while (iter != end)
1530         result /= *iter++;
1531       // normalize:
1532       result = result.lexically_normal();
1533     }
1534   return result;
1535 }