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 }