mdl_export_zip.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <string.h>
 
#include "mdl_export.h"
#include "mdl_export_internal.h"
#include "mdl_urlname.h"
#include "miniz.h"
#include "ra8_attributes.h"

RA8_INTERNAL static bool internal_zip_align_size(size_t bytes, size_t* out)
{
  const size_t alignment = _Alignof(max_align_t);
  const size_t mask      = alignment - 1U;
  if ((out == nullptr) || (bytes > (SIZE_MAX - mask))) {
    return false;
  }
  *out = (bytes + mask) & ~mask;
  return true;
}

RA8_INTERNAL static mdl_zip_block_t* internal_zip_find_block(mdl_zip_allocator_t* alloc,
                                                             const void*          address)
{
  if ((alloc == nullptr) || (alloc->ws == nullptr) || (address == nullptr)) {
    return nullptr;
  }
  uint8_t* const end = alloc->ws->data + alloc->ws->used;
  for (mdl_zip_block_t* block = alloc->first;
       (block != nullptr) && ((uint8_t*)block < end) && (block->span >= sizeof(*block));
       block = ((uint8_t*)block + block->span < end)
                 ? (mdl_zip_block_t*)((uint8_t*)block + block->span)
                 : nullptr) {
    if ((const void*)(block + 1) == address) {
      return block;
    }
  }
  return nullptr;
}

RA8_INTERNAL static void* internal_zip_workspace_alloc(void* opaque, size_t items, size_t size)
{
  mdl_zip_allocator_t* alloc = (mdl_zip_allocator_t*)opaque;
  if ((alloc == nullptr) || (alloc->ws == nullptr) || (items == 0U) || (size == 0U) ||
      (items > (SIZE_MAX / size))) {
    if (alloc != nullptr) {
      alloc->exhausted = true;
    }
    return nullptr;
  }
  const size_t bytes = items * size;
  size_t       payload_span;
  if (!internal_zip_align_size(bytes, &payload_span) ||
      (payload_span > (SIZE_MAX - sizeof(mdl_zip_block_t)))) {
    alloc->exhausted = true;
    return nullptr;
  }
  uint8_t* const end = alloc->ws->data + alloc->ws->used;
  for (mdl_zip_block_t* block = alloc->first;
       (block != nullptr) && ((uint8_t*)block < end) && (block->span >= sizeof(*block));
       block = ((uint8_t*)block + block->span < end)
                 ? (mdl_zip_block_t*)((uint8_t*)block + block->span)
                 : nullptr) {
    if (block->free && ((block->span - sizeof(*block)) >= bytes)) {
      block->bytes = bytes;
      block->free  = false;
      return block + 1;
    }
  }
  const size_t     block_span = sizeof(mdl_zip_block_t) + payload_span;
  mdl_zip_block_t* block =
    (mdl_zip_block_t*)mdl_export_workspace_take(alloc->ws, block_span, _Alignof(max_align_t));
  if (block == nullptr) {
    alloc->exhausted = true;
    return nullptr;
  }
  block->span  = block_span;
  block->bytes = bytes;
  block->free  = false;
  if (alloc->first == nullptr) {
    alloc->first = block;
  }
  return block + 1;
}

RA8_INTERNAL static void internal_zip_workspace_free(void* opaque, void* address)
{
  mdl_zip_allocator_t* alloc = (mdl_zip_allocator_t*)opaque;
  mdl_zip_block_t*     block = internal_zip_find_block(alloc, address);
  if (block != nullptr) {
    block->free = true;
  }
}

RA8_INTERNAL static void*
internal_zip_workspace_realloc(void* opaque, void* address, size_t items, size_t size)
{
  mdl_zip_allocator_t* alloc = (mdl_zip_allocator_t*)opaque;
  if (address == nullptr) {
    return internal_zip_workspace_alloc(opaque, items, size);
  }
  if ((alloc == nullptr) || (items == 0U) || (size == 0U) || (items > (SIZE_MAX / size))) {
    if (alloc != nullptr) {
      alloc->exhausted = true;
    }
    return nullptr;
  }
  mdl_zip_block_t* block = internal_zip_find_block(alloc, address);
  const size_t     bytes = items * size;
  if ((block == nullptr) || block->free) {
    alloc->exhausted = true;
    return nullptr;
  }
  if ((block->span - sizeof(*block)) >= bytes) {
    block->bytes = bytes;
    return address;
  }
  void* replacement = internal_zip_workspace_alloc(opaque, items, size);
  if (replacement == nullptr) {
    return nullptr;
  }
  memcpy(replacement, address, block->bytes);
  block->free = true;
  return replacement;
}

RA8_PRIV void priv_mdl_zip_workspace_bind(mz_zip_archive*         zip,
                                          mdl_zip_allocator_t*    alloc,
                                          mdl_export_workspace_t* ws)
{
  memset(zip, 0, sizeof(*zip));
  *alloc               = (mdl_zip_allocator_t){.ws = ws, .floor = ws->used};
  zip->m_pAlloc        = internal_zip_workspace_alloc;
  zip->m_pFree         = internal_zip_workspace_free;
  zip->m_pRealloc      = internal_zip_workspace_realloc;
  zip->m_pAlloc_opaque = alloc;
}

RA8_PRIV void priv_mdl_zip_workspace_release(mdl_zip_allocator_t* alloc)
{
  if ((alloc != nullptr) && (alloc->ws != nullptr)) {
    alloc->ws->used = alloc->floor;
  }
}

RA8_PRIV ra8_err_t priv_mdl_zip_workspace_error(const mdl_zip_allocator_t* alloc)
{
  return ((alloc != nullptr) && alloc->exhausted) ? k_ra8_err_invalid_size : k_ra8_fail;
}

RA8_PRIV ra8_err_t priv_mdl_export_prepare_cover(mdl_storage_t*           storage,
                                                 const mdl_export_meta_t* meta,
                                                 const char               names[][k_name_max],
                                                 size_t                   count,
                                                 mdl_external_cover_t*    cover)
{
  memset(cover, 0, sizeof(*cover));
  if ((meta == nullptr) || (meta->cover_path[0] == '\0')) {
    return k_ra8_ok;
  }
  if (strnlen(meta->cover_path, sizeof(meta->cover_path)) == sizeof(meta->cover_path)) {
    return k_ra8_err_invalid_arg;
  }
  for (size_t i = 0U; i < count; ++i) {
    if (strcmp(meta->cover_path, names[i]) == 0) {
      return k_ra8_ok;
    }
  }
 
  fw_fs_stat_t    stat = {};
  const ra8_err_t err  = fw_fs_stat(&storage->fs->names, meta->cover_path, &stat);
  if ((err != k_ra8_ok) || !stat.exists || (stat.type != k_fw_fs_node_file) ||
      (stat.size_bytes == 0U)) {
    return k_ra8_err_validation_failed;
  }
  char ext[k_cover_ext_bytes];
  if (mdl_urlname_sniff_file(storage,
                             meta->cover_path,
                             nullptr,
                             ext,
                             sizeof(ext),
                             cover->mime,
                             sizeof(cover->mime)) != k_ra8_ok) {
    return k_ra8_err_validation_failed;
  }
  const int written = snprintf(cover->entry, sizeof(cover->entry), "cover/cover.%s", ext);
  if (!priv_mdl_export_snprintf_fit(written, sizeof(cover->entry))) {
    return k_ra8_err_invalid_size;
  }
  cover->source   = meta->cover_path;
  cover->external = true;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cbz_add_pages(mz_zip_archive* zip,
                                                     mdl_storage_t*  storage,
                                                     const char*     dir,
                                                     char            names[][k_name_max],
                                                     size_t          count)
{
  for (size_t i = 0U; i < count; ++i) {
    char      source[k_fw_fs_path_cap];
    ra8_err_t err = priv_mdl_export_path_join(source, sizeof(source), dir, names[i]);
    if (err == k_ra8_ok) {
      err = priv_mdl_export_zip_add_file(zip, storage, names[i], source, MZ_NO_COMPRESSION);
    }
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cbz_add_metadata(mz_zip_archive*             zip,
                                                        const mdl_export_meta_t*    meta,
                                                        size_t                      count,
                                                        const mdl_external_cover_t* cover,
                                                        const mdl_zip_allocator_t*  allocator)
{
  mdl_export_meta_t        cover_meta;
  const mdl_export_meta_t* comic_meta  = meta;
  size_t                   comic_pages = count;
  if (cover->external) {
    cover_meta             = *meta;
    cover_meta.cover_index = 0;
    comic_meta             = &cover_meta;
    ++comic_pages;
  }
  char            comic_xml[4096];
  const ra8_err_t rc =
    mdl_export_build_comicinfo_pages(comic_meta, comic_pages, comic_xml, sizeof(comic_xml));
  if (rc != k_ra8_ok) {
    return rc;
  }
  const ra8_err_t added = priv_mdl_export_zip_add_memory(zip,
                                                         "ComicInfo.xml",
                                                         (const uint8_t*)comic_xml,
                                                         strlen(comic_xml),
                                                         MZ_NO_COMPRESSION);
  return (added == k_ra8_ok) ? k_ra8_ok : priv_mdl_zip_workspace_error(allocator);
}

RA8_PRIV ra8_err_t priv_mdl_export_cbz(mdl_storage_t*           storage,
                                       const char*              dir,
                                       char                     names[][k_name_max],
                                       size_t                   count,
                                       mdl_export_output_t*     output,
                                       const mdl_export_meta_t* meta,
                                       mdl_export_workspace_t*  ws)
{
  mdl_external_cover_t cover;
  ra8_err_t            rc = priv_mdl_export_prepare_cover(storage, meta, names, count, &cover);
  if (rc != k_ra8_ok) {
    return rc;
  }
  mz_zip_archive      zip;
  mdl_zip_allocator_t zip_alloc;
  priv_mdl_zip_workspace_bind(&zip, &zip_alloc, ws);
  zip.m_pWrite     = priv_mdl_export_zip_write;
  zip.m_pIO_opaque = output;
  if (mz_zip_writer_init(&zip, 0) == MZ_FALSE) {
    const ra8_err_t zip_rc = priv_mdl_zip_workspace_error(&zip_alloc);
    priv_mdl_zip_workspace_release(&zip_alloc);
    return zip_rc;
  }
  if (cover.external) {
    rc = priv_mdl_export_zip_add_file(&zip, storage, cover.entry, cover.source, MZ_NO_COMPRESSION);
    if ((rc == k_ra8_fail) && zip_alloc.exhausted) {
      rc = k_ra8_err_invalid_size;
    }
  }
  if (rc == k_ra8_ok) {
    rc = internal_cbz_add_pages(&zip, storage, dir, names, count);
    if ((rc == k_ra8_fail) && zip_alloc.exhausted) {
      rc = k_ra8_err_invalid_size;
    }
  }
  if (rc == k_ra8_ok) {
    rc = internal_cbz_add_metadata(&zip, meta, count, &cover, &zip_alloc);
  }
  if ((rc == k_ra8_ok) && (mz_zip_writer_finalize_archive(&zip) == MZ_FALSE)) {
    rc = priv_mdl_zip_workspace_error(&zip_alloc);
  }
  (void)mz_zip_writer_end(&zip); /* alloc-allow: releases caller-arena blocks */
  priv_mdl_zip_workspace_release(&zip_alloc);
  if ((rc == k_ra8_fail) && (output->error != k_ra8_ok)) {
    rc = output->error;
  }
  return rc;
}