1 //===- FuzzerIOWindows.cpp - IO utils for Windows. ------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 // IO functions implementation for Windows.
9 //===----------------------------------------------------------------------===//
10 #include "FuzzerPlatform.h"
11 #if LIBFUZZER_WINDOWS
12
13 #include "FuzzerExtFunctions.h"
14 #include "FuzzerIO.h"
15 #include <cstdarg>
16 #include <cstdio>
17 #include <fstream>
18 #include <io.h>
19 #include <iterator>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include <windows.h>
23
24 namespace fuzzer {
25
IsFile(const std::string & Path,const DWORD & FileAttributes)26 static bool IsFile(const std::string &Path, const DWORD &FileAttributes) {
27
28 if (FileAttributes & FILE_ATTRIBUTE_NORMAL)
29 return true;
30
31 if (FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
32 return false;
33
34 HANDLE FileHandle(
35 CreateFileA(Path.c_str(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
36 FILE_FLAG_BACKUP_SEMANTICS, 0));
37
38 if (FileHandle == INVALID_HANDLE_VALUE) {
39 Printf("CreateFileA() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
40 GetLastError());
41 return false;
42 }
43
44 DWORD FileType = GetFileType(FileHandle);
45
46 if (FileType == FILE_TYPE_UNKNOWN) {
47 Printf("GetFileType() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
48 GetLastError());
49 CloseHandle(FileHandle);
50 return false;
51 }
52
53 if (FileType != FILE_TYPE_DISK) {
54 CloseHandle(FileHandle);
55 return false;
56 }
57
58 CloseHandle(FileHandle);
59 return true;
60 }
61
IsFile(const std::string & Path)62 bool IsFile(const std::string &Path) {
63 DWORD Att = GetFileAttributesA(Path.c_str());
64
65 if (Att == INVALID_FILE_ATTRIBUTES) {
66 Printf("GetFileAttributesA() failed for \"%s\" (Error code: %lu).\n",
67 Path.c_str(), GetLastError());
68 return false;
69 }
70
71 return IsFile(Path, Att);
72 }
73
IsDir(DWORD FileAttrs)74 static bool IsDir(DWORD FileAttrs) {
75 if (FileAttrs == INVALID_FILE_ATTRIBUTES) return false;
76 return FileAttrs & FILE_ATTRIBUTE_DIRECTORY;
77 }
78
IsDirectory(const std::string & Path)79 bool IsDirectory(const std::string &Path) {
80 DWORD Att = GetFileAttributesA(Path.c_str());
81
82 if (Att == INVALID_FILE_ATTRIBUTES) {
83 Printf("GetFileAttributesA() failed for \"%s\" (Error code: %lu).\n",
84 Path.c_str(), GetLastError());
85 return false;
86 }
87
88 return IsDir(Att);
89 }
90
Basename(const std::string & Path)91 std::string Basename(const std::string &Path) {
92 size_t Pos = Path.find_last_of("/\\");
93 if (Pos == std::string::npos) return Path;
94 assert(Pos < Path.size());
95 return Path.substr(Pos + 1);
96 }
97
FileSize(const std::string & Path)98 size_t FileSize(const std::string &Path) {
99 WIN32_FILE_ATTRIBUTE_DATA attr;
100 if (!GetFileAttributesExA(Path.c_str(), GetFileExInfoStandard, &attr)) {
101 DWORD LastError = GetLastError();
102 if (LastError != ERROR_FILE_NOT_FOUND)
103 Printf("GetFileAttributesExA() failed for \"%s\" (Error code: %lu).\n",
104 Path.c_str(), LastError);
105 return 0;
106 }
107 ULARGE_INTEGER size;
108 size.HighPart = attr.nFileSizeHigh;
109 size.LowPart = attr.nFileSizeLow;
110 return size.QuadPart;
111 }
112
ListFilesInDirRecursive(const std::string & Dir,long * Epoch,Vector<std::string> * V,bool TopDir)113 void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
114 Vector<std::string> *V, bool TopDir) {
115 auto E = GetEpoch(Dir);
116 if (Epoch)
117 if (E && *Epoch >= E) return;
118
119 std::string Path(Dir);
120 assert(!Path.empty());
121 if (Path.back() != '\\')
122 Path.push_back('\\');
123 Path.push_back('*');
124
125 // Get the first directory entry.
126 WIN32_FIND_DATAA FindInfo;
127 HANDLE FindHandle(FindFirstFileA(Path.c_str(), &FindInfo));
128 if (FindHandle == INVALID_HANDLE_VALUE)
129 {
130 if (GetLastError() == ERROR_FILE_NOT_FOUND)
131 return;
132 Printf("No such file or directory: %s; exiting\n", Dir.c_str());
133 exit(1);
134 }
135
136 do {
137 std::string FileName = DirPlusFile(Dir, FindInfo.cFileName);
138
139 if (FindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
140 size_t FilenameLen = strlen(FindInfo.cFileName);
141 if ((FilenameLen == 1 && FindInfo.cFileName[0] == '.') ||
142 (FilenameLen == 2 && FindInfo.cFileName[0] == '.' &&
143 FindInfo.cFileName[1] == '.'))
144 continue;
145
146 ListFilesInDirRecursive(FileName, Epoch, V, false);
147 }
148 else if (IsFile(FileName, FindInfo.dwFileAttributes))
149 V->push_back(FileName);
150 } while (FindNextFileA(FindHandle, &FindInfo));
151
152 DWORD LastError = GetLastError();
153 if (LastError != ERROR_NO_MORE_FILES)
154 Printf("FindNextFileA failed (Error code: %lu).\n", LastError);
155
156 FindClose(FindHandle);
157
158 if (Epoch && TopDir)
159 *Epoch = E;
160 }
161
162
IterateDirRecursive(const std::string & Dir,void (* DirPreCallback)(const std::string & Dir),void (* DirPostCallback)(const std::string & Dir),void (* FileCallback)(const std::string & Dir))163 void IterateDirRecursive(const std::string &Dir,
164 void (*DirPreCallback)(const std::string &Dir),
165 void (*DirPostCallback)(const std::string &Dir),
166 void (*FileCallback)(const std::string &Dir)) {
167 // TODO(metzman): Implement ListFilesInDirRecursive via this function.
168 DirPreCallback(Dir);
169
170 DWORD DirAttrs = GetFileAttributesA(Dir.c_str());
171 if (!IsDir(DirAttrs)) return;
172
173 std::string TargetDir(Dir);
174 assert(!TargetDir.empty());
175 if (TargetDir.back() != '\\') TargetDir.push_back('\\');
176 TargetDir.push_back('*');
177
178 WIN32_FIND_DATAA FindInfo;
179 // Find the directory's first file.
180 HANDLE FindHandle = FindFirstFileA(TargetDir.c_str(), &FindInfo);
181 if (FindHandle == INVALID_HANDLE_VALUE) {
182 DWORD LastError = GetLastError();
183 if (LastError != ERROR_FILE_NOT_FOUND) {
184 // If the directory isn't empty, then something abnormal is going on.
185 Printf("FindFirstFileA failed for %s (Error code: %lu).\n", Dir.c_str(),
186 LastError);
187 }
188 return;
189 }
190
191 do {
192 std::string Path = DirPlusFile(Dir, FindInfo.cFileName);
193 DWORD PathAttrs = FindInfo.dwFileAttributes;
194 if (IsDir(PathAttrs)) {
195 // Is Path the current directory (".") or the parent ("..")?
196 if (strcmp(FindInfo.cFileName, ".") == 0 ||
197 strcmp(FindInfo.cFileName, "..") == 0)
198 continue;
199 IterateDirRecursive(Path, DirPreCallback, DirPostCallback, FileCallback);
200 } else if (PathAttrs != INVALID_FILE_ATTRIBUTES) {
201 FileCallback(Path);
202 }
203 } while (FindNextFileA(FindHandle, &FindInfo));
204
205 DWORD LastError = GetLastError();
206 if (LastError != ERROR_NO_MORE_FILES)
207 Printf("FindNextFileA failed for %s (Error code: %lu).\n", Dir.c_str(),
208 LastError);
209
210 FindClose(FindHandle);
211 DirPostCallback(Dir);
212 }
213
GetSeparator()214 char GetSeparator() {
215 return '\\';
216 }
217
OpenFile(int Fd,const char * Mode)218 FILE* OpenFile(int Fd, const char* Mode) {
219 return _fdopen(Fd, Mode);
220 }
221
CloseFile(int Fd)222 int CloseFile(int Fd) {
223 return _close(Fd);
224 }
225
DuplicateFile(int Fd)226 int DuplicateFile(int Fd) {
227 return _dup(Fd);
228 }
229
RemoveFile(const std::string & Path)230 void RemoveFile(const std::string &Path) {
231 _unlink(Path.c_str());
232 }
233
RenameFile(const std::string & OldPath,const std::string & NewPath)234 void RenameFile(const std::string &OldPath, const std::string &NewPath) {
235 rename(OldPath.c_str(), NewPath.c_str());
236 }
237
GetHandleFromFd(int fd)238 intptr_t GetHandleFromFd(int fd) {
239 return _get_osfhandle(fd);
240 }
241
IsSeparator(char C)242 bool IsSeparator(char C) {
243 return C == '\\' || C == '/';
244 }
245
246 // Parse disk designators, like "C:\". If Relative == true, also accepts: "C:".
247 // Returns number of characters considered if successful.
ParseDrive(const std::string & FileName,const size_t Offset,bool Relative=true)248 static size_t ParseDrive(const std::string &FileName, const size_t Offset,
249 bool Relative = true) {
250 if (Offset + 1 >= FileName.size() || FileName[Offset + 1] != ':')
251 return 0;
252 if (Offset + 2 >= FileName.size() || !IsSeparator(FileName[Offset + 2])) {
253 if (!Relative) // Accept relative path?
254 return 0;
255 else
256 return 2;
257 }
258 return 3;
259 }
260
261 // Parse a file name, like: SomeFile.txt
262 // Returns number of characters considered if successful.
ParseFileName(const std::string & FileName,const size_t Offset)263 static size_t ParseFileName(const std::string &FileName, const size_t Offset) {
264 size_t Pos = Offset;
265 const size_t End = FileName.size();
266 for(; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
267 ;
268 return Pos - Offset;
269 }
270
271 // Parse a directory ending in separator, like: `SomeDir\`
272 // Returns number of characters considered if successful.
ParseDir(const std::string & FileName,const size_t Offset)273 static size_t ParseDir(const std::string &FileName, const size_t Offset) {
274 size_t Pos = Offset;
275 const size_t End = FileName.size();
276 if (Pos >= End || IsSeparator(FileName[Pos]))
277 return 0;
278 for(; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
279 ;
280 if (Pos >= End)
281 return 0;
282 ++Pos; // Include separator.
283 return Pos - Offset;
284 }
285
286 // Parse a servername and share, like: `SomeServer\SomeShare\`
287 // Returns number of characters considered if successful.
ParseServerAndShare(const std::string & FileName,const size_t Offset)288 static size_t ParseServerAndShare(const std::string &FileName,
289 const size_t Offset) {
290 size_t Pos = Offset, Res;
291 if (!(Res = ParseDir(FileName, Pos)))
292 return 0;
293 Pos += Res;
294 if (!(Res = ParseDir(FileName, Pos)))
295 return 0;
296 Pos += Res;
297 return Pos - Offset;
298 }
299
300 // Parse the given Ref string from the position Offset, to exactly match the given
301 // string Patt.
302 // Returns number of characters considered if successful.
ParseCustomString(const std::string & Ref,size_t Offset,const char * Patt)303 static size_t ParseCustomString(const std::string &Ref, size_t Offset,
304 const char *Patt) {
305 size_t Len = strlen(Patt);
306 if (Offset + Len > Ref.size())
307 return 0;
308 return Ref.compare(Offset, Len, Patt) == 0 ? Len : 0;
309 }
310
311 // Parse a location, like:
312 // \\?\UNC\Server\Share\ \\?\C:\ \\Server\Share\ \ C:\ C:
313 // Returns number of characters considered if successful.
ParseLocation(const std::string & FileName)314 static size_t ParseLocation(const std::string &FileName) {
315 size_t Pos = 0, Res;
316
317 if ((Res = ParseCustomString(FileName, Pos, R"(\\?\)"))) {
318 Pos += Res;
319 if ((Res = ParseCustomString(FileName, Pos, R"(UNC\)"))) {
320 Pos += Res;
321 if ((Res = ParseServerAndShare(FileName, Pos)))
322 return Pos + Res;
323 return 0;
324 }
325 if ((Res = ParseDrive(FileName, Pos, false)))
326 return Pos + Res;
327 return 0;
328 }
329
330 if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {
331 ++Pos;
332 if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {
333 ++Pos;
334 if ((Res = ParseServerAndShare(FileName, Pos)))
335 return Pos + Res;
336 return 0;
337 }
338 return Pos;
339 }
340
341 if ((Res = ParseDrive(FileName, Pos)))
342 return Pos + Res;
343
344 return Pos;
345 }
346
DirName(const std::string & FileName)347 std::string DirName(const std::string &FileName) {
348 size_t LocationLen = ParseLocation(FileName);
349 size_t DirLen = 0, Res;
350 while ((Res = ParseDir(FileName, LocationLen + DirLen)))
351 DirLen += Res;
352 size_t FileLen = ParseFileName(FileName, LocationLen + DirLen);
353
354 if (LocationLen + DirLen + FileLen != FileName.size()) {
355 Printf("DirName() failed for \"%s\", invalid path.\n", FileName.c_str());
356 exit(1);
357 }
358
359 if (DirLen) {
360 --DirLen; // Remove trailing separator.
361 if (!FileLen) { // Path ended in separator.
362 assert(DirLen);
363 // Remove file name from Dir.
364 while (DirLen && !IsSeparator(FileName[LocationLen + DirLen - 1]))
365 --DirLen;
366 if (DirLen) // Remove trailing separator.
367 --DirLen;
368 }
369 }
370
371 if (!LocationLen) { // Relative path.
372 if (!DirLen)
373 return ".";
374 return std::string(".\\").append(FileName, 0, DirLen);
375 }
376
377 return FileName.substr(0, LocationLen + DirLen);
378 }
379
TmpDir()380 std::string TmpDir() {
381 std::string Tmp;
382 Tmp.resize(MAX_PATH + 1);
383 DWORD Size = GetTempPathA(Tmp.size(), &Tmp[0]);
384 if (Size == 0) {
385 Printf("Couldn't get Tmp path.\n");
386 exit(1);
387 }
388 Tmp.resize(Size);
389 return Tmp;
390 }
391
IsInterestingCoverageFile(const std::string & FileName)392 bool IsInterestingCoverageFile(const std::string &FileName) {
393 if (FileName.find("Program Files") != std::string::npos)
394 return false;
395 if (FileName.find("compiler-rt\\lib\\") != std::string::npos)
396 return false; // sanitizer internal.
397 if (FileName == "<null>")
398 return false;
399 return true;
400 }
401
RawPrint(const char * Str)402 void RawPrint(const char *Str) {
403 _write(2, Str, strlen(Str));
404 }
405
MkDir(const std::string & Path)406 void MkDir(const std::string &Path) {
407 if (CreateDirectoryA(Path.c_str(), nullptr)) return;
408 Printf("CreateDirectoryA failed for %s (Error code: %lu).\n", Path.c_str(),
409 GetLastError());
410 }
411
RmDir(const std::string & Path)412 void RmDir(const std::string &Path) {
413 if (RemoveDirectoryA(Path.c_str())) return;
414 Printf("RemoveDirectoryA failed for %s (Error code: %lu).\n", Path.c_str(),
415 GetLastError());
416 }
417
getDevNull()418 const std::string &getDevNull() {
419 static const std::string devNull = "NUL";
420 return devNull;
421 }
422
423 } // namespace fuzzer
424
425 #endif // LIBFUZZER_WINDOWS
426