[Win] Remove -DUCHAR_TYPE=wchar_t stopgap and learn to live with char16_t.
[WebKit-https.git] / Source / WTF / wtf / win / FileSystemWin.cpp
1 /*
2  * Copyright (C) 2007-2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Collabora, Ltd. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include <wtf/FileSystem.h>
32
33 #include <io.h>
34 #include <shlobj.h>
35 #include <shlwapi.h>
36 #include <sys/stat.h>
37 #include <windows.h>
38 #include <wtf/CryptographicallyRandomNumber.h>
39 #include <wtf/FileMetadata.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/text/CString.h>
42 #include <wtf/text/StringBuilder.h>
43 #include <wtf/text/win/WCharStringExtras.h>
44 #include <wtf/win/PathWalker.h>
45
46 namespace WTF {
47
48 namespace FileSystemImpl {
49
50 static const ULONGLONG kSecondsFromFileTimeToTimet = 11644473600;
51
52 static bool getFindData(String path, WIN32_FIND_DATAW& findData)
53 {
54     HANDLE handle = FindFirstFileW(path.wideCharacters().data(), &findData);
55     if (handle == INVALID_HANDLE_VALUE)
56         return false;
57     FindClose(handle);
58     return true;
59 }
60
61 static bool getFileSizeFromFindData(const WIN32_FIND_DATAW& findData, long long& size)
62 {
63     ULARGE_INTEGER fileSize;
64     fileSize.HighPart = findData.nFileSizeHigh;
65     fileSize.LowPart = findData.nFileSizeLow;
66
67     if (fileSize.QuadPart > static_cast<ULONGLONG>(std::numeric_limits<long long>::max()))
68         return false;
69
70     size = fileSize.QuadPart;
71     return true;
72 }
73
74 static bool getFileSizeFromByHandleFileInformationStructure(const BY_HANDLE_FILE_INFORMATION& fileInformation, long long& size)
75 {
76     ULARGE_INTEGER fileSize;
77     fileSize.HighPart = fileInformation.nFileSizeHigh;
78     fileSize.LowPart = fileInformation.nFileSizeLow;
79
80     if (fileSize.QuadPart > static_cast<ULONGLONG>(std::numeric_limits<long long>::max()))
81         return false;
82
83     size = fileSize.QuadPart;
84     return true;
85 }
86
87 static void getFileCreationTimeFromFindData(const WIN32_FIND_DATAW& findData, time_t& time)
88 {
89     ULARGE_INTEGER fileTime;
90     fileTime.HighPart = findData.ftCreationTime.dwHighDateTime;
91     fileTime.LowPart = findData.ftCreationTime.dwLowDateTime;
92
93     // Information about converting time_t to FileTime is available at http://msdn.microsoft.com/en-us/library/ms724228%28v=vs.85%29.aspx
94     time = fileTime.QuadPart / 10000000 - kSecondsFromFileTimeToTimet;
95 }
96
97
98 static void getFileModificationTimeFromFindData(const WIN32_FIND_DATAW& findData, time_t& time)
99 {
100     ULARGE_INTEGER fileTime;
101     fileTime.HighPart = findData.ftLastWriteTime.dwHighDateTime;
102     fileTime.LowPart = findData.ftLastWriteTime.dwLowDateTime;
103
104     // Information about converting time_t to FileTime is available at http://msdn.microsoft.com/en-us/library/ms724228%28v=vs.85%29.aspx
105     time = fileTime.QuadPart / 10000000 - kSecondsFromFileTimeToTimet;
106 }
107
108 bool getFileSize(const String& path, long long& size)
109 {
110     WIN32_FIND_DATAW findData;
111     if (!getFindData(path, findData))
112         return false;
113
114     return getFileSizeFromFindData(findData, size);
115 }
116
117 bool getFileSize(PlatformFileHandle fileHandle, long long& size)
118 {
119     BY_HANDLE_FILE_INFORMATION fileInformation;
120     if (!::GetFileInformationByHandle(fileHandle, &fileInformation))
121         return false;
122
123     return getFileSizeFromByHandleFileInformationStructure(fileInformation, size);
124 }
125
126 Optional<WallTime> getFileModificationTime(const String& path)
127 {
128     WIN32_FIND_DATAW findData;
129     if (!getFindData(path, findData))
130         return WTF::nullopt;
131
132     time_t time = 0;
133     getFileModificationTimeFromFindData(findData, time);
134     return WallTime::fromRawSeconds(time);
135 }
136
137 Optional<WallTime> getFileCreationTime(const String& path)
138 {
139     WIN32_FIND_DATAW findData;
140     if (!getFindData(path, findData))
141         return WTF::nullopt;
142
143     time_t time = 0;
144     getFileCreationTimeFromFindData(findData, time);
145     return WallTime::fromRawSeconds(time);
146 }
147
148 static String getFinalPathName(const String& path)
149 {
150     auto handle = openFile(path, FileOpenMode::Read);
151     if (!isHandleValid(handle))
152         return String();
153
154     Vector<UChar> buffer(MAX_PATH);
155     if (::GetFinalPathNameByHandleW(handle, wcharFrom(buffer.data()), buffer.size(), VOLUME_NAME_NT) >= MAX_PATH) {
156         closeFile(handle);
157         return String();
158     }
159     closeFile(handle);
160
161     buffer.shrink(wcslen(wcharFrom(buffer.data())));
162     return String::adopt(WTFMove(buffer));
163 }
164
165 static inline bool isSymbolicLink(WIN32_FIND_DATAW findData)
166 {
167     return findData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT && findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK;
168 }
169
170 static FileMetadata::Type toFileMetadataType(WIN32_FIND_DATAW findData)
171 {
172     if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
173         return FileMetadata::Type::Directory;
174     if (isSymbolicLink(findData))
175         return FileMetadata::Type::SymbolicLink;
176     return FileMetadata::Type::File;
177 }
178
179 static Optional<FileMetadata> findDataToFileMetadata(WIN32_FIND_DATAW findData)
180 {
181     long long length;
182     if (!getFileSizeFromFindData(findData, length))
183         return WTF::nullopt;
184
185     time_t modificationTime;
186     getFileModificationTimeFromFindData(findData, modificationTime);
187
188     return FileMetadata {
189         WallTime::fromRawSeconds(modificationTime),
190         length,
191         static_cast<bool>(findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN),
192         toFileMetadataType(findData)
193     };
194 }
195
196 Optional<FileMetadata> fileMetadata(const String& path)
197 {
198     WIN32_FIND_DATAW findData;
199     if (!getFindData(path, findData))
200         return WTF::nullopt;
201
202     return findDataToFileMetadata(findData);
203 }
204
205 Optional<FileMetadata> fileMetadataFollowingSymlinks(const String& path)
206 {
207     WIN32_FIND_DATAW findData;
208     if (!getFindData(path, findData))
209         return WTF::nullopt;
210
211     if (isSymbolicLink(findData)) {
212         String targetPath = getFinalPathName(path);
213         if (targetPath.isNull())
214             return WTF::nullopt;
215         if (!getFindData(targetPath, findData))
216             return WTF::nullopt;
217     }
218
219     return findDataToFileMetadata(findData);
220 }
221
222 bool createSymbolicLink(const String& targetPath, const String& symbolicLinkPath)
223 {
224     return !::CreateSymbolicLinkW(symbolicLinkPath.wideCharacters().data(), targetPath.wideCharacters().data(), 0);
225 }
226
227 bool fileExists(const String& path)
228 {
229     WIN32_FIND_DATAW findData;
230     return getFindData(path, findData);
231 }
232
233 bool deleteFile(const String& path)
234 {
235     String filename = path;
236     return !!DeleteFileW(filename.wideCharacters().data());
237 }
238
239 bool deleteEmptyDirectory(const String& path)
240 {
241     String filename = path;
242     return !!RemoveDirectoryW(filename.wideCharacters().data());
243 }
244
245 bool moveFile(const String& oldPath, const String& newPath)
246 {
247     String oldFilename = oldPath;
248     String newFilename = newPath;
249     return !!::MoveFileEx(oldFilename.wideCharacters().data(), newFilename.wideCharacters().data(), MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING);
250 }
251
252 String pathByAppendingComponent(const String& path, const String& component)
253 {
254     Vector<UChar> buffer(MAX_PATH);
255     if (path.length() + 1 > buffer.size())
256         return String();
257
258     StringView(path).getCharactersWithUpconvert(buffer.data());
259     buffer[path.length()] = '\0';
260
261     if (!PathAppendW(wcharFrom(buffer.data()), component.wideCharacters().data()))
262         return String();
263
264     buffer.shrink(wcslen(wcharFrom(buffer.data())));
265     return String::adopt(WTFMove(buffer));
266 }
267
268 String pathByAppendingComponents(StringView path, const Vector<StringView>& components)
269 {
270     String result = path.toString();
271     for (auto& component : components)
272         result = pathByAppendingComponent(result, component.toString());
273     return result;
274 }
275
276 #if !USE(CF)
277
278 CString fileSystemRepresentation(const String& path)
279 {
280     auto characters = wcharFrom(StringView(path).upconvertedCharacters());
281     int size = WideCharToMultiByte(CP_ACP, 0, characters, path.length(), 0, 0, 0, 0) - 1;
282
283     char* buffer;
284     CString string = CString::newUninitialized(size, buffer);
285
286     WideCharToMultiByte(CP_ACP, 0, characters, path.length(), buffer, size, 0, 0);
287
288     return string;
289 }
290
291 #endif // !USE(CF)
292
293 bool makeAllDirectories(const String& path)
294 {
295     String fullPath = path;
296     if (SHCreateDirectoryEx(0, fullPath.wideCharacters().data(), 0) != ERROR_SUCCESS) {
297         DWORD error = GetLastError();
298         if (error != ERROR_FILE_EXISTS && error != ERROR_ALREADY_EXISTS) {
299             LOG_ERROR("Failed to create path %s", path.ascii().data());
300             return false;
301         }
302     }
303     return true;
304 }
305
306 String homeDirectoryPath()
307 {
308     return "";
309 }
310
311 String pathGetFileName(const String& path)
312 {
313     return String(::PathFindFileName(path.wideCharacters().data()));
314 }
315
316 String directoryName(const String& path)
317 {
318     String name = path.left(path.length() - pathGetFileName(path).length());
319     if (name.characterStartingAt(name.length() - 1) == '\\') {
320         // Remove any trailing "\".
321         name.truncate(name.length() - 1);
322     }
323     return name;
324 }
325
326 static String bundleName()
327 {
328     static const NeverDestroyed<String> name = [] {
329         String name { "WebKit"_s };
330
331 #if USE(CF)
332         if (CFBundleRef bundle = CFBundleGetMainBundle()) {
333             if (CFTypeRef bundleExecutable = CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleExecutableKey)) {
334                 if (CFGetTypeID(bundleExecutable) == CFStringGetTypeID())
335                     name = reinterpret_cast<CFStringRef>(bundleExecutable);
336             }
337         }
338 #endif
339
340         return name;
341     }();
342
343     return name;
344 }
345
346 static String storageDirectory(DWORD pathIdentifier)
347 {
348     Vector<UChar> buffer(MAX_PATH);
349     if (FAILED(SHGetFolderPathW(0, pathIdentifier | CSIDL_FLAG_CREATE, 0, 0, wcharFrom(buffer.data()))))
350         return String();
351
352     buffer.shrink(wcslen(wcharFrom(buffer.data())));
353     String directory = String::adopt(WTFMove(buffer));
354
355     directory = pathByAppendingComponent(directory, "Apple Computer\\" + bundleName());
356     if (!makeAllDirectories(directory))
357         return String();
358
359     return directory;
360 }
361
362 static String cachedStorageDirectory(DWORD pathIdentifier)
363 {
364     static HashMap<DWORD, String> directories;
365
366     HashMap<DWORD, String>::iterator it = directories.find(pathIdentifier);
367     if (it != directories.end())
368         return it->value;
369
370     String directory = storageDirectory(pathIdentifier);
371     directories.add(pathIdentifier, directory);
372
373     return directory;
374 }
375
376 static String generateTemporaryPath(const Function<bool(const String&)>& action)
377 {
378     wchar_t tempPath[MAX_PATH];
379     int tempPathLength = ::GetTempPathW(WTF_ARRAY_LENGTH(tempPath), tempPath);
380     if (tempPathLength <= 0 || tempPathLength > WTF_ARRAY_LENGTH(tempPath))
381         return String();
382
383     String proposedPath;
384     do {
385         wchar_t tempFile[] = L"XXXXXXXX.tmp"; // Use 8.3 style name (more characters aren't helpful due to 8.3 short file names)
386         const int randomPartLength = 8;
387         cryptographicallyRandomValues(tempFile, randomPartLength * sizeof(wchar_t));
388
389         // Limit to valid filesystem characters, also excluding others that could be problematic, like punctuation.
390         // don't include both upper and lowercase since Windows file systems are typically not case sensitive.
391         const char validChars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
392         for (int i = 0; i < randomPartLength; ++i)
393             tempFile[i] = validChars[tempFile[i] % (sizeof(validChars) - 1)];
394
395         ASSERT(wcslen(tempFile) == WTF_ARRAY_LENGTH(tempFile) - 1);
396
397         proposedPath = pathByAppendingComponent(tempPath, tempFile);
398         if (proposedPath.isEmpty())
399             break;
400     } while (!action(proposedPath));
401
402     return proposedPath;
403 }
404
405 String openTemporaryFile(const String&, PlatformFileHandle& handle)
406 {
407     handle = INVALID_HANDLE_VALUE;
408
409     String proposedPath = generateTemporaryPath([&handle](const String& proposedPath) {
410         // use CREATE_NEW to avoid overwriting an existing file with the same name
411         handle = ::CreateFileW(proposedPath.wideCharacters().data(), GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
412
413         return isHandleValid(handle) || GetLastError() == ERROR_ALREADY_EXISTS;
414     });
415
416     if (!isHandleValid(handle))
417         return String();
418
419     return proposedPath;
420 }
421
422 PlatformFileHandle openFile(const String& path, FileOpenMode mode)
423 {
424     DWORD desiredAccess = 0;
425     DWORD creationDisposition = 0;
426     DWORD shareMode = 0;
427     switch (mode) {
428     case FileOpenMode::Read:
429         desiredAccess = GENERIC_READ;
430         creationDisposition = OPEN_EXISTING;
431         shareMode = FILE_SHARE_READ;
432         break;
433     case FileOpenMode::Write:
434         desiredAccess = GENERIC_WRITE;
435         creationDisposition = CREATE_ALWAYS;
436         break;
437     default:
438         ASSERT_NOT_REACHED();
439     }
440
441     String destination = path;
442     return CreateFile(destination.wideCharacters().data(), desiredAccess, shareMode, 0, creationDisposition, FILE_ATTRIBUTE_NORMAL, 0);
443 }
444
445 void closeFile(PlatformFileHandle& handle)
446 {
447     if (isHandleValid(handle)) {
448         ::CloseHandle(handle);
449         handle = invalidPlatformFileHandle;
450     }
451 }
452
453 long long seekFile(PlatformFileHandle handle, long long offset, FileSeekOrigin origin)
454 {
455     DWORD moveMethod = FILE_BEGIN;
456
457     if (origin == FileSeekOrigin::Current)
458         moveMethod = FILE_CURRENT;
459     else if (origin == FileSeekOrigin::End)
460         moveMethod = FILE_END;
461
462     LARGE_INTEGER largeOffset;
463     largeOffset.QuadPart = offset;
464
465     largeOffset.LowPart = SetFilePointer(handle, largeOffset.LowPart, &largeOffset.HighPart, moveMethod);
466
467     if (largeOffset.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
468         return -1;
469
470     return largeOffset.QuadPart;
471 }
472
473 int writeToFile(PlatformFileHandle handle, const char* data, int length)
474 {
475     if (!isHandleValid(handle))
476         return -1;
477
478     DWORD bytesWritten;
479     bool success = WriteFile(handle, data, length, &bytesWritten, 0);
480
481     if (!success)
482         return -1;
483     return static_cast<int>(bytesWritten);
484 }
485
486 int readFromFile(PlatformFileHandle handle, char* data, int length)
487 {
488     if (!isHandleValid(handle))
489         return -1;
490
491     DWORD bytesRead;
492     bool success = ::ReadFile(handle, data, length, &bytesRead, 0);
493
494     if (!success)
495         return -1;
496     return static_cast<int>(bytesRead);
497 }
498
499 bool hardLinkOrCopyFile(const String& source, const String& destination)
500 {
501     return !!::CopyFile(source.wideCharacters().data(), destination.wideCharacters().data(), TRUE);
502 }
503
504 String localUserSpecificStorageDirectory()
505 {
506     return cachedStorageDirectory(CSIDL_LOCAL_APPDATA);
507 }
508
509 String roamingUserSpecificStorageDirectory()
510 {
511     return cachedStorageDirectory(CSIDL_APPDATA);
512 }
513
514 Vector<String> listDirectory(const String& directory, const String& filter)
515 {
516     Vector<String> entries;
517
518     PathWalker walker(directory, filter);
519     if (!walker.isValid())
520         return entries;
521
522     do {
523         if (walker.data().dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
524             && (!wcscmp(walker.data().cFileName, L".") || !wcscmp(walker.data().cFileName, L"..")))
525             continue;
526
527         entries.append(directory + "\\" + reinterpret_cast<const UChar*>(walker.data().cFileName));
528     } while (walker.step());
529
530     return entries;
531 }
532
533 bool getVolumeFreeSpace(const String&, uint64_t&)
534 {
535     return false;
536 }
537
538 Optional<int32_t> getFileDeviceId(const CString& fsFile)
539 {
540     auto handle = openFile(fsFile.data(), FileOpenMode::Read);
541     if (!isHandleValid(handle))
542         return WTF::nullopt;
543
544     BY_HANDLE_FILE_INFORMATION fileInformation = { };
545     if (!::GetFileInformationByHandle(handle, &fileInformation)) {
546         closeFile(handle);
547         return WTF::nullopt;
548     }
549
550     closeFile(handle);
551
552     return fileInformation.dwVolumeSerialNumber;
553 }
554
555 String realPath(const String& filePath)
556 {
557     return getFinalPathName(filePath);
558 }
559
560 String createTemporaryDirectory()
561 {
562     return generateTemporaryPath([](const String& proposedPath) {
563         return makeAllDirectories(proposedPath);
564     });
565 }
566
567 bool deleteNonEmptyDirectory(const String& directoryPath)
568 {
569     SHFILEOPSTRUCT deleteOperation = {
570         nullptr,
571         FO_DELETE,
572         directoryPath.wideCharacters().data(),
573         L"",
574         FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT,
575         false,
576         0,
577         L""
578     };
579     return !SHFileOperation(&deleteOperation);
580 }
581
582 } // namespace FileSystemImpl
583 } // namespace WTF