mdl_rabook_vfs.c

Go to the documentation of this file.

 
#include "mdl_rabook_vfs.h"
 
#include <stdint.h>
#include <string.h>
 
#include "book_chunked.h"
#include "ra8_attributes.h"
#include "ra8_io_vfs.h"

RA8_INTERNAL
static ra8_err_t
internal_rabook_read_exact(void* opaque, uint64_t offset, uint8_t* dst, uint32_t len)
{
  mdl_rabook_vfs_t* const ctx = opaque;
  if (ctx == nullptr) {
    return k_ra8_err_invalid_state;
  }
  if (ctx->file == nullptr) {
    return k_ra8_err_invalid_state;
  }
  ra8_err_t err  = ra8_io_vfs_file_seek(ctx->file, offset);
  uint32_t  done = 0U;
  RA8_LOOP_BOUND(UINT32_MAX);
  while (done < len) {
    if (err != k_ra8_ok) {
      break;
    }
    uint32_t got = 0U;
    err          = ra8_io_vfs_file_read(ctx->file, &dst[done], len - done, &got);
    if (err == k_ra8_ok) {
      if (got == 0U) {
        err = k_ra8_err_invalid_size;
        continue;
      }
    }
    if (got > (len - done)) {
      err = k_ra8_err_protocol_error;
    } else {
      done += got;
    }
  }
  return err;
}

RA8_INTERNAL
static void internal_rabook_clear_open(mdl_rabook_vfs_t* ctx)
{
  ctx->reader    = (book_chunked_t){};
  ctx->header    = (book_header_t){};
  ctx->file      = nullptr;
  ctx->file_size = 0U;
  ctx->open      = false;
}

RA8_INTERNAL
static ra8_err_t internal_rabook_close(mdl_rabook_vfs_t* ctx)
{
  ra8_err_t err = k_ra8_ok;
  if (ctx->file != nullptr) {
    err = ra8_io_vfs_file_close(ctx->file);
  }
  internal_rabook_clear_open(ctx);
  return err;
}

RA8_INTERNAL
static ra8_err_t internal_rabook_open_reader(mdl_rabook_vfs_t* ctx,
                                             const char*       path,
                                             uint64_t          expected_size,
                                             bool              enforce_size)
{
  ra8_err_t err = ra8_io_vfs_file_open(path, k_ra8_fs_mode_read, &ctx->file);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_io_vfs_file_size(ctx->file, &ctx->file_size);
  if (err == k_ra8_ok) {
    if (enforce_size) {
      if (ctx->file_size != expected_size) {
        err = k_ra8_err_invalid_size;
      }
    }
  }
  if (err == k_ra8_ok) {
    err = book_chunked_open(&ctx->reader,
                            internal_rabook_read_exact,
                            ctx,
                            ctx->file_size,
                            ctx->inflate_cb,
                            ctx->table,
                            ctx->table_cap,
                            ctx->compressed,
                            ctx->compressed_cap);
  }
  if (err != k_ra8_ok) {
    const ra8_err_t close_err = internal_rabook_close(ctx);
    (void)close_err;
  }
  return err;
}

RA8_INTERNAL
static ra8_err_t internal_rabook_validate_open(mdl_rabook_vfs_t* ctx, book_header_t* out_header)
{
  return book_chunked_validate_strict(&ctx->reader,
                                      ctx->chunk,
                                      ctx->chunk_cap,
                                      ctx->scratch,
                                      ctx->scratch_cap,
                                      out_header);
}
 
ra8_err_t mdl_rabook_vfs_init(mdl_rabook_vfs_t* ctx, const mdl_rabook_vfs_config_t* config)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->inflate_cb == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->table == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->compressed == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->chunk == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->scratch == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config->table_cap < 2U) {
    return k_ra8_err_invalid_size;
  }
  if (config->compressed_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (config->chunk_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (config->scratch_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  const mdl_rabook_vfs_t initialized = {
    .inflate_cb     = config->inflate_cb,
    .table          = config->table,
    .compressed     = config->compressed,
    .chunk          = config->chunk,
    .scratch        = config->scratch,
    .table_cap      = config->table_cap,
    .compressed_cap = config->compressed_cap,
    .chunk_cap      = config->chunk_cap,
    .scratch_cap    = config->scratch_cap,
  };
  *ctx = initialized;
  return k_ra8_ok;
}
 
ra8_err_t mdl_rabook_vfs_validate(void*         opaque,
                                  const char*   staging_path,
                                  uint64_t      total_bytes,
                                  const uint8_t sha256[k_ra8_mdl_sha256_bytes])
{
  if (opaque == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (staging_path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (sha256 == nullptr) {
    return k_ra8_err_null_ptr;
  }
  mdl_rabook_vfs_t* const ctx = opaque;
  if (ctx->open) {
    return k_ra8_err_invalid_state;
  }
  if (ctx->file != nullptr) {
    return k_ra8_err_invalid_state;
  }
  ctx->transfer_validated = false;
  (void)memset(ctx->digest, 0, sizeof(ctx->digest));
  ra8_err_t     err       = internal_rabook_open_reader(ctx, staging_path, total_bytes, true);
  book_header_t validated = {};
  if (err == k_ra8_ok) {
    err = internal_rabook_validate_open(ctx, &validated);
  }
  const ra8_err_t close_err = internal_rabook_close(ctx);
  if (err == k_ra8_ok) {
    err = close_err;
  }
  if (err == k_ra8_ok) {
    ctx->header             = validated;
    ctx->file_size          = total_bytes;
    ctx->transfer_validated = true;
    (void)memcpy(ctx->digest, sha256, sizeof(ctx->digest));
  }
  return err;
}
 
ra8_err_t mdl_rabook_vfs_open(mdl_rabook_vfs_t* ctx, const char* path)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (path == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ctx->open) {
    return k_ra8_err_invalid_state;
  }
  if (ctx->file != nullptr) {
    return k_ra8_err_invalid_state;
  }
  ra8_err_t     err       = internal_rabook_open_reader(ctx, path, 0U, false);
  book_header_t validated = {};
  if (err == k_ra8_ok) {
    err = internal_rabook_validate_open(ctx, &validated);
  }
  if (err == k_ra8_ok) {
    ctx->header = validated;
    ctx->open   = true;
  } else {
    const ra8_err_t close_err = internal_rabook_close(ctx);
    (void)close_err;
  }
  return err;
}
 
ra8_err_t
mdl_rabook_vfs_read_chunk(mdl_rabook_vfs_t* ctx, uint64_t offset, uint8_t* dst, uint32_t len)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (dst == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!ctx->open) {
    return k_ra8_err_invalid_state;
  }
  if (ctx->file == nullptr) {
    return k_ra8_err_invalid_state;
  }
  return book_chunked_read(&ctx->reader, offset, dst, len);
}
 
ra8_err_t
mdl_rabook_vfs_info(const mdl_rabook_vfs_t* ctx, book_header_t* out_header, uint64_t* out_flat_size)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_header == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_flat_size == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!ctx->open) {
    return k_ra8_err_invalid_state;
  }
  if (ctx->file == nullptr) {
    return k_ra8_err_invalid_state;
  }
  *out_header    = ctx->header;
  *out_flat_size = ctx->reader.inflated_total;
  return k_ra8_ok;
}
 
ra8_err_t mdl_rabook_vfs_close(mdl_rabook_vfs_t* ctx)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  return internal_rabook_close(ctx);
}