ra8_fmt_host_spool.c

Go to the documentation of this file.

 
#define _POSIX_C_SOURCE (200809L)
 
#include <errno.h>
#include <fcntl.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"
#include "ra8_fmt_host_spool_internal.h"

typedef enum : uint32_t {
  k_spool_attempts = 16U,   
  k_spool_radix    = 10U,   
  k_spool_mode     = 0600U, 
  k_spool_digits   = 20U,   
} spool_const_t;

RA8_INTERNAL
static ra8_err_t internal_parent(const char* path, char parent[k_ra8_fmt_host_path_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, '/');
  size_t      take  = 1U;
  const char* text  = ".";
  if (slash != nullptr) {
    text = path;
    take = (slash == path) ? 1U : (size_t)(slash - path);
  }
  (void)memcpy(parent, text, take);
  parent[take] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_decimal(char name[k_ra8_fmt_host_name_cap], size_t* len, uint64_t value)
{
  char   reverse[k_spool_digits];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_spool_radix));
    value /= k_spool_radix;
  } while (value != 0U);
  if ((*len + count + 1U) > (size_t)k_ra8_fmt_host_name_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_name(uint32_t attempt, char name[k_ra8_fmt_host_name_cap])
{
  static const char prefix[] = ".ra8spool.";
  size_t            len      = sizeof(prefix) - 1U;
  (void)memcpy(name, prefix, len);
  name[len]    = '\0';
  ra8_err_t rc = internal_decimal(name, &len, (uint64_t)getpid());
  if ((rc == k_ra8_ok) && ((len + 2U) <= (size_t)k_ra8_fmt_host_name_cap)) {
    name[len++] = '.';
    name[len]   = '\0';
    rc          = internal_decimal(name, &len, attempt);
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_append(void* ctx, const uint8_t* bytes, size_t len)
{
  ra8_fmt_host_spool_t* state = (ra8_fmt_host_spool_t*)ctx;
  if ((state == nullptr) || (state->fd < 0) || state->sealed ||
      ((bytes == nullptr) && (len != 0U)) || ((uint64_t)len > (UINT64_MAX - state->position))) {
    return k_ra8_err_invalid_state;
  }
  size_t done = 0U;
  while (done < len) {
    const ssize_t rc = pwrite(state->fd, &bytes[done], len - done, (off_t)(state->position + done));
    if (rc > 0) {
      done += (size_t)rc;
    } else if ((rc < 0) && (errno == EINTR)) {
      continue;
    } else {
      return k_ra8_fail;
    }
  }
  state->position += len;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_seal(void* ctx, uint64_t expected_size)
{
  ra8_fmt_host_spool_t* state = (ra8_fmt_host_spool_t*)ctx;
  if ((state == nullptr) || (state->fd < 0) || state->sealed) {
    return k_ra8_err_invalid_state;
  }
  struct stat status = {};
  if ((state->position != expected_size) || (fstat(state->fd, &status) != 0) ||
      ((uint64_t)status.st_size != expected_size)) {
    return k_ra8_err_validation_failed;
  }
  if (fsync(state->fd) != 0) {
    return k_ra8_fail;
  }
  state->sealed = true;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_read(void* ctx, uint64_t offset, uint8_t* bytes, size_t len, size_t* got)
{
  ra8_fmt_host_spool_t* state = (ra8_fmt_host_spool_t*)ctx;
  if ((state == nullptr) || (got == nullptr) || (state->fd < 0) || !state->sealed ||
      ((bytes == nullptr) && (len != 0U))) {
    return k_ra8_err_invalid_state;
  }
  *got = 0U;
  if ((offset >= state->position) || (len == 0U)) {
    return k_ra8_ok;
  }
  const uint64_t remain = state->position - offset;
  if ((uint64_t)len > remain) {
    len = (size_t)remain;
  }
  while (*got < len) {
    const ssize_t rc = pread(state->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_create(int parent_fd, ra8_fmt_host_spool_t* state)
{
  char name[k_ra8_fmt_host_name_cap];
  for (uint32_t attempt = 0U; attempt < k_spool_attempts; ++attempt) {
    ra8_err_t rc = internal_name(attempt, name);
    if (rc != k_ra8_ok) {
      return rc;
    }
    state->fd = openat(parent_fd,
                       name,
                       O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW,
                       (mode_t)k_spool_mode);
    if (state->fd >= 0) {
      if (unlinkat(parent_fd, name, 0) == 0) {
        return k_ra8_ok;
      }
      (void)close(state->fd);
      state->fd = -1;
      (void)unlinkat(parent_fd, name, 0);
      return k_ra8_fail;
    }
    if (errno != EEXIST) {
      return k_ra8_fail;
    }
  }
  return k_ra8_err_exists;
}
 
RA8_PRIV ra8_err_t priv_fmt_host_spool_open(const char*           anchor_path,
                                            ra8_fmt_host_spool_t* state,
                                            ra8_fmt_spool_t*      out)
{
  if ((anchor_path == nullptr) || (state == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *state = (ra8_fmt_host_spool_t){.fd = -1};
  *out   = (ra8_fmt_spool_t){};
  char      parent[k_ra8_fmt_host_path_cap];
  ra8_err_t rc = internal_parent(anchor_path, parent);
  if (rc != k_ra8_ok) {
    return rc;
  }
  const int parent_fd = open(parent, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
  if (parent_fd < 0) {
    return k_ra8_fail;
  }
  rc = internal_create(parent_fd, state);
  (void)close(parent_fd);
  if (rc == k_ra8_ok) {
    *out = (ra8_fmt_spool_t){
      .read_at = internal_read,
      .append  = internal_append,
      .seal    = internal_seal,
      .ctx     = state,
    };
  }
  return rc;
}
 
RA8_PRIV void priv_fmt_host_spool_close(ra8_fmt_host_spool_t* state)
{
  if ((state != nullptr) && (state->fd >= 0)) {
    (void)close(state->fd);
    state->fd = -1;
  }
}