ra8_c6link_mdl_transfer.c

Go to the documentation of this file.

 
#include "ra8_c6link_mdl_transfer.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link_mdl_transfer_internal.h"

typedef struct {
  ra8_c6link_t*                    link;    
  const ra8_mdl_transfer_config_t* config;  
  ra8_mdl_session_t                session; 
  bool storage_active;                      
} mdl_transfer_state_t;

RA8_INTERNAL static ra8_err_t
internal_mdl_transfer_validate(const ra8_c6link_t*              link,
                               const char*                      url,
                               const char*                      destination,
                               const ra8_mdl_transfer_config_t* config,
                               const ra8_mdl_transfer_result_t* result)
{
  if ((link == nullptr) || (url == nullptr) || (destination == nullptr) || (config == nullptr) ||
      (result == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((config->storage.begin == nullptr) || (config->storage.write == nullptr) ||
      (config->storage.commit == nullptr) || (config->storage.abort == nullptr) ||
      (config->storage.ctx == nullptr) || (config->sha256.init == nullptr) ||
      (config->sha256.update == nullptr) || (config->sha256.final == nullptr) ||
      (config->sha256.ctx == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((uint32_t)config->format > (uint32_t)k_mdl_format_rabook) {
    return k_ra8_err_invalid_arg;
  }
  if ((config->format != k_mdl_format_loose) && (config->storage.validate == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const uint64_t byte_budget = (uint64_t)config->chunk_bytes * config->max_chunks;
  if ((config->chunk_bytes == 0U) || (config->chunk_bytes > k_ra8_mdl_chunk_data_max) ||
      (config->max_chunks == 0U) || (byte_budget > k_ra8_mdl_transfer_bytes_max)) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_transfer_abort(mdl_transfer_state_t* state,
                                                          ra8_err_t             cause)
{
  ra8_err_t cancel_result = k_ra8_ok;
  ra8_err_t abort_result  = k_ra8_ok;
  if (state->session.active) {
    cancel_result = ra8_c6link_mdl_cancel(state->link, &state->session);
  }
  if (state->storage_active) {
    abort_result          = state->config->storage.abort(state->config->storage.ctx);
    state->storage_active = false;
  }
  if (cause != k_ra8_ok) {
    return cause;
  }
  return (cancel_result != k_ra8_ok) ? cancel_result : abort_result;
}

RA8_INTERNAL static ra8_err_t internal_mdl_transfer_store(const ra8_mdl_transfer_config_t* config,
                                                          const ra8_mdl_chunk_t*           chunk,
                                                          uint64_t* bytes_stored)
{
  if (*bytes_stored > (UINT64_MAX - chunk->data_len)) {
    return k_ra8_err_invalid_size;
  }
  uint16_t  written = 0U;
  ra8_err_t err =
    config->storage.write(config->storage.ctx, chunk->data, chunk->data_len, &written);
  if (err != k_ra8_ok) {
    return err;
  }
  if (written != chunk->data_len) {
    return k_ra8_err_invalid_size;
  }
  err = config->sha256.update(config->sha256.ctx, chunk->data, chunk->data_len);
  if (err == k_ra8_ok) {
    *bytes_stored += written;
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_mdl_transfer_commit(mdl_transfer_state_t*  state,
                                                           const ra8_mdl_chunk_t* chunk,
                                                           uint64_t               bytes_stored,
                                                           uint32_t               chunks_received,
                                                           ra8_mdl_transfer_result_t* result)
{
  if ((!chunk->has_sha256) || (chunk->total_bytes != bytes_stored)) {
    return k_ra8_err_invalid_size;
  }
  uint8_t   digest[k_ra8_mdl_sha256_bytes] = {};
  ra8_err_t err = state->config->sha256.final(state->config->sha256.ctx, digest);
  if (err != k_ra8_ok) {
    return err;
  }
  if (memcmp(digest, chunk->sha256, sizeof(digest)) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  if (state->config->storage.validate != nullptr) {
    err = state->config->storage.validate(state->config->storage.ctx, bytes_stored, digest);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  err = state->config->storage.commit(state->config->storage.ctx);
  if (err == k_ra8_ok) {
    *result = (ra8_mdl_transfer_result_t){
      .bytes_stored    = bytes_stored,
      .chunks_received = chunks_received,
      .format          = state->config->format,
      .response        = chunk->response,
    };
    memcpy(result->sha256, digest, sizeof(digest));
    state->storage_active = false;
  }
  return err;
}
 
RA8_TEST_HELPER ra8_err_t
ra8_c6link_mdl_transfer_commit_test(const ra8_mdl_transfer_config_t* config,
                                    const ra8_mdl_chunk_t*           chunk,
                                    uint64_t                         bytes_stored,
                                    uint32_t                         chunks_received,
                                    ra8_mdl_transfer_result_t*       result)
{
  mdl_transfer_state_t state = {.config = config, .storage_active = true};
  return internal_mdl_transfer_commit(&state, chunk, bytes_stored, chunks_received, result);
}

RA8_INTERNAL static ra8_err_t internal_mdl_transfer_begin(ra8_c6link_t* link,
                                                          const char*   url,
                                                          const char*   destination,
                                                          const ra8_mdl_transfer_config_t* config,
                                                          ra8_mdl_transfer_result_t*       result,
                                                          mdl_transfer_state_t*            state)
{
  const ra8_err_t validation =
    internal_mdl_transfer_validate(link, url, destination, config, result);
  if (validation != k_ra8_ok) {
    return validation;
  }
  *result       = (ra8_mdl_transfer_result_t){};
  state->link   = link;
  state->config = config;
  ra8_err_t err = config->storage.begin(config->storage.ctx, destination);
  if (err != k_ra8_ok) {
    return err;
  }
  state->storage_active = true;
  err                   = config->sha256.init(config->sha256.ctx);
  if (err == k_ra8_ok) {
    const ra8_mdl_request_t request = {
      .url    = url,
      .format = config->format,
      .http   = config->http,
    };
    err = ra8_c6link_mdl_start_request(link, &request, &state->session);
  }
  return err;
}
 
ra8_err_t ra8_c6link_mdl_transfer(ra8_c6link_t*                    link,
                                  const char*                      url,
                                  const char*                      destination,
                                  const ra8_mdl_transfer_config_t* config,
                                  ra8_mdl_transfer_result_t*       result)
{
  mdl_transfer_state_t state = {};
  ra8_err_t err = internal_mdl_transfer_begin(link, url, destination, config, result, &state);
  if (!state.storage_active) {
    return err;
  }
  uint64_t bytes_stored = 0U;
  for (uint32_t pull = 0U; (pull < config->max_chunks) && (err == k_ra8_ok); pull++) {
    if ((config->cancel_requested != nullptr) && config->cancel_requested(config->cancel_ctx)) {
      err = k_ra8_err_cancelled;
      break;
    }
    ra8_mdl_chunk_t chunk = {};
    err                   = ra8_c6link_mdl_next(link, &state.session, config->chunk_bytes, &chunk);
    if ((err == k_ra8_ok) && (chunk.state == k_ra8_mdl_state_downloading)) {
      err = internal_mdl_transfer_store(config, &chunk, &bytes_stored);
    } else if ((err == k_ra8_ok) && (chunk.state == k_ra8_mdl_state_complete)) {
      err = internal_mdl_transfer_commit(&state, &chunk, bytes_stored, pull + 1U, result);
      return (err == k_ra8_ok) ? k_ra8_ok : internal_mdl_transfer_abort(&state, err);
      // mcdc-deactivated: ra8_c6link_mdl_transfer CANCELLED dispatch guard; whenever this arm is evaluated with err == k_ra8_ok the state is necessarily CANCELLED, so the second operand cannot be flipped. DOWNLOADING and COMPLETE are consumed by the two preceding arms, ACCEPTED and every unassigned state value are rejected by internal_mdl_chunk_semantics_valid's default arm before ra8_c6link_mdl_next returns, and FAILED must carry a nonzero status by that same validator, which internal_mdl_accept_chunk returns verbatim -- so a FAILED chunk always arrives with err != k_ra8_ok.
    } else if ((err == k_ra8_ok) && (chunk.state == k_ra8_mdl_state_cancelled)) {
      err = k_ra8_err_cancelled;
    }
  }
  // mcdc-deactivated: ra8_c6link_mdl_transfer exhausted-budget timeout guard; `state.session.active` is constant-true whenever err == k_ra8_ok here. The loop leaves err == k_ra8_ok only by exhausting max_chunks, and the session is deactivated only by a terminal response -- COMPLETE returns from inside the loop, CANCELLED sets err = k_ra8_err_cancelled, and FAILED returns its mandatory nonzero status -- so no reachable path arrives here with an inactive session and no earlier cause.
  if ((err == k_ra8_ok) && state.session.active) {
    err = k_ra8_err_timeout;
  }
  return internal_mdl_transfer_abort(&state, err);
}