comic_cbz.c

Go to the documentation of this file.

#include <stddef.h>
#include <string.h>
 
#include "comic.h"
#include "comic_internal.h"
#include "epub_miniz_alloc.h"
#include "miniz.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_decomp_limits.h"

static const char* const s_tag_cbz = "comic_cbz";
 
/* The comic record holds the mz_zip_archive inline (no heap); prove the opaque
 * byte buffer is large enough and aligned for miniz's reader state. */
static_assert(k_comic_zip_bytes >= sizeof(mz_zip_archive),
              "k_comic_zip_bytes too small for mz_zip_archive");
static_assert(alignof(mz_zip_archive) <= alignof(max_align_t),
              "mz_zip_archive alignment exceeds max_align_t");

typedef enum : uint16_t {
  k_cbz_name_max = 256U, 
} cbz_limits_t;

RA8_INTERNAL static mz_zip_archive* internal_zip(comic_t* c)
{
  /* Reinterpret the aligned byte arena as the archive via a `void*` seam (as
   * `epub` does): a direct `uint8_t* -> mz_zip_archive*` cast would trip
   * -Wcast-align, and a one-expression `(T*)(void*)p` cast trips
   * bugprone-casting-through-void, so the `void*` is a named local. */
  void* const storage = &c->zip_storage[0];
  return (mz_zip_archive*)storage;
}

RA8_INTERNAL static size_t
internal_stream_read(void* opaque, mz_uint64 file_ofs, void* buf, size_t n)
{
  const comic_stream_t* sm = (const comic_stream_t*)opaque;
  if (sm == nullptr) {
    return 0U; /* GCOVR_EXCL_LINE -- open binds a live stream; miniz never passes NULL */
  }
  if (sm->read == nullptr) {
    return 0U; /* GCOVR_EXCL_LINE -- open validates a non-NULL reader */
  }
  if (file_ofs >= sm->size) {
    return 0U; /* GCOVR_EXCL_LINE -- miniz clamps reads within the archive size */
  }
  const uint64_t avail = sm->size - file_ofs;
  const size_t   want  = ((uint64_t)n > avail) ? (size_t)avail : n;
  return sm->read(sm->ctx, (uint64_t)file_ofs, buf, want);
}

RA8_INTERNAL static ra8_err_t internal_set_alloc(comic_t* c, mz_zip_archive* zip)
{
  const ra8_err_t err = epub_miniz_arena_init(&c->miniz_arena,
                                              &c->miniz_workspace.bytes[0],
                                              sizeof(c->miniz_workspace.bytes));
  if (err != k_ra8_ok) {
    return err; /* GCOVR_EXCL_LINE -- embedded workspace is exact and aligned */
  }
  zip->m_pAlloc        = epub_miniz_alloc;
  zip->m_pFree         = epub_miniz_free;
  zip->m_pRealloc      = epub_miniz_realloc;
  zip->m_pAlloc_opaque = &c->miniz_arena;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_add_entry(comic_t* c, mz_zip_archive* zip, mz_uint i)
{
  if (mz_zip_reader_is_file_a_directory(zip, i) != MZ_FALSE) {
    return k_ra8_ok;
  }
  char nb[k_cbz_name_max] = {};
  (void)mz_zip_reader_get_filename(zip, i, nb, (mz_uint)sizeof(nb));
  nb[sizeof(nb) - 1U] = '\0';
  size_t nl           = 0U;
  for (; nl < sizeof(nb); ++nl) {
    if (nb[nl] == '\0') {
      break;
    }
  }
  if (!priv_comic_is_page_name(nb, (uint16_t)nl)) {
    return k_ra8_ok;
  }
  mz_zip_archive_file_stat st = {};
  if (mz_zip_reader_file_stat(zip, i, &st) == MZ_FALSE) {
    return k_ra8_ok; /* GCOVR_EXCL_LINE -- stat cannot fail on an index locate already found */
  }
  /* Decompression-limits guard: a page whose central-directory record
   * declares an over-cap or bomb-ratio size rejects the whole archive
   * before any inflation (the same policy every decoder enforces). */
  const ra8_decomp_limits_t lim = ra8_decomp_limits_default();
  const ra8_err_t           derr =
    ra8_decomp_check_declared(&lim, (uint64_t)st.m_comp_size, (uint64_t)st.m_uncomp_size);
  if (derr != k_ra8_ok) {
    return derr;
  }
  return priv_comic_page_add(c,
                             nb,
                             (uint16_t)nl,
                             (uint64_t)st.m_uncomp_size,
                             1U,
                             (uint8_t)k_ra8_rar_method_store, /* method unused by CBZ */
                             (uint32_t)i,
                             0U,
                             0U);
}
 
RA8_PRIV ra8_err_t priv_comic_cbz_open(comic_t* c)
{
  RA8_CHECK_NULL_PTR(c, s_tag_cbz, "cbz open: null c");
  const ra8_err_t cap_err = ra8_decomp_zip_entry_preflight(c->stream.read, c->stream.ctx, c->size);
  if (cap_err != k_ra8_ok) {
    return cap_err;
  }
  mz_zip_archive* zip = internal_zip(c);
  (void)memset(zip, 0, sizeof(*zip));
  const ra8_err_t aerr = internal_set_alloc(c, zip);
  if (aerr != k_ra8_ok) {
    return aerr; /* GCOVR_EXCL_LINE -- embedded workspace is exact and aligned */
  }
  zip->m_pRead      = internal_stream_read;
  zip->m_pIO_opaque = &c->stream;
  if (mz_zip_reader_init(zip, (mz_uint64)c->size, 0U) == MZ_FALSE) {
    epub_miniz_arena_deinit(&c->miniz_arena);
    return k_ra8_err_validation_failed;
  }
  c->zip_active     = 1U;
  const mz_uint num = mz_zip_reader_get_num_files(zip);
  /* Decompression-limits guard: the many-tiny-entries bomb dies before
   * any central-directory entry is touched. */
  const ra8_decomp_limits_t lim = ra8_decomp_limits_default();
  if ((uint64_t)num > (uint64_t)lim.max_entries) {
    (void)priv_comic_cbz_close(c);
    return k_ra8_err_decomp_entries;
  }
  for (mz_uint i = 0U; i < num; ++i) { /* bound: finite central-directory count */
    const ra8_err_t e = internal_add_entry(c, zip, i);
    if (e != k_ra8_ok) {
      (void)priv_comic_cbz_close(c);
      return e;
    }
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t
priv_comic_cbz_extract(comic_t* c, const comic_page_t* p, uint8_t* buf, size_t cap, size_t* got)
{
  RA8_CHECK_NULL_PTR(c, s_tag_cbz, "cbz extract: null c");
  RA8_CHECK_NULL_PTR(p, s_tag_cbz, "cbz extract: null p");
  RA8_CHECK_NULL_PTR(buf, s_tag_cbz, "cbz extract: null buf");
  RA8_CHECK_NULL_PTR(got, s_tag_cbz, "cbz extract: null got");
  *got = 0U;
  if (c->zip_active == 0U) {
    return k_ra8_err_invalid_state;
  }
  if ((uint64_t)cap < p->raw_size) {
    return k_ra8_err_no_mem;
  }
  mz_zip_archive* zip = internal_zip(c);
  if (mz_zip_reader_extract_to_mem(zip, (mz_uint)p->zip_index, buf, cap, 0U) == MZ_FALSE) {
    return k_ra8_err_validation_failed;
  }
  *got = (size_t)p->raw_size;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_comic_cbz_close(comic_t* c)
{
  RA8_CHECK_NULL_PTR(c, s_tag_cbz, "cbz close: null c");
  if (c->zip_active != 0U) {
    (void)mz_zip_reader_end(internal_zip(c));
    c->zip_active = 0U;
  }
  epub_miniz_arena_deinit(&c->miniz_arena);
  return k_ra8_ok;
}