file_enumerator_win.cc 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219
  1. // Copyright (c) 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/files/file_enumerator.h"
  5. #include <stdint.h>
  6. #include <string.h>
  7. #include "base/check_op.h"
  8. #include "base/notreached.h"
  9. #include "base/strings/string_util.h"
  10. #include "base/threading/scoped_blocking_call.h"
  11. #include "base/win/shlwapi.h"
  12. namespace base {
  13. namespace {
  14. FilePath BuildSearchFilter(FileEnumerator::FolderSearchPolicy policy,
  15. const FilePath& root_path,
  16. const FilePath::StringType& pattern) {
  17. // MATCH_ONLY policy filters incoming files by pattern on OS side. ALL policy
  18. // collects all files and filters them manually.
  19. switch (policy) {
  20. case FileEnumerator::FolderSearchPolicy::MATCH_ONLY:
  21. return root_path.Append(pattern);
  22. case FileEnumerator::FolderSearchPolicy::ALL:
  23. return root_path.Append(FILE_PATH_LITERAL("*"));
  24. }
  25. NOTREACHED();
  26. return {};
  27. }
  28. } // namespace
  29. // FileEnumerator::FileInfo ----------------------------------------------------
  30. FileEnumerator::FileInfo::FileInfo() {
  31. memset(&find_data_, 0, sizeof(find_data_));
  32. }
  33. bool FileEnumerator::FileInfo::IsDirectory() const {
  34. return (find_data().dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
  35. }
  36. FilePath FileEnumerator::FileInfo::GetName() const {
  37. return FilePath(find_data().cFileName);
  38. }
  39. int64_t FileEnumerator::FileInfo::GetSize() const {
  40. ULARGE_INTEGER size;
  41. size.HighPart = find_data().nFileSizeHigh;
  42. size.LowPart = find_data().nFileSizeLow;
  43. DCHECK_LE(size.QuadPart,
  44. static_cast<ULONGLONG>(std::numeric_limits<int64_t>::max()));
  45. return static_cast<int64_t>(size.QuadPart);
  46. }
  47. Time FileEnumerator::FileInfo::GetLastModifiedTime() const {
  48. return Time::FromFileTime(find_data().ftLastWriteTime);
  49. }
  50. // FileEnumerator --------------------------------------------------------------
  51. FileEnumerator::FileEnumerator(const FilePath& root_path,
  52. bool recursive,
  53. int file_type)
  54. : FileEnumerator(root_path,
  55. recursive,
  56. file_type,
  57. FilePath::StringType(),
  58. FolderSearchPolicy::MATCH_ONLY) {}
  59. FileEnumerator::FileEnumerator(const FilePath& root_path,
  60. bool recursive,
  61. int file_type,
  62. const FilePath::StringType& pattern)
  63. : FileEnumerator(root_path,
  64. recursive,
  65. file_type,
  66. pattern,
  67. FolderSearchPolicy::MATCH_ONLY) {}
  68. FileEnumerator::FileEnumerator(const FilePath& root_path,
  69. bool recursive,
  70. int file_type,
  71. const FilePath::StringType& pattern,
  72. FolderSearchPolicy folder_search_policy)
  73. : FileEnumerator(root_path,
  74. recursive,
  75. file_type,
  76. pattern,
  77. folder_search_policy,
  78. ErrorPolicy::IGNORE_ERRORS) {}
  79. FileEnumerator::FileEnumerator(const FilePath& root_path,
  80. bool recursive,
  81. int file_type,
  82. const FilePath::StringType& pattern,
  83. FolderSearchPolicy folder_search_policy,
  84. ErrorPolicy error_policy)
  85. : recursive_(recursive),
  86. file_type_(file_type),
  87. pattern_(!pattern.empty() ? pattern : FILE_PATH_LITERAL("*")),
  88. folder_search_policy_(folder_search_policy),
  89. error_policy_(error_policy) {
  90. // INCLUDE_DOT_DOT must not be specified if recursive.
  91. DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));
  92. memset(&find_data_, 0, sizeof(find_data_));
  93. pending_paths_.push(root_path);
  94. }
  95. FileEnumerator::~FileEnumerator() {
  96. if (find_handle_ != INVALID_HANDLE_VALUE)
  97. FindClose(find_handle_);
  98. }
  99. FileEnumerator::FileInfo FileEnumerator::GetInfo() const {
  100. if (!has_find_data_) {
  101. NOTREACHED();
  102. return FileInfo();
  103. }
  104. FileInfo ret;
  105. memcpy(&ret.find_data_, &find_data_, sizeof(find_data_));
  106. return ret;
  107. }
  108. FilePath FileEnumerator::Next() {
  109. ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK);
  110. while (has_find_data_ || !pending_paths_.empty()) {
  111. if (!has_find_data_) {
  112. // The last find FindFirstFile operation is done, prepare a new one.
  113. root_path_ = pending_paths_.top();
  114. pending_paths_.pop();
  115. // Start a new find operation.
  116. const FilePath src =
  117. BuildSearchFilter(folder_search_policy_, root_path_, pattern_);
  118. find_handle_ = FindFirstFileEx(src.value().c_str(),
  119. FindExInfoBasic, // Omit short name.
  120. ChromeToWindowsType(&find_data_),
  121. FindExSearchNameMatch, nullptr,
  122. FIND_FIRST_EX_LARGE_FETCH);
  123. has_find_data_ = true;
  124. } else {
  125. // Search for the next file/directory.
  126. if (!FindNextFile(find_handle_, ChromeToWindowsType(&find_data_))) {
  127. FindClose(find_handle_);
  128. find_handle_ = INVALID_HANDLE_VALUE;
  129. }
  130. }
  131. DWORD last_error = GetLastError();
  132. if (INVALID_HANDLE_VALUE == find_handle_) {
  133. has_find_data_ = false;
  134. // MATCH_ONLY policy clears pattern for matched subfolders. ALL policy
  135. // applies pattern for all subfolders.
  136. if (folder_search_policy_ == FolderSearchPolicy::MATCH_ONLY) {
  137. // This is reached when we have finished a directory and are advancing
  138. // to the next one in the queue. We applied the pattern (if any) to the
  139. // files in the root search directory, but for those directories which
  140. // were matched, we want to enumerate all files inside them. This will
  141. // happen when the handle is empty.
  142. pattern_ = FILE_PATH_LITERAL("*");
  143. }
  144. if (last_error == ERROR_NO_MORE_FILES ||
  145. error_policy_ == ErrorPolicy::IGNORE_ERRORS) {
  146. continue;
  147. }
  148. error_ = File::OSErrorToFileError(last_error);
  149. return FilePath();
  150. }
  151. const FilePath filename(find_data().cFileName);
  152. if (ShouldSkip(filename))
  153. continue;
  154. const bool is_dir =
  155. (find_data().dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
  156. const FilePath abs_path = root_path_.Append(filename);
  157. // Check if directory should be processed recursive.
  158. if (is_dir && recursive_) {
  159. // If |cur_file| is a directory, and we are doing recursive searching,
  160. // add it to pending_paths_ so we scan it after we finish scanning this
  161. // directory. However, don't do recursion through reparse points or we
  162. // may end up with an infinite cycle.
  163. DWORD attributes = GetFileAttributes(abs_path.value().c_str());
  164. if (!(attributes & FILE_ATTRIBUTE_REPARSE_POINT))
  165. pending_paths_.push(abs_path);
  166. }
  167. if (IsTypeMatched(is_dir) && IsPatternMatched(filename))
  168. return abs_path;
  169. }
  170. return FilePath();
  171. }
  172. bool FileEnumerator::IsPatternMatched(const FilePath& src) const {
  173. switch (folder_search_policy_) {
  174. case FolderSearchPolicy::MATCH_ONLY:
  175. // MATCH_ONLY policy filters by pattern on search request, so all found
  176. // files already fits to pattern.
  177. return true;
  178. case FolderSearchPolicy::ALL:
  179. // ALL policy enumerates all files, we need to check pattern match
  180. // manually.
  181. return PathMatchSpec(src.value().c_str(), pattern_.c_str()) == TRUE;
  182. }
  183. NOTREACHED();
  184. return false;
  185. }
  186. } // namespace base