ra8_ota_parse.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_ota.h"
#include "ra8_ota_internal.h"

static const char* const s_tag = "ra8_ota";

typedef enum : uint32_t {
  k_ra8_ota_json_skip_max      = 8U,    
  k_ra8_ota_u32_decimal_digits = 12U,   
  k_ra8_ota_u32_decimal_base   = 10U,   
  k_ra8_ota_hex_alpha_offset   = 10U,   
  k_ra8_ota_hex_invalid_nibble = 0xFFU, 
  k_ra8_ota_hex_chars_per_byte = 2U,    
  k_ra8_ota_hex_nibble_shift   = 4U,    
  k_ra8_ota_hex_buf_bytes      = 257U,  
} ra8_ota_internal_const_t;

RA8_PRIV
bool priv_ota_char_in_range(char c, char lo, char hi)
{
  return (c >= lo) && (c <= hi);
}

RA8_PRIV
bool priv_ota_download_state_invalid(uint32_t state_idle_val,
                                     uint32_t state_downloading_val,
                                     uint32_t state)
{
  return (state != state_idle_val) && (state != state_downloading_val);
}
 
/* =============================================================================
 * Configuration validation
 * ============================================================================= */

RA8_INTERNAL
static ra8_err_t internal_validate_cfg_net(const ra8_ota_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg->net.open, s_tag, "net.open");
  RA8_CHECK_NULL_PTR(cfg->net.read, s_tag, "net.read");
  RA8_CHECK_NULL_PTR(cfg->net.close, s_tag, "net.close");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_cfg_crypto(const ra8_ota_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg->crypto.sha256_init, s_tag, "crypto.sha256_init");
  RA8_CHECK_NULL_PTR(cfg->crypto.sha256_update, s_tag, "crypto.sha256_update");
  RA8_CHECK_NULL_PTR(cfg->crypto.sha256_final, s_tag, "crypto.sha256_final");
  RA8_CHECK_NULL_PTR(cfg->crypto.ecdsa_verify, s_tag, "crypto.ecdsa_verify");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_cfg_flash(const ra8_ota_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg->flash.erase, s_tag, "flash.erase");
  RA8_CHECK_NULL_PTR(cfg->flash.program, s_tag, "flash.program");
  RA8_CHECK_NULL_PTR(cfg->flash.set_startup, s_tag, "flash.set_startup");
  RA8_CHECK_NULL_PTR(cfg->flash.readback, s_tag, "flash.readback");
  if (cfg->flash.bank_size_bytes == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (cfg->flash.bank_size_bytes > k_ra8_ota_max_image_bytes) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_ota_validate_cfg(const ra8_ota_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  ra8_err_t e = internal_validate_cfg_net(cfg);
  if (e != k_ra8_ok) {
    return e;
  }
  e = internal_validate_cfg_crypto(cfg);
  if (e != k_ra8_ok) {
    return e;
  }
  e = internal_validate_cfg_flash(cfg);
  if (e != k_ra8_ok) {
    return e;
  }
  if (cfg->manifest_url[0] == '\0') {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * JSON / hex scanning helpers
 * ============================================================================= */

RA8_INTERNAL
static ra8_err_t internal_json_str(const char* json, const char* key, char* dst, uint32_t cap)
{
  const char* p = strstr(json, key);
  if (p == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  p = strchr(p + strlen(key), '"');
  if (p == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  ++p;
  const char* q = strchr(p, '"');
  if (q == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t n = (uint32_t)(q - p);
  if (n + 1U > cap) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(dst, p, n);
  dst[n] = '\0';
  return k_ra8_ok;
}

RA8_PRIV
ra8_err_t priv_ota_json_u32(const char* json, const char* key, uint32_t* out_v)
{
  const char* p = strstr(json, key);
  if (p == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  p += strlen(key);
  /* Skip past quote/colon/whitespace. */
  for (uint32_t guard = 0U; guard < (uint32_t)k_ra8_ota_json_skip_max; ++guard) {
    if (*p == ':' || *p == ' ' || *p == '"') {
      ++p;
    } else {
      break;
    }
  }
  uint32_t v = 0U;
  uint32_t i = 0U;
  for (; i < (uint32_t)k_ra8_ota_u32_decimal_digits; ++i) {
    const char c = p[i];
    if ((c < '0') || (c > '9')) {
      break;
    }
    v = (v * (uint32_t)k_ra8_ota_u32_decimal_base) + (uint32_t)(c - '0');
  }
  if (i == 0U) {
    return k_ra8_err_invalid_arg;
  }
  *out_v = v;
  return k_ra8_ok;
}

RA8_INTERNAL
static uint8_t internal_hex_nibble(char c)
{
  if ((c >= '0') && (c <= '9')) {
    return (uint8_t)(c - '0');
  }
  if ((c >= 'a') && (c <= 'f')) {
    return (uint8_t)((uint8_t)k_ra8_ota_hex_alpha_offset + (c - 'a'));
  }
  if (priv_ota_char_in_range(c, 'A', 'F')) {
    return (uint8_t)((uint8_t)k_ra8_ota_hex_alpha_offset + (c - 'A'));
  }
  return (uint8_t)k_ra8_ota_hex_invalid_nibble;
}

RA8_INTERNAL
static uint32_t internal_hex_decode(const char* in, uint8_t* out, uint32_t out_cap)
{
  const uint32_t in_len = (uint32_t)strlen(in);
  if ((in_len % (uint32_t)k_ra8_ota_hex_chars_per_byte) != 0U) {
    return 0U;
  }
  const uint32_t bytes = in_len / (uint32_t)k_ra8_ota_hex_chars_per_byte;
  if (bytes > out_cap) {
    return 0U;
  }
  for (uint32_t i = 0U; i < bytes; ++i) {
    const size_t  base_idx = (size_t)i * (size_t)k_ra8_ota_hex_chars_per_byte;
    const uint8_t hi       = internal_hex_nibble(in[base_idx]);
    const uint8_t lo       = internal_hex_nibble(in[base_idx + 1U]);
    if ((hi == (uint8_t)k_ra8_ota_hex_invalid_nibble) ||
        (lo == (uint8_t)k_ra8_ota_hex_invalid_nibble)) {
      return 0U;
    }
    out[i] = (uint8_t)((hi << (uint8_t)k_ra8_ota_hex_nibble_shift) | lo);
  }
  return bytes;
}
 
/* =============================================================================
 * Manifest decode
 * ============================================================================= */

RA8_INTERNAL
static ra8_err_t internal_manifest_decode_crypto(const char* json, ra8_ota_manifest_t* out)
{
  char      hex[k_ra8_ota_hex_buf_bytes];
  ra8_err_t e = internal_json_str(json, "\"sha256\"", hex, sizeof hex);
  if (e != k_ra8_ok) {
    return e;
  }
  const uint32_t n_d = internal_hex_decode(hex, out->image_sha256, k_ra8_ota_sha256_bytes);
  if (n_d != k_ra8_ota_sha256_bytes) {
    return k_ra8_err_invalid_arg;
  }
 
  e = internal_json_str(json, "\"signature\"", hex, sizeof hex);
  if (e != k_ra8_ok) {
    return e;
  }
  const uint32_t n_s = internal_hex_decode(hex, out->signature, k_ra8_ota_signature_max_bytes);
  if (n_s == 0U) {
    return k_ra8_err_invalid_arg;
  }
  out->signature_len = (uint16_t)n_s;
  return k_ra8_ok;
}

RA8_PRIV
ra8_err_t priv_ota_manifest_decode(const char* json, ra8_ota_manifest_t* out)
{
  (void)memset(out, 0, sizeof *out);
  ra8_err_t e = internal_json_str(json, "\"version\"", out->version, k_ra8_ota_version_str_bytes);
  if (e != k_ra8_ok) {
    return e;
  }
  e = internal_json_str(json, "\"url\"", out->image_url, k_ra8_ota_url_max_bytes);
  if (e != k_ra8_ok) {
    return e;
  }
  e = priv_ota_json_u32(json, "\"size\"", &out->image_size_bytes);
  if (e != k_ra8_ok) {
    return e;
  }
  if (out->image_size_bytes == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (out->image_size_bytes > k_ra8_ota_max_image_bytes) {
    return k_ra8_err_invalid_size;
  }
  return internal_manifest_decode_crypto(json, out);
}