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

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