fsfw/src/fsfw_hal/host/HostFilesystem.cpp

#include "HostFilesystem.h"

#include <filesystem>
#include <fstream>

#include "fsfw/serialize.h"

using namespace std::filesystem;
using namespace std;

HostFilesystem::HostFilesystem() = default;

ReturnValue_t HostFilesystem::writeToFile(FileOpParams params, const uint8_t *data) {
  if (params.path() == nullptr) {
    return returnvalue::FAILED;
  }
  path path(params.path());
  std::error_code e;
  if (not exists(path, e)) {
    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
  }
  // This is equivalent to "r+" mode, which is what we need here. Only using ::out would truncate
  // the file
  ofstream file(path, ios::binary | ios::out | ios::in);
  if (file.fail()) {
    return HasFileSystemIF::GENERIC_FILE_ERROR;
  }
  file.seekp(static_cast<unsigned int>(params.offset));
  file.write(reinterpret_cast<const char *>(data), static_cast<unsigned int>(params.size));
  return returnvalue::OK;
}

ReturnValue_t HostFilesystem::readFromFile(FileOpParams params, uint8_t **buffer, size_t &readSize,
                                           size_t maxSize) {
  if (params.path() == nullptr) {
    return returnvalue::FAILED;
  }
  path path(params.path());
  std::error_code e;
  if (not exists(path, e)) {
    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
  }
  ifstream file(path);
  if (file.fail()) {
    return HasFileSystemIF::GENERIC_FILE_ERROR;
  }
  auto sizeToRead = static_cast<unsigned int>(params.size);
  file.seekg(static_cast<unsigned int>(params.offset));
  if (readSize + sizeToRead > maxSize) {
    return SerializeIF::BUFFER_TOO_SHORT;
  }
  file.read(reinterpret_cast<char *>(*buffer), sizeToRead);
  readSize += sizeToRead;
  *buffer += sizeToRead;
  return returnvalue::OK;
}

ReturnValue_t HostFilesystem::createFile(FilesystemParams params, const uint8_t *data,
                                         size_t size) {
  if (params.path == nullptr) {
    return returnvalue::FAILED;
  }
  path path(params.path);
  std::error_code e;
  if (exists(path, e)) {
    return HasFileSystemIF::FILE_ALREADY_EXISTS;
  }
  ofstream file(path);
  if (file.fail()) {
    return HasFileSystemIF::GENERIC_FILE_ERROR;
  }
  return returnvalue::OK;
}

ReturnValue_t HostFilesystem::removeFile(const char *path_, FileSystemArgsIF *args) {
  if (path_ == nullptr) {
    return returnvalue::FAILED;
  }
  path path(path_);
  std::error_code e;
  if (not exists(path, e)) {
    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
  }
  if (remove(path, errorCode)) {
    return returnvalue::OK;
  }
  return HasFileSystemIF::GENERIC_FILE_ERROR;
}

ReturnValue_t HostFilesystem::createDirectory(FilesystemParams params, bool createParentDirs) {
  if (params.path == nullptr) {
    return returnvalue::FAILED;
  }
  path dirPath(params.path);

  std::error_code e;
  if (exists(dirPath, e)) {
    return HasFileSystemIF::DIRECTORY_ALREADY_EXISTS;
  }

  if (createParentDirs) {
    if (create_directories(dirPath, errorCode)) {
      return returnvalue::OK;
    }
    return HasFileSystemIF::GENERIC_DIR_ERROR;
  }
  if (create_directory(dirPath, errorCode)) {
    return returnvalue::OK;
  }
  return HasFileSystemIF::GENERIC_DIR_ERROR;
}

ReturnValue_t HostFilesystem::removeDirectory(FilesystemParams params, bool deleteRecurively) {
  if (params.path == nullptr) {
    return returnvalue::FAILED;
  }
  path dirPath(params.path);
  std::error_code e;
  if (not exists(dirPath, e)) {
    return HasFileSystemIF::DIRECTORY_DOES_NOT_EXIST;
  }
  if (is_regular_file(dirPath)) {
    return HasFileSystemIF::NOT_A_DIRECTORY;
  }
  if (deleteRecurively) {
    if (remove_all(dirPath, errorCode)) {
      return returnvalue::OK;
    }
  } else {
    if (remove(dirPath, errorCode)) {
      return returnvalue::OK;
    }
  }
  // Error handling
  if (errorCode == std::errc::directory_not_empty) {
    return HasFileSystemIF::DIRECTORY_NOT_EMPTY;
  }
  return HasFileSystemIF::GENERIC_DIR_ERROR;
}

ReturnValue_t HostFilesystem::rename(const char *oldPath_, const char *newPath_,
                                     FileSystemArgsIF *args) {
  if (oldPath_ == nullptr or newPath_ == nullptr) {
    return returnvalue::FAILED;
  }
  path oldPath(oldPath_);
  path newPath(newPath_);
  errorCode.clear();
  std::filesystem::rename(oldPath, newPath, errorCode);
  if (errorCode) {
    return HasFileSystemIF::GENERIC_RENAME_ERROR;
  }
  return returnvalue::OK;
}

bool HostFilesystem::fileExists(FilesystemParams params) {
  path path(params.path);
  std::error_code e;
  return filesystem::exists(path, e);
}

ReturnValue_t HostFilesystem::truncateFile(FilesystemParams params) {
  path path(params.path);
  std::error_code e;
  if (not filesystem::exists(path, e)) {
    return FILE_DOES_NOT_EXIST;
  }
  ofstream of(path);
  return returnvalue::OK;
}

bool HostFilesystem::isDirectory(const char *path) { return filesystem::is_directory(path); }

ReturnValue_t HostFilesystem::getBaseFilename(FilesystemParams params, char *nameBuf, size_t maxLen,
                                              size_t &baseNameLen) {
  std::string path(params.path);
  std::string baseName = path.substr(path.find_last_of("/\\") + 1);
  if (baseName.size() + 1 > maxLen) {
    return returnvalue::FAILED;
  }
  std::memcpy(nameBuf, baseName.c_str(), baseName.size());
  nameBuf[baseName.size()] = '\0';
  baseNameLen = baseName.size();
  return returnvalue::OK;
}