1 /*
2 * Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <assert.h>
12
13 #include "webrtc/base/pathutils.h"
14 #include "webrtc/base/fileutils.h"
15 #include "webrtc/base/stringutils.h"
16 #include "webrtc/base/stream.h"
17
18 #if defined(WEBRTC_WIN)
19 #include "webrtc/base/win32filesystem.h"
20 #else
21 #include "webrtc/base/unixfilesystem.h"
22 #endif
23
24 #if !defined(WEBRTC_WIN)
25 #define MAX_PATH 260
26 #endif
27
28 namespace rtc {
29
30 //////////////////////////
31 // Directory Iterator //
32 //////////////////////////
33
34 // A DirectoryIterator is created with a given directory. It originally points
35 // to the first file in the directory, and can be advanecd with Next(). This
36 // allows you to get information about each file.
37
38 // Constructor
DirectoryIterator()39 DirectoryIterator::DirectoryIterator()
40 #ifdef WEBRTC_WIN
41 : handle_(INVALID_HANDLE_VALUE) {
42 #else
43 : dir_(NULL), dirent_(NULL) {
44 #endif
45 }
46
47 // Destructor
48 DirectoryIterator::~DirectoryIterator() {
49 #if defined(WEBRTC_WIN)
50 if (handle_ != INVALID_HANDLE_VALUE)
51 ::FindClose(handle_);
52 #else
53 if (dir_)
54 closedir(dir_);
55 #endif
56 }
57
58 // Starts traversing a directory.
59 // dir is the directory to traverse
60 // returns true if the directory exists and is valid
61 bool DirectoryIterator::Iterate(const Pathname &dir) {
62 directory_ = dir.pathname();
63 #if defined(WEBRTC_WIN)
64 if (handle_ != INVALID_HANDLE_VALUE)
65 ::FindClose(handle_);
66 std::string d = dir.pathname() + '*';
67 handle_ = ::FindFirstFile(ToUtf16(d).c_str(), &data_);
68 if (handle_ == INVALID_HANDLE_VALUE)
69 return false;
70 #else
71 if (dir_ != NULL)
72 closedir(dir_);
73 dir_ = ::opendir(directory_.c_str());
74 if (dir_ == NULL)
75 return false;
76 dirent_ = readdir(dir_);
77 if (dirent_ == NULL)
78 return false;
79
80 if (::stat(std::string(directory_ + Name()).c_str(), &stat_) != 0)
81 return false;
82 #endif
83 return true;
84 }
85
86 // Advances to the next file
87 // returns true if there were more files in the directory.
88 bool DirectoryIterator::Next() {
89 #if defined(WEBRTC_WIN)
90 return ::FindNextFile(handle_, &data_) == TRUE;
91 #else
92 dirent_ = ::readdir(dir_);
93 if (dirent_ == NULL)
94 return false;
95
96 return ::stat(std::string(directory_ + Name()).c_str(), &stat_) == 0;
97 #endif
98 }
99
100 // returns true if the file currently pointed to is a directory
101 bool DirectoryIterator::IsDirectory() const {
102 #if defined(WEBRTC_WIN)
103 return (data_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FALSE;
104 #else
105 return S_ISDIR(stat_.st_mode);
106 #endif
107 }
108
109 // returns the name of the file currently pointed to
110 std::string DirectoryIterator::Name() const {
111 #if defined(WEBRTC_WIN)
112 return ToUtf8(data_.cFileName);
113 #else
114 assert(dirent_ != NULL);
115 return dirent_->d_name;
116 #endif
117 }
118
119 // returns the size of the file currently pointed to
120 size_t DirectoryIterator::FileSize() const {
121 #if !defined(WEBRTC_WIN)
122 return stat_.st_size;
123 #else
124 return data_.nFileSizeLow;
125 #endif
126 }
127
128 bool DirectoryIterator::OlderThan(int seconds) const {
129 time_t file_modify_time;
130 #if defined(WEBRTC_WIN)
131 FileTimeToUnixTime(data_.ftLastWriteTime, &file_modify_time);
132 #else
133 file_modify_time = stat_.st_mtime;
134 #endif
135 return TimeDiff(time(NULL), file_modify_time) >= seconds;
136 }
137
138 FilesystemInterface* Filesystem::default_filesystem_ = NULL;
139
140 FilesystemInterface *Filesystem::EnsureDefaultFilesystem() {
141 if (!default_filesystem_) {
142 #if defined(WEBRTC_WIN)
143 default_filesystem_ = new Win32Filesystem();
144 #else
145 default_filesystem_ = new UnixFilesystem();
146 #endif
147 }
148 return default_filesystem_;
149 }
150
151 bool FilesystemInterface::CopyFolder(const Pathname &old_path,
152 const Pathname &new_path) {
153 bool success = true;
154 VERIFY(IsFolder(old_path));
155 Pathname new_dir;
156 new_dir.SetFolder(new_path.pathname());
157 Pathname old_dir;
158 old_dir.SetFolder(old_path.pathname());
159 if (!CreateFolder(new_dir))
160 return false;
161 DirectoryIterator *di = IterateDirectory();
162 if (!di)
163 return false;
164 if (di->Iterate(old_dir.pathname())) {
165 do {
166 if (di->Name() == "." || di->Name() == "..")
167 continue;
168 Pathname source;
169 Pathname dest;
170 source.SetFolder(old_dir.pathname());
171 dest.SetFolder(new_path.pathname());
172 source.SetFilename(di->Name());
173 dest.SetFilename(di->Name());
174 if (!CopyFileOrFolder(source, dest))
175 success = false;
176 } while (di->Next());
177 }
178 delete di;
179 return success;
180 }
181
182 bool FilesystemInterface::DeleteFolderContents(const Pathname &folder) {
183 bool success = true;
184 VERIFY(IsFolder(folder));
185 DirectoryIterator *di = IterateDirectory();
186 if (!di)
187 return false;
188 if (di->Iterate(folder)) {
189 do {
190 if (di->Name() == "." || di->Name() == "..")
191 continue;
192 Pathname subdir;
193 subdir.SetFolder(folder.pathname());
194 if (di->IsDirectory()) {
195 subdir.AppendFolder(di->Name());
196 if (!DeleteFolderAndContents(subdir)) {
197 success = false;
198 }
199 } else {
200 subdir.SetFilename(di->Name());
201 if (!DeleteFile(subdir)) {
202 success = false;
203 }
204 }
205 } while (di->Next());
206 }
207 delete di;
208 return success;
209 }
210
211 bool FilesystemInterface::CleanAppTempFolder() {
212 Pathname path;
213 if (!GetAppTempFolder(&path))
214 return false;
215 if (IsAbsent(path))
216 return true;
217 if (!IsTemporaryPath(path)) {
218 ASSERT(false);
219 return false;
220 }
221 return DeleteFolderContents(path);
222 }
223
224 Pathname Filesystem::GetCurrentDirectory() {
225 return EnsureDefaultFilesystem()->GetCurrentDirectory();
226 }
227
228 bool CreateUniqueFile(Pathname& path, bool create_empty) {
229 LOG(LS_INFO) << "Path " << path.pathname() << std::endl;
230 // If no folder is supplied, use the temporary folder
231 if (path.folder().empty()) {
232 Pathname temporary_path;
233 if (!Filesystem::GetTemporaryFolder(temporary_path, true, NULL)) {
234 printf("Get temp failed\n");
235 return false;
236 }
237 path.SetFolder(temporary_path.pathname());
238 }
239
240 // If no filename is supplied, use a temporary name
241 if (path.filename().empty()) {
242 std::string folder(path.folder());
243 std::string filename = Filesystem::TempFilename(folder, "gt");
244 path.SetPathname(filename);
245 if (!create_empty) {
246 Filesystem::DeleteFile(path.pathname());
247 }
248 return true;
249 }
250
251 // Otherwise, create a unique name based on the given filename
252 // foo.txt -> foo-N.txt
253 const std::string basename = path.basename();
254 const size_t MAX_VERSION = 100;
255 size_t version = 0;
256 while (version < MAX_VERSION) {
257 std::string pathname = path.pathname();
258
259 if (!Filesystem::IsFile(pathname)) {
260 if (create_empty) {
261 FileStream* fs = Filesystem::OpenFile(pathname, "w");
262 delete fs;
263 }
264 return true;
265 }
266 version += 1;
267 char version_base[MAX_PATH];
268 sprintfn(version_base, ARRAY_SIZE(version_base), "%s-%u",
269 basename.c_str(), version);
270 path.SetBasename(version_base);
271 }
272 return true;
273 }
274
275 } // namespace rtc
276