epub_chapter.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#include "miniz.h"
 
/* stb_truetype is a single-header library; the implementation lives
 * in apps/shared_libs/third_party/stb/stb_truetype_impl.c so that clang-tidy's
 * third_party path exclusion keeps stb's dense magic-number / huge-
 * function code out of the lint pass. We include only declarations
 * here. */
#include "epub.h"
#include "epub_internal.h"
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_stbtt_guard.h"
#include "stb_truetype.h"
 
/* ---------------------------------------------------------------------------
 * Internal limits.
 * ---------------------------------------------------------------------------
 */

typedef enum : uint16_t {
  k_epub_min_font_bytes = 16, 
} epub_chapter_internal_t;
 
/* ---------------------------------------------------------------------------
 * Helpers.
 * ---------------------------------------------------------------------------
 */

RA8_PRIV bool priv_epub_glyph_dim_invalid(int w, int h)
{
  return (w < 0) || (h < 0);
}

RA8_PRIV bool priv_epub_book_not_ready(uint8_t in_use, uint8_t zip_archive_active)
{
  return (in_use == 0U) || (zip_archive_active == 0U);
}

RA8_PRIV void priv_epub_join_path(const char* dir, const char* name, char* dst, size_t cap)
{
  if ((dst == nullptr) || (cap == 0U)) {
    return;
  }
  dst[0]     = '\0';
  size_t off = 0U;
  if (dir != nullptr) {
    while ((off < (cap - 1U)) && (dir[off] != '\0')) {
      dst[off] = dir[off];
      ++off;
    }
  }
  if (name != nullptr) {
    size_t i = 0U;
    while ((off < (cap - 1U)) && (name[i] != '\0')) {
      dst[off] = name[i];
      ++off;
      ++i;
    }
  }
  dst[off] = '\0';
}

RA8_INTERNAL
static ra8_err_t internal_locate_extract(mz_zip_archive* zip,
                                         const char*     prefixed_path,
                                         const char*     bare_path,
                                         uint8_t*        out_buf,
                                         size_t          max_len,
                                         size_t*         got_len)
{
  int32_t file_idx = mz_zip_reader_locate_file(zip, prefixed_path, nullptr, 0U);
  if (file_idx < 0) {
    file_idx = mz_zip_reader_locate_file(zip, bare_path, nullptr, 0U);
  }
  if (file_idx < 0) {
    return k_ra8_err_not_found;
  }
  mz_zip_archive_file_stat st;
  /* Name lookup does not fully parse extended-size metadata, so malformed
   * central-directory fields may still fail at this validation boundary. */
  if (mz_zip_reader_file_stat(zip, (mz_uint)file_idx, &st) == MZ_FALSE) {
    return k_ra8_err_validation_failed;
  }
  const ra8_err_t gerr = priv_epub_zip_guard_entry(&st);
  if (gerr != k_ra8_ok) {
    return gerr; /* lying header / declared bomb: reject before inflation */
  }
  if ((size_t)st.m_uncomp_size > max_len) {
    return k_ra8_err_no_mem;
  }
  /* Defensive: extract can only fail here if the compressed stream is
   * corrupt (bad CRC or LZ data), which requires a malformed archive. */
  if (mz_zip_reader_extract_to_mem(zip, (mz_uint)file_idx, out_buf, max_len, 0U) == MZ_FALSE) {
    return k_ra8_err_validation_failed;
  }
  *got_len = (size_t)st.m_uncomp_size;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_font_init(const epub_book_t* book, stbtt_fontinfo* out_font)
{
  /* Guard against malformed font blobs: stbtt_GetFontOffsetForIndex
   * returns -1 for non-TTF input, and stbtt_InitFont dereferences past
   * the buffer when handed that offset. */
  const int32_t offset = stbtt_GetFontOffsetForIndex(book->font_data, 0);
  if (offset < 0) {
    return k_ra8_err_validation_failed;
  }
  /* Bound-check the sfnt table directory before stbtt_InitFont walks it: the
   * font bytes are attacker-controlled (an EPUB @font-face / epub_set_font
   * blob) and stb_truetype reads the directory with no length check (#217). */
  if (!ra8_stbtt_sfnt_dir_in_bounds(book->font_data, book->font_size, (uint32_t)offset)) {
    return k_ra8_err_validation_failed;
  }
  if (stbtt_InitFont(out_font, book->font_data, (int)book->font_size, offset) == 0) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_render_into(const stbtt_fontinfo* font,
                                      int32_t               codepoint,
                                      float                 font_size,
                                      uint8_t*              out_bitmap,
                                      size_t                max_pixels,
                                      uint32_t*             out_w,
                                      uint32_t*             out_h)
{
  /* No-allocation glyph rasterisation. stbtt_GetCodepointBitmap()
   * calls STBTT_malloc internally; instead use the two-step "Box"
   * + "Make" path that writes into the caller's buffer. NASA Rule 3
   * compliance. */
  const float scale = stbtt_ScaleForPixelHeight(font, font_size);
  int         x0    = 0;
  int         y0    = 0;
  int         x1    = 0;
  int         y1    = 0;
  stbtt_GetCodepointBitmapBox(font, codepoint, scale, scale, &x0, &y0, &x1, &y1);
  const int w = x1 - x0;
  const int h = y1 - y0;
  /* The raw glyf bounding box remains untrusted after the font directory has
   * initialized; reject reversed coordinates before the signed dimensions are
   * converted to size_t. */
  if (priv_epub_glyph_dim_invalid(w, h)) {
    return k_ra8_err_validation_failed;
  }
  const size_t total = (size_t)w * (size_t)h;
  if (total > max_pixels) {
    return k_ra8_err_no_mem;
  }
  if (total > 0U) {
    /* Stride = w (tightly packed alpha-8). MakeCodepointBitmap writes
     * directly into out_bitmap with no malloc. */
    stbtt_MakeCodepointBitmap(font, out_bitmap, w, h, w, scale, scale, codepoint);
  }
  *out_w = (uint32_t)w;
  *out_h = (uint32_t)h;
  return k_ra8_ok;
}
 
/* ---------------------------------------------------------------------------
 * Public API.
 * ---------------------------------------------------------------------------
 */
 
ra8_err_t epub_get_chapter_count(const epub_book_t* book, uint16_t* out_count)
{
  if ((book == nullptr) || (out_count == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  *out_count = book->chapter_count;
  return k_ra8_ok;
}
 
ra8_err_t epub_load_chapter(epub_book_t* book,
                            uint16_t     idx,
                            uint8_t*     out_xhtml,
                            size_t       max_len,
                            size_t*      got_len)
{
  if ((book == nullptr) || (out_xhtml == nullptr) || (got_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *got_len = 0U;
  if (priv_epub_book_not_ready(book->in_use, book->zip_archive_active)) {
    return k_ra8_err_not_initialized;
  }
  if (max_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (idx >= book->chapter_count) {
    return k_ra8_err_out_of_range;
  }
 
  char full_path[k_epub_max_path_len];
  priv_epub_join_path(book->opf_dir, book->chapter_paths[idx], full_path, sizeof(full_path));
 
  void* const     zip_storage = &book->zip_archive_storage[0];
  mz_zip_archive* zip         = (mz_zip_archive*)zip_storage;
  return internal_locate_extract(zip,
                                 full_path,
                                 book->chapter_paths[idx],
                                 out_xhtml,
                                 max_len,
                                 got_len);
}
 
ra8_err_t epub_get_toc_kind(const epub_book_t* book, uint8_t* out_kind)
{
  if ((book == nullptr) || (out_kind == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  *out_kind = book->toc_kind;
  return k_ra8_ok;
}
 
ra8_err_t epub_get_toc_count(const epub_book_t* book, uint16_t* out_count)
{
  if ((book == nullptr) || (out_count == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  *out_count = book->toc_count;
  return k_ra8_ok;
}
 
ra8_err_t epub_get_toc_entry(const epub_book_t* book, uint16_t idx, epub_toc_entry_t* out_entry)
{
  if ((book == nullptr) || (out_entry == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if (idx >= book->toc_count) {
    return k_ra8_err_out_of_range;
  }
  *out_entry = book->toc[idx];
  return k_ra8_ok;
}
 
ra8_err_t
epub_toc_entry_to_chapter(const epub_book_t* book, uint16_t toc_idx, uint16_t* out_chapter_idx)
{
  if ((book == nullptr) || (out_chapter_idx == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if (toc_idx >= book->toc_count) {
    return k_ra8_err_out_of_range;
  }
 
  /* Match the entry href up to (but excluding) any "#fragment": the spine
   * stores whole-document paths, while a TOC href may target an anchor. */
  const char* const href     = book->toc[toc_idx].href;
  size_t            base_len = 0U;
  while ((href[base_len] != '\0') && (href[base_len] != '#')) {
    ++base_len;
  }
 
  for (uint16_t i = 0U; i < book->chapter_count; i++) {
    const char* path = book->chapter_paths[i];
    if (strlen(path) != base_len) {
      continue;
    }
    if (strncmp(path, href, base_len) != 0) {
      continue;
    }
    *out_chapter_idx = i;
    return k_ra8_ok;
  }
  return k_ra8_err_not_found;
}
 
ra8_err_t epub_get_metadata(const epub_book_t* book, epub_metadata_t* out_meta)
{
  if ((book == nullptr) || (out_meta == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  out_meta->title      = book->title;
  out_meta->author     = book->author;
  out_meta->language   = book->language;
  out_meta->identifier = book->identifier;
  return k_ra8_ok;
}
 
ra8_err_t epub_get_cover_image(epub_book_t* book, uint8_t* out_buf, size_t max_len, size_t* got_len)
{
  if ((book == nullptr) || (out_buf == nullptr) || (got_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *got_len = 0U;
  if (priv_epub_book_not_ready(book->in_use, book->zip_archive_active)) {
    return k_ra8_err_not_initialized;
  }
  if (max_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (book->cover_path[0] == '\0') {
    return k_ra8_err_not_found;
  }
 
  char full_path[k_epub_max_path_len];
  priv_epub_join_path(book->opf_dir, book->cover_path, full_path, sizeof(full_path));
 
  void* const     zip_storage = &book->zip_archive_storage[0];
  mz_zip_archive* zip         = (mz_zip_archive*)zip_storage;
  return internal_locate_extract(zip, full_path, book->cover_path, out_buf, max_len, got_len);
}
 
ra8_err_t epub_get_resource(epub_book_t* book,
                            const char*  path,
                            uint8_t*     out_buf,
                            size_t       max_len,
                            size_t*      got_len)
{
  if ((book == nullptr) || (path == nullptr) || (out_buf == nullptr) || (got_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *got_len = 0U;
  if (priv_epub_book_not_ready(book->in_use, book->zip_archive_active)) {
    return k_ra8_err_not_initialized;
  }
  if (max_len == 0U) {
    return k_ra8_err_invalid_size;
  }
 
  char full_path[k_epub_max_path_len];
  priv_epub_join_path(book->opf_dir, path, full_path, sizeof(full_path));
 
  void* const     zip_storage = &book->zip_archive_storage[0];
  mz_zip_archive* zip         = (mz_zip_archive*)zip_storage;
  return internal_locate_extract(zip, full_path, path, out_buf, max_len, got_len);
}
 
ra8_err_t epub_get_embedded_font_count(const epub_book_t* book, uint16_t* out_count)
{
  if ((book == nullptr) || (out_count == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  *out_count = book->embedded_font_count;
  return k_ra8_ok;
}
 
uint16_t epub_manifest_count(const epub_book_t* book)
{
  if (book == nullptr) {
    return 0U;
  }
  if (book->in_use == 0U) {
    return 0U;
  }
  return book->manifest_count;
}
 
const epub_manifest_item_t* epub_manifest_item(const epub_book_t* book, uint16_t index)
{
  if ((book == nullptr) || (book->in_use == 0U)) {
    return nullptr;
  }
  if (index >= book->manifest_count) {
    return nullptr;
  }
  return &book->manifest[index];
}
 
ra8_err_t epub_get_embedded_font(epub_book_t* book,
                                 uint16_t     idx,
                                 uint8_t*     out_buf,
                                 size_t       max_len,
                                 size_t*      got_len)
{
  if ((book == nullptr) || (out_buf == nullptr) || (got_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *got_len = 0U;
  if (priv_epub_book_not_ready(book->in_use, book->zip_archive_active)) {
    return k_ra8_err_not_initialized;
  }
  if (max_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (idx >= book->embedded_font_count) {
    return k_ra8_err_out_of_range;
  }
 
  char full_path[k_epub_max_path_len];
  priv_epub_join_path(book->opf_dir, book->embedded_font_paths[idx], full_path, sizeof(full_path));
 
  void* const     zip_storage = &book->zip_archive_storage[0];
  mz_zip_archive* zip         = (mz_zip_archive*)zip_storage;
  return internal_locate_extract(zip,
                                 full_path,
                                 book->embedded_font_paths[idx],
                                 out_buf,
                                 max_len,
                                 got_len);
}
 
ra8_err_t epub_set_font(epub_book_t* book, const uint8_t* font_data, size_t font_size)
{
  if ((book == nullptr) || (font_data == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (book->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if (font_size < (size_t)k_epub_min_font_bytes) {
    return k_ra8_err_invalid_size;
  }
  book->font_data = font_data;
  book->font_size = font_size;
  return k_ra8_ok;
}
 
ra8_err_t epub_render_glyph(const epub_book_t* book,
                            int32_t            codepoint,
                            float              font_size,
                            uint8_t*           out_bitmap,
                            size_t             max_pixels,
                            uint32_t*          out_w,
                            uint32_t*          out_h)
{
  if ((book == nullptr) || (out_bitmap == nullptr) || (out_w == nullptr) || (out_h == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_w = 0U;
  *out_h = 0U;
  if ((book->in_use == 0U) || (book->font_data == nullptr)) {
    return k_ra8_err_not_initialized;
  }
  if (font_size <= 0.0F) {
    return k_ra8_err_invalid_arg;
  }
 
  stbtt_fontinfo font;
  ra8_err_t      err = internal_font_init(book, &font);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_render_into(&font, codepoint, font_size, out_bitmap, max_pixels, out_w, out_h);
}