mdl_export_epub.c

Go to the documentation of this file.

 
#include <limits.h>
#include <stdio.h>
#include <string.h>
 
#include "mdl_export.h"
#include "mdl_export_epub_internal.h"
#include "mdl_export_internal.h"
#include "mdl_sanitize.h"
#include "mdl_urlname.h"
#include "miniz.h"
#include "ra8_attributes.h"
 
/* --- EPUB (self-contained: a valid EPUB3 of the page images via miniz) ---- */

static const char* const s_epub_container_xml =
  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
  "<container version=\"1.0\" "
  "xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\"><rootfiles>"
  "<rootfile full-path=\"OEBPS/content.opf\" "
  "media-type=\"application/oebps-package+xml\"/></rootfiles></container>";

RA8_INTERNAL static ra8_err_t internal_epub_media_type_from_sniff(mdl_storage_t* storage,
                                                                  const char*    dir,
                                                                  const char*    name,
                                                                  const char**   out)
{
  char src[k_fw_fs_path_cap];
  if (priv_mdl_export_path_join(src, sizeof(src), dir, name) != k_ra8_ok) {
    return k_ra8_err_invalid_size;
  }
  char            mime[64];
  const ra8_err_t sniff =
    mdl_urlname_sniff_file(storage, src, nullptr, nullptr, 0U, mime, sizeof(mime));
  if (sniff != k_ra8_ok) {
    return (sniff == k_ra8_err_validation_failed) ? k_ra8_err_not_found : sniff;
  }
  if (strcmp(mime, "image/png") == 0) {
    *out = "image/png";
    return k_ra8_ok;
  }
  if (strcmp(mime, "image/gif") == 0) {
    *out = "image/gif";
    return k_ra8_ok;
  }
  if (strcmp(mime, "image/webp") == 0) {
    *out = "image/webp";
    return k_ra8_ok;
  }
  if (strcmp(mime, "image/jpeg") == 0) {
    *out = "image/jpeg";
    return k_ra8_ok;
  }
  return k_ra8_err_not_found;
}

RA8_INTERNAL static void internal_epub_media_type_from_suffix(const char* name, const char** out)
{
  const char* dot = strrchr(name, '.');
  if (dot != nullptr) {
    if ((strcmp(dot, ".png") == 0) || (strcmp(dot, ".PNG") == 0)) {
      *out = "image/png";
      return;
    }
    if ((strcmp(dot, ".gif") == 0) || (strcmp(dot, ".GIF") == 0)) {
      *out = "image/gif";
      return;
    }
    if ((strcmp(dot, ".webp") == 0) || (strcmp(dot, ".WEBP") == 0)) {
      *out = "image/webp";
      return;
    }
    if ((strcmp(dot, ".bmp") == 0) || (strcmp(dot, ".BMP") == 0)) {
      *out = "image/bmp";
      return;
    }
  }
  *out = "image/jpeg";
}

RA8_INTERNAL static ra8_err_t internal_epub_media_type(mdl_storage_t* storage,
                                                       const char*    dir,
                                                       const char*    name,
                                                       const char**   out)
{
  if (dir != nullptr) {
    const ra8_err_t sniffed = internal_epub_media_type_from_sniff(storage, dir, name, out);
    if (sniffed == k_ra8_ok) {
      return k_ra8_ok;
    }
    if (sniffed != k_ra8_err_not_found) {
      return sniffed;
    }
  }
  internal_epub_media_type_from_suffix(name, out);
  return k_ra8_ok;
}
 
RA8_PRIV bool priv_mdl_epub_str_cat(char* dst, size_t cap, const char* text)
{
  const size_t cur = strlen(dst);
  const size_t add = strlen(text);
  if (cur + add + 1U > cap) {
    return false;
  }
  memcpy(dst + cur, text, add + 1U);
  return true;
}
 
RA8_PRIV bool priv_mdl_epub_add_str(mz_zip_archive* zip, const char* name, const char* body)
{
  return priv_mdl_export_zip_add_memory(zip,
                                        name,
                                        (const uint8_t*)body,
                                        strlen(body),
                                        MZ_NO_COMPRESSION) == k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_epub_add_external_cover(mz_zip_archive*             zip,
                                                               mdl_storage_t*              storage,
                                                               const mdl_external_cover_t* cover,
                                                               char*                       mani,
                                                               size_t                      cap)
{
  if (!cover->external) {
    return k_ra8_ok;
  }
  char      archive_entry[k_epub_entry_max];
  const int entry_len = snprintf(archive_entry, sizeof(archive_entry), "OEBPS/%s", cover->entry);
  if (!priv_mdl_export_snprintf_fit(entry_len, sizeof(archive_entry)) ||
      (priv_mdl_export_zip_add_file(zip,
                                    storage,
                                    archive_entry,
                                    cover->source,
                                    MZ_NO_COMPRESSION) != k_ra8_ok)) {
    return k_ra8_fail;
  }
  char      frag[k_epub_frag_max];
  const int frag_len = snprintf(frag,
                                sizeof(frag),
                                "<item id=\"cover-image\" href=\"%s\" media-type=\"%s\" "
                                "properties=\"cover-image\"/>",
                                cover->entry,
                                cover->mime);
  return priv_mdl_export_snprintf_fit(frag_len, sizeof(frag)) &&
             priv_mdl_epub_str_cat(mani, cap, frag)
           ? k_ra8_ok
           : k_ra8_fail;
}

RA8_INTERNAL static ra8_err_t internal_epub_append_frags(char*       mani,
                                                         char*       spine,
                                                         char*       nav,
                                                         size_t      cap,
                                                         const char* esc_name,
                                                         const char* media,
                                                         size_t      idx,
                                                         unsigned    n,
                                                         bool        is_cover)
{
  char        frag[k_epub_frag_max];
  const char* prop_attr = is_cover ? " properties=\"cover-image\"" : "";
  const int   fn        = snprintf(frag,
                                   sizeof(frag),
                                   "<item id=\"pg%zu\" href=\"page_%03u.xhtml\" "
                                   "media-type=\"application/xhtml+xml\"/>"
                                   "<item id=\"img%zu\" href=\"images/%s\" media-type=\"%s\"%s/>",
                                   idx,
                                   n,
                                   idx,
                                   esc_name,
                                   media,
                                   prop_attr);
  if (!priv_mdl_export_snprintf_fit(fn, sizeof(frag))) {
    return k_ra8_fail;
  }
  if (!priv_mdl_epub_str_cat(mani, cap, frag)) {
    return k_ra8_fail;
  }
  (void)snprintf(frag, sizeof(frag), "<itemref idref=\"pg%zu\"/>", idx);
  if (!priv_mdl_epub_str_cat(spine, cap, frag)) {
    return k_ra8_fail;
  }
  (void)snprintf(frag, sizeof(frag), "<li><a href=\"page_%03u.xhtml\">Page %u</a></li>", n, n);
  if (!priv_mdl_epub_str_cat(nav, cap, frag)) {
    return k_ra8_fail;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static bool
internal_epub_page_is_cover(const mdl_export_meta_t* meta, const char* name, size_t idx)
{
  if (meta == nullptr) {
    return false;
  }
  if ((meta->cover_index >= 0) && ((size_t)meta->cover_index == idx)) {
    return true;
  }
  return (meta->cover_path[0] != '\0') && (strcmp(name, meta->cover_path) == 0);
}

RA8_INTERNAL static ra8_err_t internal_epub_write_page_xhtml(mz_zip_archive* zip,
                                                             const char*     name,
                                                             unsigned        n,
                                                             char*           esc,
                                                             size_t          esc_cap)
{
  if (!mdl_xml_escape(name, esc, esc_cap)) {
    return k_ra8_fail; /* untrusted filename must not break the container XML */
  }
  char      xhtml[k_epub_xhtml_max];
  const int xn = snprintf(xhtml,
                          sizeof(xhtml),
                          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                          "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head><title>Page %u"
                          "</title></head><body><img src=\"images/%s\" alt=\"Page %u\"/>"
                          "</body></html>",
                          n,
                          esc,
                          n);
  if (!priv_mdl_export_snprintf_fit(xn, sizeof(xhtml))) {
    return k_ra8_fail;
  }
  char entry[k_epub_entry_max];
  (void)snprintf(entry, sizeof(entry), "OEBPS/page_%03u.xhtml", n);
  if (!priv_mdl_epub_add_str(zip, entry, xhtml)) {
    return k_ra8_fail;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_epub_add_page(mdl_storage_t*           storage,
                                                     mz_zip_archive*          zip,
                                                     const char*              dir,
                                                     const char*              name,
                                                     size_t                   idx,
                                                     char*                    mani,
                                                     char*                    spine,
                                                     char*                    nav,
                                                     size_t                   cap,
                                                     const mdl_export_meta_t* meta)
{
  const unsigned  n = (unsigned)(idx + 1U);
  char            esc[k_epub_name_esc_max];
  const ra8_err_t xhtml_err = internal_epub_write_page_xhtml(zip, name, n, esc, sizeof(esc));
  if (xhtml_err != k_ra8_ok) {
    return xhtml_err;
  }
  char src[k_fw_fs_path_cap];
  if (priv_mdl_export_path_join(src, sizeof(src), dir, name) != k_ra8_ok) {
    return k_ra8_err_invalid_size;
  }
  char      entry[k_epub_entry_max];
  const int en = snprintf(entry, sizeof(entry), "OEBPS/images/%s", name);
  if (!priv_mdl_export_snprintf_fit(en, sizeof(entry))) {
    return k_ra8_fail;
  }
  const ra8_err_t source_err =
    priv_mdl_export_zip_add_file(zip, storage, entry, src, MZ_NO_COMPRESSION);
  if (source_err != k_ra8_ok) {
    return source_err;
  }
  const bool      is_cover   = internal_epub_page_is_cover(meta, name, idx);
  const char*     media_type = nullptr;
  const ra8_err_t media_err  = internal_epub_media_type(storage, dir, name, &media_type);
  if (media_err != k_ra8_ok) {
    return media_err;
  }
  return internal_epub_append_frags(mani, spine, nav, cap, esc, media_type, idx, n, is_cover);
}

RA8_INTERNAL static const mdl_export_meta_t*
internal_epub_page_meta(const mdl_external_cover_t* cover,
                        const mdl_export_meta_t*    meta,
                        mdl_export_meta_t*          page_meta)
{
  if (!cover->external) {
    return meta;
  }
  *page_meta               = *meta;
  page_meta->cover_index   = -1;
  page_meta->cover_path[0] = '\0';
  return page_meta;
}

RA8_INTERNAL static ra8_err_t internal_epub_carve_workspace(mdl_export_workspace_t* ws,
                                                            size_t                  cap,
                                                            char**                  mani,
                                                            char**                  spine,
                                                            char**                  nav,
                                                            char**                  opf,
                                                            char**                  navdoc)
{
  *mani   = (char*)mdl_export_workspace_take(ws, cap, 1U);
  *spine  = (char*)mdl_export_workspace_take(ws, cap, 1U);
  *nav    = (char*)mdl_export_workspace_take(ws, cap, 1U);
  *opf    = (char*)mdl_export_workspace_take(ws, cap, 1U);
  *navdoc = (char*)mdl_export_workspace_take(ws, cap, 1U);
  if ((*mani == nullptr) || (*spine == nullptr) || (*nav == nullptr) || (*opf == nullptr) ||
      (*navdoc == nullptr)) {
    return k_ra8_err_invalid_size;
  }
  (*mani)[0]  = '\0';
  (*spine)[0] = '\0';
  (*nav)[0]   = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_epub_finish_writer(mz_zip_archive*            zip,
                                                          bool                       zip_open,
                                                          mdl_zip_allocator_t*       zip_alloc,
                                                          ra8_err_t                  rc,
                                                          const mdl_export_output_t* output)
{
  if (zip_open) {
    (void)mz_zip_writer_end(zip); /* alloc-allow: releases caller-arena blocks */
  }
  if ((rc == k_ra8_fail) && zip_alloc->exhausted) {
    rc = k_ra8_err_invalid_size;
  }
  if ((rc == k_ra8_fail) && (output->error != k_ra8_ok)) {
    rc = output->error;
  }
  priv_mdl_zip_workspace_release(zip_alloc);
  return rc;
}

RA8_PRIV ra8_err_t priv_mdl_export_epub(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;
  }
  const size_t cap = (size_t)k_epub_base_bytes + (count * (size_t)k_epub_per_page_bytes);
  char*        mani;
  char*        spine;
  char*        nav;
  char*        opf;
  char*        navdoc;
  rc = internal_epub_carve_workspace(ws, cap, &mani, &spine, &nav, &opf, &navdoc);
  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;
  const bool zip_open = (mz_zip_writer_init(&zip, 0) != MZ_FALSE);
  rc                  = zip_open ? k_ra8_ok : priv_mdl_zip_workspace_error(&zip_alloc);
  if ((rc == k_ra8_ok) &&
      (!priv_mdl_epub_add_str(&zip, "mimetype", "application/epub+zip") ||
       !priv_mdl_epub_add_str(&zip, "META-INF/container.xml", s_epub_container_xml))) {
    rc = k_ra8_fail;
  }
  if (rc == k_ra8_ok) {
    rc = internal_epub_add_external_cover(&zip, storage, &cover, mani, cap);
  }
  mdl_export_meta_t        page_meta;
  const mdl_export_meta_t* page_meta_ptr = internal_epub_page_meta(&cover, meta, &page_meta);
  for (size_t i = 0U; (rc == k_ra8_ok) && (i < count); ++i) {
    rc =
      internal_epub_add_page(storage, &zip, dir, names[i], i, mani, spine, nav, cap, page_meta_ptr);
  }
  if (rc == k_ra8_ok) {
    rc = priv_mdl_epub_add_meta(&zip, mani, spine, nav, count, meta, opf, cap, navdoc, cap);
  }
  /* The coordinator aborts this stage unless writer completion and verification pass. */
  return internal_epub_finish_writer(&zip, zip_open, &zip_alloc, rc, output);
}