comic_wrapped.c

Go to the documentation of this file.

#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "comic.h"
#include "comic_internal.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "unarch_gzip.h"
#include "unarch_io.h"
#include "unarch_xz.h"

typedef enum : uint16_t {
  k_wrap_hdr_bytes = (uint16_t)((sizeof(unarch_mem_t) + ((size_t)k_comic_wrap_align - 1U)) &
                                ~((size_t)k_comic_wrap_align - 1U)),
} wrap_dims_t;

RA8_INTERNAL
static ra8_err_t internal_unwrap(comic_read_fn read,
                                 void*         ctx,
                                 uint64_t      size,
                                 bool          is_gzip,
                                 uint8_t*      payload,
                                 size_t        payload_cap,
                                 void*         xz_scratch,
                                 uint32_t      xz_scratch_len,
                                 size_t*       out_len)
{
  if (is_gzip) {
    return unarch_gzip_unwrap(read, ctx, size, payload, payload_cap, nullptr, out_len);
  }
  return unarch_xz_unwrap(read,
                          ctx,
                          size,
                          payload,
                          payload_cap,
                          xz_scratch,
                          xz_scratch_len,
                          nullptr,
                          out_len);
}

RA8_INTERNAL static bool internal_arena_valid(uint8_t* arena, size_t arena_cap)
{
  uintptr_t arena_address = 0U;
  static_assert(sizeof(arena_address) == sizeof(arena),
                "uintptr_t must preserve pointer representation");
  (void)memcpy((void*)&arena_address, (const void*)&arena, sizeof(arena_address));
  return ((arena_address % (uintptr_t)k_comic_wrap_align) == 0U) &&
         (arena_cap > (size_t)k_wrap_hdr_bytes);
}

RA8_INTERNAL
static ra8_err_t internal_open_unwrapped(comic_t*      c,
                                         uint8_t*      payload,
                                         size_t        inner_len,
                                         comic_page_t* pages,
                                         uint32_t      page_cap,
                                         char*         names,
                                         uint32_t      names_cap,
                                         uint8_t*      arena)
{
  /* Nesting bomb: a wrapper inside the wrapper is rejected before any inner
   * decode -- the one reachable depth bound in this pipeline. Both probes are
   * read into locals rather than tested in place, and the whole helper has a
   * single exit. */
  const bool inner_gzip = unarch_gzip_magic(payload, inner_len);
  const bool inner_xz   = unarch_xz_magic(payload, inner_len);
  ra8_err_t  err        = k_ra8_err_decomp_depth;
  if (!inner_gzip) {
    if (!inner_xz) {
      /* The flat-memory descriptor lives at the arena start so it out-lives
       * this call: page extraction keeps reading through it. */
      void* const         header_slot = arena;
      unarch_mem_t* const memory      = (unarch_mem_t*)header_slot;
      memory->base                    = payload;
      memory->len                     = inner_len;
      err                             = comic_open(c,
                                                   unarch_mem_read,
                                                   memory,
                                                   (uint64_t)inner_len,
                                                   pages,
                                                   page_cap,
                                                   names,
                                                   names_cap);
    }
  }
  return err;
}
 
ra8_err_t comic_open_wrapped(comic_t*      c,
                             comic_read_fn read,
                             void*         ctx,
                             uint64_t      size,
                             comic_page_t* pages,
                             uint32_t      page_cap,
                             char*         names,
                             uint32_t      names_cap,
                             uint8_t*      arena,
                             size_t        arena_cap,
                             void*         xz_scratch,
                             uint32_t      xz_scratch_len)
{
  static const char* const s_tag_wrap = "comic_wrap";
  RA8_CHECK_NULL_PTR(c, s_tag_wrap, "wrapped open: null c");
  RA8_CHECK_NULL_PTR(read, s_tag_wrap, "wrapped open: null read");
  RA8_CHECK_NULL_PTR(arena, s_tag_wrap, "wrapped open: null arena");
  if (size == 0U) {
    return k_ra8_err_invalid_size;
  }
  uint8_t      sig[k_comic_magic_len] = {};
  const size_t got                    = read(ctx, 0U, sig, sizeof(sig));
  const bool   is_gzip                = unarch_gzip_magic(sig, got);
  const bool   is_xz                  = unarch_xz_magic(sig, got);
  if (!is_gzip && !is_xz) {
    /* Not a wrapper: the ordinary container detect owns it. */
    return comic_open(c, read, ctx, size, pages, page_cap, names, names_cap);
  }
  if (!internal_arena_valid(arena, arena_cap)) {
    return k_ra8_err_invalid_size;
  }
  uint8_t*        payload     = &arena[k_wrap_hdr_bytes];
  const size_t    payload_cap = arena_cap - (size_t)k_wrap_hdr_bytes;
  size_t          inner_len   = 0U;
  const ra8_err_t uerr        = internal_unwrap(read,
                                                ctx,
                                                size,
                                                is_gzip,
                                                payload,
                                                payload_cap,
                                                xz_scratch,
                                                xz_scratch_len,
                                                &inner_len);
  if (uerr != k_ra8_ok) {
    return uerr;
  }
  return internal_open_unwrapped(c, payload, inner_len, pages, page_cap, names, names_cap, arena);
}