mdl_service.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "esp_idf_mdl_compat_internal.h"
#include "ra8_attributes.h"
#include "ra8_c6link_mdl_msg.h"
#include "ra8_mdl_service.h"

typedef enum : uint16_t {
  k_mdl_http_timeout_ms = 15000U, 
  k_mdl_http_status_min = 100U,   
  k_mdl_http_status_max = 599U,   
} mdl_http_const_t;

typedef struct mdl_http_state {
  esp_http_client_handle_t http;                   
  mbedtls_sha256_context   sha;                    
  char                     url[k_ra8_mdl_url_max]; 
  char user_agent[k_ra8_mdl_user_agent_max];       
  char referer[k_ra8_mdl_referer_max];             
  char if_none_match[k_ra8_mdl_etag_max];          
  char if_modified_since[k_ra8_mdl_http_date_max]; 
  ra8_mdl_http_response_t response;                
  ra8_err_t               header_error;            
  uint64_t                total;                   
  uint64_t                received;                
  mdl_format_t            format;                  
  bool                    total_known;             
  bool                    opened;                  
  bool                    hashing;                 
} mdl_http_state_t;
 
static mdl_http_state_t  s_http;
static ra8_mdl_service_t s_service;
static bool              s_initialised;

typedef uint32_t (*mdl_component_abi_fn_t)(void);
 
[[gnu::noinline]] uint32_t ra8_mdl_service_component_abi(void)
{
  return 1U;
}
 
/* The volatile indirection is intentional: it keeps a relocation to the ABI
 * marker through optimization and --gc-sections, making the post-link symbol
 * assertion meaningful in release images. */
static mdl_component_abi_fn_t volatile s_component_abi = ra8_mdl_service_component_abi;

RA8_INTERNAL static void internal_mdl_http_reset_job(mdl_http_state_t* state)
{
  if (state->http != nullptr) {
    (void)esp_http_client_close( // alloc-allow: ESP-IDF SOUP releases transport state
      state->http);
  }
  state->url[0]               = '\0';
  state->user_agent[0]        = '\0';
  state->referer[0]           = '\0';
  state->if_none_match[0]     = '\0';
  state->if_modified_since[0] = '\0';
  state->response             = (ra8_mdl_http_response_t){};
  state->header_error         = k_ra8_ok;
  state->total                = 0U;
  state->received             = 0U;
  state->format               = k_mdl_format_invalid;
  state->total_known          = false;
  state->opened               = false;
  state->hashing              = false;
}

RA8_INTERNAL static bool internal_mdl_header_equal(const char* lhs, const char* rhs)
{
  if (lhs == nullptr) {
    return false;
  }
  size_t index = 0U;
  while ((lhs[index] != '\0') && (rhs[index] != '\0')) {
    unsigned char left  = (unsigned char)lhs[index];
    unsigned char right = (unsigned char)rhs[index];
    if ((left >= (unsigned char)'A') && (left <= (unsigned char)'Z')) {
      left = (unsigned char)(left + ((unsigned char)'a' - (unsigned char)'A'));
    }
    if ((right >= (unsigned char)'A') && (right <= (unsigned char)'Z')) {
      right = (unsigned char)(right + ((unsigned char)'a' - (unsigned char)'A'));
    }
    if (left != right) {
      return false;
    }
    index++;
  }
  return (lhs[index] == '\0') && (rhs[index] == '\0');
}

RA8_INTERNAL static ra8_err_t
internal_mdl_copy_field(char* destination, size_t capacity, const char* source)
{
  destination[0] = '\0';
  if ((source == nullptr) || (source[0] == '\0')) {
    return k_ra8_ok;
  }
  const size_t length = strnlen(source, capacity);
  if (length >= capacity) {
    return k_ra8_err_invalid_size;
  }
  for (size_t i = 0U; i < length; ++i) {
    if ((source[i] == '\r') || (source[i] == '\n')) {
      return k_ra8_err_invalid_arg;
    }
  }
  memcpy(destination, source, length + 1U);
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_mdl_select_response_header(mdl_http_state_t* state,
                                                             const char*       key,
                                                             char**            destination,
                                                             size_t*           capacity)
{
  *destination = nullptr;
  *capacity    = 0U;
  if (internal_mdl_header_equal(key, "Retry-After")) {
    *destination = state->response.retry_after;
    *capacity    = sizeof(state->response.retry_after);
  } else if (internal_mdl_header_equal(key, "ETag")) {
    *destination = state->response.etag;
    *capacity    = sizeof(state->response.etag);
  } else if (internal_mdl_header_equal(key, "Last-Modified")) {
    *destination = state->response.last_modified;
    *capacity    = sizeof(state->response.last_modified);
  } else if (internal_mdl_header_equal(key, "Content-Type")) {
    *destination = state->response.content_type;
    *capacity    = sizeof(state->response.content_type);
  } else {
    /* Unselected header: destination stays null and capacity stays zero. */
  }
}

RA8_INTERNAL static esp_err_t internal_mdl_http_event(esp_http_client_event_t* event)
{
  if ((event == nullptr) || (event->user_data == nullptr)) {
    return ESP_FAIL;
  }
  if (event->event_id != HTTP_EVENT_ON_HEADER) {
    return ESP_OK;
  }
  mdl_http_state_t* state = (mdl_http_state_t*)event->user_data;
  char*             destination;
  size_t            capacity;
  internal_mdl_select_response_header(state, event->header_key, &destination, &capacity);
  if (destination == nullptr) {
    return ESP_OK;
  }
  const ra8_err_t copied = internal_mdl_copy_field(destination, capacity, event->header_value);
  if (copied != k_ra8_ok) {
    state->header_error = copied;
    return ESP_FAIL;
  }
  return ESP_OK;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_init(mdl_http_state_t* state)
{
  const esp_http_client_config_t cfg = {
    .url                   = "https://127.0.0.1/",
    .timeout_ms            = k_mdl_http_timeout_ms,
    .buffer_size           = k_ra8_mdl_chunk_data_max,
    .crt_bundle_attach     = esp_crt_bundle_attach,
    .disable_auto_redirect = true,
    .event_handler         = internal_mdl_http_event,
    .user_data             = state,
  };
  state->http =
    esp_http_client_init(&cfg); /* alloc-allow: ESP-IDF SOUP creates one retained HTTP client */
  if (state->http == nullptr) {
    return k_ra8_err_no_mem;
  }
  mbedtls_sha256_init(&state->sha);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_mdl_http_set_header(mdl_http_state_t* state, const char* name, const char* value)
{
  (void)esp_http_client_delete_header(state->http, name);
  if (value[0] == '\0') {
    return k_ra8_ok;
  }
  return (esp_http_client_set_header(state->http, name, value) == ESP_OK) ? k_ra8_ok : k_ra8_fail;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_apply_request(mdl_http_state_t*        state,
                                                              const ra8_mdl_request_t* request)
{
  ra8_err_t result = internal_mdl_copy_field(state->url, sizeof(state->url), request->url);
  if (result == k_ra8_ok) {
    result = internal_mdl_copy_field(state->user_agent,
                                     sizeof(state->user_agent),
                                     request->http.user_agent);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_copy_field(state->referer, sizeof(state->referer), request->http.referer);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_copy_field(state->if_none_match,
                                     sizeof(state->if_none_match),
                                     request->http.if_none_match);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_copy_field(state->if_modified_since,
                                     sizeof(state->if_modified_since),
                                     request->http.if_modified_since);
  }
  if (result != k_ra8_ok) {
    return result;
  }
  const uint32_t timeout =
    (request->http.timeout_ms == 0U) ? k_mdl_http_timeout_ms : request->http.timeout_ms;
  if (esp_http_client_set_timeout_ms(state->http, (int)timeout) != ESP_OK) {
    result = k_ra8_fail;
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_http_set_header(state, "User-Agent", state->user_agent);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_http_set_header(state, "Referer", state->referer);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_http_set_header(state, "If-None-Match", state->if_none_match);
  }
  if (result == k_ra8_ok) {
    result = internal_mdl_http_set_header(state, "If-Modified-Since", state->if_modified_since);
  }
  return result;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_begin(void* ctx, const ra8_mdl_request_t* request)
{
  mdl_http_state_t* state            = (mdl_http_state_t*)ctx;
  const size_t      https_prefix_len = sizeof("https://") - 1U;
  if ((uint32_t)request->format > (uint32_t)k_mdl_format_rabook) {
    return k_ra8_err_invalid_arg;
  }
  if (strncmp(request->url, "https://", https_prefix_len) != 0) {
    return k_ra8_err_invalid_arg;
  }
  if (request->url[https_prefix_len] == '\0') {
    return k_ra8_err_invalid_arg;
  }
  internal_mdl_http_reset_job(state);
  const ra8_err_t applied = internal_mdl_http_apply_request(state, request);
  if (applied != k_ra8_ok) {
    internal_mdl_http_reset_job(state);
    return applied;
  }
  state->format = request->format;
  const esp_err_t url_status =
    esp_http_client_set_url( // alloc-allow: ESP-IDF SOUP copies URL state
      state->http,
      state->url);
  if (url_status != ESP_OK) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  if (mbedtls_sha256_starts(&state->sha, 0) != 0) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  state->hashing = true;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_open(mdl_http_state_t* state)
{
  if (state->opened) {
    return k_ra8_ok;
  }
  const esp_err_t open_status = esp_http_client_open( // alloc-allow: ESP-IDF SOUP creates TLS state
    state->http,
    0);
  if (open_status != ESP_OK) {
    return k_ra8_fail;
  }
  const int64_t content_length = esp_http_client_fetch_headers(state->http);
  const int     status         = esp_http_client_get_status_code(state->http);
  if (state->header_error != k_ra8_ok) {
    return state->header_error;
  }
  if ((status < k_mdl_http_status_min) || (status > k_mdl_http_status_max)) {
    return k_ra8_err_protocol_error;
  }
  state->response.status = status;
  state->total           = (content_length >= 0) ? (uint64_t)content_length : 0U;
  state->total_known     = (content_length >= 0);
  state->opened          = true;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_finish(mdl_http_state_t* state,
                                                       uint64_t*         total_bytes,
                                                       bool*             complete,
                                                       uint8_t sha256[k_ra8_mdl_sha256_bytes],
                                                       ra8_mdl_http_response_t* response)
{
  if (!esp_http_client_is_complete_data_received(state->http)) {
    internal_mdl_http_reset_job(state);
    return k_ra8_err_protocol_error;
  }
  if (state->total_known) {
    if (state->received != state->total) {
      internal_mdl_http_reset_job(state);
      return k_ra8_err_protocol_error;
    }
  }
  if (mbedtls_sha256_finish(&state->sha, sha256) != 0) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  if (!state->total_known) {
    state->total = state->received;
  }
  *total_bytes = state->total;
  *complete    = true;
  *response    = state->response;
  internal_mdl_http_reset_job(state);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_account_read(mdl_http_state_t* state,
                                                             const uint8_t*    out,
                                                             int               read,
                                                             uint16_t*         got,
                                                             uint64_t*         total_bytes)
{
  if (state->received > (UINT64_MAX - (uint64_t)read)) {
    internal_mdl_http_reset_job(state);
    return k_ra8_err_invalid_size;
  }
  const uint64_t next_received = state->received + (uint64_t)read;
  if (state->total_known) {
    if (next_received > state->total) {
      internal_mdl_http_reset_job(state);
      return k_ra8_err_protocol_error;
    }
  }
  if (mbedtls_sha256_update(&state->sha, out, (size_t)read) != 0) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  state->received = next_received;
  *got            = (uint16_t)read;
  *total_bytes    = state->total;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_read(void*     ctx,
                                                     uint8_t*  out,
                                                     uint16_t  cap,
                                                     uint16_t* got,
                                                     uint64_t* total_bytes,
                                                     bool*     complete,
                                                     uint8_t   sha256[k_ra8_mdl_sha256_bytes],
                                                     ra8_mdl_http_response_t* response)
{
  *got                     = 0U;
  *total_bytes             = 0U;
  *complete                = false;
  *response                = (ra8_mdl_http_response_t){};
  mdl_http_state_t* state  = (mdl_http_state_t*)ctx;
  const ra8_err_t   opened = internal_mdl_http_open(state);
  if (opened != k_ra8_ok) {
    internal_mdl_http_reset_job(state);
    return opened;
  }
  const int read = esp_http_client_read(state->http, (char*)out, cap);
  if (read < 0) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  if ((uint32_t)read > (uint32_t)cap) {
    internal_mdl_http_reset_job(state);
    return k_ra8_fail;
  }
  if (read > 0) {
    return internal_mdl_http_account_read(state, out, read, got, total_bytes);
  }
  return internal_mdl_http_finish(state, total_bytes, complete, sha256, response);
}

RA8_INTERNAL static ra8_err_t internal_mdl_http_cancel(void* ctx)
{
  internal_mdl_http_reset_job((mdl_http_state_t*)ctx);
  return k_ra8_ok;
}

RA8_INTERNAL static esp_err_t internal_mdl_to_esp_status(ra8_err_t result)
{
  switch (result) {
    case k_ra8_ok:
      return ESP_OK;
    case k_ra8_err_no_mem:
      return ESP_ERR_NO_MEM;
    case k_ra8_err_null_ptr:
    case k_ra8_err_invalid_arg:
      return ESP_ERR_INVALID_ARG;
    case k_ra8_err_busy:
    case k_ra8_err_invalid_state:
      return ESP_ERR_INVALID_STATE;
    case k_ra8_err_invalid_size:
      return ESP_ERR_INVALID_SIZE;
    case k_ra8_err_not_found:
      return ESP_ERR_NOT_FOUND;
    case k_ra8_err_timeout:
      return ESP_ERR_TIMEOUT;
    case k_ra8_err_protocol_error:
    case k_ra8_err_validation_failed:
      return ESP_ERR_INVALID_RESPONSE;
    case k_ra8_err_checksum_mismatch:
      return ESP_ERR_INVALID_CRC;
    default:
      return ESP_FAIL;
  }
}

esp_err_t esp_hosted_custom_rpc_sync_handler(uint32_t       message_id,
                                             const uint8_t* request,
                                             size_t         request_len,
                                             uint8_t*       response,
                                             size_t         response_cap,
                                             size_t*        response_len)
{
  if (response_len == nullptr) {
    return ESP_ERR_INVALID_ARG;
  }
  *response_len = 0U;
  if ((message_id != k_ra8_mdl_rpc_start) && (message_id != k_ra8_mdl_rpc_next) &&
      (message_id != k_ra8_mdl_rpc_cancel)) {
    return ESP_ERR_NOT_SUPPORTED;
  }
  if (s_component_abi() != 1U) {
    return ESP_FAIL;
  }
  if (!s_initialised) {
    if (internal_mdl_http_init(&s_http) != k_ra8_ok) {
      return ESP_FAIL;
    }
    const ra8_mdl_service_backend_t backend = {.begin  = internal_mdl_http_begin,
                                               .read   = internal_mdl_http_read,
                                               .cancel = internal_mdl_http_cancel,
                                               .ctx    = &s_http};
    if (ra8_mdl_service_init(&s_service, &backend) != k_ra8_ok) {
      return ESP_FAIL;
    }
    s_initialised = true;
  }
  const ra8_err_t result = ra8_mdl_service_dispatch(&s_service,
                                                    message_id,
                                                    request,
                                                    request_len,
                                                    response,
                                                    response_cap,
                                                    response_len);
  return internal_mdl_to_esp_status(result);
}