libcxx/src/filesystem/directory_iterator.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <__assert>
  10 #include <__config>
  11 #include <errno.h>
  12 #include <filesystem>
  13 #include <stack>
  14 #include <utility>
  15
  16 #include "error.h"
  17 #include "file_descriptor.h"
  18
  19 #if defined(_LIBCPP_WIN32API)
  20 # define WIN32_LEAN_AND_MEAN
  21 # define NOMINMAX
  22 # include <windows.h>
  23 #else
  24 # include <dirent.h>   // for DIR & friends
  25 #endif
  26
  27 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
  28
  29 using detail::ErrorHandler;
  30
  31 #if defined(_LIBCPP_WIN32API)
  32 class __dir_stream {
  33 public:
  34   __dir_stream() = delete;
  35   __dir_stream& operator=(const __dir_stream&) = delete;
  36
  37   __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
  38                                                __root_(std::move(__ds.__root_)),
  39                                                __entry_(std::move(__ds.__entry_)) {
  40     __ds.__stream_ = INVALID_HANDLE_VALUE;
  41   }
  42
  43   __dir_stream(const path& root, directory_options opts, error_code& ec)
  44       : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
  45     if (root.native().empty()) {
  46       ec = make_error_code(errc::no_such_file_or_directory);
  47       return;
  48     }
  49     __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_);
  50     if (__stream_ == INVALID_HANDLE_VALUE) {
  51       ec = detail::make_windows_error(GetLastError());
  52       const bool ignore_permission_denied =
  53           bool(opts & directory_options::skip_permission_denied);
  54       if (ignore_permission_denied &&
  55           ec.value() == static_cast<int>(errc::permission_denied))
  56         ec.clear();
  57       return;
  58     }
  59     if (!assign())
  60       advance(ec);
  61   }
  62
  63   ~__dir_stream() noexcept {
  64     if (__stream_ == INVALID_HANDLE_VALUE)
  65       return;
  66     close();
  67   }
  68
  69   bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
  70
  71   bool advance(error_code& ec) {
  72     while (::FindNextFileW(__stream_, &__data_)) {
  73       if (assign())
  74         return true;
  75     }
  76     close();
  77     return false;
  78   }
  79
  80   bool assign() {
  81     if (!wcscmp(__data_.cFileName, L".") || !wcscmp(__data_.cFileName, L".."))
  82       return false;
  83     // FIXME: Cache more of this
  84     //directory_entry::__cached_data cdata;
  85     //cdata.__type_ = get_file_type(__data_);
  86     //cdata.__size_ = get_file_size(__data_);
  87     //cdata.__write_time_ = get_write_time(__data_);
  88     __entry_.__assign_iter_entry(
  89         __root_ / __data_.cFileName,
  90         directory_entry::__create_iter_result(detail::get_file_type(__data_)));
  91     return true;
  92   }
  93
  94 private:
  95   error_code close() noexcept {
  96     error_code ec;
  97     if (!::FindClose(__stream_))
  98       ec = detail::make_windows_error(GetLastError());
  99     __stream_ = INVALID_HANDLE_VALUE;
 100     return ec;
 101   }
 102
 103   HANDLE __stream_{INVALID_HANDLE_VALUE};
 104   WIN32_FIND_DATAW __data_;
 105
 106 public:
 107   path __root_;
 108   directory_entry __entry_;
 109 };
 110 #else
 111 class __dir_stream {
 112 public:
 113   __dir_stream() = delete;
 114   __dir_stream& operator=(const __dir_stream&) = delete;
 115
 116   __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_),
 117                                                 __root_(std::move(other.__root_)),
 118                                                 __entry_(std::move(other.__entry_)) {
 119     other.__stream_ = nullptr;
 120   }
 121
 122   __dir_stream(const path& root, directory_options opts, error_code& ec)
 123       : __stream_(nullptr), __root_(root) {
 124     if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
 125       ec = detail::capture_errno();
 126       const bool allow_eacces =
 127           bool(opts & directory_options::skip_permission_denied);
 128       if (allow_eacces && ec.value() == EACCES)
 129         ec.clear();
 130       return;
 131     }
 132     advance(ec);
 133   }
 134
 135   ~__dir_stream() noexcept {
 136     if (__stream_)
 137       close();
 138   }
 139
 140   bool good() const noexcept { return __stream_ != nullptr; }
 141
 142   bool advance(error_code& ec) {
 143     while (true) {
 144       auto str_type_pair = detail::posix_readdir(__stream_, ec);
 145       auto& str = str_type_pair.first;
 146       if (str == "." || str == "..") {
 147         continue;
 148       } else if (ec || str.empty()) {
 149         close();
 150         return false;
 151       } else {
 152         __entry_.__assign_iter_entry(
 153             __root_ / str,
 154             directory_entry::__create_iter_result(str_type_pair.second));
 155         return true;
 156       }
 157     }
 158   }
 159
 160 private:
 161   error_code close() noexcept {
 162     error_code m_ec;
 163     if (::closedir(__stream_) == -1)
 164       m_ec = detail::capture_errno();
 165     __stream_ = nullptr;
 166     return m_ec;
 167   }
 168
 169   DIR* __stream_{nullptr};
 170
 171 public:
 172   path __root_;
 173   directory_entry __entry_;
 174 };
 175 #endif
 176
 177 // directory_iterator
 178
 179 directory_iterator::directory_iterator(const path& p, error_code* ec,
 180                                        directory_options opts) {
 181   ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
 182
 183   error_code m_ec;
 184   __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
 185   if (ec)
 186     *ec = m_ec;
 187   if (!__imp_->good()) {
 188     __imp_.reset();
 189     if (m_ec)
 190       err.report(m_ec);
 191   }
 192 }
 193
 194 directory_iterator& directory_iterator::__increment(error_code* ec) {
 195   _LIBCPP_ASSERT_UNCATEGORIZED(__imp_, "Attempting to increment an invalid iterator");
 196   ErrorHandler<void> err("directory_iterator::operator++()", ec);
 197
 198   error_code m_ec;
 199   if (!__imp_->advance(m_ec)) {
 200     path root = std::move(__imp_->__root_);
 201     __imp_.reset();
 202     if (m_ec)
 203       err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
 204   }
 205   return *this;
 206 }
 207
 208 directory_entry const& directory_iterator::__dereference() const {
 209   _LIBCPP_ASSERT_UNCATEGORIZED(__imp_, "Attempting to dereference an invalid iterator");
 210   return __imp_->__entry_;
 211 }
 212
 213 // recursive_directory_iterator
 214
 215 struct recursive_directory_iterator::__shared_imp {
 216   stack<__dir_stream> __stack_;
 217   directory_options __options_;
 218 };
 219
 220 recursive_directory_iterator::recursive_directory_iterator(
 221     const path& p, directory_options opt, error_code* ec)
 222     : __imp_(nullptr), __rec_(true) {
 223   ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
 224
 225   error_code m_ec;
 226   __dir_stream new_s(p, opt, m_ec);
 227   if (m_ec)
 228     err.report(m_ec);
 229   if (m_ec || !new_s.good())
 230     return;
 231
 232   __imp_ = make_shared<__shared_imp>();
 233   __imp_->__options_ = opt;
 234   __imp_->__stack_.push(std::move(new_s));
 235 }
 236
 237 void recursive_directory_iterator::__pop(error_code* ec) {
 238   _LIBCPP_ASSERT_UNCATEGORIZED(__imp_, "Popping the end iterator");
 239   if (ec)
 240     ec->clear();
 241   __imp_->__stack_.pop();
 242   if (__imp_->__stack_.size() == 0)
 243     __imp_.reset();
 244   else
 245     __advance(ec);
 246 }
 247
 248 directory_options recursive_directory_iterator::options() const {
 249   return __imp_->__options_;
 250 }
 251
 252 int recursive_directory_iterator::depth() const {
 253   return __imp_->__stack_.size() - 1;
 254 }
 255
 256 const directory_entry& recursive_directory_iterator::__dereference() const {
 257   return __imp_->__stack_.top().__entry_;
 258 }
 259
 260 recursive_directory_iterator&
 261 recursive_directory_iterator::__increment(error_code* ec) {
 262   if (ec)
 263     ec->clear();
 264   if (recursion_pending()) {
 265     if (__try_recursion(ec) || (ec && *ec))
 266       return *this;
 267   }
 268   __rec_ = true;
 269   __advance(ec);
 270   return *this;
 271 }
 272
 273 void recursive_directory_iterator::__advance(error_code* ec) {
 274   ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
 275
 276   const directory_iterator end_it;
 277   auto& stack = __imp_->__stack_;
 278   error_code m_ec;
 279   while (stack.size() > 0) {
 280     if (stack.top().advance(m_ec))
 281       return;
 282     if (m_ec)
 283       break;
 284     stack.pop();
 285   }
 286
 287   if (m_ec) {
 288     path root = std::move(stack.top().__root_);
 289     __imp_.reset();
 290     err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
 291   } else {
 292     __imp_.reset();
 293   }
 294 }
 295
 296 bool recursive_directory_iterator::__try_recursion(error_code* ec) {
 297   ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
 298
 299   bool rec_sym = bool(options() & directory_options::follow_directory_symlink);
 300
 301   auto& curr_it = __imp_->__stack_.top();
 302
 303   bool skip_rec = false;
 304   error_code m_ec;
 305   if (!rec_sym) {
 306     file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
 307     if (m_ec && status_known(st))
 308       m_ec.clear();
 309     if (m_ec || is_symlink(st) || !is_directory(st))
 310       skip_rec = true;
 311   } else {
 312     file_status st(curr_it.__entry_.__get_ft(&m_ec));
 313     if (m_ec && status_known(st))
 314       m_ec.clear();
 315     if (m_ec || !is_directory(st))
 316       skip_rec = true;
 317   }
 318
 319   if (!skip_rec) {
 320     __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
 321     if (new_it.good()) {
 322       __imp_->__stack_.push(std::move(new_it));
 323       return true;
 324     }
 325   }
 326   if (m_ec) {
 327     const bool allow_eacess =
 328         bool(__imp_->__options_ & directory_options::skip_permission_denied);
 329     if (m_ec.value() == EACCES && allow_eacess) {
 330       if (ec)
 331         ec->clear();
 332     } else {
 333       path at_ent = std::move(curr_it.__entry_.__p_);
 334       __imp_.reset();
 335       err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
 336                  at_ent.c_str());
 337     }
 338   }
 339   return false;
 340 }
 341
 342 _LIBCPP_END_NAMESPACE_FILESYSTEM