mdl_verify_rabook.c

Go to the documentation of this file.

 
#include <stddef.h>
 
#include "book_chunked.h"
#include "mdl_verify_rabook_internal.h"
#include "miniz.h"

typedef enum : uint32_t {
  k_rabook_chunk_bytes      = 4U * 1024U * 1024U, 
  k_rabook_compressed_bytes = k_rabook_chunk_bytes + (64U * 1024U),
  k_rabook_scratch_bytes = 4U * 1024U * 1024U, 
  k_rabook_table_entries = 65537U,             
  k_rabook_read_calls    = 1000000U,           
} mdl_verify_rabook_limit_t;

typedef struct {
  fw_fs_file_t* file;       
  uint64_t      size_bytes; 
  uint32_t      calls;      
} mdl_rabook_io_t;

RA8_INTERNAL
static ra8_err_t
internal_rabook_read(void* opaque, uint64_t offset, uint8_t* destination, uint32_t length)
{
  mdl_rabook_io_t* io = (mdl_rabook_io_t*)opaque;
  if ((offset > io->size_bytes) || ((uint64_t)length > (io->size_bytes - offset))) {
    return k_ra8_err_out_of_range;
  }
  ra8_err_t error = fw_fs_seek(io->file, offset);
  uint32_t  done  = 0U;
  while ((error == k_ra8_ok) && (done < length)) {
    if (io->calls >= (uint32_t)k_rabook_read_calls) {
      return k_ra8_err_invalid_size;
    }
    uint32_t got = 0U;
    error        = fw_fs_read(io->file, &destination[done], length - done, &got);
    ++io->calls;
    if ((error == k_ra8_ok) && (got == 0U)) {
      error = k_ra8_err_invalid_state;
    }
    done += got;
  }
  return error;
}

RA8_INTERNAL
static ra8_err_t internal_rabook_inflate(const void* source,
                                         size_t      source_bytes,
                                         void*       destination,
                                         size_t      destination_bytes,
                                         size_t*     out_bytes)
{
  const size_t result = tinfl_decompress_mem_to_mem(
    destination,
    destination_bytes,
    source,
    source_bytes,
    (int)(TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF));
  if (result == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
    return k_ra8_err_validation_failed;
  }
  *out_bytes = result;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_mdl_verify_rabook(fw_fs_file_t*           file,
                                          uint64_t                size_bytes,
                                          mdl_export_workspace_t* workspace,
                                          mdl_verify_report_t*    report)
{
  if ((file == nullptr) || (workspace == nullptr) || (report == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  uint64_t* table =
    (uint64_t*)mdl_export_workspace_take(workspace,
                                         (size_t)k_rabook_table_entries * sizeof(uint64_t),
                                         _Alignof(uint64_t));
  uint8_t* compressed = (uint8_t*)mdl_export_workspace_take(workspace,
                                                            (size_t)k_rabook_compressed_bytes,
                                                            _Alignof(max_align_t));
  uint8_t* chunk      = (uint8_t*)mdl_export_workspace_take(workspace,
                                                            (size_t)k_rabook_chunk_bytes,
                                                            _Alignof(max_align_t));
  uint8_t* scratch    = (uint8_t*)mdl_export_workspace_take(workspace,
                                                            (size_t)k_rabook_scratch_bytes,
                                                            _Alignof(max_align_t));
  if ((table == nullptr) || (compressed == nullptr) || (chunk == nullptr) || (scratch == nullptr)) {
    return k_ra8_err_invalid_size;
  }
  mdl_rabook_io_t io     = {.file = file, .size_bytes = size_bytes};
  book_chunked_t  reader = {};
  ra8_err_t       error  = book_chunked_open(&reader,
                                             internal_rabook_read,
                                             &io,
                                             size_bytes,
                                             internal_rabook_inflate,
                                             table,
                                             (uint32_t)k_rabook_table_entries,
                                             compressed,
                                             (uint32_t)k_rabook_compressed_bytes);
  book_header_t   header = {};
  if (error == k_ra8_ok) {
    error = book_chunked_validate_strict(&reader,
                                         chunk,
                                         (uint32_t)k_rabook_chunk_bytes,
                                         scratch,
                                         (uint32_t)k_rabook_scratch_bytes,
                                         &header);
  }
  if (error == k_ra8_ok) {
    report->page_count   = header.chapter_count;
    report->member_count = header.image_count;
    report->metadata_present =
      (header.title_off != 0U) || (header.author_off != 0U) || (header.identifier_off != 0U);
  }
  return error;
}