book.c

Go to the documentation of this file.

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

static const char* const s_tag_book = "book";

RA8_INTERNAL static void internal_copy_object(void* dst, const void* src, size_t len)
{
  (void)memcpy(dst, src, len);
}

typedef enum : uint32_t {
  k_book_crc_init = 0xFFFFFFFFU, 
  k_book_crc_poly = 0xEDB88320U, 
} book_crc_const_t;
 
typedef enum : uint8_t {
  k_book_crc_bits_per_byte = 8U, 
} book_crc_byte_t;

RA8_PRIV uint32_t priv_book_crc32_extend(uint32_t crc, const uint8_t* data, size_t len)
{
  uint32_t state = crc ^ k_book_crc_init;
  for (size_t i = 0U; i < len; ++i) {
    state ^= (uint32_t)data[i];
    for (uint8_t bit = 0U; bit < k_book_crc_bits_per_byte; ++bit) {
      const uint32_t mask = ((state & 1U) != 0U) ? k_book_crc_init : 0U;
      state               = (state >> 1U) ^ (k_book_crc_poly & mask);
    }
  }
  return state ^ k_book_crc_init;
}

RA8_INTERNAL
RA8_NO_RECURSION
RA8_INTERNAL static uint32_t internal_crc32(const uint8_t* data, size_t len)
{
  return priv_book_crc32_extend(0U, data, len);
}

RA8_INTERNAL static bool
internal_table_fits(uint32_t off, uint32_t count, uint32_t elem, uint32_t total)
{
  uint64_t end = (uint64_t)off + ((uint64_t)count * (uint64_t)elem);
  return (off <= total) && (end <= (uint64_t)total);
}

RA8_INTERNAL static bool internal_image_pixfmts_known(const void* base, const book_header_t* hdr)
{
  const book_image_t* imgs  = book_images(base);
  bool                known = true;
  for (uint32_t i = 0U; i < hdr->image_count; ++i) { /* bound: validated image_count */
    if (imgs[i].pixel_format > (uint8_t)k_book_pixfmt_gray8) {
      known = false;
    }
  }
  return known;
}

RA8_INTERNAL static bool internal_magic_ok(const book_header_t* hdr)
{
  const char expect[8] = {'R', 'A', 'B', 'O', 'O', 'K', '1', '\0'};
  bool       ok        = true;
  for (uint8_t i = 0U; i < (uint8_t)sizeof(expect); ++i) {
    if (hdr->magic[i] != expect[i]) {
      ok = false;
    }
  }
  return ok;
}
 
ra8_err_t book_validate(const void* base, size_t size)
{
  RA8_CHECK_NULL_PTR(base, s_tag_book, "validate: null base");
 
  if (size < sizeof(book_header_t)) {
    return k_ra8_err_invalid_size;
  }
 
  const book_header_t* hdr = (const book_header_t*)base;
 
  if (!internal_magic_ok(hdr)) {
    return k_ra8_err_invalid_arg;
  }
  if (hdr->format_version != k_book_format_version) {
    return k_ra8_err_invalid_arg;
  }
  /* Unknown feature bits mean the blob relies on a presentation semantic this
   * firmware does not implement (e.g. a reading-order mode newer than
   * book_flag_t) -- refuse it rather than silently mis-render it. */
  if ((hdr->flags & ~(uint32_t)k_book_flag_mask_known) != 0U) {
    return k_ra8_err_invalid_arg;
  }
 
  uint32_t total = hdr->total_size;
  if ((total < sizeof(book_header_t)) || ((size_t)total > size)) {
    return k_ra8_err_invalid_size;
  }
 
  const bool tables_ok =
    internal_table_fits(hdr->chapter_off, hdr->chapter_count, sizeof(book_chapter_t), total) &&
    internal_table_fits(hdr->node_off, hdr->node_count, sizeof(book_node_t), total) &&
    internal_table_fits(hdr->attr_off, hdr->attr_count, sizeof(book_attr_t), total) &&
    internal_table_fits(hdr->stylesheet_off,
                        hdr->stylesheet_count,
                        sizeof(book_stylesheet_t),
                        total) &&
    internal_table_fits(hdr->image_off, hdr->image_count, sizeof(book_image_t), total) &&
    internal_table_fits(hdr->string_off, hdr->string_size, 1U, total) &&
    internal_table_fits(hdr->image_pool_off, hdr->image_pool_size, 1U, total);
  if (!tables_ok) {
    return k_ra8_err_invalid_size;
  }
 
  /* Every image descriptor must name a pixel depth this build can unpack; an
   * unknown depth is refused (fail-closed) rather than fed to the wrong blit. */
  if (!internal_image_pixfmts_known(base, hdr)) {
    return k_ra8_err_invalid_arg;
  }
 
  const uint8_t* body     = &((const uint8_t*)base)[sizeof(book_header_t)];
  uint32_t       body_len = total - (uint32_t)sizeof(book_header_t);
  if (internal_crc32(body, body_len) != hdr->crc32_val) {
    return k_ra8_err_range_check_failed;
  }
 
  return k_ra8_ok;
}

RA8_PRIV ra8_err_t priv_book_container_header_fields(const uint8_t* hdr,
                                                     uint32_t*      out_chunk_bytes,
                                                     uint64_t*      out_total,
                                                     uint32_t*      out_count)
{
  RA8_CHECK_NULL_PTR(hdr, s_tag_book, "hdr fields: null hdr");
  RA8_CHECK_NULL_PTR(out_chunk_bytes, s_tag_book, "hdr fields: null out");
  const char cmagic[k_book_container_magic_len] = {'R', 'B', 'K', 'C'};
  for (uint8_t i = 0U; i < k_book_container_magic_len; ++i) {
    if ((char)hdr[i] != cmagic[i]) {
      return k_ra8_err_invalid_arg;
    }
  }
  uint32_t chunk_bytes = 0U;
  uint64_t total       = 0U;
  uint32_t count       = 0U;
  uint32_t reserved    = 0U;
  internal_copy_object(&chunk_bytes, &hdr[k_book_cont_off_chunk_bytes], sizeof(chunk_bytes));
  internal_copy_object(&total, &hdr[k_book_cont_off_total], sizeof(total));
  internal_copy_object(&count, &hdr[k_book_cont_off_count], sizeof(count));
  internal_copy_object(&reserved, &hdr[k_book_cont_off_reserved], sizeof(reserved));
  if ((chunk_bytes == 0U) || (total == 0U) || (reserved != 0U)) {
    return k_ra8_err_invalid_arg;
  }
  const uint64_t want_count = (total + (uint64_t)chunk_bytes - 1U) / (uint64_t)chunk_bytes;
  if ((uint64_t)count != want_count) {
    return k_ra8_err_invalid_arg;
  }
  *out_chunk_bytes = chunk_bytes;
  *out_total       = total;
  *out_count       = count;
  return k_ra8_ok;
}

RA8_PRIV uint64_t priv_book_container_table_entry(const uint8_t* table, uint32_t idx)
{
  uint64_t entry = 0U;
  internal_copy_object(&entry, &table[(size_t)idx * k_book_container_entry_len], sizeof(entry));
  return entry;
}

typedef struct {
  const uint8_t* table;       
  const uint8_t* payload;     
  uint64_t       total;       
  uint64_t       payload_len; 
  uint32_t       chunk_bytes; 
  uint32_t       chunk_count; 
} book_container_view_t;

RA8_INTERNAL static ra8_err_t internal_container_view(const uint8_t*         bytes,
                                                      size_t                 file_len,
                                                      size_t                 scratch_cap,
                                                      book_container_view_t* out_view)
{
  if (file_len < k_book_container_header_len) {
    return k_ra8_err_invalid_size;
  }
  ra8_err_t err = priv_book_container_header_fields(bytes,
                                                    &out_view->chunk_bytes,
                                                    &out_view->total,
                                                    &out_view->chunk_count);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint64_t entries     = (uint64_t)out_view->chunk_count + 1U;
  const uint64_t table_bytes = entries * k_book_container_entry_len;
  if ((uint64_t)file_len < ((uint64_t)k_book_container_header_len + table_bytes)) {
    return k_ra8_err_invalid_size;
  }
  if ((uint64_t)scratch_cap < out_view->total) {
    return k_ra8_err_invalid_size;
  }
  out_view->table       = &bytes[k_book_container_header_len];
  out_view->payload     = &out_view->table[table_bytes];
  out_view->payload_len = (uint64_t)file_len - k_book_container_header_len - table_bytes;
  uint64_t prev         = priv_book_container_table_entry(out_view->table, 0U);
  if (prev != 0U) {
    return k_ra8_err_invalid_arg;
  }
  for (uint32_t i = 1U; i <= out_view->chunk_count; ++i) { /* bound: validated chunk_count */
    const uint64_t cur = priv_book_container_table_entry(out_view->table, i);
    if (cur <= prev) {
      return k_ra8_err_invalid_arg;
    }
    prev = cur;
  }
  if (prev != out_view->payload_len) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_inflate_chunks(const book_container_view_t* view,
                                                      book_inflate_fn              inflate,
                                                      uint8_t*                     scratch)
{
  for (uint32_t i = 0U; i < view->chunk_count; ++i) { /* bound: validated chunk_count */
    const uint64_t off      = priv_book_container_table_entry(view->table, i);
    const uint64_t next     = priv_book_container_table_entry(view->table, i + 1U);
    const uint64_t dst_off  = (uint64_t)i * view->chunk_bytes;
    uint64_t       expected = view->total - dst_off;
    if (expected > (uint64_t)view->chunk_bytes) {
      expected = view->chunk_bytes;
    }
    size_t          produced = 0U;
    const ra8_err_t err      = inflate(&view->payload[(size_t)off],
                                       (size_t)(next - off),
                                       &scratch[(size_t)dst_off],
                                       (size_t)expected,
                                       &produced);
    if (err != k_ra8_ok) {
      return err;
    }
    if (produced != (size_t)expected) {
      return k_ra8_err_invalid_size;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_open_body(const uint8_t*  bytes,
                                                 size_t          file_len,
                                                 book_inflate_fn inflate,
                                                 void*           scratch,
                                                 size_t          scratch_cap,
                                                 const void**    out_base,
                                                 size_t*         out_size)
{
  book_container_view_t view = {};
  ra8_err_t             err  = internal_container_view(bytes, file_len, scratch_cap, &view);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_inflate_chunks(&view, inflate, (uint8_t*)scratch);
  if (err != k_ra8_ok) {
    return err;
  }
  err = book_validate(scratch, (size_t)view.total);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_base = scratch;
  *out_size = (size_t)view.total;
  return k_ra8_ok;
}
 
ra8_err_t book_open(const void*     file,
                    size_t          file_len,
                    book_inflate_fn inflate,
                    void*           scratch,
                    size_t          scratch_cap,
                    const void**    out_base,
                    size_t*         out_size)
{
  RA8_CHECK_NULL_PTR(file, s_tag_book, "open: null file");
  RA8_CHECK_NULL_PTR(inflate, s_tag_book, "open: null inflate");
  RA8_CHECK_NULL_PTR(scratch, s_tag_book, "open: null scratch");
  RA8_CHECK_NULL_PTR(out_base, s_tag_book, "open: null out_base");
  RA8_CHECK_NULL_PTR(out_size, s_tag_book, "open: null out_size");
 
  return internal_open_body((const uint8_t*)file,
                            file_len,
                            inflate,
                            scratch,
                            scratch_cap,
                            out_base,
                            out_size);
}