book_chunked.c

Go to the documentation of this file.

#include "book_chunked.h"
 
#include <string.h>
 
#include "book_internal.h"
#include "ra8_attributes.h"
#include "ra8_check.h"

static const char* const s_tag_chunked = "book_chunked";

RA8_INTERNAL
static ra8_err_t
internal_table_check(const book_chunked_t* rd, const uint64_t* table_buf, uint64_t payload_len)
{
  if (table_buf[0] != 0U) {
    return k_ra8_err_invalid_arg;
  }
  uint64_t max_clen = 0U;
  for (uint32_t i = 0U; i < rd->chunk_count; ++i) { /* bound: validated chunk_count */
    if (table_buf[i + 1U] <= table_buf[i]) {
      return k_ra8_err_invalid_arg;
    }
    const uint64_t clen = table_buf[i + 1U] - table_buf[i];
    if (clen > max_clen) {
      max_clen = clen;
    }
  }
  if (table_buf[rd->chunk_count] != payload_len) {
    return k_ra8_err_invalid_arg;
  }
  if (max_clen > (uint64_t)rd->staging_cap) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_load_table(book_chunked_t* rd,
                                                  uint64_t        file_len,
                                                  uint64_t*       table_buf,
                                                  uint32_t        table_cap_entries)
{
  const uint64_t entries     = (uint64_t)rd->chunk_count + 1U;
  const uint64_t table_bytes = entries * k_book_container_entry_len;
  if (entries > (uint64_t)table_cap_entries) {
    return k_ra8_err_invalid_size;
  }
  if (table_bytes > (uint64_t)UINT32_MAX) {
    return k_ra8_err_invalid_size;
  }
  if (file_len < ((uint64_t)k_book_container_header_len + table_bytes)) {
    return k_ra8_err_invalid_size;
  }
  const ra8_err_t err = rd->file_read(rd->file_ctx,
                                      (uint64_t)k_book_container_header_len,
                                      (uint8_t*)table_buf,
                                      (uint32_t)table_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint64_t  payload_off = (uint64_t)k_book_container_header_len + table_bytes;
  const ra8_err_t shape       = internal_table_check(rd, table_buf, file_len - payload_off);
  if (shape != k_ra8_ok) {
    return shape;
  }
  rd->table             = table_buf;
  rd->table_cap_entries = table_cap_entries;
  rd->payload_off       = payload_off;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_chunked_open_body(book_chunked_t* rd,
                                                         uint64_t        file_len,
                                                         uint64_t*       table_buf,
                                                         uint32_t        table_cap_entries)
{
  if (file_len < (uint64_t)k_book_container_header_len) {
    return k_ra8_err_invalid_size;
  }
  uint8_t   hdr[k_book_container_header_len] = {};
  ra8_err_t err = rd->file_read(rd->file_ctx, 0U, hdr, (uint32_t)sizeof(hdr));
  if (err != k_ra8_ok) {
    return err;
  }
  err =
    priv_book_container_header_fields(hdr, &rd->chunk_bytes, &rd->inflated_total, &rd->chunk_count);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_load_table(rd, file_len, table_buf, table_cap_entries);
}
 
ra8_err_t book_chunked_open(book_chunked_t*     rd,
                            ra8_vsource_read_fn file_read,
                            void*               file_ctx,
                            uint64_t            file_len,
                            book_inflate_fn     inflate,
                            uint64_t*           table_buf,
                            uint32_t            table_cap_entries,
                            uint8_t*            staging,
                            uint32_t            staging_cap)
{
  RA8_CHECK_NULL_PTR(rd, s_tag_chunked, "open: null rd");
  RA8_CHECK_NULL_PTR(file_read, s_tag_chunked, "open: null file_read");
  RA8_CHECK_NULL_PTR(inflate, s_tag_chunked, "open: null inflate");
  RA8_CHECK_NULL_PTR(table_buf, s_tag_chunked, "open: null table_buf");
  RA8_CHECK_NULL_PTR(staging, s_tag_chunked, "open: null staging");
 
  *rd             = (book_chunked_t){};
  rd->file_read   = file_read;
  rd->file_ctx    = file_ctx;
  rd->inflate_cb  = inflate;
  rd->staging     = staging;
  rd->staging_cap = staging_cap;
  return internal_chunked_open_body(rd, file_len, table_buf, table_cap_entries);
}

RA8_INTERNAL
static ra8_err_t
internal_stage_and_inflate(const book_chunked_t* rd, uint32_t idx, uint8_t* buf, uint32_t len)
{
  const uint64_t clen = rd->table[idx + 1U] - rd->table[idx];
  ra8_err_t      err =
    rd->file_read(rd->file_ctx, rd->payload_off + rd->table[idx], rd->staging, (uint32_t)clen);
  if (err != k_ra8_ok) {
    return err;
  }
  size_t produced = 0U;
  err             = rd->inflate_cb(rd->staging, (size_t)clen, buf, (size_t)len, &produced);
  if (err != k_ra8_ok) {
    return err;
  }
  if (produced != (size_t)len) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
ra8_err_t book_chunked_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_chunked, "read: null ctx");
  RA8_CHECK_NULL_PTR(buf, s_tag_chunked, "read: null buf");
  const book_chunked_t* rd = (const book_chunked_t*)ctx;
  if (rd->table == nullptr) {
    return k_ra8_err_invalid_state;
  }
  if (offset >= rd->inflated_total) {
    return k_ra8_err_out_of_range;
  }
  if ((offset % (uint64_t)rd->chunk_bytes) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  uint64_t expected = rd->inflated_total - offset;
  if (expected > (uint64_t)rd->chunk_bytes) {
    expected = rd->chunk_bytes;
  }
  if ((uint64_t)len != expected) {
    return k_ra8_err_invalid_arg;
  }
  return internal_stage_and_inflate(rd, (uint32_t)(offset / (uint64_t)rd->chunk_bytes), buf, len);
}