mdl_export_meta.c

Go to the documentation of this file.

 
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "mdl_export.h"
#include "mdl_export_internal.h"
#include "mdl_sanitize.h"
#include "mdl_url_guard.h"
#include "ra8_attributes.h"

typedef enum : uint16_t {
  k_decimal_radix       = 10U,  
  k_xml_amp_entity_len  = 5U,   
  k_meta_line_slack     = 128U, 
  k_meta_fragment_slack = 64U,  
} mdl_meta_text_bounds_t;

RA8_PRIV ra8_err_t priv_mdl_export_validate_source_url(const char* url)
{
  const size_t len = strnlen(url, (size_t)k_mdl_meta_url_max);
  if (len == (size_t)k_mdl_meta_url_max) {
    return k_ra8_err_invalid_size;
  }
  if (len == 0U) {
    return k_ra8_ok;
  }
  char host[k_mdl_meta_url_max];
  if (!mdl_url_scheme_allowed(url) || !mdl_url_host(url, host, sizeof(host))) {
    return k_ra8_err_invalid_arg;
  }
  for (size_t i = 0U; i < len; ++i) {
    if (isspace((unsigned char)url[i]) || iscntrl((unsigned char)url[i])) {
      return k_ra8_err_invalid_arg;
    }
  }
  return k_ra8_ok;
}

RA8_PRIV bool priv_mdl_export_snprintf_fit(int written, size_t cap)
{
  return (written >= 0) && ((size_t)written < cap);
}
 
void mdl_meta_init(mdl_export_meta_t* meta)
{
  if (meta == nullptr) {
    return;
  }
  memset(meta, 0, sizeof(*meta));
  meta->cover_index       = -1;
  meta->reading_direction = k_mdl_read_ltr;
  (void)snprintf(meta->language, sizeof(meta->language), "en");
  meta->modified[0] = '\0';
}

RA8_INTERNAL static bool internal_str_copy_trimmed(char* dst, size_t cap, const char* src)
{
  while ((*src != '\0') && isspace((unsigned char)*src)) {
    src++;
  }
  size_t len = strlen(src);
  while ((len > 0U) && isspace((unsigned char)src[len - 1U])) {
    len--;
  }
  if ((cap == 0U) || (len >= cap)) {
    return false;
  }
  memcpy(dst, src, len);
  dst[len] = '\0';
  return true;
}

RA8_INTERNAL static bool internal_parse_double_strict(const char* text, double* out)
{
  errno              = 0;
  char*        end   = nullptr;
  const double value = strtod(text, &end);
  while ((end != nullptr) && isspace((unsigned char)*end)) {
    ++end;
  }
  if ((end == text) || (end == nullptr) || (*end != '\0') || (errno == ERANGE) ||
      !isfinite(value) || (value < 0.0)) {
    return false;
  }
  *out = value;
  return true;
}

RA8_INTERNAL static bool internal_parse_int_strict(const char* text, int* out)
{
  errno            = 0;
  char*      end   = nullptr;
  const long value = strtol(text, &end, k_decimal_radix);
  while ((end != nullptr) && isspace((unsigned char)*end)) {
    ++end;
  }
  if ((end == text) || (end == nullptr) || (*end != '\0') || (errno == ERANGE) || (value < -1L) ||
      (value > INT_MAX)) {
    return false;
  }
  *out = (int)value;
  return true;
}

RA8_INTERNAL static bool internal_xml_unescape(const char* raw, char* out, size_t cap)
{
  size_t r = 0U;
  size_t w = 0U;
  while ((raw[r] != '\0') && (w + 1U < cap)) {
    const char* entity   = nullptr;
    char        decoded  = '\0';
    size_t      consumed = 0U;
    if (raw[r] == '&') {
      if (strncmp(raw + r, "&amp;", k_xml_amp_entity_len) == 0) {
        entity  = "&amp;";
        decoded = '&';
      } else if (strncmp(raw + r, "&lt;", 4U) == 0) {
        entity  = "&lt;";
        decoded = '<';
      } else if (strncmp(raw + r, "&gt;", 4U) == 0) {
        entity  = "&gt;";
        decoded = '>';
      } else if (strncmp(raw + r, "&quot;", 6U) == 0) {
        entity  = "&quot;";
        decoded = '"';
      } else if (strncmp(raw + r, "&apos;", 6U) == 0) {
        entity  = "&apos;";
        decoded = '\'';
      }
    }
    consumed = (entity == nullptr) ? 1U : strlen(entity);
    out[w++] = (char)((entity == nullptr) ? raw[r] : decoded);
    r += consumed;
  }
  out[w] = '\0';
  return raw[r] == '\0';
}

RA8_INTERNAL static bool
internal_parse_xml_tag(const char* xml, const char* tag, char* out, size_t cap)
{
  char open_tag[64];
  char close_tag[64];
  (void)snprintf(open_tag, sizeof(open_tag), "<%s>", tag);
  (void)snprintf(close_tag, sizeof(close_tag), "</%s>", tag);
  const char* start = strstr(xml, open_tag);
  if (start == nullptr) {
    (void)snprintf(open_tag, sizeof(open_tag), "<%s ", tag);
    start = strstr(xml, open_tag);
    start = (start == nullptr) ? nullptr : strchr(start, '>');
    start = (start == nullptr) ? nullptr : start + 1;
  } else {
    start += strlen(open_tag);
  }
  const char* end = (start == nullptr) ? nullptr : strstr(start, close_tag);
  if (end == nullptr) {
    return true;
  }
  const size_t len = (size_t)(end - start);
  char         raw[k_mdl_meta_path_max + 1U];
  if (len >= sizeof(raw)) {
    return false;
  }
  memcpy(raw, start, len);
  raw[len] = '\0';
  return internal_xml_unescape(raw, out, cap);
}

typedef struct {
  const char* tag; 
  char*       dst; 
  size_t      cap; 
} mdl_meta_xml_field_t;

RA8_INTERNAL static ra8_err_t internal_parse_xml_field(const char*                 text,
                                                       const mdl_meta_xml_field_t* field)
{
  char value[k_mdl_meta_path_max + 1U] = {};
  if (!internal_parse_xml_tag(text, field->tag, value, sizeof(value))) {
    return k_ra8_err_invalid_size;
  }
  if ((value[0] != '\0') && !internal_str_copy_trimmed(field->dst, field->cap, value)) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_parse_xml_semantics(mdl_export_meta_t* meta,
                                                           const char*        text)
{
  char value[k_mdl_meta_path_max + 1U] = {};
  if (!internal_parse_xml_tag(text, "Web", value, sizeof(value))) {
    return k_ra8_err_invalid_size;
  }
  if ((value[0] != '\0') &&
      !internal_str_copy_trimmed(meta->source_url, sizeof(meta->source_url), value)) {
    return k_ra8_err_invalid_size;
  }
  if (value[0] != '\0') {
    const ra8_err_t rc = priv_mdl_export_validate_source_url(meta->source_url);
    if (rc != k_ra8_ok) {
      meta->source_url[0] = '\0';
      return rc;
    }
  }
  value[0] = '\0';
  if (!internal_parse_xml_tag(text, "Number", value, sizeof(value))) {
    return k_ra8_err_invalid_size;
  }
  if ((value[0] != '\0') && !internal_parse_double_strict(value, &meta->chapter_number)) {
    return k_ra8_err_invalid_arg;
  }
  value[0] = '\0';
  if (!internal_parse_xml_tag(text, "Manga", value, sizeof(value))) {
    return k_ra8_err_invalid_size;
  }
  if (strcmp(value, "YesAndRightToLeft") == 0) {
    meta->reading_direction = k_mdl_read_rtl;
  } else if (strcmp(value, "No") == 0) {
    meta->reading_direction = k_mdl_read_ltr;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_parse_xml(mdl_export_meta_t* meta, const char* text)
{
  mdl_meta_xml_field_t fields[] = {{"Title", meta->chapter_title, sizeof(meta->chapter_title)},
                                   {"Series", meta->series_title, sizeof(meta->series_title)},
                                   {"Summary", meta->summary, sizeof(meta->summary)},
                                   {"Writer", meta->writer, sizeof(meta->writer)},
                                   {"Artist", meta->artist, sizeof(meta->artist)},
                                   {"LanguageISO", meta->language, sizeof(meta->language)},
                                   {"CoverImage", meta->cover_path, sizeof(meta->cover_path)}};
  for (size_t i = 0U; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
    const ra8_err_t rc = internal_parse_xml_field(text, &fields[i]);
    if (rc != k_ra8_ok) {
      return rc;
    }
  }
  return internal_parse_xml_semantics(meta, text);
}

RA8_INTERNAL static bool internal_key_is(const char* key,
                                         const char* a,
                                         const char* b,
                                         const char* c,
                                         const char* d,
                                         const char* e)
{
  return (strcmp(key, a) == 0) || ((b != nullptr) && (strcmp(key, b) == 0)) ||
         ((c != nullptr) && (strcmp(key, c) == 0)) || ((d != nullptr) && (strcmp(key, d) == 0)) ||
         ((e != nullptr) && (strcmp(key, e) == 0));
}

RA8_INTERNAL static bool
internal_find_descriptive_key(mdl_export_meta_t* meta, const char* key, char** dst, size_t* cap)
{
  if (internal_key_is(key, "series", "series_title", "seriestitle", "series title", nullptr)) {
    *dst = meta->series_title;
    *cap = sizeof(meta->series_title);
  } else if (internal_key_is(key, "summary", "description", "abstract", nullptr, nullptr)) {
    *dst = meta->summary;
    *cap = sizeof(meta->summary);
  } else if (internal_key_is(key,
                             "chapter_title",
                             "chaptertitle",
                             "chapter title",
                             "title",
                             nullptr)) {
    *dst = meta->chapter_title;
    *cap = sizeof(meta->chapter_title);
  } else {
    return false;
  }
  return true;
}

RA8_INTERNAL static bool
internal_find_publication_key(mdl_export_meta_t* meta, const char* key, char** dst, size_t* cap)
{
  if (internal_key_is(key, "writer", "author", "creator", nullptr, nullptr)) {
    *dst = meta->writer;
    *cap = sizeof(meta->writer);
  } else if (internal_key_is(key, "artist", "penciller", "illustrator", nullptr, nullptr)) {
    *dst = meta->artist;
    *cap = sizeof(meta->artist);
  } else if (internal_key_is(key,
                             "cover",
                             "cover_path",
                             "coverpath",
                             "cover path",
                             "cover_image")) {
    *dst = meta->cover_path;
    *cap = sizeof(meta->cover_path);
  } else if (internal_key_is(key, "language", "language_iso", "lang", nullptr, nullptr)) {
    *dst = meta->language;
    *cap = sizeof(meta->language);
  } else if (internal_key_is(key, "identifier", "uuid", nullptr, nullptr, nullptr)) {
    *dst = meta->identifier;
    *cap = sizeof(meta->identifier);
  } else if (internal_key_is(key, "modified", "date_modified", nullptr, nullptr, nullptr)) {
    *dst = meta->modified;
    *cap = sizeof(meta->modified);
  } else {
    return false;
  }
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_apply_text_key(mdl_export_meta_t* meta, const char* key, const char* value)
{
  char*  dst = nullptr;
  size_t cap = 0U;
  if (!internal_find_descriptive_key(meta, key, &dst, &cap) &&
      !internal_find_publication_key(meta, key, &dst, &cap)) {
    return k_ra8_err_not_found;
  }
  return internal_str_copy_trimmed(dst, cap, value) ? k_ra8_ok : k_ra8_err_invalid_size;
}

RA8_INTERNAL static ra8_err_t
internal_apply_semantic_key(mdl_export_meta_t* meta, const char* key, const char* value)
{
  char parsed[64];
  if (internal_key_is(key, "source_url", "source", "web", nullptr, nullptr)) {
    if (!internal_str_copy_trimmed(meta->source_url, sizeof(meta->source_url), value)) {
      return k_ra8_err_invalid_size;
    }
    const ra8_err_t rc = priv_mdl_export_validate_source_url(meta->source_url);
    if (rc != k_ra8_ok) {
      meta->source_url[0] = '\0';
    }
    return rc;
  }
  if (internal_key_is(key, "number", "chapter_number", "chapternumber", "chapter number", "num")) {
    if (!internal_str_copy_trimmed(parsed, sizeof(parsed), value)) {
      return k_ra8_err_invalid_size;
    }
    return internal_parse_double_strict(parsed, &meta->chapter_number) ? k_ra8_ok
                                                                       : k_ra8_err_invalid_arg;
  }
  if (internal_key_is(key, "cover_index", "coverindex", "cover index", "cover_idx", nullptr)) {
    if (!internal_str_copy_trimmed(parsed, sizeof(parsed), value)) {
      return k_ra8_err_invalid_size;
    }
    return internal_parse_int_strict(parsed, &meta->cover_index) ? k_ra8_ok : k_ra8_err_invalid_arg;
  }
  if (internal_key_is(key,
                      "reading_direction",
                      "direction",
                      "page_progression",
                      nullptr,
                      nullptr)) {
    if (!internal_str_copy_trimmed(parsed, sizeof(parsed), value)) {
      return k_ra8_err_invalid_size;
    }
    if (strcmp(parsed, "rtl") == 0) {
      meta->reading_direction = k_mdl_read_rtl;
    } else if (strcmp(parsed, "ltr") == 0) {
      meta->reading_direction = k_mdl_read_ltr;
    } else {
      return k_ra8_err_invalid_arg;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_parse_kv_line(mdl_export_meta_t* meta, char* line)
{
  char* start = line;
  while ((*start != '\0') && isspace((unsigned char)*start)) {
    ++start;
  }
  if ((*start == '\0') || (*start == '#') || (*start == ';')) {
    return k_ra8_ok;
  }
  char* separator = strchr(start, '=');
  separator       = (separator == nullptr) ? strchr(start, ':') : separator;
  if (separator == nullptr) {
    return k_ra8_ok;
  }
  *separator = '\0';
  char key[128];
  if (!internal_str_copy_trimmed(key, sizeof(key), start)) {
    return k_ra8_err_invalid_size;
  }
  for (size_t i = 0U; key[i] != '\0'; ++i) {
    key[i] = (char)tolower((unsigned char)key[i]);
  }
  ra8_err_t rc = internal_apply_text_key(meta, key, separator + 1);
  if (rc == k_ra8_err_not_found) {
    rc = internal_apply_semantic_key(meta, key, separator + 1);
  }
  return rc;
}
 
ra8_err_t mdl_meta_parse(mdl_export_meta_t* meta, const char* text)
{
  if ((meta == nullptr) || (text == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  if ((strstr(text, "<ComicInfo") != nullptr) || (strstr(text, "<Title>") != nullptr) ||
      (strstr(text, "<Series>") != nullptr) || (strstr(text, "<Web>") != nullptr)) {
    return internal_parse_xml(meta, text);
  }
  const char* cursor = text;
  while (*cursor != '\0') {
    const char*  end    = strchr(cursor, '\n');
    const size_t length = (end == nullptr) ? strlen(cursor) : (size_t)(end - cursor);
    char         line[k_mdl_meta_path_max + k_meta_line_slack];
    if (length >= sizeof(line)) {
      return k_ra8_err_invalid_size;
    }
    memcpy(line, cursor, length);
    line[length]       = '\0';
    const ra8_err_t rc = internal_parse_kv_line(meta, line);
    if (rc != k_ra8_ok) {
      return rc;
    }
    cursor += length;
    if (*cursor == '\n') {
      ++cursor;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_meta_candidate_path(const char* directory,
                                                           const char* candidate,
                                                           bool        parent,
                                                           char*       out,
                                                           size_t      capacity)
{
  if (!parent) {
    return priv_mdl_export_path_join(out, capacity, directory, candidate);
  }
  char   parent_path[k_fw_fs_path_cap];
  size_t length = strnlen(directory, sizeof(parent_path));
  if ((length == 0U) || (length >= sizeof(parent_path))) {
    return k_ra8_err_invalid_arg;
  }
  memcpy(parent_path, directory, length + 1U);
  while ((length > 1U) && (parent_path[length - 1U] != '/')) {
    --length;
  }
  if (length > 1U) {
    parent_path[length - 1U] = '\0';
  } else {
    parent_path[1] = '\0';
  }
  return priv_mdl_export_path_join(out, capacity, parent_path, candidate);
}

RA8_INTERNAL static ra8_err_t internal_meta_load_candidate(mdl_storage_t*     storage,
                                                           const char*        dir,
                                                           const char*        candidate,
                                                           bool               is_fallback,
                                                           mdl_export_meta_t* meta)
{
  char      path[k_fw_fs_path_cap];
  ra8_err_t err = internal_meta_candidate_path(dir, candidate, is_fallback, path, sizeof(path));
  if (err != k_ra8_ok) {
    return err;
  }
  fw_fs_stat_t stat = {};
  err               = fw_fs_stat(&storage->fs->names, path, &stat);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!stat.exists) {
    return k_ra8_ok;
  }
  if (stat.type != k_fw_fs_node_file) {
    return k_ra8_err_invalid_arg;
  }
  if (stat.size_bytes == 0U) {
    return k_ra8_ok;
  }
  char buf[4096];
  if (stat.size_bytes >= sizeof(buf)) {
    return k_ra8_err_invalid_size;
  }
  size_t got = 0U;
  err        = priv_mdl_export_source_slurp(storage, path, (uint8_t*)buf, sizeof(buf) - 1U, &got);
  if (err != k_ra8_ok) {
    return err;
  }
  buf[got] = '\0';
  return mdl_meta_parse(meta, buf);
}
 
ra8_err_t mdl_meta_load_dir(mdl_storage_t* storage, mdl_export_meta_t* meta, const char* dir)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (meta == nullptr) || (dir == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  mdl_meta_init(meta);
 
  static const char* const candidate_files[] = {"metadata.txt",
                                                "ComicInfo.xml",
                                                ".mdl_meta",
                                                "metadata.conf",
                                                "metadata.txt"};
 
  for (size_t i = 0U; i < (sizeof(candidate_files) / sizeof(candidate_files[0])); ++i) {
    const ra8_err_t err =
      internal_meta_load_candidate(storage, dir, candidate_files[i], i == 4U, meta);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

typedef struct {
  char title[k_mdl_meta_title_max * 6U];     
  char series[k_mdl_meta_title_max * 6U];    
  char summary[k_mdl_meta_summary_max * 6U]; 
  char writer[k_mdl_meta_name_max * 6U];     
  char artist[k_mdl_meta_name_max * 6U];     
  char language[k_mdl_meta_lang_max * 6U];   
  char source[k_mdl_meta_url_max * 6U];      
} mdl_comicinfo_text_t;

RA8_INTERNAL static ra8_err_t internal_escape_comicinfo(const mdl_export_meta_t* meta,
                                                        mdl_comicinfo_text_t*    escaped)
{
  const char* title_fallback = (meta->series_title[0] != '\0') ? meta->series_title : "Chapter";
  const char* title  = (meta->chapter_title[0] != '\0') ? meta->chapter_title : title_fallback;
  const char* series = (meta->series_title[0] != '\0') ? meta->series_title : "Series";
  if (!mdl_xml_escape(title, escaped->title, sizeof(escaped->title))) {
    (void)snprintf(escaped->title, sizeof(escaped->title), "Chapter");
  }
  if (!mdl_xml_escape(series, escaped->series, sizeof(escaped->series))) {
    (void)snprintf(escaped->series, sizeof(escaped->series), "Series");
  }
  if (!mdl_xml_escape(meta->summary, escaped->summary, sizeof(escaped->summary))) {
    escaped->summary[0] = '\0';
  }
  if (!mdl_xml_escape(meta->writer, escaped->writer, sizeof(escaped->writer))) {
    escaped->writer[0] = '\0';
  }
  if (!mdl_xml_escape(meta->artist, escaped->artist, sizeof(escaped->artist))) {
    escaped->artist[0] = '\0';
  }
  return (mdl_xml_escape(meta->language, escaped->language, sizeof(escaped->language)) &&
          mdl_xml_escape(meta->source_url, escaped->source, sizeof(escaped->source)))
           ? k_ra8_ok
           : k_ra8_err_invalid_size;
}

RA8_INTERNAL static ra8_err_t internal_render_comicinfo(const mdl_export_meta_t*    meta,
                                                        const mdl_comicinfo_text_t* escaped,
                                                        size_t                      page_count,
                                                        const char*                 web,
                                                        const char*                 number,
                                                        const char*                 pages,
                                                        char*                       buf,
                                                        size_t                      cap)
{
  const char* manga = (meta->reading_direction == k_mdl_read_rtl) ? "YesAndRightToLeft" : "No";
  const int written = snprintf(buf,
                               cap,
                               "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                               "<ComicInfo xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
                               "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n"
                               "  <Title>%s</Title>\n  <Series>%s</Series>\n  <Number>%s</Number>\n"
                               "  <Summary>%s</Summary>\n  <Writer>%s</Writer>\n  "
                               "<Artist>%s</Artist>\n%s"
                               "  <PageCount>%zu</PageCount>\n  <LanguageISO>%s</LanguageISO>\n"
                               "  <Manga>%s</Manga>\n%s</ComicInfo>",
                               escaped->title,
                               escaped->series,
                               number,
                               escaped->summary,
                               escaped->writer,
                               escaped->artist,
                               web,
                               page_count,
                               escaped->language,
                               manga,
                               pages);
  return priv_mdl_export_snprintf_fit(written, cap) ? k_ra8_ok : k_ra8_err_invalid_size;
}
 
ra8_err_t mdl_export_build_comicinfo_pages(const mdl_export_meta_t* meta,
                                           size_t                   page_count,
                                           char*                    buf,
                                           size_t                   cap)
{
  if ((buf == nullptr) || (cap == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  mdl_export_meta_t resolved;
  if (meta != nullptr) {
    resolved = *meta;
  } else {
    mdl_meta_init(&resolved);
  }
  ra8_err_t            rc      = priv_mdl_export_validate_source_url(resolved.source_url);
  mdl_comicinfo_text_t escaped = {};
  if (rc == k_ra8_ok) {
    rc = internal_escape_comicinfo(&resolved, &escaped);
  }
  if (rc != k_ra8_ok) {
    return rc;
  }
  char web[k_mdl_meta_url_max * 6U + k_meta_fragment_slack] = {};
  if (escaped.source[0] != '\0') {
    const int n = snprintf(web, sizeof(web), "  <Web>%s</Web>\n", escaped.source);
    if (!priv_mdl_export_snprintf_fit(n, sizeof(web))) {
      return k_ra8_err_invalid_size;
    }
  }
  char number[32];
  if (resolved.chapter_number <= 0.0) {
    (void)snprintf(number, sizeof(number), "1");
  } else if (resolved.chapter_number == (double)(long)resolved.chapter_number) {
    (void)snprintf(number, sizeof(number), "%ld", (long)resolved.chapter_number);
  } else {
    (void)snprintf(number, sizeof(number), "%.1f", resolved.chapter_number);
  }
  char pages[160] = {};
  if ((resolved.cover_index >= 0) && ((size_t)resolved.cover_index < page_count)) {
    const int n = snprintf(pages,
                           sizeof(pages),
                           "  <Pages><Page Image=\"%d\" Type=\"FrontCover\"/></Pages>\n",
                           resolved.cover_index);
    if (!priv_mdl_export_snprintf_fit(n, sizeof(pages))) {
      return k_ra8_err_invalid_size;
    }
  }
  return internal_render_comicinfo(&resolved, &escaped, page_count, web, number, pages, buf, cap);
}
 
ra8_err_t mdl_export_build_comicinfo(const mdl_export_meta_t* meta, char* buf, size_t cap)
{
  return mdl_export_build_comicinfo_pages(meta, 0U, buf, cap);
}