//===- FuzzerIOWindows.cpp - IO utils for Windows. ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// IO functions implementation for Windows.
//===----------------------------------------------------------------------===//
#include "FuzzerPlatform.h"
#if LIBFUZZER_WINDOWS

  #include "FuzzerExtFunctions.h"
  #include "FuzzerIO.h"
  #include <cstdarg>
  #include <cstdio>
  #include <fstream>
  #include <io.h>
  #include <iterator>
  #include <sys/stat.h>
  #include <sys/types.h>
  #include <windows.h>

namespace fuzzer {

static bool IsFile(const std::string &Path, const DWORD &FileAttributes) {

  if (FileAttributes & FILE_ATTRIBUTE_NORMAL) return true;

  if (FileAttributes & FILE_ATTRIBUTE_DIRECTORY) return false;

  HANDLE FileHandle(CreateFileA(Path.c_str(), 0, FILE_SHARE_READ, NULL,
                                OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0));

  if (FileHandle == INVALID_HANDLE_VALUE) {

    Printf("CreateFileA() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
           GetLastError());
    return false;

  }

  DWORD FileType = GetFileType(FileHandle);

  if (FileType == FILE_TYPE_UNKNOWN) {

    Printf("GetFileType() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
           GetLastError());
    CloseHandle(FileHandle);
    return false;

  }

  if (FileType != FILE_TYPE_DISK) {

    CloseHandle(FileHandle);
    return false;

  }

  CloseHandle(FileHandle);
  return true;

}

bool IsFile(const std::string &Path) {

  DWORD Att = GetFileAttributesA(Path.c_str());

  if (Att == INVALID_FILE_ATTRIBUTES) {

    Printf("GetFileAttributesA() failed for \"%s\" (Error code: %lu).\n",
           Path.c_str(), GetLastError());
    return false;

  }

  return IsFile(Path, Att);

}

static bool IsDir(DWORD FileAttrs) {

  if (FileAttrs == INVALID_FILE_ATTRIBUTES) return false;
  return FileAttrs & FILE_ATTRIBUTE_DIRECTORY;

}

bool IsDirectory(const std::string &Path) {

  DWORD Att = GetFileAttributesA(Path.c_str());

  if (Att == INVALID_FILE_ATTRIBUTES) {

    Printf("GetFileAttributesA() failed for \"%s\" (Error code: %lu).\n",
           Path.c_str(), GetLastError());
    return false;

  }

  return IsDir(Att);

}

std::string Basename(const std::string &Path) {

  size_t Pos = Path.find_last_of("/\\");
  if (Pos == std::string::npos) return Path;
  assert(Pos < Path.size());
  return Path.substr(Pos + 1);

}

size_t FileSize(const std::string &Path) {

  WIN32_FILE_ATTRIBUTE_DATA attr;
  if (!GetFileAttributesExA(Path.c_str(), GetFileExInfoStandard, &attr)) {

    DWORD LastError = GetLastError();
    if (LastError != ERROR_FILE_NOT_FOUND)
      Printf("GetFileAttributesExA() failed for \"%s\" (Error code: %lu).\n",
             Path.c_str(), LastError);
    return 0;

  }

  ULARGE_INTEGER size;
  size.HighPart = attr.nFileSizeHigh;
  size.LowPart = attr.nFileSizeLow;
  return size.QuadPart;

}

void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
                             Vector<std::string> *V, bool TopDir) {

  auto E = GetEpoch(Dir);
  if (Epoch)
    if (E && *Epoch >= E) return;

  std::string Path(Dir);
  assert(!Path.empty());
  if (Path.back() != '\\') Path.push_back('\\');
  Path.push_back('*');

  // Get the first directory entry.
  WIN32_FIND_DATAA FindInfo;
  HANDLE           FindHandle(FindFirstFileA(Path.c_str(), &FindInfo));
  if (FindHandle == INVALID_HANDLE_VALUE) {

    if (GetLastError() == ERROR_FILE_NOT_FOUND) return;
    Printf("No such file or directory: %s; exiting\n", Dir.c_str());
    exit(1);

  }

  do {

    std::string FileName = DirPlusFile(Dir, FindInfo.cFileName);

    if (FindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {

      size_t FilenameLen = strlen(FindInfo.cFileName);
      if ((FilenameLen == 1 && FindInfo.cFileName[0] == '.') ||
          (FilenameLen == 2 && FindInfo.cFileName[0] == '.' &&
           FindInfo.cFileName[1] == '.'))
        continue;

      ListFilesInDirRecursive(FileName, Epoch, V, false);

    } else if (IsFile(FileName, FindInfo.dwFileAttributes))

      V->push_back(FileName);

  } while (FindNextFileA(FindHandle, &FindInfo));

  DWORD LastError = GetLastError();
  if (LastError != ERROR_NO_MORE_FILES)
    Printf("FindNextFileA failed (Error code: %lu).\n", LastError);

  FindClose(FindHandle);

  if (Epoch && TopDir) *Epoch = E;

}

void IterateDirRecursive(const std::string &Dir,
                         void (*DirPreCallback)(const std::string &Dir),
                         void (*DirPostCallback)(const std::string &Dir),
                         void (*FileCallback)(const std::string &Dir)) {

  // TODO(metzman): Implement ListFilesInDirRecursive via this function.
  DirPreCallback(Dir);

  DWORD DirAttrs = GetFileAttributesA(Dir.c_str());
  if (!IsDir(DirAttrs)) return;

  std::string TargetDir(Dir);
  assert(!TargetDir.empty());
  if (TargetDir.back() != '\\') TargetDir.push_back('\\');
  TargetDir.push_back('*');

  WIN32_FIND_DATAA FindInfo;
  // Find the directory's first file.
  HANDLE FindHandle = FindFirstFileA(TargetDir.c_str(), &FindInfo);
  if (FindHandle == INVALID_HANDLE_VALUE) {

    DWORD LastError = GetLastError();
    if (LastError != ERROR_FILE_NOT_FOUND) {

      // If the directory isn't empty, then something abnormal is going on.
      Printf("FindFirstFileA failed for %s (Error code: %lu).\n", Dir.c_str(),
             LastError);

    }

    return;

  }

  do {

    std::string Path = DirPlusFile(Dir, FindInfo.cFileName);
    DWORD       PathAttrs = FindInfo.dwFileAttributes;
    if (IsDir(PathAttrs)) {

      // Is Path the current directory (".") or the parent ("..")?
      if (strcmp(FindInfo.cFileName, ".") == 0 ||
          strcmp(FindInfo.cFileName, "..") == 0)
        continue;
      IterateDirRecursive(Path, DirPreCallback, DirPostCallback, FileCallback);

    } else if (PathAttrs != INVALID_FILE_ATTRIBUTES) {

      FileCallback(Path);

    }

  } while (FindNextFileA(FindHandle, &FindInfo));

  DWORD LastError = GetLastError();
  if (LastError != ERROR_NO_MORE_FILES)
    Printf("FindNextFileA failed for %s (Error code: %lu).\n", Dir.c_str(),
           LastError);

  FindClose(FindHandle);
  DirPostCallback(Dir);

}

char GetSeparator() {

  return '\\';

}

FILE *OpenFile(int Fd, const char *Mode) {

  return _fdopen(Fd, Mode);

}

int CloseFile(int Fd) {

  return _close(Fd);

}

int DuplicateFile(int Fd) {

  return _dup(Fd);

}

void RemoveFile(const std::string &Path) {

  _unlink(Path.c_str());

}

void RenameFile(const std::string &OldPath, const std::string &NewPath) {

  rename(OldPath.c_str(), NewPath.c_str());

}

intptr_t GetHandleFromFd(int fd) {

  return _get_osfhandle(fd);

}

bool IsSeparator(char C) {

  return C == '\\' || C == '/';

}

// Parse disk designators, like "C:\". If Relative == true, also accepts: "C:".
// Returns number of characters considered if successful.
static size_t ParseDrive(const std::string &FileName, const size_t Offset,
                         bool Relative = true) {

  if (Offset + 1 >= FileName.size() || FileName[Offset + 1] != ':') return 0;
  if (Offset + 2 >= FileName.size() || !IsSeparator(FileName[Offset + 2])) {

    if (!Relative)  // Accept relative path?
      return 0;
    else
      return 2;

  }

  return 3;

}

// Parse a file name, like: SomeFile.txt
// Returns number of characters considered if successful.
static size_t ParseFileName(const std::string &FileName, const size_t Offset) {

  size_t       Pos = Offset;
  const size_t End = FileName.size();
  for (; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
    ;
  return Pos - Offset;

}

// Parse a directory ending in separator, like: `SomeDir\`
// Returns number of characters considered if successful.
static size_t ParseDir(const std::string &FileName, const size_t Offset) {

  size_t       Pos = Offset;
  const size_t End = FileName.size();
  if (Pos >= End || IsSeparator(FileName[Pos])) return 0;
  for (; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
    ;
  if (Pos >= End) return 0;
  ++Pos;  // Include separator.
  return Pos - Offset;

}

// Parse a servername and share, like: `SomeServer\SomeShare\`
// Returns number of characters considered if successful.
static size_t ParseServerAndShare(const std::string &FileName,
                                  const size_t       Offset) {

  size_t Pos = Offset, Res;
  if (!(Res = ParseDir(FileName, Pos))) return 0;
  Pos += Res;
  if (!(Res = ParseDir(FileName, Pos))) return 0;
  Pos += Res;
  return Pos - Offset;

}

// Parse the given Ref string from the position Offset, to exactly match the
// given string Patt. Returns number of characters considered if successful.
static size_t ParseCustomString(const std::string &Ref, size_t Offset,
                                const char *Patt) {

  size_t Len = strlen(Patt);
  if (Offset + Len > Ref.size()) return 0;
  return Ref.compare(Offset, Len, Patt) == 0 ? Len : 0;

}

// Parse a location, like:
// \\?\UNC\Server\Share\  \\?\C:\  \\Server\Share\  \  C:\  C:
// Returns number of characters considered if successful.
static size_t ParseLocation(const std::string &FileName) {

  size_t Pos = 0, Res;

  if ((Res = ParseCustomString(FileName, Pos, R"(\\?\)"))) {

    Pos += Res;
    if ((Res = ParseCustomString(FileName, Pos, R"(UNC\)"))) {

      Pos += Res;
      if ((Res = ParseServerAndShare(FileName, Pos))) return Pos + Res;
      return 0;

    }

    if ((Res = ParseDrive(FileName, Pos, false))) return Pos + Res;
    return 0;

  }

  if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {

    ++Pos;
    if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {

      ++Pos;
      if ((Res = ParseServerAndShare(FileName, Pos))) return Pos + Res;
      return 0;

    }

    return Pos;

  }

  if ((Res = ParseDrive(FileName, Pos))) return Pos + Res;

  return Pos;

}

std::string DirName(const std::string &FileName) {

  size_t LocationLen = ParseLocation(FileName);
  size_t DirLen = 0, Res;
  while ((Res = ParseDir(FileName, LocationLen + DirLen)))
    DirLen += Res;
  size_t FileLen = ParseFileName(FileName, LocationLen + DirLen);

  if (LocationLen + DirLen + FileLen != FileName.size()) {

    Printf("DirName() failed for \"%s\", invalid path.\n", FileName.c_str());
    exit(1);

  }

  if (DirLen) {

    --DirLen;        // Remove trailing separator.
    if (!FileLen) {  // Path ended in separator.
      assert(DirLen);
      // Remove file name from Dir.
      while (DirLen && !IsSeparator(FileName[LocationLen + DirLen - 1]))
        --DirLen;
      if (DirLen)  // Remove trailing separator.
        --DirLen;

    }

  }

  if (!LocationLen) {  // Relative path.
    if (!DirLen) return ".";
    return std::string(".\\").append(FileName, 0, DirLen);

  }

  return FileName.substr(0, LocationLen + DirLen);

}

std::string TmpDir() {

  std::string Tmp;
  Tmp.resize(MAX_PATH + 1);
  DWORD Size = GetTempPathA(Tmp.size(), &Tmp[0]);
  if (Size == 0) {

    Printf("Couldn't get Tmp path.\n");
    exit(1);

  }

  Tmp.resize(Size);
  return Tmp;

}

bool IsInterestingCoverageFile(const std::string &FileName) {

  if (FileName.find("Program Files") != std::string::npos) return false;
  if (FileName.find("compiler-rt\\lib\\") != std::string::npos)
    return false;  // sanitizer internal.
  if (FileName == "<null>") return false;
  return true;

}

void RawPrint(const char *Str) {

  _write(2, Str, strlen(Str));

}

void MkDir(const std::string &Path) {

  if (CreateDirectoryA(Path.c_str(), nullptr)) return;
  Printf("CreateDirectoryA failed for %s (Error code: %lu).\n", Path.c_str(),
         GetLastError());

}

void RmDir(const std::string &Path) {

  if (RemoveDirectoryA(Path.c_str())) return;
  Printf("RemoveDirectoryA failed for %s (Error code: %lu).\n", Path.c_str(),
         GetLastError());

}

const std::string &getDevNull() {

  static const std::string devNull = "NUL";
  return devNull;

}

}  // namespace fuzzer

#endif  // LIBFUZZER_WINDOWS

