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