IO.Windows.cpp

#include "IO.h"
 
#include "MemoryBufferBackedFileContents.h"
#include "Unicode.h"
 
#include "Unicode.h"
#include "../Logging/Logger.h"
#include "../StringUtilities.h"
#include "../StringViewFormat.h"
 
#include "Unicode.h"
 
#include <ShlObj.h>
#include <Shlwapi.h>
#include <cinttypes>
#include <fstream>
#include <regex>
namespace
{
  Cogs::Logging::Log envLogger = Cogs::Logging::getLogger("PlatformIO");
 
  void logError(HRESULT hr, const char* prefix = "") {
    thread_local static char err[2000];
 
    err[0] = 0;
    if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                       nullptr,
                       hr,
                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                       err,
                       sizeof(err),
                       nullptr) != 0) {
      // Kill newlines.
      for(size_t i = 0; i < std::size(err); i++) {
        if(err[i] == '\r' || err[i] == '\n') err[i] = ' ';
      }
      LOG_ERROR(envLogger, "%s: %s", prefix, err);
    }
    else {
      LOG_ERROR(envLogger, "%s: Failed to retrieve error message for error code %08x.", prefix, hr);
    }
  }
}
 
void Cogs::IO::readFileAsync(const std::string & fileName, const FileContents::Callback& callback, uint64_t offset, uint64_t size, FileContentsHints hints)
{
  if (size == 0 && offset != 0) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: Illegal range, trying to read zero bytes from offset (%" PRIu64 ")", offset);
    callback(std::unique_ptr<FileContents>());
    return;
  }
 
  std::ifstream file(fileName, std::ios::binary | std::ios::in | std::ios::ate);
  if (!file.is_open()) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: Failed to open file %s", fileName.c_str());
    callback(std::unique_ptr<FileContents>());
    return;
  }
 
  file.seekg(0, std::ios::end);
  {
    std::streampos fileSize = file.tellg();
    if (fileSize < 0) {
      LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: tellg returned an error.");
      goto error;
    }
    uint64_t readOffset = 0;
    uint64_t readSize = static_cast<uint64_t>(fileSize);
    if (size != 0) {
      if (readSize < offset) {
        LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: offset (%" PRIu64 ") is greater than filesize (%" PRIu64 ")", offset, static_cast<uint64_t>(fileSize));
        goto error;
      }
      readOffset = offset;
      readSize -= readOffset;
      if (readSize < size) {
        LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: offset (%" PRIu64 ") + size(%" PRIu64 ") is greater than filesize (%" PRIu64 ")", offset, size, static_cast<uint64_t>(fileSize));
        goto error;
      }
      readSize = size;
    }
 
    if (static_cast<uint64_t>(std::numeric_limits<size_t>::max()) < static_cast<uint64_t>(readSize)) {
      LOG_ERROR(envLogger, "Cogs::IO::readFileAsync: offset (%" PRIu64 ") + size(%" PRIu64 ") is greater than max size_t (>4GB read on 32bit?)", offset, size);
      goto error;
    }
 
    auto contents = std::make_unique<MemoryBufferBackedFileContents>(readSize, fileName, hints);
    file.seekg(static_cast<std::streamoff>(readOffset), std::ios::beg);
    file.read((char*)contents->bytes.data(), contents->bytes.size());
    file.close();
    callback(std::move(contents));
  }
  return;
 
error:
  file.close();
  callback(std::unique_ptr<FileContents>());
  return;
}
 
Cogs::FileContents::Ptr Cogs::IO::readFileSync(const std::string & fileName, uint64_t offset, uint64_t size, FileContentsHints hints)
{
  if (size == 0 && offset != 0) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileSync: Illegal range, trying to read zero bytes from offset (%" PRIu64 ")", offset);
    return std::unique_ptr<FileContents>();
  }
 
  std::ifstream file(fileName, std::ios::binary | std::ios::in | std::ios::ate);
  if (!file.is_open()) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileSync: Failed to open file %s", fileName.c_str());
    return std::unique_ptr<FileContents>();
  }
 
  file.seekg(0, std::ios::end);
  std::streampos fileSize = file.tellg();
  if (fileSize < 0) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileSync: tellg returned an error.");
    return std::unique_ptr<FileContents>();
  }
  uint64_t readOffset = 0;
  uint64_t readSize = static_cast<uint64_t>(fileSize);
  if (size != 0) {
    if (readSize < offset) {
      LOG_ERROR(envLogger, "Cogs::IO::readFileSync: offset (%" PRIu64 ") is greater than filesize (%" PRIu64 ")", offset, static_cast<uint64_t>(fileSize));
      return std::unique_ptr<FileContents>();
    }
    readOffset = offset;
    readSize -= readOffset;
    if (readSize < size) {
      LOG_ERROR(envLogger, "Cogs::IO::readFileSync: offset (%" PRIu64 ") + size(%" PRIu64 ") is greater than filesize (%" PRIu64 ")", offset, size, static_cast<uint64_t>(fileSize));
      return std::unique_ptr<FileContents>();
    }
    readSize = size;
  }
 
  if (static_cast<uint64_t>(std::numeric_limits<size_t>::max()) < readSize) {
    LOG_ERROR(envLogger, "Cogs::IO::readFileSync: offset (%" PRIu64 ") + size(%" PRIu64 ") is greater than max size_t (>4GB read on 32bit?)", offset, size);
    return std::unique_ptr<FileContents>();
  }
 
  auto contents = std::make_unique<MemoryBufferBackedFileContents>(readSize, fileName, hints);
  file.seekg(static_cast<std::streamoff>(readOffset), std::ios::beg);
  file.read((char*)contents->bytes.data(), contents->bytes.size());
  file.close();
  return contents;
}
 
bool Cogs::IO::readTextFile(std::string& content, const std::string & fileName) {
  std::ifstream in(fileName);
 
  if (in.good()) {
    content = std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
    return true;
  }
  LOG_ERROR(envLogger, "Cogs::IO::readTextFile(%s): Failed to open file.", fileName.c_str());
  return false;
}
 
void Cogs::IO::autoExpandEnvironmentVariables(std::string & text) {
  static std::regex env("%([0-9A-Za-z\\/]*)%");
 
  std::smatch match;
  while (std::regex_search(text, match, env)) {
    const char * s = std::getenv(match[1].str().c_str());
    const std::string environmentVariable(s == nullptr ? "" : s);
 
    text.replace(match[0].first, match[0].second, environmentVariable);
  }
}
 
std::string Cogs::IO::expandEnvironmentVariables(const std::string & input) {
  std::string text = input;
  autoExpandEnvironmentVariables(text);
  return text;
}
 
std::string Cogs::IO::expandEnvironmentVariable(const std::string & name) {
  const std::string decoratedName = "%" + name + "%";
  char              buffer[2048];
 
  ExpandEnvironmentStringsA(decoratedName.c_str(), buffer, 2048);
  return buffer;
}
 
char Cogs::IO::pathSeparator() {
  return '\\';
}
 
bool Cogs::IO::exists(std::string_view path) {
  return fs::exists(path);
}
 
bool Cogs::IO::isFile(std::string_view path) {
 return fs::is_regular_file(path);
}
 
bool Cogs::IO::isDirectory(std::string_view path) {
  return fs::is_directory(path);
}
 
std::string Cogs::IO::absolute(std::string_view path) {
  return fs::absolute(fs::path(path)).string();
}
 
std::string Cogs::IO::canonical(std::string_view path) {
  std::error_code ec;
  return fs::canonical(fs::path(path), ec).string();
}
 
bool Cogs::IO::remove(std::string_view path) {
  return fs::remove(path);
}
 
std::string Cogs::IO::combine(std::string_view path, std::string_view extensionPath) {
  return (fs::path(path).append(extensionPath)).string();
}
 
std::string Cogs::IO::expandPath(std::string_view fileName) {
  return expandEnvironmentVariables(fs::path(fileName).string());
}
 
std::string Cogs::IO::parentPath(std::string_view str) {
  return fs::path(str.begin(), str.end()).parent_path().string();
}
 
std::string Cogs::IO::relativePath(std::string_view str) {
  return fs::path(str).relative_path().string();
}
 
std::string Cogs::IO::relativePath(std::string_view str, std::string_view base) {
  auto dir = fs::path(base);
  auto p = fs::path(str);
 
  dir = fs::absolute(dir);
  p = fs::absolute(p);
 
  auto beginA = p.begin();
  auto beginB = dir.begin();
 
  while (beginA != p.end() && beginB != dir.end()) {
    if (*beginA != *beginB) break;
 
    ++beginA;
    ++beginB;
  }
 
  fs::path relative;
  for (; beginB != dir.end(); ++beginB) {
    relative /= "..";
  }
 
  for (; beginA != p.end(); ++beginA) {
    relative /= *beginA;
  }
 
  return relative.string();
}
 
std::string Cogs::IO::getPathToExe() {
  char  path[_MAX_PATH];
 
  if (GetModuleFileNameA(nullptr, path, sizeof(path))) {
    return path;
  }
  logError(GetLastError(), "Cogs::UI::getPathToExe()");
  return "";
}
 
std::string Cogs::IO::getPathRelativeToDll(const std::string& fileName, void* handle) {
  wchar_t dllPath[MAX_PATH];
  wchar_t fullPath[MAX_PATH];
  HMODULE hm = nullptr;
 
  if (!GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                          GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                          static_cast<LPCSTR>(handle),
                          &hm)) {
    std::string prefix = "Cogs::UI::getPathRelativeToDll(" + fileName + ")";
    logError(GetLastError(), prefix.c_str());
    return fileName;
  }
 
  GetModuleFileNameW(hm, dllPath, MAX_PATH);
  PathRemoveFileSpecW(dllPath);
  PathCombineW(fullPath, dllPath, Cogs::widen(fileName).c_str());
 
  return narrow(fullPath);
}
 
std::string Cogs::IO::getTempPath() {
  PWSTR       str;
  std::string result;
  HRESULT     hr = SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &str);
 
  if (SUCCEEDED(hr)) {
    char  converted[_MAX_PATH];
 
    if (!WideCharToMultiByte(CP_UTF8, 0, str, -1, converted, sizeof(converted), nullptr, nullptr)) {
      logError(GetLastError(), "Cogs::IO::getTempPath()");
      return "";
    }
    result = converted;
    result += "\\Temp\\";
    CoTaskMemFree(str);
  }
  else {
    logError(hr, "Cogs::IO::getTempPath()");
  }
  return result;
}
 
std::string Cogs::IO::getAppDataPath() {
  return getOrgLocalDataPath() + "\\Cogs\\";
}
 
std::string Cogs::IO::getOrgLocalDataPath() {
  PWSTR       ptr;
  std::string path;
 
  if (SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_DEFAULT, nullptr, &ptr) == S_OK) {
    char  converted[_MAX_PATH];
 
    if (!WideCharToMultiByte(CP_UTF8, 0, ptr, -1, converted, sizeof(converted), nullptr, nullptr)) {
      logError(GetLastError(), "Cogs::IO::getAppDataPath()");
      return "";
    }
    path = converted;
    path += "\\Kongsberg Digital\\";
    CoTaskMemFree(ptr);
  }
  return path;
}
 
bool Cogs::IO::isAbsolute(std::string_view str) {
  return !str.empty() && ((str.size() >= 1 && (str[0] == '/' || str[0] == '\\')) || (str.size() >= 2 && str[1] == ':'));
}
 
bool Cogs::IO::isRelative(std::string_view str) {
  return !isAbsolute(str);
}
 
std::string Cogs::IO::fileName(std::string_view str) {
  return fs::path(str).filename().string();
}
 
std::string Cogs::IO::extension(std::string_view str) {
  return fs::path(str).extension().string();
}
 
std::string Cogs::IO::stem(std::string_view str) {
  return fs::path(str.begin(), str.end()).stem().string();
}
 
void Cogs::IO::replaceAll(std::string& str, std::string_view from, std::string_view to) {
  if (from.empty()) return;
 
  size_t startPos = 0;
  while ((startPos = str.find(from, startPos)) != std::string::npos) {
    str.replace(startPos, from.length(), to);
    startPos += to.length();
  }
}
 
Cogs::IO::FileTimeType Cogs::IO::getFileTime(std::string_view path) {
  std::error_code ec;
  return fs::last_write_time(fs::path(path.begin(), path.end()), ec);
}
 
uint64_t Cogs::IO::getFileSize(std::string_view path) {
  WIN32_FILE_ATTRIBUTE_DATA fad;
  if (!GetFileAttributesExW(Cogs::widen(path).c_str(), GetFileExInfoStandard, &fad)) {
    std::string prefix = Cogs::stringConcatenate({ "Cogs::IO::getFileSize(", path, ")" });
    logError(GetLastError(), prefix.c_str());
    return 0;
  }
  LARGE_INTEGER size;
  size.HighPart = fad.nFileSizeHigh;
  size.LowPart = fad.nFileSizeLow;
  return static_cast<uint64_t>(size.QuadPart);
}
 
bool Cogs::IO::writeBinaryFile(const std::string& fileName, const void* content, size_t contentSize) {
  if (!createDirectories(fileName)) {
    return false;
  }
 
  HANDLE hFile = CreateFileW(Cogs::widen(fs::path(fileName).string()).c_str(),
                             GENERIC_WRITE,
                             0,
                             nullptr,
                             CREATE_ALWAYS,
                             FILE_ATTRIBUTE_NORMAL,
                             nullptr);
 
  if (hFile == INVALID_HANDLE_VALUE) {
    std::string prefix = "Cogs::IO::writeBinaryFile(" + fileName + ")";
    logError(GetLastError(), prefix.c_str());
    return false;
  }
 
  const uint8_t *src = static_cast<const uint8_t*>(content);
  size_t remaining = contentSize;
  while(remaining){
    DWORD write_size = static_cast<DWORD>(std::min(remaining, static_cast<size_t>(std::numeric_limits<DWORD>::max())));
    DWORD written = 0;
 
    if (!WriteFile(hFile, src, write_size, &written, nullptr)) {
      std::string prefix = "Cogs::IO::writeBinaryFile(" + fileName + ")";
      logError(GetLastError(), prefix.c_str());
      CloseHandle(hFile);
      return false;
    }
    src += written;
    remaining -= written;
  }
  CloseHandle(hFile);
  return true;
}
 
bool Cogs::IO::createDirectories(std::string_view fileName) {
  fs::path path(fileName);
 
  if (path.has_parent_path() && !fs::exists(path.parent_path()) && !fs::create_directories(path.parent_path())) {
    LOG_ERROR(envLogger, "Cogs::IO::createDirectories(%.*s) failed.", StringViewFormat(fileName));
    return false;
  }
  return true;
}
 
Cogs::IO::RecursiveDirIterator Cogs::IO::directoryIterator(std::string_view directory) {
  return RecursiveDirIterator(directory);
}
 
std::string Cogs::IO::getPath(const DirectoryEntry& entry) {
  return entry.path().string();
}
 
Cogs::FileHandle::Ptr Cogs::IO::openFile(std::string_view path, FileHandle::OpenMode openMode, FileHandle::AccessMode accessMode) {
  return FileHandle::open(path, openMode, accessMode);
}
 
void Cogs::IO::closeFile(const FileHandle::Ptr& handle) {
  if (handle) {
    handle->close();
  }
}
 
size_t Cogs::IO::fileSize(const FileHandle::Ptr& handle) {
  return handle ? handle->getSize() : 0;
}
 
void* Cogs::IO::mapFile(const FileHandle::Ptr& handle, FileHandle::ProtectionMode protectionMode, size_t offset, size_t size) {
  return handle ? handle->map(protectionMode, offset, size) : nullptr;
}
 
void Cogs::IO::unmapFile(const FileHandle::Ptr& handle) {
  if (handle) {
    handle->unmap();
  }
}
 
bool Cogs::IO::copyFile(std::string_view src, std::string_view dest) {
  BOOL bFailIfExists = FALSE;
 
  if (!CopyFileW(Cogs::widen(src).c_str(), Cogs::widen(dest).c_str(), bFailIfExists)) {
    std::string prefix = Cogs::stringConcatenate({ "Cogs::IO::copyFile(", src, ", ", dest, ")" });
    logError(GetLastError(), prefix.c_str());
    return false;
  }
  return true;
}