rabook_import.c

Go to the documentation of this file.

 
#include "rabook_import.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_log.h"
#include "rabook_import_internal.h"
 
/* -------------------------------------------------------------------------- */
/* Private constants */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_crc32_poly = 0xEDB88320U, 
  k_crc32_seed = 0xFFFFFFFFU, 
} ra8_import_crc_const_t;

typedef enum : uint32_t {
  k_crc32_bits        = 8U,      
  k_import_max_chunks = 131072U, 
} ra8_import_misc_t;

static const char* const s_tag = "rabook_import";
 
/* -------------------------------------------------------------------------- */
/* Private helpers */
/* -------------------------------------------------------------------------- */

RA8_INTERNAL static uint32_t internal_crc32_block(uint32_t crc, const uint8_t* data, uint32_t len)
{
  if (data == nullptr) {
    return crc;
  }
  if (len == 0U) {
    return crc;
  }
  uint32_t running_crc = crc;
  for (uint32_t i = 0U; i < len; i++) {
    running_crc ^= data[i];
    for (uint8_t b = 0U; b < (uint8_t)k_crc32_bits; b++) {
      const bool lsb = (running_crc & 1U) != 0U;
      running_crc >>= 1U;
      if (lsb) {
        running_crc ^= (uint32_t)k_crc32_poly;
      }
    }
  }
  return running_crc;
}

RA8_INTERNAL static ra8_err_t internal_crc_stream_read_chunk(rabook_import_read_fn read_fn,
                                                             void*                 read_ctx,
                                                             uint64_t              expected_size,
                                                             uint8_t*              buf,
                                                             uint32_t              cap,
                                                             uint32_t*             crc,
                                                             uint32_t*             total)
{
  uint64_t remain  = expected_size - (uint64_t)*total;
  uint32_t request = cap;
  if (remain < (uint64_t)request) {
    request = (uint32_t)remain;
  }
  uint32_t        got = 0U;
  const ra8_err_t err = read_fn(read_ctx, buf, request, &got);
  if (err != k_ra8_ok) {
    return err;
  }
  if ((got == 0U) || (got > request)) {
    return k_ra8_err_invalid_size;
  }
  *crc = internal_crc32_block(*crc, buf, got);
  *total += got;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_crc_stream_validate_args(rabook_import_read_fn read_fn,
                                                                const uint8_t*        buf,
                                                                const uint32_t*       out_size,
                                                                const uint32_t*       out_crc,
                                                                uint64_t              expected_size,
                                                                uint32_t              cap,
                                                                uint32_t              max_reads)
{
  if (read_fn == nullptr) {
    ra8_log_error(s_tag, "read_fn is NULL");
    return k_ra8_err_null_ptr;
  }
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
  RA8_CHECK_NULL_PTR(out_size, s_tag, "out_size");
  RA8_CHECK_NULL_PTR(out_crc, s_tag, "out_crc");
  if ((cap == 0U) || (expected_size > (uint64_t)UINT32_MAX)) {
    return k_ra8_err_invalid_size;
  }
  const uint64_t required_reads =
    (expected_size / (uint64_t)cap) + (((expected_size % (uint64_t)cap) != 0U) ? 1U : 0U);
  if (required_reads > (uint64_t)max_reads) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_rabook_import_crc_stream(rabook_import_read_fn read_fn,
                                                 void*                 read_ctx,
                                                 uint64_t              expected_size,
                                                 uint8_t*              buf,
                                                 uint32_t              cap,
                                                 uint32_t              max_reads,
                                                 uint32_t*             out_size,
                                                 uint32_t*             out_crc)
{
  const ra8_err_t arg_err = internal_crc_stream_validate_args(read_fn,
                                                              buf,
                                                              out_size,
                                                              out_crc,
                                                              expected_size,
                                                              cap,
                                                              max_reads);
  if (arg_err != k_ra8_ok) {
    return arg_err;
  }
 
  uint32_t crc   = (uint32_t)k_crc32_seed;
  uint32_t total = 0U;
  for (uint32_t i = 0U; (i < max_reads) && ((uint64_t)total < expected_size); ++i) {
    const ra8_err_t err =
      internal_crc_stream_read_chunk(read_fn, read_ctx, expected_size, buf, cap, &crc, &total);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  if ((uint64_t)total != expected_size) {
    return k_ra8_err_invalid_size;
  }
  uint32_t        extra = 0U;
  const ra8_err_t err   = read_fn(read_ctx, buf, 1U, &extra);
  if (err != k_ra8_ok) {
    return err;
  }
  if (extra != 0U) {
    return k_ra8_err_invalid_size;
  }
  *out_size = total;
  *out_crc  = crc ^ (uint32_t)k_crc32_seed;
  return k_ra8_ok;
}
 
RA8_TEST_HELPER ra8_err_t rabook_import_crc_stream_test(rabook_import_read_fn read_fn,
                                                        void*                 read_ctx,
                                                        uint64_t              expected_size,
                                                        uint8_t*              buf,
                                                        uint32_t              cap,
                                                        uint32_t              max_reads,
                                                        uint32_t*             out_size,
                                                        uint32_t*             out_crc)
{
  return priv_rabook_import_crc_stream(read_fn,
                                       read_ctx,
                                       expected_size,
                                       buf,
                                       cap,
                                       max_reads,
                                       out_size,
                                       out_crc);
}

RA8_INTERNAL static ra8_err_t
internal_import_fs_read(void* ctx, uint8_t* buf, uint32_t requested, uint32_t* out_read)
{
  return ra8_fs_read((ra8_fs_file_t*)ctx, buf, requested, out_read);
}

RA8_INTERNAL static ra8_err_t internal_crc_stream(ra8_fs_file_t* file,
                                                  uint8_t*       buf,
                                                  uint32_t       cap,
                                                  uint32_t*      out_size,
                                                  uint32_t*      out_crc)
{
  RA8_CHECK_NULL_PTR(file, s_tag, "file");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf");
 
  uint64_t  expected_size = 0U;
  ra8_err_t err           = ra8_fs_size(file, &expected_size);
  if (err != k_ra8_ok) {
    return err;
  }
  return priv_rabook_import_crc_stream(internal_import_fs_read,
                                       file,
                                       expected_size,
                                       buf,
                                       cap,
                                       (uint32_t)k_import_max_chunks,
                                       out_size,
                                       out_crc);
}

RA8_INTERNAL static ra8_err_t internal_compute_source_key(ra8_fs_mount_t* mount,
                                                          const char*     epub_path,
                                                          uint8_t*        buf,
                                                          uint32_t        cap,
                                                          uint32_t*       out_size,
                                                          uint32_t*       out_crc)
{
  RA8_CHECK_NULL_PTR(out_size, s_tag, "out_size");
  RA8_CHECK_NULL_PTR(out_crc, s_tag, "out_crc");
  if (cap == 0U) {
    return k_ra8_err_invalid_size;
  }
 
  ra8_fs_file_t* file = nullptr;
  ra8_err_t      err  = ra8_fs_open(mount, epub_path, k_ra8_fs_mode_read, &file);
  if (err != k_ra8_ok) {
    return err;
  }
  err            = internal_crc_stream(file, buf, cap, out_size, out_crc);
  ra8_err_t cerr = ra8_fs_close(file);
  if (err != k_ra8_ok) {
    return err;
  }
  return cerr;
}

RA8_INTERNAL static ra8_err_t internal_derive_stem(const char* epub_path, char* out, uint32_t cap)
{
  RA8_CHECK_NULL_PTR(epub_path, s_tag, "epub_path");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
 
  size_t start = 0U;
  size_t i     = 0U;
  for (; epub_path[i] != '\0'; i++) {
    if (epub_path[i] == '/') {
      start = i + 1U;
    }
  }
  size_t len = i - start;
  for (size_t j = len; j > 1U; j--) {
    if (epub_path[start + j - 1U] == '.') {
      len = j - 1U;
      break;
    }
  }
  if (len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (len >= (size_t)cap) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(out, &epub_path[start], len);
  out[len] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_make_name(const char* stem, const char* suffix, char* out, uint32_t cap)
{
  RA8_CHECK_NULL_PTR(stem, s_tag, "stem");
  RA8_CHECK_NULL_PTR(suffix, s_tag, "suffix");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  const size_t sn = strlen(stem);
  const size_t xn = strlen(suffix);
  if ((sn + xn + 1U) > (size_t)cap) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(out, stem, sn);
  (void)memcpy(&out[sn], suffix, xn);
  out[sn + xn] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_derive_names(const char* stem, char* cache_name, char* tmp_name, char* mark_name)
{
  RA8_CHECK_NULL_PTR(cache_name, s_tag, "cache_name");
  RA8_CHECK_NULL_PTR(tmp_name, s_tag, "tmp_name");
  RA8_CHECK_NULL_PTR(mark_name, s_tag, "mark_name");
  static const char* const ext_cache = ".rabook";     /* cache blob       */
  static const char* const ext_tmp   = ".rabook.tmp"; /* crash-safe temp  */
  static const char* const ext_mark  = ".rabook.mrk"; /* freshness marker */
  const uint32_t           cap       = (uint32_t)k_rabook_import_name_cap;
  ra8_err_t                err       = internal_make_name(stem, ext_cache, cache_name, cap);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_make_name(stem, ext_tmp, tmp_name, cap);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_make_name(stem, ext_mark, mark_name, cap);
}

RA8_INTERNAL static bool internal_file_exists(ra8_fs_mount_t* mount, const char* path)
{
  if (mount == nullptr) {
    return false;
  }
  if (path == nullptr) {
    return false;
  }
  ra8_fs_file_t* file = nullptr;
  ra8_err_t      err  = ra8_fs_open(mount, path, k_ra8_fs_mode_read, &file);
  if (err != k_ra8_ok) {
    return false;
  }
  (void)ra8_fs_close(file);
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_read_stamp(ra8_fs_mount_t* mount, const char* path, rabook_import_stamp_t* out)
{
  RA8_CHECK_NULL_PTR(mount, s_tag, "mount");
  RA8_CHECK_NULL_PTR(path, s_tag, "path");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
 
  ra8_fs_file_t* file = nullptr;
  ra8_err_t      err  = ra8_fs_open(mount, path, k_ra8_fs_mode_read, &file);
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t got   = 0U;
  err            = ra8_fs_read(file, (uint8_t*)out, (uint32_t)sizeof(*out), &got);
  ra8_err_t cerr = ra8_fs_close(file);
  if (err != k_ra8_ok) {
    return err;
  }
  if (got != (uint32_t)sizeof(*out)) {
    return k_ra8_err_invalid_size;
  }
  return cerr;
}

RA8_INTERNAL static bool internal_cache_is_fresh(ra8_fs_mount_t*              mount,
                                                 const char*                  mark_path,
                                                 const rabook_import_stamp_t* want)
{
  if (mount == nullptr) {
    return false;
  }
  if (want == nullptr) {
    return false;
  }
  rabook_import_stamp_t got = {};
  ra8_err_t             err = internal_read_stamp(mount, mark_path, &got);
  if (err != k_ra8_ok) {
    return false;
  }
  return (got.magic == want->magic) && (got.format_version == want->format_version) &&
         (got.importer_version == want->importer_version) &&
         (got.source_size == want->source_size) && (got.source_crc32 == want->source_crc32);
}

RA8_INTERNAL static ra8_err_t
internal_write_stamp(ra8_fs_mount_t* mount, const char* path, const rabook_import_stamp_t* stamp)
{
  RA8_CHECK_NULL_PTR(mount, s_tag, "mount");
  RA8_CHECK_NULL_PTR(path, s_tag, "path");
  RA8_CHECK_NULL_PTR(stamp, s_tag, "stamp");
  (void)ra8_fs_unlink(mount, path);
  return ra8_fs_write_file(mount, path, (const uint8_t*)stamp, (uint32_t)sizeof(*stamp));
}

RA8_INTERNAL static ra8_err_t
internal_atomic_replace(ra8_fs_mount_t* mount, const char* tmp_path, const char* dst_path)
{
  RA8_CHECK_NULL_PTR(mount, s_tag, "mount");
  RA8_CHECK_NULL_PTR(tmp_path, s_tag, "tmp_path");
  RA8_CHECK_NULL_PTR(dst_path, s_tag, "dst_path");
  (void)ra8_fs_unlink(mount, dst_path);
  return ra8_fs_rename(mount, tmp_path, dst_path);
}

RA8_INTERNAL static ra8_err_t internal_copy_name(char* dst, uint32_t cap, const char* src)
{
  RA8_CHECK_NULL_PTR(dst, s_tag, "dst");
  RA8_CHECK_NULL_PTR(src, s_tag, "src");
  for (uint32_t i = 0U; i < cap; i++) {
    dst[i] = src[i];
    if (src[i] == '\0') {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_invalid_size;
}

RA8_INTERNAL static ra8_err_t internal_compile_and_cache(const rabook_import_cfg_t*   cfg,
                                                         const char*                  epub_path,
                                                         const char*                  cache_name,
                                                         const char*                  tmp_name,
                                                         const char*                  mark_name,
                                                         const rabook_import_stamp_t* want)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  RA8_CHECK_NULL_PTR(cfg->compile, s_tag, "cfg->compile");
  RA8_CHECK_NULL_PTR(want, s_tag, "want");
  (void)ra8_fs_unlink(cfg->mount, tmp_name);
  ra8_err_t err = cfg->compile(cfg->compile_ctx, cfg->mount, epub_path, tmp_name);
  if (err != k_ra8_ok) {
    ra8_log_error(s_tag, "compile seam failed");
    return err;
  }
  err = internal_atomic_replace(cfg->mount, tmp_name, cache_name);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_write_stamp(cfg->mount, mark_name, want);
}

RA8_INTERNAL static ra8_err_t
internal_validate_open_args(const rabook_import_cfg_t*     cfg,
                            const char*                    epub_path,
                            const char*                    out_cache_path,
                            uint32_t                       cache_path_cap,
                            const rabook_import_outcome_t* out_outcome)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  RA8_CHECK_NULL_PTR(epub_path, s_tag, "epub_path");
  RA8_CHECK_NULL_PTR(out_cache_path, s_tag, "out_cache_path");
  RA8_CHECK_NULL_PTR(out_outcome, s_tag, "out_outcome");
  RA8_CHECK_NULL_PTR(cfg->mount, s_tag, "cfg->mount");
  if (cache_path_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
/* -------------------------------------------------------------------------- */
/* Public API */
/* -------------------------------------------------------------------------- */
 
ra8_err_t rabook_import_open(const rabook_import_cfg_t* cfg,
                             const char*                epub_path,
                             char*                      out_cache_path,
                             uint32_t                   cache_path_cap,
                             rabook_import_outcome_t*   out_outcome)
{
  ra8_err_t err =
    internal_validate_open_args(cfg, epub_path, out_cache_path, cache_path_cap, out_outcome);
  if (err != k_ra8_ok) {
    return err;
  }
  /* Derive the cache names from the source's own basename FIRST, so a bad name
   * or a too-small output buffer is refused before the source is streamed or
   * the compiler is invoked (a compile must never run for a doomed request). */
  char stem[k_rabook_import_name_cap];
  err = internal_derive_stem(epub_path, stem, (uint32_t)k_rabook_import_name_cap);
  if (err != k_ra8_ok) {
    return err;
  }
  char cache_name[k_rabook_import_name_cap];
  char tmp_name[k_rabook_import_name_cap];
  char mark_name[k_rabook_import_name_cap];
  err = internal_derive_names(stem, cache_name, tmp_name, mark_name);
  if (err != k_ra8_ok) {
    return err;
  }
  if ((strlen(cache_name) + 1U) > (size_t)cache_path_cap) {
    return k_ra8_err_invalid_size;
  }
 
  uint32_t src_size = 0U;
  uint32_t src_crc  = 0U;
  err               = internal_compute_source_key(cfg->mount,
                                                  epub_path,
                                                  cfg->scratch,
                                                  cfg->scratch_cap,
                                                  &src_size,
                                                  &src_crc);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const rabook_import_stamp_t want = {
    .magic            = (uint32_t)k_rabook_import_stamp_magic,
    .format_version   = cfg->format_version,
    .importer_version = cfg->importer_version,
    .source_size      = src_size,
    .source_crc32     = src_crc,
  };
 
  if (internal_cache_is_fresh(cfg->mount, mark_name, &want)) {
    if (internal_file_exists(cfg->mount, cache_name)) {
      *out_outcome = k_rabook_import_hit;
      return internal_copy_name(out_cache_path, cache_path_cap, cache_name);
    }
  }
 
  err = internal_compile_and_cache(cfg, epub_path, cache_name, tmp_name, mark_name, &want);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_outcome = k_rabook_import_compiled;
  return internal_copy_name(out_cache_path, cache_path_cap, cache_name);
}