ra8_fmt_host_fd.c

Go to the documentation of this file.

 
#define _POSIX_C_SOURCE (200809L)
 
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "ra8_attributes.h"
#include "ra8_fmt_host_fd_internal.h"

extern int renameat(int old_dir_fd, const char* old_path, int new_dir_fd, const char* new_path);

typedef enum : uint32_t {
  k_host_create_attempts = 16U,   
  k_host_decimal_radix   = 10U,   
  k_host_mode_private    = 0600U, 
} host_const_t;

RA8_INTERNAL
static ra8_err_t internal_pread(void* ctx, uint64_t offset, uint8_t* bytes, size_t len, size_t* got)
{
  ra8_fmt_host_source_t* source = (ra8_fmt_host_source_t*)ctx;
  if ((source == nullptr) || (got == nullptr) || ((bytes == nullptr) && (len != 0U))) {
    return k_ra8_err_null_ptr;
  }
  *got = 0U;
  if ((offset >= source->source.size) || (len == 0U)) {
    return k_ra8_ok;
  }
  uint64_t remain = source->source.size - offset;
  if ((uint64_t)len > remain) {
    len = (size_t)remain;
  }
  while (*got < len) {
    const ssize_t rc = pread(source->fd, &bytes[*got], len - *got, (off_t)(offset + *got));
    if (rc > 0) {
      *got += (size_t)rc;
    } else if (rc == 0) {
      break;
    } else if (errno != EINTR) {
      return k_ra8_fail;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fd_write(void* ctx, const uint8_t* bytes, size_t len)
{
  ra8_fmt_host_fd_sink_t* sink = (ra8_fmt_host_fd_sink_t*)ctx;
  if ((sink == nullptr) || ((bytes == nullptr) && (len != 0U))) {
    return k_ra8_err_null_ptr;
  }
  size_t done = 0U;
  while (done < len) {
    const ssize_t rc = write(sink->fd, &bytes[done], len - done);
    if (rc > 0) {
      done += (size_t)rc;
    } else if ((rc < 0) && (errno == EINTR)) {
      continue;
    } else {
      return k_ra8_fail;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_copy(char* out, size_t cap, const char* text, size_t len)
{
  if ((len + 1U) > cap) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(out, text, len);
  out[len] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_split_path(const char* path,
                                     char        parent[k_ra8_fmt_host_path_cap],
                                     char        leaf[k_ra8_fmt_host_name_cap])
{
  const size_t len = (path == nullptr) ? 0U : strlen(path);
  if ((len == 0U) || (len >= (size_t)k_ra8_fmt_host_path_cap)) {
    return k_ra8_err_invalid_size;
  }
  const char*  slash    = strrchr(path, '/');
  const char*  name     = (slash == nullptr) ? path : &slash[1];
  const size_t name_len = len - (size_t)(name - path);
  if ((name_len == 0U) || ((name_len == 1U) && (name[0] == '.')) ||
      ((name_len == 2U) && (name[0] == '.') && (name[1] == '.'))) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t rc = internal_copy(leaf, k_ra8_fmt_host_name_cap, name, name_len);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (slash == nullptr) {
    return internal_copy(parent, k_ra8_fmt_host_path_cap, ".", 1U);
  }
  const size_t parent_len = (slash == path) ? 1U : (size_t)(slash - path);
  return internal_copy(parent, k_ra8_fmt_host_path_cap, path, parent_len);
}

RA8_INTERNAL
static ra8_err_t internal_name_u64(char* name, size_t cap, size_t* len, uint64_t value)
{
  char   reverse[20U];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_host_decimal_radix));
    value /= k_host_decimal_radix;
  } while (value != 0U);
  if ((*len + count + 1U) > cap) {
    return k_ra8_err_invalid_size;
  }
  while (count != 0U) {
    name[(*len)++] = reverse[--count];
  }
  name[*len] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_stage_name(ra8_fmt_host_transaction_t* state, uint32_t attempt)
{
  static const char suffix[] = ".ra8tmp.";
  size_t            len      = 0U;
  state->stage_name[len++]   = '.';
  const size_t leaf_len      = strlen(state->final_name);
  if ((1U + leaf_len + sizeof(suffix)) > sizeof(state->stage_name)) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(&state->stage_name[len], state->final_name, leaf_len);
  len += leaf_len;
  (void)memcpy(&state->stage_name[len], suffix, sizeof(suffix) - 1U);
  len += sizeof(suffix) - 1U;
  ra8_err_t rc =
    internal_name_u64(state->stage_name, sizeof(state->stage_name), &len, (uint64_t)getpid());
  if ((rc == k_ra8_ok) && ((len + 2U) <= sizeof(state->stage_name))) {
    state->stage_name[len++] = '.';
    state->stage_name[len]   = '\0';
    rc = internal_name_u64(state->stage_name, sizeof(state->stage_name), &len, attempt);
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_validate_destination(int parent_fd, const char* leaf)
{
  struct stat status = {};
  if (fstatat(parent_fd, leaf, &status, AT_SYMLINK_NOFOLLOW) == 0) {
    return S_ISREG(status.st_mode) ? k_ra8_ok : k_ra8_err_access_denied;
  }
  return (errno == ENOENT) ? k_ra8_ok : k_ra8_fail;
}

RA8_INTERNAL
static ra8_err_t internal_transaction_append(void* ctx, const uint8_t* bytes, size_t len)
{
  ra8_fmt_host_transaction_t* state = (ra8_fmt_host_transaction_t*)ctx;
  if ((state == nullptr) || !state->active || ((bytes == nullptr) && (len != 0U))) {
    return k_ra8_err_invalid_state;
  }
  ra8_fmt_host_fd_sink_t sink = {.fd = state->stage_fd};
  const ra8_err_t        rc   = internal_fd_write(&sink, bytes, len);
  if (rc == k_ra8_ok) {
    state->position += len;
  }
  return rc;
}

RA8_INTERNAL
static void internal_transaction_abort(void* ctx)
{
  ra8_fmt_host_transaction_t* state = (ra8_fmt_host_transaction_t*)ctx;
  if (state == nullptr) {
    return;
  }
  if (state->stage_fd >= 0) {
    (void)close(state->stage_fd);
    state->stage_fd = -1;
  }
  if (state->stage_exists && (state->parent_fd >= 0)) {
    (void)unlinkat(state->parent_fd, state->stage_name, 0);
  }
  if (state->parent_fd >= 0) {
    (void)close(state->parent_fd);
    state->parent_fd = -1;
  }
  state->stage_exists = false;
  state->active       = false;
}

RA8_INTERNAL
static ra8_err_t internal_transaction_commit(void* ctx)
{
  ra8_fmt_host_transaction_t* state = (ra8_fmt_host_transaction_t*)ctx;
  if ((state == nullptr) || !state->active || (state->stage_fd < 0)) {
    return k_ra8_err_invalid_state;
  }
  const int stage_sync_rc  = fsync(state->stage_fd);
  const int stage_close_rc = close(state->stage_fd);
  state->stage_fd          = -1;
  if ((stage_sync_rc != 0) || (stage_close_rc != 0)) {
    internal_transaction_abort(state);
    return k_ra8_fail;
  }
  if (renameat(state->parent_fd, state->stage_name, state->parent_fd, state->final_name) != 0) {
    internal_transaction_abort(state);
    return k_ra8_fail;
  }
  state->stage_exists = false;
  const int sync_rc   = fsync(state->parent_fd);
  (void)close(state->parent_fd);
  state->parent_fd = -1;
  state->active    = false;
  return (sync_rc == 0) ? k_ra8_ok : k_ra8_fail;
}

RA8_INTERNAL
static void internal_snapshot(const struct stat* status, ra8_fmt_host_snapshot_t* out)
{
#ifdef __APPLE__
  const struct timespec modified = status->st_mtimespec;
  const struct timespec changed  = status->st_ctimespec;
#else
  const struct timespec modified = status->st_mtim;
  const struct timespec changed  = status->st_ctim;
#endif
  *out = (ra8_fmt_host_snapshot_t){
    .device     = (uint64_t)status->st_dev,
    .inode      = (uint64_t)status->st_ino,
    .size       = (uint64_t)status->st_size,
    .mtime_sec  = (int64_t)modified.tv_sec,
    .mtime_nsec = (int64_t)modified.tv_nsec,
    .ctime_sec  = (int64_t)changed.tv_sec,
    .ctime_nsec = (int64_t)changed.tv_nsec,
  };
}

RA8_INTERNAL
static bool internal_snapshot_same(const ra8_fmt_host_snapshot_t* first,
                                   const ra8_fmt_host_snapshot_t* second)
{
  return (first->device == second->device) && (first->inode == second->inode) &&
         (first->size == second->size) && (first->mtime_sec == second->mtime_sec) &&
         (first->mtime_nsec == second->mtime_nsec) && (first->ctime_sec == second->ctime_sec) &&
         (first->ctime_nsec == second->ctime_nsec);
}

RA8_INTERNAL
static ra8_err_t internal_source_validate(void* ctx, uint64_t expected_size)
{
  const ra8_fmt_host_source_t* source = (const ra8_fmt_host_source_t*)ctx;
  if ((source == nullptr) || (source->source.size != expected_size)) {
    return k_ra8_err_validation_failed;
  }
  return priv_fmt_host_source_unchanged(source);
}
 
static const ra8_fmt_transaction_ops_t s_transaction_ops = {
  .append = internal_transaction_append,
  .commit = internal_transaction_commit,
  .abort  = internal_transaction_abort,
};
 
RA8_PRIV ra8_err_t priv_fmt_host_source_open(const char*            path,
                                             uint64_t               max_size,
                                             ra8_fmt_host_source_t* out)
{
  if ((path == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out         = (ra8_fmt_host_source_t){.fd = -1};
  const int fd = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
  if (fd < 0) {
    return (errno == ELOOP) ? k_ra8_err_access_denied : k_ra8_fail;
  }
  struct stat status = {};
  if ((fstat(fd, &status) != 0) || !S_ISREG(status.st_mode) || (status.st_size <= 0) ||
      ((uint64_t)status.st_size > max_size)) {
    (void)close(fd);
    return k_ra8_err_invalid_size;
  }
  out->fd              = fd;
  out->source.read_at  = internal_pread;
  out->source.validate = internal_source_validate;
  out->source.ctx      = out;
  out->source.size     = (uint64_t)status.st_size;
  internal_snapshot(&status, &out->snapshot);
  return k_ra8_ok;
}
 
RA8_PRIV bool priv_fmt_host_sources_same(const ra8_fmt_host_source_t* first,
                                         const ra8_fmt_host_source_t* second)
{
  if ((first == nullptr) || (second == nullptr) || (first == second) || (first->fd < 0) ||
      (second->fd < 0) || (first->fd == second->fd)) {
    return false;
  }
  return internal_snapshot_same(&first->snapshot, &second->snapshot);
}
 
RA8_PRIV ra8_err_t priv_fmt_host_source_unchanged(const ra8_fmt_host_source_t* source)
{
  if ((source == nullptr) || (source->fd < 0)) {
    return k_ra8_err_invalid_state;
  }
  struct stat status = {};
  if (fstat(source->fd, &status) != 0) {
    return k_ra8_fail;
  }
  if (!S_ISREG(status.st_mode)) {
    return k_ra8_err_validation_failed;
  }
  ra8_fmt_host_snapshot_t current;
  internal_snapshot(&status, &current);
  return internal_snapshot_same(&source->snapshot, &current) ? k_ra8_ok
                                                             : k_ra8_err_validation_failed;
}
 
RA8_PRIV void priv_fmt_host_source_close(ra8_fmt_host_source_t* source)
{
  if ((source != nullptr) && (source->fd >= 0)) {
    (void)close(source->fd);
    source->fd = -1;
  }
}
 
RA8_PRIV ra8_fmt_sink_t priv_fmt_host_fd_sink(ra8_fmt_host_fd_sink_t* state)
{
  return (ra8_fmt_sink_t){.write = internal_fd_write, .ctx = state};
}
 
RA8_PRIV void priv_fmt_host_log_byte(void* ctx, uint8_t byte)
{
  (void)internal_fd_write(ctx, &byte, 1U);
}
 
RA8_PRIV ra8_err_t priv_fmt_host_transaction_begin(const char*                 path,
                                                   ra8_fmt_host_transaction_t* state,
                                                   ra8_fmt_transaction_t*      out)
{
  if ((path == nullptr) || (state == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *state = (ra8_fmt_host_transaction_t){.parent_fd = -1, .stage_fd = -1};
  *out   = (ra8_fmt_transaction_t){};
  char      parent[k_ra8_fmt_host_path_cap];
  ra8_err_t rc = internal_split_path(path, parent, state->final_name);
  if (rc != k_ra8_ok) {
    return rc;
  }
  state->parent_fd = open(parent, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
  if (state->parent_fd < 0) {
    return k_ra8_fail;
  }
  rc = internal_validate_destination(state->parent_fd, state->final_name);
  for (uint32_t attempt = 0U; (attempt < k_host_create_attempts) && (rc == k_ra8_ok); ++attempt) {
    rc = internal_stage_name(state, attempt);
    if (rc == k_ra8_ok) {
      state->stage_fd = openat(state->parent_fd,
                               state->stage_name,
                               O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW,
                               (mode_t)k_host_mode_private);
      if (state->stage_fd >= 0) {
        state->stage_exists = true;
        state->active       = true;
        out->ops            = &s_transaction_ops;
        out->ctx            = state;
        return k_ra8_ok;
      }
      rc = (errno == EEXIST) ? k_ra8_ok : k_ra8_fail;
    }
  }
  internal_transaction_abort(state);
  return (rc == k_ra8_ok) ? k_ra8_err_exists : rc;
}