|
1 /* |
|
2 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 |
|
26 #include "FilePath.h" |
|
27 |
|
28 #include <algorithm> |
|
29 #include <list> |
|
30 #include <ShellAPI.h> |
|
31 |
|
32 bool FilePath::FileExists(const TString FileName) { |
|
33 bool result = false; |
|
34 WIN32_FIND_DATA FindFileData; |
|
35 TString fileName = FixPathForPlatform(FileName); |
|
36 HANDLE handle = FindFirstFile(fileName.data(), &FindFileData); |
|
37 |
|
38 if (handle != INVALID_HANDLE_VALUE) { |
|
39 if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes) { |
|
40 result = true; |
|
41 } |
|
42 else { |
|
43 result = true; |
|
44 } |
|
45 |
|
46 FindClose(handle); |
|
47 } |
|
48 return result; |
|
49 } |
|
50 |
|
51 bool FilePath::DirectoryExists(const TString DirectoryName) { |
|
52 bool result = false; |
|
53 WIN32_FIND_DATA FindFileData; |
|
54 TString directoryName = FixPathForPlatform(DirectoryName); |
|
55 HANDLE handle = FindFirstFile(directoryName.data(), &FindFileData); |
|
56 |
|
57 if (handle != INVALID_HANDLE_VALUE) { |
|
58 if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes) { |
|
59 result = true; |
|
60 } |
|
61 |
|
62 FindClose(handle); |
|
63 } |
|
64 return result; |
|
65 } |
|
66 |
|
67 std::string GetLastErrorAsString() { |
|
68 // Get the error message, if any. |
|
69 DWORD errorMessageID = ::GetLastError(); |
|
70 |
|
71 if (errorMessageID == 0) { |
|
72 return "No error message has been recorded"; |
|
73 } |
|
74 |
|
75 LPSTR messageBuffer = NULL; |
|
76 size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
77 | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, |
|
78 NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, |
|
79 SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL); |
|
80 |
|
81 std::string message(messageBuffer, size); |
|
82 |
|
83 // Free the buffer. |
|
84 LocalFree(messageBuffer); |
|
85 |
|
86 return message; |
|
87 } |
|
88 |
|
89 bool FilePath::DeleteFile(const TString FileName) { |
|
90 bool result = false; |
|
91 |
|
92 if (FileExists(FileName) == true) { |
|
93 TString lFileName = FixPathForPlatform(FileName); |
|
94 FileAttributes attributes(lFileName); |
|
95 |
|
96 if (attributes.Contains(faReadOnly) == true) { |
|
97 attributes.Remove(faReadOnly); |
|
98 } |
|
99 |
|
100 result = ::DeleteFile(lFileName.data()) == TRUE; |
|
101 } |
|
102 |
|
103 return result; |
|
104 } |
|
105 |
|
106 bool FilePath::DeleteDirectory(const TString DirectoryName) { |
|
107 bool result = false; |
|
108 |
|
109 if (DirectoryExists(DirectoryName) == true) { |
|
110 SHFILEOPSTRUCTW fos = {0}; |
|
111 TString directoryName = FixPathForPlatform(DirectoryName); |
|
112 DynamicBuffer<TCHAR> lDirectoryName(directoryName.size() + 2); |
|
113 if (lDirectoryName.GetData() == NULL) { |
|
114 return false; |
|
115 } |
|
116 memcpy(lDirectoryName.GetData(), directoryName.data(), |
|
117 (directoryName.size() + 2) * sizeof(TCHAR)); |
|
118 lDirectoryName[directoryName.size() + 1] = NULL; |
|
119 // Double null terminate for SHFileOperation. |
|
120 |
|
121 // Delete the folder and everything inside. |
|
122 fos.wFunc = FO_DELETE; |
|
123 fos.pFrom = lDirectoryName.GetData(); |
|
124 fos.fFlags = FOF_NO_UI; |
|
125 result = SHFileOperation(&fos) == 0; |
|
126 } |
|
127 |
|
128 return result; |
|
129 } |
|
130 |
|
131 TString FilePath::IncludeTrailingSeparator(const TString value) { |
|
132 TString result = value; |
|
133 |
|
134 if (value.size() > 0) { |
|
135 TString::iterator i = result.end(); |
|
136 i--; |
|
137 |
|
138 if (*i != TRAILING_PATHSEPARATOR) { |
|
139 result += TRAILING_PATHSEPARATOR; |
|
140 } |
|
141 } |
|
142 |
|
143 return result; |
|
144 } |
|
145 |
|
146 TString FilePath::IncludeTrailingSeparator(const char* value) { |
|
147 TString lvalue = PlatformString(value).toString(); |
|
148 return IncludeTrailingSeparator(lvalue); |
|
149 } |
|
150 |
|
151 TString FilePath::IncludeTrailingSeparator(const wchar_t* value) { |
|
152 TString lvalue = PlatformString(value).toString(); |
|
153 return IncludeTrailingSeparator(lvalue); |
|
154 } |
|
155 |
|
156 TString FilePath::ExtractFilePath(TString Path) { |
|
157 TString result; |
|
158 size_t slash = Path.find_last_of(TRAILING_PATHSEPARATOR); |
|
159 if (slash != TString::npos) |
|
160 result = Path.substr(0, slash); |
|
161 return result; |
|
162 } |
|
163 |
|
164 TString FilePath::ExtractFileExt(TString Path) { |
|
165 TString result; |
|
166 size_t dot = Path.find_last_of('.'); |
|
167 |
|
168 if (dot != TString::npos) { |
|
169 result = Path.substr(dot, Path.size() - dot); |
|
170 } |
|
171 |
|
172 return result; |
|
173 } |
|
174 |
|
175 TString FilePath::ExtractFileName(TString Path) { |
|
176 TString result; |
|
177 |
|
178 size_t slash = Path.find_last_of(TRAILING_PATHSEPARATOR); |
|
179 if (slash != TString::npos) |
|
180 result = Path.substr(slash + 1, Path.size() - slash - 1); |
|
181 |
|
182 return result; |
|
183 } |
|
184 |
|
185 TString FilePath::ChangeFileExt(TString Path, TString Extension) { |
|
186 TString result; |
|
187 size_t dot = Path.find_last_of('.'); |
|
188 |
|
189 if (dot != TString::npos) { |
|
190 result = Path.substr(0, dot) + Extension; |
|
191 } |
|
192 |
|
193 if (result.empty() == true) { |
|
194 result = Path; |
|
195 } |
|
196 |
|
197 return result; |
|
198 } |
|
199 |
|
200 TString FilePath::FixPathForPlatform(TString Path) { |
|
201 TString result = Path; |
|
202 std::replace(result.begin(), result.end(), |
|
203 BAD_TRAILING_PATHSEPARATOR, TRAILING_PATHSEPARATOR); |
|
204 // The maximum path that does not require long path prefix. On Windows the |
|
205 // maximum path is 260 minus 1 (NUL) but for directories it is 260 minus |
|
206 // 12 minus 1 (to allow for the creation of a 8.3 file in the directory). |
|
207 const int maxPath = 247; |
|
208 if (result.length() > maxPath && |
|
209 result.find(_T("\\\\?\\")) == TString::npos && |
|
210 result.find(_T("\\\\?\\UNC")) == TString::npos) { |
|
211 const TString prefix(_T("\\\\")); |
|
212 if (!result.compare(0, prefix.size(), prefix)) { |
|
213 // UNC path, converting to UNC path in long notation |
|
214 result = _T("\\\\?\\UNC") + result.substr(1, result.length()); |
|
215 } else { |
|
216 // converting to non-UNC path in long notation |
|
217 result = _T("\\\\?\\") + result; |
|
218 } |
|
219 } |
|
220 return result; |
|
221 } |
|
222 |
|
223 TString FilePath::FixPathSeparatorForPlatform(TString Path) { |
|
224 TString result = Path; |
|
225 std::replace(result.begin(), result.end(), |
|
226 BAD_PATH_SEPARATOR, PATH_SEPARATOR); |
|
227 return result; |
|
228 } |
|
229 |
|
230 TString FilePath::PathSeparator() { |
|
231 TString result; |
|
232 result = PATH_SEPARATOR; |
|
233 return result; |
|
234 } |
|
235 |
|
236 bool FilePath::CreateDirectory(TString Path, bool ownerOnly) { |
|
237 bool result = false; |
|
238 |
|
239 std::list<TString> paths; |
|
240 TString lpath = Path; |
|
241 |
|
242 while (lpath.empty() == false && DirectoryExists(lpath) == false) { |
|
243 paths.push_front(lpath); |
|
244 lpath = ExtractFilePath(lpath); |
|
245 } |
|
246 |
|
247 for (std::list<TString>::iterator iterator = paths.begin(); |
|
248 iterator != paths.end(); iterator++) { |
|
249 lpath = *iterator; |
|
250 |
|
251 if (_wmkdir(lpath.data()) == 0) { |
|
252 result = true; |
|
253 } else { |
|
254 result = false; |
|
255 break; |
|
256 } |
|
257 } |
|
258 |
|
259 return result; |
|
260 } |
|
261 |
|
262 void FilePath::ChangePermissions(TString FileName, bool ownerOnly) { |
|
263 } |
|
264 |
|
265 #include <algorithm> |
|
266 |
|
267 FileAttributes::FileAttributes(const TString FileName, bool FollowLink) { |
|
268 FFileName = FileName; |
|
269 FFollowLink = FollowLink; |
|
270 ReadAttributes(); |
|
271 } |
|
272 |
|
273 bool FileAttributes::WriteAttributes() { |
|
274 bool result = false; |
|
275 |
|
276 DWORD attributes = 0; |
|
277 |
|
278 for (std::vector<FileAttribute>::const_iterator iterator = |
|
279 FAttributes.begin(); |
|
280 iterator != FAttributes.end(); iterator++) { |
|
281 switch (*iterator) { |
|
282 case faArchive: { |
|
283 attributes = attributes & FILE_ATTRIBUTE_ARCHIVE; |
|
284 break; |
|
285 } |
|
286 case faCompressed: { |
|
287 attributes = attributes & FILE_ATTRIBUTE_COMPRESSED; |
|
288 break; |
|
289 } |
|
290 case faDevice: { |
|
291 attributes = attributes & FILE_ATTRIBUTE_DEVICE; |
|
292 break; |
|
293 } |
|
294 case faDirectory: { |
|
295 attributes = attributes & FILE_ATTRIBUTE_DIRECTORY; |
|
296 break; |
|
297 } |
|
298 case faEncrypted: { |
|
299 attributes = attributes & FILE_ATTRIBUTE_ENCRYPTED; |
|
300 break; |
|
301 } |
|
302 case faHidden: { |
|
303 attributes = attributes & FILE_ATTRIBUTE_HIDDEN; |
|
304 break; |
|
305 } |
|
306 case faNormal: { |
|
307 attributes = attributes & FILE_ATTRIBUTE_NORMAL; |
|
308 break; |
|
309 } |
|
310 case faNotContentIndexed: { |
|
311 attributes = attributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED; |
|
312 break; |
|
313 } |
|
314 case faOffline: { |
|
315 attributes = attributes & FILE_ATTRIBUTE_OFFLINE; |
|
316 break; |
|
317 } |
|
318 case faSystem: { |
|
319 attributes = attributes & FILE_ATTRIBUTE_SYSTEM; |
|
320 break; |
|
321 } |
|
322 case faSymbolicLink: { |
|
323 attributes = attributes & FILE_ATTRIBUTE_REPARSE_POINT; |
|
324 break; |
|
325 } |
|
326 case faSparceFile: { |
|
327 attributes = attributes & FILE_ATTRIBUTE_SPARSE_FILE; |
|
328 break; |
|
329 } |
|
330 case faReadOnly: { |
|
331 attributes = attributes & FILE_ATTRIBUTE_READONLY; |
|
332 break; |
|
333 } |
|
334 case faTemporary: { |
|
335 attributes = attributes & FILE_ATTRIBUTE_TEMPORARY; |
|
336 break; |
|
337 } |
|
338 case faVirtual: { |
|
339 attributes = attributes & FILE_ATTRIBUTE_VIRTUAL; |
|
340 break; |
|
341 } |
|
342 } |
|
343 } |
|
344 |
|
345 if (::SetFileAttributes(FFileName.data(), attributes) != 0) { |
|
346 result = true; |
|
347 } |
|
348 |
|
349 return result; |
|
350 } |
|
351 |
|
352 #define S_ISRUSR(m) (((m) & S_IRWXU) == S_IRUSR) |
|
353 #define S_ISWUSR(m) (((m) & S_IRWXU) == S_IWUSR) |
|
354 #define S_ISXUSR(m) (((m) & S_IRWXU) == S_IXUSR) |
|
355 |
|
356 #define S_ISRGRP(m) (((m) & S_IRWXG) == S_IRGRP) |
|
357 #define S_ISWGRP(m) (((m) & S_IRWXG) == S_IWGRP) |
|
358 #define S_ISXGRP(m) (((m) & S_IRWXG) == S_IXGRP) |
|
359 |
|
360 #define S_ISROTH(m) (((m) & S_IRWXO) == S_IROTH) |
|
361 #define S_ISWOTH(m) (((m) & S_IRWXO) == S_IWOTH) |
|
362 #define S_ISXOTH(m) (((m) & S_IRWXO) == S_IXOTH) |
|
363 |
|
364 bool FileAttributes::ReadAttributes() { |
|
365 bool result = false; |
|
366 |
|
367 DWORD attributes = ::GetFileAttributes(FFileName.data()); |
|
368 |
|
369 if (attributes != INVALID_FILE_ATTRIBUTES) { |
|
370 result = true; |
|
371 |
|
372 if (attributes | FILE_ATTRIBUTE_ARCHIVE) { |
|
373 FAttributes.push_back(faArchive); |
|
374 } |
|
375 if (attributes | FILE_ATTRIBUTE_COMPRESSED) { |
|
376 FAttributes.push_back(faCompressed); |
|
377 } |
|
378 if (attributes | FILE_ATTRIBUTE_DEVICE) { |
|
379 FAttributes.push_back(faDevice); |
|
380 } |
|
381 if (attributes | FILE_ATTRIBUTE_DIRECTORY) { |
|
382 FAttributes.push_back(faDirectory); |
|
383 } |
|
384 if (attributes | FILE_ATTRIBUTE_ENCRYPTED) { |
|
385 FAttributes.push_back(faEncrypted); |
|
386 } |
|
387 if (attributes | FILE_ATTRIBUTE_HIDDEN) { |
|
388 FAttributes.push_back(faHidden); |
|
389 } |
|
390 if (attributes | FILE_ATTRIBUTE_NORMAL) { |
|
391 FAttributes.push_back(faNormal); |
|
392 } |
|
393 if (attributes | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) { |
|
394 FAttributes.push_back(faNotContentIndexed); |
|
395 } |
|
396 if (attributes | FILE_ATTRIBUTE_SYSTEM) { |
|
397 FAttributes.push_back(faSystem); |
|
398 } |
|
399 if (attributes | FILE_ATTRIBUTE_OFFLINE) { |
|
400 FAttributes.push_back(faOffline); |
|
401 } |
|
402 if (attributes | FILE_ATTRIBUTE_REPARSE_POINT) { |
|
403 FAttributes.push_back(faSymbolicLink); |
|
404 } |
|
405 if (attributes | FILE_ATTRIBUTE_SPARSE_FILE) { |
|
406 FAttributes.push_back(faSparceFile); |
|
407 } |
|
408 if (attributes | FILE_ATTRIBUTE_READONLY ) { |
|
409 FAttributes.push_back(faReadOnly); |
|
410 } |
|
411 if (attributes | FILE_ATTRIBUTE_TEMPORARY) { |
|
412 FAttributes.push_back(faTemporary); |
|
413 } |
|
414 if (attributes | FILE_ATTRIBUTE_VIRTUAL) { |
|
415 FAttributes.push_back(faVirtual); |
|
416 } |
|
417 } |
|
418 |
|
419 return result; |
|
420 } |
|
421 |
|
422 bool FileAttributes::Valid(const FileAttribute Value) { |
|
423 bool result = false; |
|
424 |
|
425 switch (Value) { |
|
426 case faHidden: |
|
427 case faReadOnly: { |
|
428 result = true; |
|
429 break; |
|
430 } |
|
431 default: |
|
432 break; |
|
433 } |
|
434 |
|
435 return result; |
|
436 } |
|
437 |
|
438 void FileAttributes::Append(FileAttribute Value) { |
|
439 if (Valid(Value) == true) { |
|
440 FAttributes.push_back(Value); |
|
441 WriteAttributes(); |
|
442 } |
|
443 } |
|
444 |
|
445 bool FileAttributes::Contains(FileAttribute Value) { |
|
446 bool result = false; |
|
447 |
|
448 std::vector<FileAttribute>::const_iterator iterator = |
|
449 std::find(FAttributes.begin(), FAttributes.end(), Value); |
|
450 |
|
451 if (iterator != FAttributes.end()) { |
|
452 result = true; |
|
453 } |
|
454 |
|
455 return result; |
|
456 } |
|
457 |
|
458 void FileAttributes::Remove(FileAttribute Value) { |
|
459 if (Valid(Value) == true) { |
|
460 std::vector<FileAttribute>::iterator iterator = |
|
461 std::find(FAttributes.begin(), FAttributes.end(), Value); |
|
462 |
|
463 if (iterator != FAttributes.end()) { |
|
464 FAttributes.erase(iterator); |
|
465 WriteAttributes(); |
|
466 } |
|
467 } |
|
468 } |