fs.cpp

#include "crucible/unix/fs.hpp"

#include "crucible/core/resource_warden.inl"

#include <dirent.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <cstring>
#include <type_traits>
#include <utility>

namespace crucible::unix::fs {
  namespace {
    struct CloseAdapter final {
      auto operator()(int const descriptor) const -> void {
        ::close(descriptor);
      }
    };

    using FileDescriptorWarden = core::resource_warden::ResourceWarden<int const, CloseAdapter>;

    struct CloseDirAdapter final {
      auto operator()(::DIR *directory_handle) const -> void {
        ::closedir(directory_handle);
      }
    };

    using DirectoryHandleWarden = core::resource_warden::ResourceWarden<::DIR *, CloseDirAdapter>;

    [[nodiscard]]
    auto permissions_to_bits(std::set<FilePermission> const &permissions) -> ::mode_t {
      ::mode_t permission_bits { 0 };

      for (auto const permission : permissions) {
        switch (permission) {
        case FilePermission::OwnerCanRead:
          permission_bits |= S_IRUSR;
          break;

        case FilePermission::OwnerCanWrite:
          permission_bits |= S_IWUSR;
          break;

        case FilePermission::OwnerCanExecute:
          permission_bits |= S_IXUSR;
          break;

        case FilePermission::GroupCanRead:
          permission_bits |= S_IRGRP;
          break;

        case FilePermission::GroupCanWrite:
          permission_bits |= S_IWGRP;
          break;

        case FilePermission::GroupCanExecute:
          permission_bits |= S_IXGRP;
          break;

        case FilePermission::WorldCanRead:
          permission_bits |= S_IROTH;
          break;

        case FilePermission::WorldCanWrite:
          permission_bits |= S_IWOTH;
          break;

        case FilePermission::WorldCanExecute:
          permission_bits |= S_IXOTH;
          break;

        case FilePermission::SetUserID:
          permission_bits |= S_ISUID;
          break;

        case FilePermission::SetGroupID:
          permission_bits |= S_ISGID;
          break;

        case FilePermission::Sticky:
          permission_bits |= S_ISVTX;
          break;
        }
      }

      return permission_bits;
    }
  }

  auto create_directory(std::string const &path, std::set<FilePermission> const &permissions) -> errors::UnixResult<core::none::None> {
    auto const permission_bits { permissions_to_bits(permissions) };

    int const mkdir_status { ::mkdir(path.data(), permission_bits) };
    if (mkdir_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::MkdirFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto create_file(std::string const &path, std::vector<std::byte> const &buffer, std::set<FilePermission> const &permissions) -> errors::UnixResult<core::none::None> {
    auto const permission_bits { permissions_to_bits(permissions) };

    int const file_descriptor { ::open(path.data(), O_WRONLY | O_CREAT | O_EXCL | O_TRUNC, permission_bits) };
    if (file_descriptor < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::OpenFailed {});
    }

    FileDescriptorWarden const warden { file_descriptor };

    std::size_t const total_size { buffer.size() };
    std::size_t bytes_written { 0 };

    int write_status { 0 };

    do {
      write_status = ::write(file_descriptor, buffer.data(), total_size - bytes_written);
      if (write_status > 0) {
        bytes_written += write_status;
      }
    } while (bytes_written < total_size && write_status > 0);

    if (write_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::WriteFailed {});
    } else if (bytes_written < total_size) {
      return core::either::make_lhs<errors::UnixError>(errors::IncompleteWrite {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto delete_directory(std::string const &path) -> errors::UnixResult<core::none::None> {
    int const rmdir_status { ::rmdir(path.data()) };

    if (rmdir_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::RmdirFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto delete_file(std::string const &path) -> errors::UnixResult<core::none::None> {
    int const unlink_status { ::unlink(path.data()) };

    if (unlink_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::UnlinkFailed {});
    }

    return core::either::make_rhs<core::none::None>();
  }

  auto is_directory(std::string const &path) -> errors::UnixResult<bool> {
    struct ::stat metadata;

    int const stat_status { ::stat(path.data(), &metadata) };
    if (stat_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::StatFailed {});
    }

    return core::either::make_rhs<bool>((metadata.st_mode & S_IFMT) == S_IFDIR);
  }

  auto is_file(std::string const &path) -> errors::UnixResult<bool> {
    struct ::stat metadata;

    int const stat_status { ::stat(path.data(), &metadata) };
    if (stat_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::StatFailed {});
    }

    return core::either::make_rhs<bool>((metadata.st_mode & S_IFMT) == S_IFREG);
  }

  auto read_directory_list(std::string const &path) -> errors::UnixResult<std::vector<std::string>> {
    ::DIR *handle { ::opendir(path.data()) };
    if (!handle) {
      return core::either::make_lhs<errors::UnixError>(errors::OpendirFailed {});
    }

    DirectoryHandleWarden const warden { handle };

    std::vector<std::string> items {};
    struct ::dirent *entry { nullptr };

    while ((errno = 0, entry = ::readdir(handle)) != nullptr) {
      bool const is_dot { std::strncmp(entry->d_name, ".", entry->d_namlen) == 0 };
      bool const is_dot_dot { std::strncmp(entry->d_name, "..", entry->d_namlen) == 0 };

      if (is_dot || is_dot_dot) {
        continue;
      }

      items.emplace_back(entry->d_name, entry->d_namlen);
    }

    if (errno != 0) {
      return core::either::make_lhs<errors::UnixError>(errors::ReaddirFailed {});
    }

    return core::either::make_rhs(std::move(items));
  }

  auto read_file_data(std::string const &path) -> errors::UnixResult<std::vector<std::byte>> {
    int const file_descriptor { ::open(path.data(), O_RDONLY) };
    if (file_descriptor < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::OpenFailed {});
    }

    FileDescriptorWarden const warden { file_descriptor };

    struct ::stat metadata {};
    int const fstat_status { ::fstat(file_descriptor, &metadata) };

    if (fstat_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::FstatFailed {});
    }

    if (metadata.st_size < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::NegativeFileSize {});
    }

    static_assert(sizeof(metadata.st_size) <= sizeof(std::size_t));
    auto const total_size { static_cast<std::size_t>(metadata.st_size) };
    std::size_t bytes_read { 0 };

    std::vector<std::byte> buffer(total_size, std::byte(0x00));
    int read_status { 0 };

    do {
      read_status = ::read(file_descriptor, buffer.data() + bytes_read, total_size - bytes_read);
      if (read_status > 0) {
        bytes_read += read_status;
      }
    } while (bytes_read < total_size && read_status > 0);

    if (read_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::ReadFailed {});
    } else if (bytes_read < total_size) {
      return core::either::make_lhs<errors::UnixError>(errors::IncompleteRead {});
    }

    return core::either::make_rhs(std::move(buffer));
  }

  auto read_file_size(std::string const &path) -> errors::UnixResult<std::size_t> {
    struct ::stat metadata {};

    int const stat_status { ::stat(path.data(), &metadata) };
    if (stat_status < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::StatFailed {});
    }

    if (metadata.st_size < 0) {
      return core::either::make_lhs<errors::UnixError>(errors::NegativeFileSize {});
    }

    static_assert(sizeof(metadata.st_size) <= sizeof(std::size_t));
    auto const size { static_cast<std::size_t>(metadata.st_size) };

    return core::either::make_rhs<std::size_t>(size);
  }
}