mdl_export_tar.c

Go to the documentation of this file.

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

typedef enum : uint16_t {
  k_tar_block   = 512U, 
  k_off_name    = 0U,   
  k_len_name    = 100U, 
  k_off_mode    = 100U, 
  k_off_uid     = 108U, 
  k_off_gid     = 116U, 
  k_len_id      = 8U,   
  k_off_size    = 124U, 
  k_len_size    = 12U,  
  k_off_mtime   = 136U, 
  k_len_mtime   = 12U,  
  k_off_chksum  = 148U, 
  k_len_chksum  = 8U,   
  k_off_type    = 156U, 
  k_off_magic   = 257U, 
  k_len_magic   = 6U,   
  k_off_version = 263U, 
} mdl_tar_layout_t;

typedef enum : uint16_t {
  k_file_mode = 0644U, 
} mdl_tar_mode_t;

typedef enum : uint64_t {
  k_tar_size_max = 077777777777ULL, 
} mdl_tar_size_t;

typedef enum : uint16_t {
  k_gzip_header_bytes = 10U,  
  k_gzip_u32_bytes    = 4U,   
  k_byte_bits         = 8U,   
  k_byte_mask         = 255U, 
} mdl_gzip_layout_t;

typedef enum : uint8_t {
  k_gzip_id1        = 0x1FU, 
  k_gzip_id2        = 0x8BU, 
  k_gzip_deflate    = 0x08U, 
  k_gzip_os_unknown = 0xFFU, 
} mdl_gzip_header_t;

typedef struct {
  mdl_export_output_t* output; 
} internal_tar_sink_t;

typedef struct {
  mdl_export_output_t* output;     
  tdefl_compressor*    compressor; 
  uint32_t             crc;        
  uint32_t             size;       
  ra8_err_t            error;      
} internal_gzip_sink_t;

static const uint8_t s_ustar_magic[k_len_magic] = {'u', 's', 't', 'a', 'r', '\0'};
static const uint8_t s_ustar_version[2]         = {'0', '0'};

RA8_INTERNAL static size_t internal_round_block(size_t bytes)
{
  return ((bytes + (size_t)k_tar_block - 1U) / (size_t)k_tar_block) * (size_t)k_tar_block;
}

RA8_INTERNAL static ra8_err_t internal_tar_header(uint8_t* block, const char* name, size_t size)
{
  if ((strlen(name) >= (size_t)k_len_name) || (size > k_tar_size_max)) {
    return k_ra8_err_invalid_size;
  }
  memset(block, 0, k_tar_block);
  (void)snprintf((char*)block + k_off_name, k_len_name, "%s", name);
  (void)snprintf((char*)block + k_off_mode, k_len_id, "%07o", (unsigned)k_file_mode);
  (void)snprintf((char*)block + k_off_uid, k_len_id, "%07o", 0U);
  (void)snprintf((char*)block + k_off_gid, k_len_id, "%07o", 0U);
  (void)snprintf((char*)block + k_off_size, k_len_size, "%011zo", size);
  (void)snprintf((char*)block + k_off_mtime, k_len_mtime, "%011o", 0U);
  block[k_off_type] = '0';
  memcpy(block + k_off_magic, s_ustar_magic, sizeof(s_ustar_magic));
  memcpy(block + k_off_version, s_ustar_version, sizeof(s_ustar_version));
  memset(block + k_off_chksum, ' ', k_len_chksum);
  unsigned sum = 0U;
  for (size_t i = 0U; i < (size_t)k_tar_block; ++i) {
    sum += block[i];
  }
  (void)snprintf((char*)block + k_off_chksum, k_len_chksum - 1U, "%06o", sum);
  block[k_off_chksum + k_len_chksum - 1U] = ' ';
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_direct_sink(void* ctx, const uint8_t* bytes, uint32_t length)
{
  return priv_mdl_export_output_write(((internal_tar_sink_t*)ctx)->output, bytes, length);
}

RA8_INTERNAL static ra8_err_t
internal_write_zeros(mdl_export_sink_fn_t sink, void* ctx, uint32_t length)
{
  const uint8_t zeros[k_tar_block] = {};
  return (length == 0U) ? k_ra8_ok : sink(ctx, zeros, length);
}

RA8_INTERNAL static ra8_err_t internal_tar_write_memory(mdl_export_sink_fn_t sink,
                                                        void*                ctx,
                                                        const char*          name,
                                                        const uint8_t*       bytes,
                                                        size_t               length)
{
  uint8_t   header[k_tar_block];
  ra8_err_t err = internal_tar_header(header, name, length);
  if (err == k_ra8_ok) {
    err = sink(ctx, header, sizeof(header));
  }
  if ((err == k_ra8_ok) && (length > UINT32_MAX)) {
    err = k_ra8_err_invalid_size;
  }
  if ((err == k_ra8_ok) && (length != 0U)) {
    err = sink(ctx, bytes, (uint32_t)length);
  }
  if (err == k_ra8_ok) {
    err = internal_write_zeros(sink, ctx, (uint32_t)(internal_round_block(length) - length));
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_tar_write_source(mdl_storage_t*       storage,
                                                        const char*          path,
                                                        const char*          member,
                                                        mdl_export_sink_fn_t sink,
                                                        void*                ctx)
{
  mdl_export_source_t source      = {};
  ra8_err_t           err         = priv_mdl_export_source_open(&source, storage, path);
  uint64_t            source_size = source.size;
  if ((err == k_ra8_ok) && (source.size > SIZE_MAX)) {
    err = k_ra8_err_invalid_size;
  }
  uint8_t header[k_tar_block];
  if (err == k_ra8_ok) {
    err = internal_tar_header(header, member, (size_t)source.size);
  }
  if (err == k_ra8_ok) {
    err = sink(ctx, header, sizeof(header));
  }
  if (err == k_ra8_ok) {
    err = priv_mdl_export_source_copy(&source, sink, ctx);
  } else if (source.file.is_open) {
    const ra8_err_t closed = priv_mdl_export_source_close(&source);
    if (closed != k_ra8_ok) {
      err = closed;
    }
  }
  if (err == k_ra8_ok) {
    err = internal_write_zeros(
      sink,
      ctx,
      (uint32_t)(internal_round_block((size_t)source_size) - (size_t)source_size));
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_build_tar(mdl_storage_t*           storage,
                                                 const char*              directory,
                                                 char                     names[][k_name_max],
                                                 size_t                   count,
                                                 const mdl_export_meta_t* meta,
                                                 mdl_export_sink_fn_t     sink,
                                                 void*                    ctx)
{
  ra8_err_t err = k_ra8_ok;
  for (size_t i = 0U; (err == k_ra8_ok) && (i < count); ++i) {
    char path[k_fw_fs_path_cap];
    err = priv_mdl_export_path_join(path, sizeof(path), directory, names[i]);
    if (err == k_ra8_ok) {
      err = internal_tar_write_source(storage, path, names[i], sink, ctx);
    }
  }
  char comic_xml[4096];
  if (err == k_ra8_ok) {
    err = mdl_export_build_comicinfo_pages(meta, count, comic_xml, sizeof(comic_xml));
  }
  if (err == k_ra8_ok) {
    err = internal_tar_write_memory(sink,
                                    ctx,
                                    "ComicInfo.xml",
                                    (const uint8_t*)comic_xml,
                                    strlen(comic_xml));
  }
  if (err == k_ra8_ok) {
    const uint8_t trailer[2U * (size_t)k_tar_block] = {};
    err                                             = sink(ctx, trailer, sizeof(trailer));
  }
  return err;
}

RA8_INTERNAL static mz_bool internal_gzip_put(const void* bytes, int length, void* ctx)
{
  internal_gzip_sink_t* gzip = (internal_gzip_sink_t*)ctx;
  if ((gzip == nullptr) || (length < 0) || (gzip->error != k_ra8_ok)) {
    return MZ_FALSE;
  }
  gzip->error = priv_mdl_export_output_write(gzip->output, bytes, (uint32_t)length);
  return (gzip->error == k_ra8_ok) ? MZ_TRUE : MZ_FALSE;
}

RA8_INTERNAL static ra8_err_t internal_gzip_sink(void* ctx, const uint8_t* bytes, uint32_t length)
{
  internal_gzip_sink_t* gzip = (internal_gzip_sink_t*)ctx;
  if (gzip->error != k_ra8_ok) {
    return gzip->error;
  }
  gzip->crc = (uint32_t)mz_crc32(gzip->crc, bytes, length);
  gzip->size += length;
  if (tdefl_compress_buffer(gzip->compressor, bytes, length, TDEFL_NO_FLUSH) != TDEFL_STATUS_OKAY) {
    gzip->error = (gzip->error == k_ra8_ok) ? k_ra8_fail : gzip->error;
  }
  return gzip->error;
}

RA8_INTERNAL static void internal_put_u32le(uint8_t* bytes, uint32_t value)
{
  for (size_t i = 0U; i < (size_t)k_gzip_u32_bytes; ++i) {
    bytes[i] = (uint8_t)(value & (uint32_t)k_byte_mask);
    value >>= (uint32_t)k_byte_bits;
  }
}
 
RA8_PRIV ra8_err_t priv_mdl_export_tar(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)
{
  internal_tar_sink_t sink = {.output = output};
  return internal_build_tar(storage, dir, names, count, meta, internal_direct_sink, &sink);
}
 
RA8_PRIV ra8_err_t priv_mdl_export_tar_gzip(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)
{
  tdefl_compressor* compressor =
    (tdefl_compressor*)mdl_export_workspace_take(ws, sizeof(*compressor), 16U);
  if (compressor == nullptr) {
    return k_ra8_err_invalid_size;
  }
  static const uint8_t header[k_gzip_header_bytes] =
    {k_gzip_id1, k_gzip_id2, k_gzip_deflate, 0U, 0U, 0U, 0U, 0U, 0U, k_gzip_os_unknown};
  ra8_err_t            err  = priv_mdl_export_output_write(output, header, sizeof(header));
  internal_gzip_sink_t gzip = {.output     = output,
                               .compressor = compressor,
                               .crc        = (uint32_t)MZ_CRC32_INIT,
                               .error      = err};
  if ((err == k_ra8_ok) &&
      (tdefl_init(compressor, internal_gzip_put, &gzip, TDEFL_DEFAULT_MAX_PROBES) !=
       TDEFL_STATUS_OKAY)) {
    err = k_ra8_fail;
  }
  if (err == k_ra8_ok) {
    err = internal_build_tar(storage, dir, names, count, meta, internal_gzip_sink, &gzip);
  }
  if ((err == k_ra8_ok) &&
      (tdefl_compress_buffer(compressor, nullptr, 0U, TDEFL_FINISH) != TDEFL_STATUS_DONE)) {
    err = (gzip.error == k_ra8_ok) ? k_ra8_fail : gzip.error;
  }
  uint8_t trailer[2U * k_gzip_u32_bytes];
  internal_put_u32le(trailer, gzip.crc);
  internal_put_u32le(&trailer[k_gzip_u32_bytes], gzip.size);
  if (err == k_ra8_ok) {
    err = priv_mdl_export_output_write(output, trailer, sizeof(trailer));
  }
  return err;
}