comic.c

Go to the documentation of this file.

#include "comic.h"
 
#include <string.h>
 
#include "comic_internal.h"
#include "ra8_attributes.h"
#include "ra8_check.h"

static const char* const s_tag_comic = "comic";

typedef enum : uint16_t {
  k_zip_b0        = 0x50U, 
  k_zip_b1        = 0x4BU, 
  k_zip_lfh_b2    = 0x03U, 
  k_zip_lfh_b3    = 0x04U, 
  k_zip_eocd_b2   = 0x05U, 
  k_zip_eocd_b3   = 0x06U, 
  k_comic_sig_min = 4U,    
} comic_magic_t;

typedef enum : uint8_t {
  k_ascii_upper_a = 0x41U, 
  k_ascii_alpha_n = 26U,   
  k_ascii_case_sh = 5U,    
  k_comic_ext_max = 8U,    
} comic_ascii_t;

RA8_INTERNAL static uint8_t internal_lower(uint8_t c)
{
  const uint8_t up =
    (uint8_t)(((uint8_t)(c - (uint8_t)k_ascii_upper_a) < (uint8_t)k_ascii_alpha_n) ? 1U : 0U);
  return (uint8_t)(c | (uint8_t)(up << (uint8_t)k_ascii_case_sh));
}

RA8_INTERNAL static bool internal_ends_with_ci(const char* name, uint16_t len, const char* ext)
{
  size_t elen = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_comic_ext_max; ++i) { /* bound: fixed max ext */
    if (ext[i] == '\0') {
      break;
    }
    elen = (size_t)i + 1U;
  }
  if ((size_t)len < elen) {
    return false;
  }
  const char* tail = &name[(size_t)len - elen];
  for (size_t i = 0U; i < elen; ++i) { /* bound: elen <= k_comic_ext_max */
    if (internal_lower((uint8_t)tail[i]) != internal_lower((uint8_t)ext[i])) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_is_image_ext(const char* name, uint16_t len)
{
  static const char* const k_exts[] = {".jpg", ".jpeg", ".png", ".gif", ".bmp"};
  for (uint8_t i = 0U; i < (uint8_t)(sizeof(k_exts) / sizeof(k_exts[0]));
       ++i) { /* bound: fixed table */
    if (internal_ends_with_ci(name, len, k_exts[i])) {
      return true;
    }
  }
  return false;
}
 
RA8_PRIV bool priv_comic_is_page_name(const char* name, uint16_t len)
{
  if (name == nullptr) {
    return false;
  }
  if (len == 0U) {
    return false;
  }
  size_t base = 0U;
  for (size_t i = 0U; i < (size_t)len; ++i) { /* bound: len */
    if (name[i] == '/') {
      base = i + 1U;
    }
    if (name[i] == '\\') {
      base = i + 1U;
    }
  }
  if (base < (size_t)len) {
    if (name[base] == '.') {
      return false; /* hidden entry or macOS AppleDouble resource fork */
    }
  }
  return internal_is_image_ext(name, len);
}
 
RA8_PRIV ra8_err_t priv_comic_page_add(comic_t*    c,
                                       const char* name,
                                       uint16_t    name_len,
                                       uint64_t    raw_size,
                                       uint8_t     extractable,
                                       uint8_t     method,
                                       uint32_t    zip_index,
                                       uint64_t    data_off,
                                       uint64_t    pack_size)
{
  RA8_CHECK_NULL_PTR(c, s_tag_comic, "add: null c");
  RA8_CHECK_NULL_PTR(name, s_tag_comic, "add: null name");
  if (c->page_count >= c->page_cap) {
    return k_ra8_err_invalid_size;
  }
  if (((uint64_t)c->names_len + (uint64_t)name_len) > (uint64_t)c->names_cap) {
    return k_ra8_err_invalid_size;
  }
  comic_page_t* p = &c->pages[c->page_count];
  *p              = (comic_page_t){};
  p->name_off     = c->names_len;
  p->name_len     = name_len;
  p->extractable  = extractable;
  p->rar_method   = method;
  p->zip_index    = zip_index;
  p->data_off     = data_off;
  p->pack_size    = pack_size;
  p->raw_size     = raw_size;
  if (name_len > 0U) {
    (void)memcpy(&c->names[c->names_len], name, (size_t)name_len);
  }
  c->names_len += (uint32_t)name_len;
  c->page_count += 1U;
  return k_ra8_ok;
}

RA8_INTERNAL static int32_t
internal_name_cmp(const char* a, uint16_t alen, const char* b, uint16_t blen)
{
  const uint16_t m = (alen < blen) ? alen : blen;
  int            c = 0;
  for (uint16_t i = 0U; (i < m) && (c == 0); ++i) {
    c = (int)(uint8_t)a[i] - (int)(uint8_t)b[i];
  }
  if (c != 0) {
    return (c < 0) ? -1 : 1;
  }
  if (alen < blen) {
    return -1;
  }
  if (alen > blen) {
    return 1;
  }
  return 0;
}

RA8_INTERNAL static void internal_sort(comic_t* c)
{
  for (uint32_t i = 1U; i < c->page_count; ++i) { /* bound: page_count <= page_cap */
    const comic_page_t key = c->pages[i];
    const char* const  kn  = &c->names[key.name_off];
    uint32_t           j   = i;
    while (j > 0U) { /* bound: j strictly decreases toward 0 */
      const comic_page_t prev = c->pages[j - 1U];
      if (internal_name_cmp(&c->names[prev.name_off], prev.name_len, kn, key.name_len) <= 0) {
        break;
      }
      c->pages[j] = prev;
      j -= 1U;
    }
    c->pages[j] = key;
  }
}

RA8_INTERNAL static bool internal_is_zip(const uint8_t* s)
{
  if (s[0] != (uint8_t)k_zip_b0) {
    return false;
  }
  if (s[1] != (uint8_t)k_zip_b1) {
    return false;
  }
  if (s[2] == (uint8_t)k_zip_lfh_b2) {
    return s[3] == (uint8_t)k_zip_lfh_b3;
  }
  if (s[2] == (uint8_t)k_zip_eocd_b2) {
    return s[3] == (uint8_t)k_zip_eocd_b3;
  }
  return false;
}

RA8_INTERNAL static ra8_err_t internal_open_reject_null(const comic_t*      c,
                                                        comic_read_fn       read,
                                                        const comic_page_t* pages,
                                                        const char*         names)
{
  RA8_CHECK_NULL_PTR(c, s_tag_comic, "open: null c");
  RA8_CHECK_NULL_PTR(read, s_tag_comic, "open: null read");
  RA8_CHECK_NULL_PTR(pages, s_tag_comic, "open: null pages");
  RA8_CHECK_NULL_PTR(names, s_tag_comic, "open: null names");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_open_detect(comic_t* c)
{
  uint8_t      sig[k_comic_magic_len] = {};
  const size_t got                    = c->read(c->ctx, 0U, sig, sizeof(sig));
  if (got < (size_t)k_comic_sig_min) {
    return k_ra8_err_invalid_size;
  }
  if (internal_is_zip(sig)) {
    c->kind        = k_comic_kind_cbz;
    c->stream.read = c->read;
    c->stream.ctx  = c->ctx;
    c->stream.size = c->size;
    return priv_comic_cbz_open(c);
  }
  const ra8_err_t rerr = ra8_rar_open(&c->rar, c->read, c->ctx, c->size);
  if (rerr == k_ra8_ok) {
    c->kind = k_comic_kind_cbr;
    return priv_comic_cbr_open(c);
  }
  /* tar has no leading magic bytes; the walker's open probes block 0
   * (ustar magic + checksum), so a non-tar file is rejected cheaply. */
  const ra8_err_t terr = unarch_tar_open(&c->tar, c->read, c->ctx, c->size, nullptr);
  if (terr == k_ra8_ok) {
    c->kind = k_comic_kind_cbt;
    return priv_comic_cbt_open(c);
  }
  return k_ra8_err_not_supported;
}
 
ra8_err_t comic_open(comic_t*      c,
                     comic_read_fn read,
                     void*         ctx,
                     uint64_t      size,
                     comic_page_t* pages,
                     uint32_t      page_cap,
                     char*         names,
                     uint32_t      names_cap)
{
  const ra8_err_t nerr = internal_open_reject_null(c, read, pages, names);
  if (nerr != k_ra8_ok) {
    return nerr;
  }
  *c = (comic_t){};
  if (size == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (page_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (names_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  c->read      = read;
  c->ctx       = ctx;
  c->size      = size;
  c->pages     = pages;
  c->page_cap  = page_cap;
  c->names     = names;
  c->names_cap = names_cap;
 
  const ra8_err_t err = internal_open_detect(c);
  if (err != k_ra8_ok) {
    (void)comic_close(c);
    return err;
  }
  if (c->page_count == 0U) {
    (void)comic_close(c);
    return k_ra8_err_not_found;
  }
  internal_sort(c);
  return k_ra8_ok;
}
 
ra8_err_t comic_page_info(const comic_t* c,
                          uint32_t       page,
                          char*          name_buf,
                          uint16_t       name_cap,
                          uint16_t*      out_name_len,
                          uint64_t*      out_raw_size,
                          uint8_t*       out_extractable)
{
  RA8_CHECK_NULL_PTR(c, s_tag_comic, "info: null c");
  if (c->kind == k_comic_kind_none) {
    return k_ra8_err_invalid_state;
  }
  if (page >= c->page_count) {
    return k_ra8_err_out_of_range;
  }
  const comic_page_t* p = &c->pages[page];
  if (name_buf != nullptr) {
    const uint16_t want = (p->name_len > name_cap) ? name_cap : p->name_len;
    if (want > 0U) {
      (void)memcpy(name_buf, &c->names[p->name_off], (size_t)want);
    }
    if (out_name_len != nullptr) {
      *out_name_len = want;
    }
  } else if (out_name_len != nullptr) {
    *out_name_len = p->name_len;
  } else {
    /* The caller did not request a page name or its length. */
  }
  if (out_raw_size != nullptr) {
    *out_raw_size = p->raw_size;
  }
  if (out_extractable != nullptr) {
    *out_extractable = p->extractable;
  }
  return k_ra8_ok;
}
 
ra8_err_t comic_page_read(comic_t* c, uint32_t page, uint8_t* buf, size_t cap, size_t* got)
{
  RA8_CHECK_NULL_PTR(c, s_tag_comic, "read: null c");
  RA8_CHECK_NULL_PTR(buf, s_tag_comic, "read: null buf");
  RA8_CHECK_NULL_PTR(got, s_tag_comic, "read: null got");
  *got = 0U;
  if (c->kind == k_comic_kind_none) {
    return k_ra8_err_invalid_state;
  }
  if (page >= c->page_count) {
    return k_ra8_err_out_of_range;
  }
  const comic_page_t* p = &c->pages[page];
  if (c->kind == k_comic_kind_cbz) {
    return priv_comic_cbz_extract(c, p, buf, cap, got);
  }
  if (c->kind == k_comic_kind_cbt) {
    return priv_comic_cbt_extract(c, p, buf, cap, got);
  }
  return priv_comic_cbr_extract(c, p, buf, cap, got);
}
 
ra8_err_t comic_close(comic_t* c)
{
  RA8_CHECK_NULL_PTR(c, s_tag_comic, "close: null c");
  if (c->kind == k_comic_kind_cbz) {
    (void)priv_comic_cbz_close(c);
  }
  c->kind       = k_comic_kind_none;
  c->page_count = 0U;
  c->zip_active = 0U;
  c->tar.live   = false; /* the tar walker holds no resources to release */
  return k_ra8_ok;
}