1 // Class filesystem::directory_entry etc. -*- C++ -*- 2 3 // Copyright (C) 2014-2019 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 <bits/largefile-config.h> 30 #include <filesystem> 31 #include <utility> 32 #include <stack> 33 #include <string.h> 34 #include <errno.h> 35 #define _GLIBCXX_BEGIN_NAMESPACE_FILESYSTEM namespace filesystem { 36 #define _GLIBCXX_END_NAMESPACE_FILESYSTEM } 37 #include "../filesystem/dir-common.h" 38 39 namespace fs = std::filesystem; 40 namespace posix = std::filesystem::__gnu_posix; 41 42 template class std::__shared_ptr<fs::_Dir>; 43 template class std::__shared_ptr<fs::recursive_directory_iterator::_Dir_stack>; 44 45 struct fs::_Dir : _Dir_base 46 { 47 _Dir(const fs::path& p, bool skip_permission_denied, error_code& ec) 48 : _Dir_base(p.c_str(), skip_permission_denied, ec) 49 { 50 if (!ec) 51 path = p; 52 } 53 54 _Dir(posix::DIR* dirp, const path& p) : _Dir_base(dirp), path(p) { } 55 56 _Dir(_Dir&&) = default; 57 58 // Returns false when the end of the directory entries is reached. 59 // Reports errors by setting ec. 60 bool advance(bool skip_permission_denied, error_code& ec) noexcept 61 { 62 if (const auto entp = _Dir_base::advance(skip_permission_denied, ec)) 63 { 64 auto name = path; 65 name /= entp->d_name; 66 file_type type = file_type::none; 67 #ifdef _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE 68 // Even if the OS supports dirent::d_type the filesystem might not: 69 if (entp->d_type != DT_UNKNOWN) 70 type = get_file_type(*entp); 71 #endif 72 entry = fs::directory_entry{std::move(name), type}; 73 return true; 74 } 75 else if (!ec) 76 { 77 // reached the end 78 entry = {}; 79 } 80 return false; 81 } 82 83 bool advance(error_code& ec) noexcept { return advance(false, ec); } 84 85 // Returns false when the end of the directory entries is reached. 86 // Reports errors by throwing. 87 bool advance(bool skip_permission_denied = false) 88 { 89 error_code ec; 90 const bool ok = advance(skip_permission_denied, ec); 91 if (ec) 92 _GLIBCXX_THROW_OR_ABORT(filesystem_error( 93 "directory iterator cannot advance", ec)); 94 return ok; 95 } 96 97 bool should_recurse(bool follow_symlink, error_code& ec) const 98 { 99 file_type type = entry._M_type; 100 if (type == file_type::none) 101 { 102 type = entry.symlink_status(ec).type(); 103 if (ec) 104 return false; 105 } 106 107 if (type == file_type::directory) 108 return true; 109 if (type == file_type::symlink) 110 return follow_symlink && is_directory(entry.status(ec)); 111 return false; 112 } 113 114 fs::path path; 115 directory_entry entry; 116 }; 117 118 namespace 119 { 120 template<typename Bitmask> 121 inline bool 122 is_set(Bitmask obj, Bitmask bits) 123 { 124 return (obj & bits) != Bitmask::none; 125 } 126 } 127 128 fs::directory_iterator:: 129 directory_iterator(const path& p, directory_options options, error_code* ecptr) 130 { 131 const bool skip_permission_denied 132 = is_set(options, directory_options::skip_permission_denied); 133 134 error_code ec; 135 _Dir dir(p, skip_permission_denied, ec); 136 137 if (dir.dirp) 138 { 139 auto sp = std::__make_shared<fs::_Dir>(std::move(dir)); 140 if (sp->advance(skip_permission_denied, ec)) 141 _M_dir.swap(sp); 142 } 143 if (ecptr) 144 *ecptr = ec; 145 else if (ec) 146 _GLIBCXX_THROW_OR_ABORT(fs::filesystem_error( 147 "directory iterator cannot open directory", p, ec)); 148 } 149 150 const fs::directory_entry& 151 fs::directory_iterator::operator*() const 152 { 153 if (!_M_dir) 154 _GLIBCXX_THROW_OR_ABORT(filesystem_error( 155 "non-dereferenceable directory iterator", 156 std::make_error_code(errc::invalid_argument))); 157 return _M_dir->entry; 158 } 159 160 fs::directory_iterator& 161 fs::directory_iterator::operator++() 162 { 163 if (!_M_dir) 164 _GLIBCXX_THROW_OR_ABORT(filesystem_error( 165 "cannot advance non-dereferenceable directory iterator", 166 std::make_error_code(errc::invalid_argument))); 167 if (!_M_dir->advance()) 168 _M_dir.reset(); 169 return *this; 170 } 171 172 fs::directory_iterator& 173 fs::directory_iterator::increment(error_code& ec) 174 { 175 if (!_M_dir) 176 { 177 ec = std::make_error_code(errc::invalid_argument); 178 return *this; 179 } 180 if (!_M_dir->advance(ec)) 181 _M_dir.reset(); 182 return *this; 183 } 184 185 struct fs::recursive_directory_iterator::_Dir_stack : std::stack<_Dir> 186 { 187 _Dir_stack(directory_options opts, posix::DIR* dirp, const path& p) 188 : options(opts), pending(true) 189 { 190 this->emplace(dirp, p); 191 } 192 193 const directory_options options; 194 bool pending; 195 196 void clear() { c.clear(); } 197 }; 198 199 fs::recursive_directory_iterator:: 200 recursive_directory_iterator(const path& p, directory_options options, 201 error_code* ecptr) 202 { 203 if (posix::DIR* dirp = posix::opendir(p.c_str())) 204 { 205 if (ecptr) 206 ecptr->clear(); 207 auto sp = std::__make_shared<_Dir_stack>(options, dirp, p); 208 if (ecptr ? sp->top().advance(*ecptr) : sp->top().advance()) 209 _M_dirs.swap(sp); 210 } 211 else 212 { 213 const int err = errno; 214 if (err == EACCES 215 && is_set(options, fs::directory_options::skip_permission_denied)) 216 { 217 if (ecptr) 218 ecptr->clear(); 219 return; 220 } 221 222 if (!ecptr) 223 _GLIBCXX_THROW_OR_ABORT(filesystem_error( 224 "recursive directory iterator cannot open directory", p, 225 std::error_code(err, std::generic_category()))); 226 227 ecptr->assign(err, std::generic_category()); 228 } 229 } 230 231 fs::recursive_directory_iterator::~recursive_directory_iterator() = default; 232 233 fs::directory_options 234 fs::recursive_directory_iterator::options() const noexcept 235 { 236 return _M_dirs->options; 237 } 238 239 int 240 fs::recursive_directory_iterator::depth() const noexcept 241 { 242 return int(_M_dirs->size()) - 1; 243 } 244 245 bool 246 fs::recursive_directory_iterator::recursion_pending() const noexcept 247 { 248 return _M_dirs->pending; 249 } 250 251 const fs::directory_entry& 252 fs::recursive_directory_iterator::operator*() const noexcept 253 { 254 return _M_dirs->top().entry; 255 } 256 257 fs::recursive_directory_iterator& 258 fs::recursive_directory_iterator:: 259 operator=(const recursive_directory_iterator& other) noexcept = default; 260 261 fs::recursive_directory_iterator& 262 fs::recursive_directory_iterator:: 263 operator=(recursive_directory_iterator&& other) noexcept = default; 264 265 fs::recursive_directory_iterator& 266 fs::recursive_directory_iterator::operator++() 267 { 268 error_code ec; 269 increment(ec); 270 if (ec) 271 _GLIBCXX_THROW_OR_ABORT(filesystem_error( 272 "cannot increment recursive directory iterator", ec)); 273 return *this; 274 } 275 276 fs::recursive_directory_iterator& 277 fs::recursive_directory_iterator::increment(error_code& ec) 278 { 279 if (!_M_dirs) 280 { 281 ec = std::make_error_code(errc::invalid_argument); 282 return *this; 283 } 284 285 const bool follow 286 = is_set(_M_dirs->options, directory_options::follow_directory_symlink); 287 const bool skip_permission_denied 288 = is_set(_M_dirs->options, directory_options::skip_permission_denied); 289 290 auto& top = _M_dirs->top(); 291 292 if (std::exchange(_M_dirs->pending, true) && top.should_recurse(follow, ec)) 293 { 294 _Dir dir(top.entry.path(), skip_permission_denied, ec); 295 if (ec) 296 { 297 _M_dirs.reset(); 298 return *this; 299 } 300 if (dir.dirp) 301 _M_dirs->push(std::move(dir)); 302 } 303 304 while (!_M_dirs->top().advance(skip_permission_denied, ec) && !ec) 305 { 306 _M_dirs->pop(); 307 if (_M_dirs->empty()) 308 { 309 _M_dirs.reset(); 310 return *this; 311 } 312 } 313 return *this; 314 } 315 316 void 317 fs::recursive_directory_iterator::pop(error_code& ec) 318 { 319 if (!_M_dirs) 320 { 321 ec = std::make_error_code(errc::invalid_argument); 322 return; 323 } 324 325 const bool skip_permission_denied 326 = is_set(_M_dirs->options, directory_options::skip_permission_denied); 327 328 do { 329 _M_dirs->pop(); 330 if (_M_dirs->empty()) 331 { 332 _M_dirs.reset(); 333 ec.clear(); 334 return; 335 } 336 } while (!_M_dirs->top().advance(skip_permission_denied, ec)); 337 } 338 339 void 340 fs::recursive_directory_iterator::pop() 341 { 342 error_code ec; 343 pop(ec); 344 if (ec) 345 _GLIBCXX_THROW_OR_ABORT(filesystem_error(_M_dirs 346 ? "recursive directory iterator cannot pop" 347 : "non-dereferenceable recursive directory iterator cannot pop", 348 ec)); 349 } 350 351 void 352 fs::recursive_directory_iterator::disable_recursion_pending() noexcept 353 { 354 _M_dirs->pending = false; 355 } 356