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 5 #include "base/files/file_enumerator.h" 6 7 #include <dirent.h> 8 #include <errno.h> 9 #include <fnmatch.h> 10 11 #include "base/logging.h" 12 #include "base/threading/thread_restrictions.h" 13 14 namespace base { 15 16 // FileEnumerator::FileInfo ---------------------------------------------------- 17 18 FileEnumerator::FileInfo::FileInfo() { 19 memset(&stat_, 0, sizeof(stat_)); 20 } 21 22 bool FileEnumerator::FileInfo::IsDirectory() const { 23 return S_ISDIR(stat_.st_mode); 24 } 25 26 FilePath FileEnumerator::FileInfo::GetName() const { 27 return filename_; 28 } 29 30 int64 FileEnumerator::FileInfo::GetSize() const { 31 return stat_.st_size; 32 } 33 34 base::Time FileEnumerator::FileInfo::GetLastModifiedTime() const { 35 return base::Time::FromTimeT(stat_.st_mtime); 36 } 37 38 // FileEnumerator -------------------------------------------------------------- 39 40 FileEnumerator::FileEnumerator(const FilePath& root_path, 41 bool recursive, 42 int file_type) 43 : current_directory_entry_(0), 44 root_path_(root_path), 45 recursive_(recursive), 46 file_type_(file_type) { 47 // INCLUDE_DOT_DOT must not be specified if recursive. 48 DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_))); 49 pending_paths_.push(root_path); 50 } 51 52 FileEnumerator::FileEnumerator(const FilePath& root_path, 53 bool recursive, 54 int file_type, 55 const FilePath::StringType& pattern) 56 : current_directory_entry_(0), 57 root_path_(root_path), 58 recursive_(recursive), 59 file_type_(file_type), 60 pattern_(root_path.Append(pattern).value()) { 61 // INCLUDE_DOT_DOT must not be specified if recursive. 62 DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_))); 63 // The Windows version of this code appends the pattern to the root_path, 64 // potentially only matching against items in the top-most directory. 65 // Do the same here. 66 if (pattern.empty()) 67 pattern_ = FilePath::StringType(); 68 pending_paths_.push(root_path); 69 } 70 71 FileEnumerator::~FileEnumerator() { 72 } 73 74 FilePath FileEnumerator::Next() { 75 ++current_directory_entry_; 76 77 // While we've exhausted the entries in the current directory, do the next 78 while (current_directory_entry_ >= directory_entries_.size()) { 79 if (pending_paths_.empty()) 80 return FilePath(); 81 82 root_path_ = pending_paths_.top(); 83 root_path_ = root_path_.StripTrailingSeparators(); 84 pending_paths_.pop(); 85 86 std::vector<FileInfo> entries; 87 if (!ReadDirectory(&entries, root_path_, file_type_ & SHOW_SYM_LINKS)) 88 continue; 89 90 directory_entries_.clear(); 91 current_directory_entry_ = 0; 92 for (std::vector<FileInfo>::const_iterator i = entries.begin(); 93 i != entries.end(); ++i) { 94 FilePath full_path = root_path_.Append(i->filename_); 95 if (ShouldSkip(full_path)) 96 continue; 97 98 if (pattern_.size() && 99 fnmatch(pattern_.c_str(), full_path.value().c_str(), FNM_NOESCAPE)) 100 continue; 101 102 if (recursive_ && S_ISDIR(i->stat_.st_mode)) 103 pending_paths_.push(full_path); 104 105 if ((S_ISDIR(i->stat_.st_mode) && (file_type_ & DIRECTORIES)) || 106 (!S_ISDIR(i->stat_.st_mode) && (file_type_ & FILES))) 107 directory_entries_.push_back(*i); 108 } 109 } 110 111 return root_path_.Append( 112 directory_entries_[current_directory_entry_].filename_); 113 } 114 115 FileEnumerator::FileInfo FileEnumerator::GetInfo() const { 116 return directory_entries_[current_directory_entry_]; 117 } 118 119 bool FileEnumerator::ReadDirectory(std::vector<FileInfo>* entries, 120 const FilePath& source, bool show_links) { 121 base::ThreadRestrictions::AssertIOAllowed(); 122 DIR* dir = opendir(source.value().c_str()); 123 if (!dir) 124 return false; 125 126 #if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_BSD) && \ 127 !defined(OS_SOLARIS) && !defined(OS_ANDROID) 128 #error Port warning: depending on the definition of struct dirent, \ 129 additional space for pathname may be needed 130 #endif 131 132 struct dirent dent_buf; 133 struct dirent* dent; 134 while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) { 135 FileInfo info; 136 info.filename_ = FilePath(dent->d_name); 137 138 FilePath full_name = source.Append(dent->d_name); 139 int ret; 140 if (show_links) 141 ret = lstat(full_name.value().c_str(), &info.stat_); 142 else 143 ret = stat(full_name.value().c_str(), &info.stat_); 144 if (ret < 0) { 145 // Print the stat() error message unless it was ENOENT and we're 146 // following symlinks. 147 if (!(errno == ENOENT && !show_links)) { 148 DPLOG(ERROR) << "Couldn't stat " 149 << source.Append(dent->d_name).value(); 150 } 151 memset(&info.stat_, 0, sizeof(info.stat_)); 152 } 153 entries->push_back(info); 154 } 155 156 closedir(dir); 157 return true; 158 } 159 160 } // namespace base 161