lovr/src/filesystem/filesystem.c

#include "filesystem/filesystem.h"
#include "filesystem/file.h"
#include "util.h"
#include <physfs.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef __APPLE__
#include <mach-o/dyld.h>
#endif
#if _WIN32
#include <windows.h>
#include <initguid.h>
#include <KnownFolders.h>
#include <ShlObj.h>
#include <wchar.h>
#else
#include <unistd.h>
#include <pwd.h>
#endif

static FilesystemState state;

void lovrFilesystemInit(const char* arg0, const char* arg1) {
  if (!PHYSFS_init(arg0)) {
    lovrThrow("Could not initialize filesystem: %s", PHYSFS_getLastError());
  }

  state.source = malloc(LOVR_PATH_MAX * sizeof(char));
  state.identity = NULL;
  state.isFused = 1;

  // Try to mount either an archive fused to the executable or an archive from the command line
  lovrFilesystemGetExecutablePath(state.source, LOVR_PATH_MAX);
  if (lovrFilesystemMount(state.source, NULL, 1)) {
    state.isFused = 0;

    if (arg1) {
      strncpy(state.source, arg1, LOVR_PATH_MAX);
      if (!lovrFilesystemMount(state.source, NULL, 1)) {
        goto mounted;
      }
    }

    free(state.source);
    state.source = NULL;
  }

mounted:
  atexit(lovrFilesystemDestroy);
}

void lovrFilesystemDestroy() {
  free(state.source);
  free(state.savePathFull);
  free(state.savePathRelative);
  PHYSFS_deinit();
}

int lovrFilesystemCreateDirectory(const char* path) {
  return !PHYSFS_mkdir(path);
}

int lovrFilesystemExists(const char* path) {
  return PHYSFS_exists(path);
}

int lovrFilesystemGetAppdataDirectory(char* dest, unsigned int size) {
#ifdef __APPLE__
  const char* home;
  if ((home = getenv("HOME")) == NULL) {
    home = getpwuid(getuid())->pw_dir;
  }

  snprintf(dest, size, "%s/Library/Application Support", home);
  return 0;
#elif _WIN32
  PWSTR appData = NULL;
  SHGetKnownFolderPath(&FOLDERID_RoamingAppData, 0, NULL, &appData);
  wcstombs(dest, appData, size);
  CoTaskMemFree(appData);
  return 0;
#elif EMSCRIPTEN
  strncpy(dest, "/home/web_user", size);
  return 0;
#elif __linux__
  const char* home;
  if ((home = getenv("HOME")) == NULL) {
    home = getpwuid(getuid())->pw_dir;
  }

  snprintf(dest, size, "%s/.config", home);
#else
#error "This platform is missing an implementation for lovrFilesystemGetAppdataDirectory"
#endif

  return 1;
}

void lovrFilesystemGetDirectoryItems(const char* path, getDirectoryItemsCallback callback, void* userdata) {
  PHYSFS_enumerateFilesCallback(path, callback, userdata);
}

int lovrFilesystemGetExecutablePath(char* dest, unsigned int size) {
#ifdef __APPLE__
  if (_NSGetExecutablePath(dest, &size) == 0) {
    return 0;
  }
#elif _WIN32
  return !GetModuleFileName(NULL, dest, size);
#elif EMSCRIPTEN
  return 1;
#elif __linux__
  memset(dest, 0, size);
  if (readlink("/proc/self/exe", dest, size) == -1) {
    return 1;
  }
#else
#error "This platform is missing an implementation for lovrFilesystemGetExecutablePath"
#endif

  return 1;
}

const char* lovrFilesystemGetIdentity() {
  return state.identity;
}

long lovrFilesystemGetLastModified(const char* path) {
  return PHYSFS_getLastModTime(path);
}

const char* lovrFilesystemGetRealDirectory(const char* path) {
  return PHYSFS_getRealDir(path);
}

const char* lovrFilesystemGetSaveDirectory() {
  return state.savePathFull;
}

size_t lovrFilesystemGetSize(const char* path) {
  File* file = lovrFileCreate(path);
  lovrFileOpen(file, OPEN_READ);
  size_t size = lovrFileGetSize(file);
  lovrFileClose(file);
  lovrRelease(&file->ref);
  return size;
}

const char* lovrFilesystemGetSource() {
  return state.source;
}

const char* lovrFilesystemGetUserDirectory() {
  return PHYSFS_getUserDir();
}

int lovrFilesystemIsDirectory(const char* path) {
  return PHYSFS_isDirectory(path);
}

int lovrFilesystemIsFile(const char* path) {
  return lovrFilesystemExists(path) && !lovrFilesystemIsDirectory(path);
}

int lovrFilesystemIsFused() {
  return state.isFused;
}

int lovrFilesystemMount(const char* path, const char* mountpoint, int append) {
  return !PHYSFS_mount(path, mountpoint, append);
}

void* lovrFilesystemRead(const char* path, size_t* bytesRead) {

  // Create file
  File* file = lovrFileCreate(path);
  if (!file) {
    return NULL;
  }

  // Open it
  if (lovrFileOpen(file, OPEN_READ)) {
    return NULL;
  }

  // Get file size
  size_t size = lovrFileGetSize(file);
  if (size == (unsigned int) -1) {
    return NULL;
  }

  // Allocate buffer
  void* data = malloc(size);
  if (!data) {
    return NULL;
  }

  // Perform read
  *bytesRead = lovrFileRead(file, data, 1, size);
  lovrFileClose(file);

  // Make sure we got everything
  if (*bytesRead != (size_t) size) {
    free(data);
    return NULL;
  }

  return data;
}

int lovrFilesystemRemove(const char* path) {
  return !PHYSFS_delete(path);
}

int lovrFilesystemSetIdentity(const char* identity) {
  state.identity = identity;

  // Unmount old write directory
  if (state.savePathFull && state.savePathRelative) {
    PHYSFS_removeFromSearchPath(state.savePathRelative);
  } else {
    state.savePathRelative = malloc(LOVR_PATH_MAX);
    state.savePathFull = malloc(LOVR_PATH_MAX);
    if (!state.savePathRelative || !state.savePathFull) {
      return 1;
    }
  }

  lovrFilesystemGetAppdataDirectory(state.savePathFull, LOVR_PATH_MAX);
  PHYSFS_setWriteDir(state.savePathFull);
  snprintf(state.savePathRelative, LOVR_PATH_MAX, "LOVR/%s", identity ? identity : "default");
  char fullPathBuffer[LOVR_PATH_MAX];
  snprintf(fullPathBuffer, LOVR_PATH_MAX, "%s/%s", state.savePathFull, state.savePathRelative);
  strncpy(state.savePathFull, fullPathBuffer, LOVR_PATH_MAX);
  PHYSFS_mkdir(state.savePathRelative);
  if (!PHYSFS_setWriteDir(state.savePathFull)) {
    lovrThrow("Could not set write directory: %s (%s)", PHYSFS_getLastError(), state.savePathRelative);
  }

  PHYSFS_mount(state.savePathFull, NULL, 0);

  return 0;
}

int lovrFilesystemUnmount(const char* path) {
  return !PHYSFS_removeFromSearchPath(path);
}

size_t lovrFilesystemWrite(const char* path, const char* content, size_t size, int append) {
  File* file = lovrFileCreate(path);
  if (!file) {
    return 0;
  }

  lovrFileOpen(file, append ? OPEN_APPEND : OPEN_WRITE);
  size_t bytesWritten = lovrFileWrite(file, (void*) content, 1, size);
  lovrFileClose(file);
  lovrRelease(&file->ref);
  return bytesWritten;
}