IO.Linux.cpp

#if !defined( _GNU_SOURCE )
  #define _GNU_SOURCE
#endif
 
#include "IO.h"
 
#include "MemoryBufferBackedFileContents.h"
 
#include "../Logging/Logger.h"
 
#include <cinttypes>
#include <dlfcn.h>
#include <fcntl.h>
#include <fstream>
#include <regex>
#include <unistd.h>
#include <sys/stat.h>
 
namespace
{
  Cogs::Logging::Log envLogger = Cogs::Logging::getLogger("PlatformIO");
}
 
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, "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, "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, "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, "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, "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, "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;
}
 
std::unique_ptr<Cogs::FileContents> Cogs::IO::readFileSync(const std::string & fileName, uint64_t offset, uint64_t size, FileContentsHints hints)
{
  if (size == 0 && offset != 0) {
    LOG_ERROR(envLogger, "readFileAsync: 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, "readFileAsync: 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, "readFileAsync: 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, "readFileAsync: 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, "readFileAsync: 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, "readFileAsync: 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;
  }
  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 char *tmp = getenv(name.c_str());
 
  return std::string(tmp ? tmp : "");
}
 
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[200] = {};
 
  readlink("/proc/self/exe", path, sizeof(path) - 1);
  return path;
}
 
std::string Cogs::IO::getPathRelativeToDll(const std::string& fileName, void* handle) {
  Dl_info     info;
  std::string fullPath;
 
  if (!dladdr(handle, &info)) {
    return fileName;
  }
  fullPath = info.dli_fname;
  fullPath = fullPath.substr(0, fullPath.find_last_of('/') + 1);
  fullPath += fileName;
 
  return fullPath;
}
 
std::string Cogs::IO::getTempPath() {
  return "/tmp/";
}
 
std::string Cogs::IO::getAppDataPath() {
  return getOrgLocalDataPath() + "/Cogs/";
}
 
std::string Cogs::IO::getOrgLocalDataPath() {
  if(getuid() == 0){
    mkdir("/etc/Kongsberg",  S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
    return std::string("/etc/Kongsberg Digital/");
  }
  else{
    std::string path = expandEnvironmentVariable("HOME");
    path += "/.local/share/Kongsberg Digital/";
    return path;
  }
}
 
bool Cogs::IO::isAbsolute(std::string_view str) {
  return (str.size() >= 1) && (str[0] == '/');
}
 
bool Cogs::IO::isRelative(std::string_view str) {
  return !isAbsolute(str);
}
 
std::string Cogs::IO::fileName(std::string_view str) {
  size_t lastSep = str.find_last_of("/\\");
  if (lastSep != std::string_view::npos) {
    str = str.substr(lastSep + 1);
  }
 
  return std::string(str);
}
 
std::string Cogs::IO::extension(std::string_view str) {
  size_t lastSep = str.find_last_of("/\\");
  if (lastSep != std::string_view::npos) {
    str = str.substr(lastSep + 1);
  }
 
  return fs::path(str).extension().string();
}
 
std::string Cogs::IO::stem(std::string_view str) {
  size_t lastSep = str.find_last_of("/\\");
  if (lastSep != std::string_view::npos) {
    str = str.substr(lastSep + 1);
  }
 
  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) {
  struct stat st;
  if(::stat(std::string(path).c_str(), &st) != 0) {
    return 0;
  }
  return static_cast<uint64_t>(st.st_size);
}
 
bool Cogs::IO::writeBinaryFile(const std::string & fileName, const void * content, size_t contentSize) {
  fs::path path(fileName);
 
  if (path.has_parent_path() && !fs::exists(path.parent_path()) && !fs::create_directories(path.parent_path())) {
    return false;
  }
 
  int fd = open(path.string().c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0664);
  if(fd == -1) return false;
 
  const uint8_t *src = static_cast<const uint8_t*>(content);
  size_t remaining = contentSize;
  while(remaining){
    size_t write_size = remaining;
    ssize_t ret = write(fd, src, write_size);
    if(ret == 0 || (ret == -1 && errno != EINTR)){
      close(fd);
      return false;
    }
    if(ret > 0){
      size_t written = ret;
      src += written;
      remaining -= written;
    }
  }
 
  close(fd);
  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())) {
    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();
}
 
#ifdef __linux__
 
 
bool Cogs::IO::copyFile(std::string_view src, std::string_view dest)
{
  int fd_in = open(src.data(), O_RDONLY);
  if(fd_in == -1){
    return false;
  }
  struct stat s;
  if(fstat(fd_in, &s) == -1){
    close(fd_in);
    return false;
  }
  int fd_out = open(dest.data(), O_CREAT | O_WRONLY | O_TRUNC, s.st_mode&0x777);
  if(fd_out == -1){
    close(fd_in);
    return false;
  }
 
  size_t remaining = s.st_size;
  while(remaining){
    ssize_t ret = copy_file_range(fd_in, nullptr, fd_out, nullptr, remaining, 0);
    if(ret == -1){
      close(fd_in);
      close(fd_out);
      return false;
    }
    remaining -= ret;
  }
 
  close(fd_in);
  close(fd_out);
  return true;
}
 
#else
#include <filesystem>
bool Cogs::IO::copyFile(std::string_view src, std::string_view dest)
{
  std::error_code ec;
  if(!std::filesystem::copy_file(src, dest, ec)) {
    return false;
  }
  if(!ec) {
    LOG_ERROR(envLogger, "Failed to copy %.*s to %.*s: %s",
              StringViewFormat(src),
              StringViewFormat(dest),
              ec.message().c_str());
    return false;
  }
  return true;
}
#endif