IO.Emscripten.cpp

#include "IO.h"
 
#include "FileContents.h"
 
#include "../Logging/Logger.h"
#include "../Collections/SmallVector.h"
 
#include <emscripten/emscripten.h>
#include <emscripten/fetch.h>
#include <cinttypes>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EmscriptenIO");
 
  struct MallocedFileContents : public Cogs::FileContents {
    std::string _origin;
 
    MallocedFileContents(const uint8_t* ptr, size_t len, const std::string& origin, Cogs::FileContentsHints hints) : FileContents(ptr, len, hints), _origin(origin) {}
 
    ~MallocedFileContents() {
      EM_ASM({
        _free($0);
      }, ptr);
    }
    Cogs::Memory::MemoryBuffer  take() override       { return takeCopy(); }
    Cogs::StringView            origin() override     { return _origin; }
  };
 
  struct FetchBackedFileContents : public Cogs::FileContents {
    emscripten_fetch_t* fetch = nullptr;
 
    FetchBackedFileContents(emscripten_fetch_t* fetch, Cogs::FileContentsHints hints) : FileContents((const uint8_t*)fetch->data, fetch->numBytes, hints), fetch(fetch) {}
 
    ~FetchBackedFileContents() {
      if (fetch) {
        emscripten_fetch_close(fetch);
      }
    }
 
    Cogs::Memory::MemoryBuffer  take() override       { return takeCopy(); }
    Cogs::StringView            origin() override     { return fetch->url; }
  };
 
  struct UserData {
    std::string                   name;
    Cogs::FileContents::Callback  callback;
    Cogs::FileContentsHints       hints;
  };
 
  // Signature of fetch-handler provided by client.
  // ----------------------------------------------
  //
  // offset == 0 and size == 0 means read as much as possible.
  // Otherwise, try to read the specified range.
  // offset != 0 and size == 0 is an error and is supposed to get
  // caught before fetch handler is invoked, i.e. it is OK to
  // assert on that.
  void(*EmscriptenIO_fetchHandler)(const char*, UserData*, double offset, double size) = nullptr;
 
  void downloadSucceeded(emscripten_fetch_t *fetch) {
    std::unique_ptr<UserData> userData(reinterpret_cast<UserData *>(fetch->userData));
 
    LOG_TRACE(logger, "Fetched %s (%llu bytes)", fetch->url, fetch->numBytes);
 
    auto contents = std::make_unique<FetchBackedFileContents>(fetch, userData->hints);
    userData->callback(std::move(contents));
  }
 
  void downloadFailed(emscripten_fetch_t *fetch) {
    std::unique_ptr<UserData> userData(reinterpret_cast<UserData *>(fetch->userData));
 
    LOG_ERROR(logger, "Failed to fetch %s (error=%d, status=%s)", fetch->url, fetch->status, fetch->statusText);
 
    emscripten_fetch_close(fetch);
    userData->callback(std::unique_ptr<Cogs::FileContents>());
  }
 
  extern "C" {
    EMSCRIPTEN_KEEPALIVE void registerFetchHandler(void* handler_callback)
    {
      EmscriptenIO_fetchHandler = reinterpret_cast<void(*)(const char*, UserData*, double offset, double size)>(handler_callback);
      LOG_DEBUG(logger, "Client fetch handler set (function=%zu)", size_t(EmscriptenIO_fetchHandler));
    }
 
    EMSCRIPTEN_KEEPALIVE void handleFetchSuccess(void * /*ctx*/, const uint8_t* data, size_t len, UserData* userData)
    {
      LOG_TRACE(logger, "Fetched %s (data=%#zX, len=%zu)", userData->name.c_str(), size_t(data), len);
      auto contents = std::make_unique<MallocedFileContents>(data, len, userData->name, userData->hints);
      userData->callback(std::move(contents));
      delete userData;
    }
 
    EMSCRIPTEN_KEEPALIVE void handleFetchFailure(void * /*ctx*/, UserData* userData)
    {
      LOG_ERROR(logger, "Failed to fetch %s", userData->name.c_str());
      userData->callback(std::unique_ptr<Cogs::FileContents>());
      delete userData;
    }
  }
}
 
void Cogs::IO::readFileAsync(const std::string & path, const FileContents::Callback& callback, uint64_t offset, uint64_t size, FileContentsHints hints)
{
  if(size == 0 && offset != 0) {
    LOG_ERROR(logger, "readFileAsync: Illegal range, trying to read zero bytes from offset (%" PRIu64 ")", offset);
    callback(std::unique_ptr<Cogs::FileContents>());
    return;
  }
 
  auto userData = new UserData{ path, callback, hints };
 
  if (EmscriptenIO_fetchHandler) {
    EmscriptenIO_fetchHandler(path.c_str(), userData, offset, size);
  }
 
  else {
    // uint64_t is max 20, max length is 6(bytes=) + 20 + 1(-) + 20 + 1(/0) = 48.
    char rangeBuffer[64];
    Cogs::Collections::SmallVector<const char*,3> headers;
 
    if(size != 0) {
      // add headers {"Range", "bytes=<start>-<stop>"};
      int n = snprintf(rangeBuffer, sizeof(rangeBuffer),
                       "bytes=%" PRIu64 "-%" PRIu64,
                       offset, offset + std::max(uint64_t(1), size) - 1);
      if( (n < 0) || ( sizeof(rangeBuffer) <= static_cast<size_t>(n)) ) {
        LOG_ERROR(logger, "snprintf failed for: bytes=%" PRIu64 "-%" PRIu64, offset, offset + std::max(uint64_t(1), size) - 1);
        callback(std::unique_ptr<Cogs::FileContents>());
        return;
      }
      headers.push_back("Range");
      headers.push_back(rangeBuffer);
      headers.push_back(nullptr);
    }
 
    emscripten_fetch_attr_t attr;
    emscripten_fetch_attr_init(&attr);
    attr.userData = userData;
    strcpy(attr.requestMethod, "GET");
    attr.attributes = EMSCRIPTEN_FETCH_LOAD_TO_MEMORY;
    attr.onsuccess = downloadSucceeded;
    attr.onerror = downloadFailed;
    if(0 < headers.size()) {
      // header strings get strdup'd in emscripten/system/lib/fetch/emscripten_fetch.cpp
      attr.requestHeaders = headers.data();
    }
    emscripten_fetch(&attr, path.c_str());
  }
}
 
Cogs::FileContents::Ptr Cogs::IO::readFileSync(const std::string& /*fileName*/, uint64_t /*offset*/, uint64_t /*size*/, FileContentsHints /*hints*/) {
  assert(false && "Should not happen");
  return {};
}
 
bool Cogs::IO::readTextFile(std::string& /*content*/, const std::string& /*fileName*/) {
  return false;
}
 
void Cogs::IO::autoExpandEnvironmentVariables(std::string& /*text*/) {
}
 
std::string Cogs::IO::expandEnvironmentVariables(const std::string& input) {
  return input;
}
 
std::string Cogs::IO::expandEnvironmentVariable(const std::string& /*name*/) {
  return std::string();
}
 
char Cogs::IO::pathSeparator() {
  return '/';
}
 
bool Cogs::IO::exists(std::string_view /*path*/) {
  return false;
}
 
bool Cogs::IO::isFile(std::string_view /*path*/) {
  return false;
}
 
bool Cogs::IO::isDirectory(std::string_view /*path*/) {
  return false;
}
 
std::string Cogs::IO::absolute(std::string_view path) {
  return std::string(path);
}
 
std::string Cogs::IO::canonical(std::string_view path) {
  return std::string(path);
}
 
bool Cogs::IO::remove(std::string_view /*path*/) {
  return false;
}
 
std::string Cogs::IO::combine(std::string_view path, std::string_view extensionPath) {
  if (path.empty()) return std::string(extensionPath);
 
  // For some urls with parameter list where we dont want / between search path and resource name.  Eg. service?fileName=resourceName
  std::string combined;
  combined.reserve(path.length() + extensionPath.length() + 1U);
 
  combined += path;
  if (path.back() != '=') {
    combined += '/';
  }
  combined += extensionPath;
 
  const std::string sep = "://";
  size_t sepI = combined.find(sep);
  sepI = (sepI == std::string::npos) ? 0 : sepI + sep.size();
 
  std::string prefix = combined.substr(0, sepI);
  std::string body = combined.substr(sepI);
 
  replaceAll(body, "\\", "/");
 
  size_t newSize = 0;
  for (size_t i = 0, n = body.size(); i < n; i++) {
    body[newSize++] = body[i];
 
    // Skip consecutive '/': "a///b/c///d//" => "a/b/c/d/"
    while (i + 1 < n && body[i] == '/' && body[i + 1] == '/') i++;
  }
  body.resize(newSize);
 
  return prefix + body;
}
 
std::string Cogs::IO::expandPath(std::string_view /*fileName*/) {
  return std::string();
}
 
std::string Cogs::IO::parentPath(std::string_view str) {
  std::string path(str);
 
  replaceAll(path, "\\", "/");
  return path.substr(0, path.find_last_of('/'));
}
 
std::string Cogs::IO::relativePath(std::string_view str) {
  return std::string(str);
}
 
std::string Cogs::IO::relativePath(std::string_view str, std::string_view /*base*/) {
  return std::string(str);
}
 
std::string Cogs::IO::getPathToExe() {
  assert(false); // TODO
  return std::string();
}
 
std::string Cogs::IO::getPathRelativeToDll(const std::string& /*fileName*/, void* /*handle*/) {
  assert(false); // TODO
  return std::string();
}
 
std::string Cogs::IO::getTempPath() {
  return std::string();
}
 
std::string Cogs::IO::getAppDataPath() {
  return "./";
}
 
std::string Cogs::IO::getOrgLocalDataPath() {
  return "./";
}
 
bool Cogs::IO::isAbsolute(std::string_view str) {
  // If separator after URL scheme is present, assume it is an absolute path, otherwise assume relative.
  return str.find("://") != std::string_view::npos;
}
 
bool Cogs::IO::isRelative(std::string_view str) {
  // If separator after URL scheme is present, assume it is an absolute path, otherwise assume relative.
  return str.find("://") == std::string_view::npos;
}
 
std::string Cogs::IO::fileName(std::string_view str) {
  size_t lastSep = str.find_last_of("/\\");
  return lastSep == std::string_view::npos ? std::string(str) : std::string(str.substr(lastSep + 1U));
}
 
std::string Cogs::IO::extension(std::string_view str) {
  size_t found = str.find_last_of('.');
  size_t lastSep = str.find_last_of("/\\");
  if (found == std::string_view::npos) {
    return std::string();
  }
  else if (lastSep != std::string_view::npos && lastSep > found) {
    return std::string();
  }
  return std::string(str.substr(found));
}
 
std::string Cogs::IO::stem(std::string_view str) {
  std::string fn = Cogs::IO::fileName(str);
  std::string ext = Cogs::IO::extension(fn);
  return fn.substr(0, fn.length() - ext.length());
}
 
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*/) {
  return {};
}
 
uint64_t Cogs::IO::getFileSize(std::string_view /*path*/) {
  return 0;
}
 
bool Cogs::IO::writeBinaryFile(const std::string& /*fileName*/, const void* /*content*/, size_t /*contentSize*/) {
  return false;
}
 
bool Cogs::IO::createDirectories(std::string_view /*fileName*/) {
  return false;
}
 
Cogs::IO::RecursiveDirIterator Cogs::IO::directoryIterator(std::string_view /*directory*/) {
  return {};
}
 
std::string Cogs::IO::getPath(const DirectoryEntry& entry) {
  return entry;
}