mdl_fetch_body.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
 
#include "mdl_fetch_body_internal.h"
#include "mdl_urlname.h"

RA8_INTERNAL static bool internal_body_paths(mdl_fetch_body_t* body, const char* extension)
{
  const char* abs_dot = strrchr(body->target_abs, '.');
  const char* rel_dot = strrchr(body->target_rel, '.');
  if ((abs_dot == nullptr) || (rel_dot == nullptr) || (extension[0] == '\0')) {
    return false;
  }
  const int abs_length = snprintf(body->actual_abs,
                                  sizeof(body->actual_abs),
                                  "%.*s.%s",
                                  (int)(abs_dot - body->target_abs),
                                  body->target_abs,
                                  extension);
  const int rel_length = snprintf(body->actual_rel,
                                  sizeof(body->actual_rel),
                                  "%.*s.%s",
                                  (int)(rel_dot - body->target_rel),
                                  body->target_rel,
                                  extension);
  return (abs_length > 0) && ((size_t)abs_length < sizeof(body->actual_abs)) && (rel_length > 0) &&
         ((size_t)rel_length < sizeof(body->actual_rel));
}

RA8_INTERNAL static ra8_err_t internal_body_begin(mdl_fetch_body_t* body)
{
  if (body->writer.transaction.active) {
    return k_ra8_ok;
  }
  if (body->mode == k_mdl_fetch_body_exact) {
    const int copied = snprintf(body->actual_abs, sizeof(body->actual_abs), "%s", body->target_abs);
    if ((copied < 0) || ((size_t)copied >= sizeof(body->actual_abs))) {
      return k_ra8_err_invalid_size;
    }
  } else {
    char extension[8] = {};
    if (!mdl_urlname_sniff_image_type(body->prefix,
                                      body->prefix_bytes,
                                      nullptr,
                                      extension,
                                      sizeof(extension),
                                      nullptr,
                                      0U)) {
      return k_ra8_err_validation_failed;
    }
    if (!internal_body_paths(body, extension)) {
      return k_ra8_err_invalid_size;
    }
  }
  return mdl_storage_txn_begin(&body->writer, body->storage, body->actual_abs);
}

RA8_INTERNAL static ra8_err_t internal_body_flush_prefix(mdl_fetch_body_t* body)
{
  ra8_err_t error = internal_body_begin(body);
  if ((error == k_ra8_ok) && (body->prefix_bytes != 0U)) {
    error = mdl_storage_txn_write(&body->writer, body->prefix, body->prefix_bytes);
    if (error == k_ra8_ok) {
      body->prefix_bytes = 0U;
    }
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_body_reset(void* context)
{
  mdl_fetch_body_t* body = (mdl_fetch_body_t*)context;
  if (body == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t error = mdl_storage_txn_abort(&body->writer);
  if (error != k_ra8_ok) {
    return error;
  }
  body->prefix_bytes  = 0U;
  body->received      = 0U;
  body->actual_abs[0] = '\0';
  body->actual_rel[0] = '\0';
  return k_ra8_ok;
}

RA8_INTERNAL static uint32_t
internal_body_buffer_prefix(mdl_fetch_body_t* body, const uint8_t* bytes, uint32_t length)
{
  const uint32_t room = (uint32_t)k_mdl_fetch_magic_bytes - (uint32_t)body->prefix_bytes;
  const uint32_t take = (length < room) ? length : room;
  memcpy(body->prefix + body->prefix_bytes, bytes, take);
  body->prefix_bytes = (uint8_t)((uint32_t)body->prefix_bytes + take);
  return take;
}

RA8_INTERNAL static ra8_err_t
internal_body_write(void* context, const uint8_t* bytes, uint32_t length, uint32_t* out_written)
{
  mdl_fetch_body_t* body = (mdl_fetch_body_t*)context;
  if ((body == nullptr) || (out_written == nullptr) || ((bytes == nullptr) && (length != 0U))) {
    return k_ra8_err_invalid_arg;
  }
  *out_written = 0U;
  if (length == 0U) {
    return k_ra8_ok;
  }
  uint32_t offset = 0U;
  if ((body->mode == k_mdl_fetch_body_image) && !body->writer.transaction.active) {
    offset = internal_body_buffer_prefix(body, bytes, length);
    if (body->prefix_bytes < (uint8_t)k_mdl_fetch_magic_bytes) {
      body->received += (uint64_t)length;
      *out_written = length;
      return k_ra8_ok;
    }
    const ra8_err_t error = internal_body_flush_prefix(body);
    if (error != k_ra8_ok) {
      return error;
    }
  } else if (!body->writer.transaction.active) {
    const ra8_err_t error = internal_body_begin(body);
    if (error != k_ra8_ok) {
      return error;
    }
  }
  const ra8_err_t error = mdl_storage_txn_write(&body->writer, bytes + offset, length - offset);
  if (error == k_ra8_ok) {
    body->received += (uint64_t)length;
    *out_written = length;
  }
  return error;
}
 
ra8_err_t priv_mdl_fetch_body_init_exact(mdl_fetch_body_t* body,
                                         mdl_storage_t*    storage,
                                         const char*       target_abs)
{
  if ((body == nullptr) || (storage == nullptr) || (target_abs == nullptr) ||
      (target_abs[0] != '/')) {
    return k_ra8_err_invalid_arg;
  }
  *body = (mdl_fetch_body_t){.storage    = storage,
                             .target_abs = target_abs,
                             .target_rel = nullptr,
                             .mode       = k_mdl_fetch_body_exact};
  return k_ra8_ok;
}
 
ra8_err_t priv_mdl_fetch_body_init_image(mdl_fetch_body_t* body,
                                         mdl_storage_t*    storage,
                                         const char*       target_abs,
                                         const char*       target_rel)
{
  if ((body == nullptr) || (storage == nullptr) || (target_abs == nullptr) ||
      (target_rel == nullptr) || (target_abs[0] != '/')) {
    return k_ra8_err_invalid_arg;
  }
  *body = (mdl_fetch_body_t){.storage    = storage,
                             .target_abs = target_abs,
                             .target_rel = target_rel,
                             .mode       = k_mdl_fetch_body_image};
  return k_ra8_ok;
}
 
mdl_net_body_sink_t priv_mdl_fetch_body_sink(mdl_fetch_body_t* body)
{
  return (
    mdl_net_body_sink_t){.reset = internal_body_reset, .write = internal_body_write, .ctx = body};
}
 
ra8_err_t priv_mdl_fetch_body_prepare(mdl_fetch_body_t* body)
{
  if ((body == nullptr) || (body->storage == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  if (body->received == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (!body->writer.transaction.active) {
    return internal_body_flush_prefix(body);
  }
  return k_ra8_ok;
}
 
ra8_err_t priv_mdl_fetch_body_commit(mdl_fetch_body_t* body)
{
  if ((body == nullptr) || !body->writer.transaction.active) {
    return k_ra8_err_invalid_arg;
  }
  return mdl_storage_txn_commit(&body->writer);
}
 
ra8_err_t priv_mdl_fetch_body_abort(mdl_fetch_body_t* body)
{
  if (body == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t error = mdl_storage_txn_abort(&body->writer);
  if (error == k_ra8_ok) {
    body->prefix_bytes = 0U;
    body->received     = 0U;
  }
  return error;
}