1 //===------------------ directory_iterator.cpp ----------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "filesystem" 10 #include "__config" 11 #if defined(_LIBCPP_WIN32API) 12 #define WIN32_LEAN_AND_MEAN 13 #include <windows.h> 14 #else 15 #include <dirent.h> 16 #endif 17 #include <errno.h> 18 19 #include "filesystem_common.h" 20 21 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM 22 23 namespace detail { 24 namespace { 25 26 #if !defined(_LIBCPP_WIN32API) 27 28 #if defined(DT_BLK) 29 template <class DirEntT, class = decltype(DirEntT::d_type)> 30 static file_type get_file_type(DirEntT* ent, int) { 31 switch (ent->d_type) { 32 case DT_BLK: 33 return file_type::block; 34 case DT_CHR: 35 return file_type::character; 36 case DT_DIR: 37 return file_type::directory; 38 case DT_FIFO: 39 return file_type::fifo; 40 case DT_LNK: 41 return file_type::symlink; 42 case DT_REG: 43 return file_type::regular; 44 case DT_SOCK: 45 return file_type::socket; 46 // Unlike in lstat, hitting "unknown" here simply means that the underlying 47 // filesystem doesn't support d_type. Report is as 'none' so we correctly 48 // set the cache to empty. 49 case DT_UNKNOWN: 50 break; 51 } 52 return file_type::none; 53 } 54 #endif // defined(DT_BLK) 55 56 template <class DirEntT> 57 static file_type get_file_type(DirEntT* ent, long) { 58 return file_type::none; 59 } 60 61 static pair<string_view, file_type> posix_readdir(DIR* dir_stream, 62 error_code& ec) { 63 struct dirent* dir_entry_ptr = nullptr; 64 errno = 0; // zero errno in order to detect errors 65 ec.clear(); 66 if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) { 67 if (errno) 68 ec = capture_errno(); 69 return {}; 70 } else { 71 return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)}; 72 } 73 } 74 #else 75 76 static file_type get_file_type(const WIN32_FIND_DATA& data) { 77 //auto attrs = data.dwFileAttributes; 78 // FIXME(EricWF) 79 return file_type::unknown; 80 } 81 static uintmax_t get_file_size(const WIN32_FIND_DATA& data) { 82 return (data.nFileSizeHigh * (MAXDWORD + 1)) + data.nFileSizeLow; 83 } 84 static file_time_type get_write_time(const WIN32_FIND_DATA& data) { 85 ULARGE_INTEGER tmp; 86 const FILETIME& time = data.ftLastWriteTime; 87 tmp.u.LowPart = time.dwLowDateTime; 88 tmp.u.HighPart = time.dwHighDateTime; 89 return file_time_type(file_time_type::duration(tmp.QuadPart)); 90 } 91 92 #endif 93 94 } // namespace 95 } // namespace detail 96 97 using detail::ErrorHandler; 98 99 #if defined(_LIBCPP_WIN32API) 100 class __dir_stream { 101 public: 102 __dir_stream() = delete; 103 __dir_stream& operator=(const __dir_stream&) = delete; 104 105 __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_), 106 __root_(move(__ds.__root_)), 107 __entry_(move(__ds.__entry_)) { 108 __ds.__stream_ = INVALID_HANDLE_VALUE; 109 } 110 111 __dir_stream(const path& root, directory_options opts, error_code& ec) 112 : __stream_(INVALID_HANDLE_VALUE), __root_(root) { 113 __stream_ = ::FindFirstFile(root.c_str(), &__data_); 114 if (__stream_ == INVALID_HANDLE_VALUE) { 115 ec = error_code(::GetLastError(), generic_category()); 116 const bool ignore_permission_denied = 117 bool(opts & directory_options::skip_permission_denied); 118 if (ignore_permission_denied && ec.value() == ERROR_ACCESS_DENIED) 119 ec.clear(); 120 return; 121 } 122 } 123 124 ~__dir_stream() noexcept { 125 if (__stream_ == INVALID_HANDLE_VALUE) 126 return; 127 close(); 128 } 129 130 bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; } 131 132 bool advance(error_code& ec) { 133 while (::FindNextFile(__stream_, &__data_)) { 134 if (!strcmp(__data_.cFileName, ".") || strcmp(__data_.cFileName, "..")) 135 continue; 136 // FIXME: Cache more of this 137 //directory_entry::__cached_data cdata; 138 //cdata.__type_ = get_file_type(__data_); 139 //cdata.__size_ = get_file_size(__data_); 140 //cdata.__write_time_ = get_write_time(__data_); 141 __entry_.__assign_iter_entry( 142 __root_ / __data_.cFileName, 143 directory_entry::__create_iter_result(detail::get_file_type(__data))); 144 return true; 145 } 146 ec = error_code(::GetLastError(), generic_category()); 147 close(); 148 return false; 149 } 150 151 private: 152 error_code close() noexcept { 153 error_code ec; 154 if (!::FindClose(__stream_)) 155 ec = error_code(::GetLastError(), generic_category()); 156 __stream_ = INVALID_HANDLE_VALUE; 157 return ec; 158 } 159 160 HANDLE __stream_{INVALID_HANDLE_VALUE}; 161 WIN32_FIND_DATA __data_; 162 163 public: 164 path __root_; 165 directory_entry __entry_; 166 }; 167 #else 168 class __dir_stream { 169 public: 170 __dir_stream() = delete; 171 __dir_stream& operator=(const __dir_stream&) = delete; 172 173 __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_), 174 __root_(move(other.__root_)), 175 __entry_(move(other.__entry_)) { 176 other.__stream_ = nullptr; 177 } 178 179 __dir_stream(const path& root, directory_options opts, error_code& ec) 180 : __stream_(nullptr), __root_(root) { 181 if ((__stream_ = ::opendir(root.c_str())) == nullptr) { 182 ec = detail::capture_errno(); 183 const bool allow_eacess = 184 bool(opts & directory_options::skip_permission_denied); 185 if (allow_eacess && ec.value() == EACCES) 186 ec.clear(); 187 return; 188 } 189 advance(ec); 190 } 191 192 ~__dir_stream() noexcept { 193 if (__stream_) 194 close(); 195 } 196 197 bool good() const noexcept { return __stream_ != nullptr; } 198 199 bool advance(error_code& ec) { 200 while (true) { 201 auto str_type_pair = detail::posix_readdir(__stream_, ec); 202 auto& str = str_type_pair.first; 203 if (str == "." || str == "..") { 204 continue; 205 } else if (ec || str.empty()) { 206 close(); 207 return false; 208 } else { 209 __entry_.__assign_iter_entry( 210 __root_ / str, 211 directory_entry::__create_iter_result(str_type_pair.second)); 212 return true; 213 } 214 } 215 } 216 217 private: 218 error_code close() noexcept { 219 error_code m_ec; 220 if (::closedir(__stream_) == -1) 221 m_ec = detail::capture_errno(); 222 __stream_ = nullptr; 223 return m_ec; 224 } 225 226 DIR* __stream_{nullptr}; 227 228 public: 229 path __root_; 230 directory_entry __entry_; 231 }; 232 #endif 233 234 // directory_iterator 235 236 directory_iterator::directory_iterator(const path& p, error_code* ec, 237 directory_options opts) { 238 ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p); 239 240 error_code m_ec; 241 __imp_ = make_shared<__dir_stream>(p, opts, m_ec); 242 if (ec) 243 *ec = m_ec; 244 if (!__imp_->good()) { 245 __imp_.reset(); 246 if (m_ec) 247 err.report(m_ec); 248 } 249 } 250 251 directory_iterator& directory_iterator::__increment(error_code* ec) { 252 _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator"); 253 ErrorHandler<void> err("directory_iterator::operator++()", ec); 254 255 error_code m_ec; 256 if (!__imp_->advance(m_ec)) { 257 path root = move(__imp_->__root_); 258 __imp_.reset(); 259 if (m_ec) 260 err.report(m_ec, "at root \"%s\"", root); 261 } 262 return *this; 263 } 264 265 directory_entry const& directory_iterator::__dereference() const { 266 _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator"); 267 return __imp_->__entry_; 268 } 269 270 // recursive_directory_iterator 271 272 struct recursive_directory_iterator::__shared_imp { 273 stack<__dir_stream> __stack_; 274 directory_options __options_; 275 }; 276 277 recursive_directory_iterator::recursive_directory_iterator( 278 const path& p, directory_options opt, error_code* ec) 279 : __imp_(nullptr), __rec_(true) { 280 ErrorHandler<void> err("recursive_directory_iterator", ec, &p); 281 282 error_code m_ec; 283 __dir_stream new_s(p, opt, m_ec); 284 if (m_ec) 285 err.report(m_ec); 286 if (m_ec || !new_s.good()) 287 return; 288 289 __imp_ = make_shared<__shared_imp>(); 290 __imp_->__options_ = opt; 291 __imp_->__stack_.push(move(new_s)); 292 } 293 294 void recursive_directory_iterator::__pop(error_code* ec) { 295 _LIBCPP_ASSERT(__imp_, "Popping the end iterator"); 296 if (ec) 297 ec->clear(); 298 __imp_->__stack_.pop(); 299 if (__imp_->__stack_.size() == 0) 300 __imp_.reset(); 301 else 302 __advance(ec); 303 } 304 305 directory_options recursive_directory_iterator::options() const { 306 return __imp_->__options_; 307 } 308 309 int recursive_directory_iterator::depth() const { 310 return __imp_->__stack_.size() - 1; 311 } 312 313 const directory_entry& recursive_directory_iterator::__dereference() const { 314 return __imp_->__stack_.top().__entry_; 315 } 316 317 recursive_directory_iterator& 318 recursive_directory_iterator::__increment(error_code* ec) { 319 if (ec) 320 ec->clear(); 321 if (recursion_pending()) { 322 if (__try_recursion(ec) || (ec && *ec)) 323 return *this; 324 } 325 __rec_ = true; 326 __advance(ec); 327 return *this; 328 } 329 330 void recursive_directory_iterator::__advance(error_code* ec) { 331 ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec); 332 333 const directory_iterator end_it; 334 auto& stack = __imp_->__stack_; 335 error_code m_ec; 336 while (stack.size() > 0) { 337 if (stack.top().advance(m_ec)) 338 return; 339 if (m_ec) 340 break; 341 stack.pop(); 342 } 343 344 if (m_ec) { 345 path root = move(stack.top().__root_); 346 __imp_.reset(); 347 err.report(m_ec, "at root \"%s\"", root); 348 } else { 349 __imp_.reset(); 350 } 351 } 352 353 bool recursive_directory_iterator::__try_recursion(error_code* ec) { 354 ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec); 355 356 bool rec_sym = bool(options() & directory_options::follow_directory_symlink); 357 358 auto& curr_it = __imp_->__stack_.top(); 359 360 bool skip_rec = false; 361 error_code m_ec; 362 if (!rec_sym) { 363 file_status st(curr_it.__entry_.__get_sym_ft(&m_ec)); 364 if (m_ec && status_known(st)) 365 m_ec.clear(); 366 if (m_ec || is_symlink(st) || !is_directory(st)) 367 skip_rec = true; 368 } else { 369 file_status st(curr_it.__entry_.__get_ft(&m_ec)); 370 if (m_ec && status_known(st)) 371 m_ec.clear(); 372 if (m_ec || !is_directory(st)) 373 skip_rec = true; 374 } 375 376 if (!skip_rec) { 377 __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec); 378 if (new_it.good()) { 379 __imp_->__stack_.push(move(new_it)); 380 return true; 381 } 382 } 383 if (m_ec) { 384 const bool allow_eacess = 385 bool(__imp_->__options_ & directory_options::skip_permission_denied); 386 if (m_ec.value() == EACCES && allow_eacess) { 387 if (ec) 388 ec->clear(); 389 } else { 390 path at_ent = move(curr_it.__entry_.__p_); 391 __imp_.reset(); 392 err.report(m_ec, "attempting recursion into \"%s\"", at_ent); 393 } 394 } 395 return false; 396 } 397 398 _LIBCPP_END_NAMESPACE_FILESYSTEM 399