ra8_rabook_container.c

Go to the documentation of this file.

 
#include "ra8_rabook_container.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "ra8_attributes.h"
#include "ra8_compress.h"

typedef enum : uint8_t {
  k_rbkc_chunk_bytes_off = 4U,  
  k_rbkc_total_off       = 8U,  
  k_rbkc_count_off       = 16U, 
  k_rbkc_reserved_off    = 20U, 
  k_rbkc_u32_bytes       = 4U,  
  k_rbkc_u64_bytes       = 8U,  
} rbkc_layout_t;

typedef enum : uint8_t {
  k_rbkc_bits_per_byte = 8U, 
} rbkc_bits_t;

RA8_INTERNAL static void internal_put_u32(uint8_t* out, uint32_t value)
{
  for (uint8_t i = 0U; i < (uint8_t)k_rbkc_u32_bytes; i++) {
    out[i] = (uint8_t)(value >> ((uint32_t)i * (uint32_t)k_rbkc_bits_per_byte));
  }
}

RA8_INTERNAL static void internal_put_u64(uint8_t* out, uint64_t value)
{
  for (uint8_t i = 0U; i < (uint8_t)k_rbkc_u64_bytes; i++) {
    const uint32_t shift = (uint32_t)i * (uint32_t)k_rbkc_bits_per_byte;
    out[i]               = (uint8_t)(value >> shift);
  }
}

RA8_INTERNAL static ra8_err_t internal_write_exact(ra8_rabook_write_at_fn write_at,
                                                   void*                  ctx,
                                                   uint64_t               offset,
                                                   const uint8_t*         src,
                                                   uint32_t               len)
{
  uint32_t        written = 0U;
  const ra8_err_t err     = write_at(ctx, offset, src, len, &written);
  if (err != k_ra8_ok) {
    return err;
  }
  return (written == len) ? k_ra8_ok : k_ra8_err_invalid_size;
}

RA8_INTERNAL static ra8_err_t internal_validate_pointers(ra8_rabook_flat_read_fn read,
                                                         ra8_rabook_write_at_fn  write_at,
                                                         const ra8_rabook_container_workspace_t* ws,
                                                         const uint64_t* out_len,
                                                         const uint32_t* out_count)
{
  if (read == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (write_at == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_len == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_count == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->input == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->compressed == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->compressor == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->offsets == nullptr) {
    return k_ra8_err_null_ptr;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_validate(ra8_rabook_flat_read_fn                 read,
                                                uint32_t                                flat_len,
                                                uint32_t                                chunk_bytes,
                                                ra8_rabook_write_at_fn                  write_at,
                                                const ra8_rabook_container_workspace_t* ws,
                                                const uint64_t*                         out_len,
                                                uint32_t*                               out_count)
{
  const ra8_err_t ptr_err = internal_validate_pointers(read, write_at, ws, out_len, out_count);
  if (ptr_err != k_ra8_ok) {
    return ptr_err;
  }
  if (flat_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (chunk_bytes == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (chunk_bytes > ws->input_cap) {
    return k_ra8_err_invalid_size;
  }
  if (ws->compressor_cap < (uint32_t)k_ra8_compress_scratch_bytes) {
    return k_ra8_err_invalid_size;
  }
  const uint32_t count = ((flat_len - 1U) / chunk_bytes) + 1U;
  if (count == UINT32_MAX) {
    return k_ra8_err_invalid_size;
  }
  if (ws->offset_cap < (count + 1U)) {
    return k_ra8_err_invalid_size;
  }
  *out_count = count;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_write_prefix(ra8_rabook_write_at_fn write_at,
                                                    void*                  ctx,
                                                    uint32_t               flat_len,
                                                    uint32_t               chunk_bytes,
                                                    uint32_t               count)
{
  static const uint8_t rbkc_magic[k_book_container_magic_len] = {'R', 'B', 'K', 'C'};
  uint8_t              header[k_book_container_header_len]    = {};
  for (uint8_t i = 0U; i < (uint8_t)k_book_container_magic_len; i++) {
    header[i] = rbkc_magic[i];
  }
  internal_put_u32(&header[k_rbkc_chunk_bytes_off], chunk_bytes);
  internal_put_u64(&header[k_rbkc_total_off], (uint64_t)flat_len);
  internal_put_u32(&header[k_rbkc_count_off], count);
  internal_put_u32(&header[k_rbkc_reserved_off], 0U);
  ra8_err_t err = internal_write_exact(write_at, ctx, 0U, header, (uint32_t)sizeof(header));
  if (err != k_ra8_ok) {
    return err;
  }
  const uint8_t zero[k_book_container_entry_len] = {};
  for (uint32_t i = 0U; i <= count; i++) {
    const uint64_t at =
      (uint64_t)k_book_container_header_len + ((uint64_t)i * (uint64_t)k_book_container_entry_len);
    err = internal_write_exact(write_at, ctx, at, zero, (uint32_t)sizeof(zero));
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_write_chunks(ra8_rabook_flat_read_fn           read,
                                                    void*                             read_ctx,
                                                    uint32_t                          flat_len,
                                                    uint32_t                          chunk_bytes,
                                                    ra8_rabook_write_at_fn            write_at,
                                                    void*                             write_ctx,
                                                    ra8_rabook_container_workspace_t* ws,
                                                    uint32_t                          count,
                                                    uint64_t                          payload_off)
{
  uint32_t flat_off    = 0U;
  uint64_t payload_len = 0U;
  for (uint32_t i = 0U; i < count; i++) {
    const uint32_t remaining = flat_len - flat_off;
    const uint32_t want      = (remaining < chunk_bytes) ? remaining : chunk_bytes;
    uint32_t       got       = 0U;
    ra8_err_t      err       = read(read_ctx, flat_off, ws->input, want, &got);
    if (err != k_ra8_ok) {
      return err;
    }
    if (got != want) {
      return k_ra8_err_invalid_size;
    }
    uint32_t packed = 0U;
    err             = ra8_compress_zlib(ws->input,
                                        want,
                                        ws->compressed,
                                        ws->compressed_cap,
                                        ws->compressor,
                                        ws->compressor_cap,
                                        &packed);
    if (err != k_ra8_ok) {
      return err;
    }
    if ((uint64_t)packed > (UINT64_MAX - payload_len)) {
      return k_ra8_err_invalid_size;
    }
    if (payload_len > (UINT64_MAX - payload_off)) {
      return k_ra8_err_invalid_size;
    }
    ws->offsets[i] = payload_len;
    err =
      internal_write_exact(write_at, write_ctx, payload_off + payload_len, ws->compressed, packed);
    if (err != k_ra8_ok) {
      return err;
    }
    payload_len += packed;
    flat_off += want;
  }
  ws->offsets[count] = payload_len;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_write_table(ra8_rabook_write_at_fn                  write_at,
                                                   void*                                   ctx,
                                                   const ra8_rabook_container_workspace_t* ws,
                                                   uint32_t                                count)
{
  uint8_t encoded[k_book_container_entry_len];
  for (uint32_t i = 0U; i <= count; i++) {
    internal_put_u64(encoded, ws->offsets[i]);
    const uint64_t at =
      (uint64_t)k_book_container_header_len + ((uint64_t)i * (uint64_t)k_book_container_entry_len);
    const ra8_err_t err =
      internal_write_exact(write_at, ctx, at, encoded, (uint32_t)sizeof(encoded));
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_container_write(ra8_rabook_flat_read_fn           read,
                                     void*                             read_ctx,
                                     uint32_t                          flat_len,
                                     uint32_t                          chunk_bytes,
                                     ra8_rabook_write_at_fn            write_at,
                                     void*                             write_ctx,
                                     ra8_rabook_container_workspace_t* ws,
                                     uint64_t*                         out_len)
{
  if (out_len != nullptr) {
    *out_len = 0U;
  }
  uint32_t        count = 0U;
  const ra8_err_t valid =
    internal_validate(read, flat_len, chunk_bytes, write_at, ws, out_len, &count);
  if (valid != k_ra8_ok) {
    return valid;
  }
  const uint64_t table_bytes = ((uint64_t)count + 1U) * (uint64_t)k_book_container_entry_len;
  const uint64_t payload_off = (uint64_t)k_book_container_header_len + table_bytes;
  ra8_err_t      err = internal_write_prefix(write_at, write_ctx, flat_len, chunk_bytes, count);
  if (err == k_ra8_ok) {
    err = internal_write_chunks(read,
                                read_ctx,
                                flat_len,
                                chunk_bytes,
                                write_at,
                                write_ctx,
                                ws,
                                count,
                                payload_off);
  }
  if (err == k_ra8_ok) {
    err = internal_write_table(write_at, write_ctx, ws, count);
  }
  if (err == k_ra8_ok) {
    if (ws->offsets[count] > (UINT64_MAX - payload_off)) {
      return k_ra8_err_invalid_size;
    }
    *out_len = payload_off + ws->offsets[count];
  }
  return err;
}