comic_cbr.c

Go to the documentation of this file.

#include <stddef.h>
#include <stdint.h>
 
#include "comic.h"
#include "comic_internal.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_decomp_limits.h"
#include "ra8_rar.h"

static const char* const s_tag_cbr = "comic_cbr";

typedef enum : uint32_t {
  k_cbr_name_max   = 256U,    
  k_cbr_max_blocks = 100000U, 
} cbr_limits_t;

RA8_INTERNAL
static ra8_err_t
internal_add_member(comic_t* c, const ra8_rar_entry_t* ent, const char* name, uint16_t nlen)
{
  if (ent->is_file == 0U) {
    return k_ra8_ok;
  }
  if (ent->is_dir != 0U) {
    return k_ra8_ok;
  }
  if (!priv_comic_is_page_name(name, nlen)) {
    return k_ra8_ok;
  }
  /* Decompression-limits guard: a page whose block header declares an
   * over-cap or bomb-ratio size rejects the whole archive before any
   * decode (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, ent->pack_size, ent->unp_size);
  if (derr != k_ra8_ok) {
    return derr;
  }
  const bool is_store = (ent->method == (uint8_t)k_ra8_rar_method_store);
  const bool is_rar5  = (c->rar.version == k_ra8_rar_ver_5);
  /* STORE always decodes; a compressed member decodes only on RAR5 (the RAR4
   * legacy codec is out of scope), so a RAR4-compressed page stays inert. */
  const uint8_t extractable = (is_store || is_rar5) ? 1U : 0U;
  return priv_comic_page_add(c,
                             name,
                             nlen,
                             ent->unp_size,
                             extractable,
                             ent->method,
                             0U,
                             ent->data_off,
                             ent->pack_size);
}
 
RA8_PRIV ra8_err_t priv_comic_cbr_open(comic_t* c)
{
  RA8_CHECK_NULL_PTR(c, s_tag_cbr, "cbr open: null c");
  if (c->rar.version == k_ra8_rar_ver_none) {
    return k_ra8_err_invalid_state;
  }
  /* Decompression-limits budget for the whole enumeration: every walked
   * block charges the entry cap, so the many-tiny-blocks bomb dies within
   * policy long before the static loop cap. Direct field bind (not
   * ra8_decomp_budget_init) because the default policy cannot fail
   * validation and the counters start zeroed. */
  ra8_decomp_budget_t budget = {};
  budget.limits              = ra8_decomp_limits_default();
  uint64_t off               = c->rar.first_off;
  for (uint32_t n = 0U; n < (uint32_t)k_cbr_max_blocks; ++n) {
    if (off >= c->rar.size) {
      break;
    }
    const ra8_err_t ce = ra8_decomp_budget_charge_entry(&budget);
    if (ce != k_ra8_ok) {
      return ce; /* block-flood bomb: reject the archive */
    }
    char            nb[k_cbr_name_max] = {};
    ra8_rar_entry_t ent                = {};
    if (ra8_rar_next(&c->rar, off, nb, (uint16_t)sizeof(nb), &ent) != k_ra8_ok) {
      /* Tolerate trailing junk and let the loop's sole exit handle it. */
      off = c->rar.size;
      continue;
    }
    const ra8_err_t ae = internal_add_member(c, &ent, nb, ent.name_len);
    if (ae != k_ra8_ok) {
      return ae; /* capacity / policy breach -- a real error, propagate */
    }
    off = ent.next_off;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t
priv_comic_cbr_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_cbr, "cbr extract: null c");
  RA8_CHECK_NULL_PTR(p, s_tag_cbr, "cbr extract: null p");
  RA8_CHECK_NULL_PTR(buf, s_tag_cbr, "cbr extract: null buf");
  RA8_CHECK_NULL_PTR(got, s_tag_cbr, "cbr extract: null got");
  *got = 0U;
  if (c->rar.version == k_ra8_rar_ver_none) {
    return k_ra8_err_invalid_state;
  }
  if (p->extractable == 0U) {
    return k_ra8_err_not_supported;
  }
  ra8_rar_entry_t ent = {};
  ent.is_file         = 1U;
  ent.is_dir          = 0U;
  ent.method          = p->rar_method;
  ent.data_off        = p->data_off;
  ent.pack_size       = p->pack_size;
  ent.unp_size        = p->raw_size;
  return ra8_rar_extract(&c->rar, &ent, buf, cap, &c->rar5_state, got);
}