ra8_c6link_rpc.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_internal.h"
#include "ra8_secure.h"

typedef enum : int32_t {
  k_c6link_esp_err_no_mem           = 0x101, 
  k_c6link_esp_err_invalid_arg      = 0x102, 
  k_c6link_esp_err_invalid_state    = 0x103, 
  k_c6link_esp_err_invalid_size     = 0x104, 
  k_c6link_esp_err_not_found        = 0x105, 
  k_c6link_esp_err_not_supported    = 0x106, 
  k_c6link_esp_err_timeout          = 0x107, 
  k_c6link_esp_err_invalid_response = 0x108, 
  k_c6link_esp_err_invalid_crc      = 0x109, 
  k_c6link_esp_err_not_allowed      = 0x10D, 
} c6link_esp_status_t;

RA8_INTERNAL static ra8_err_t internal_c6link_rpc_stage(ra8_c6link_t* link, Rpc* req)
{
  link->tx_len = 0U;
 
  const size_t packed = rpc__get_packed_size(req);
  if (packed > (size_t)k_ra8_c6link_max_payload) {
    return k_ra8_err_invalid_size;
  }
 
  uint8_t*        payload = &link->tx[k_ra8_c6link_header_bytes];
  uint16_t        body_at = 0U;
  const ra8_err_t opened =
    priv_c6link_tlv_open(payload, (uint16_t)k_ra8_c6link_max_payload, (uint16_t)packed, &body_at);
  if (opened != k_ra8_ok) {
    return opened;
  }
  if (rpc__pack(req, &payload[body_at]) != packed) {
    return k_ra8_err_validation_failed;
  }
 
  link->tx_len = (uint16_t)((uint32_t)body_at + (uint32_t)packed);
  link->tx_if  = (uint8_t)ESP_SERIAL_IF;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_c6link_remote_error(int32_t response)
{
  switch (response) {
    case k_c6link_esp_err_no_mem:
      return k_ra8_err_no_mem;
    case k_c6link_esp_err_invalid_arg:
      return k_ra8_err_invalid_arg;
    case k_c6link_esp_err_invalid_state:
      return k_ra8_err_invalid_state;
    case k_c6link_esp_err_invalid_size:
      return k_ra8_err_invalid_size;
    case k_c6link_esp_err_not_found:
      return k_ra8_err_not_found;
    case k_c6link_esp_err_not_supported:
      return k_ra8_err_not_supported;
    case k_c6link_esp_err_timeout:
      return k_ra8_err_timeout;
    case k_c6link_esp_err_invalid_crc:
      return k_ra8_err_checksum_mismatch;
    case k_c6link_esp_err_not_allowed:
      return k_ra8_err_access_denied;
    case k_c6link_esp_err_invalid_response:
    default:
      return k_ra8_err_protocol_error;
  }
}
 
RA8_PRIV ra8_err_t priv_c6link_resp(ra8_c6link_t* link, uint32_t rpc_id, int32_t resp)
{
  if (link == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (resp != 0) {
    link->fault.rpc_id = rpc_id;
    link->fault.resp   = resp;
    return internal_c6link_remote_error(resp);
  }
  link->fault.rpc_id = 0U;
  link->fault.resp   = 0;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_c6link_rpc_call(ra8_c6link_t*        link,
                                        Rpc*                 req,
                                        uint32_t             resp_id,
                                        ra8_c6link_take_fn_t take,
                                        void*                take_ctx)
{
  if ((link == nullptr) || (req == nullptr) || (take == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!link->open) {
    return k_ra8_err_not_initialized;
  }
  if (link->wait.armed || (link->tx_len != 0U)) {
    return k_ra8_err_busy;
  }
 
  link->next_uid = link->next_uid + 1U;
  req->uid       = link->next_uid;
 
  const ra8_err_t staged = internal_c6link_rpc_stage(link, req);
  if (staged != k_ra8_ok) {
    ra8_secure_memzero(link->tx, sizeof(link->tx));
    return staged;
  }
 
  link->wait = (ra8_c6link_wait_t){
    .uid       = req->uid,
    .resp_id   = resp_id,
    .take      = take,
    .take_ctx  = take_ctx,
    .result    = k_ra8_ok,
    .armed     = true,
    .satisfied = false,
  };
 
  ra8_c6link_stats_t stats  = {};
  const ra8_err_t    pumped = priv_c6link_pump(link, (uint16_t)k_ra8_c6link_rpc_transfers, &stats);
  const bool         got    = link->wait.satisfied;
  const ra8_err_t    result = link->wait.result;
  link->wait                = (ra8_c6link_wait_t){};
  link->tx_len              = 0U;
  ra8_secure_memzero(link->tx, sizeof(link->tx));
 
  if (pumped != k_ra8_ok) {
    return pumped;
  }
  if (!got) {
    link->fault.rpc_id = (uint32_t)req->msg_id;
    link->fault.resp   = 0;
    return k_ra8_err_timeout;
  }
  return result;
}

RA8_INTERNAL static void internal_c6link_rpc_ev_connected(ra8_c6link_event_t*          ev,
                                                          const WifiEventStaConnected* body)
{
  if (body == nullptr) {
    return;
  }
  ev->ssid_len = priv_c6link_copy_str(ev->ssid, (uint8_t)sizeof ev->ssid, &body->ssid);
  ev->channel  = (uint8_t)body->channel;
  (void)priv_c6link_copy_mac(&ev->bssid, &body->bssid);
}

RA8_INTERNAL static void internal_c6link_rpc_ev_disconnected(ra8_c6link_event_t*             ev,
                                                             const WifiEventStaDisconnected* body)
{
  if (body == nullptr) {
    return;
  }
  ev->ssid_len = priv_c6link_copy_str(ev->ssid, (uint8_t)sizeof ev->ssid, &body->ssid);
  ev->reason   = (uint16_t)body->reason;
  ev->rssi     = (int8_t)body->rssi;
  (void)priv_c6link_copy_mac(&ev->bssid, &body->bssid);
}

RA8_INTERNAL static void internal_c6link_rpc_event(ra8_c6link_t* link, const Rpc* msg)
{
  ra8_c6link_event_t ev = {};
 
  switch ((int32_t)msg->msg_id) {
    case (int32_t)RPC_ID__Event_ESPInit:
      ev.kind = k_ra8_c6link_event_boot;
      if (msg->event_esp_init != nullptr) {
        ev.reset_reason = msg->event_esp_init->cp_reset_reason;
      }
      break;
    case (int32_t)RPC_ID__Event_StaConnected:
      ev.kind = k_ra8_c6link_event_sta_connected;
      if (msg->event_sta_connected != nullptr) {
        internal_c6link_rpc_ev_connected(&ev, msg->event_sta_connected->sta_connected);
      }
      break;
    case (int32_t)RPC_ID__Event_StaDisconnected:
      ev.kind = k_ra8_c6link_event_sta_disconnected;
      if (msg->event_sta_disconnected != nullptr) {
        internal_c6link_rpc_ev_disconnected(&ev, msg->event_sta_disconnected->sta_disconnected);
      }
      break;
    case (int32_t)RPC_ID__Event_WifiEventNoArgs:
      ev.kind = k_ra8_c6link_event_wifi;
      if (msg->event_wifi_event_no_args != nullptr) {
        ev.wifi_event_id = msg->event_wifi_event_no_args->event_id;
      }
      break;
    default:
      return;
  }
  priv_c6link_emit(link, &ev);
}

RA8_INTERNAL static bool internal_c6link_rpc_answer(ra8_c6link_t* link, const Rpc* msg)
{
  if (!link->wait.armed || (msg->uid != link->wait.uid) ||
      ((uint32_t)msg->msg_id != link->wait.resp_id)) {
    return false;
  }
  link->wait.result    = link->wait.take(link->wait.take_ctx, msg);
  link->wait.satisfied = true;
  return true;
}
 
RA8_PRIV bool priv_c6link_rpc_consume(ra8_c6link_t* link, const uint8_t* payload, uint16_t len)
{
  if ((link == nullptr) || (payload == nullptr)) {
    return false;
  }
 
  uint16_t       proto_len = 0U;
  const uint8_t* proto     = priv_c6link_tlv_body(payload, len, &proto_len);
  if (proto == nullptr) {
    if (link->stats != nullptr) {
      link->stats->undecodable++;
    }
    return false;
  }
 
  ProtobufCAllocator alloc = {};
  priv_c6link_arena_bind(&alloc, link);
  priv_c6link_arena_reset(link);
 
  Rpc* msg = rpc__unpack(&alloc, (size_t)proto_len, proto);
  if (msg == nullptr) {
    if (link->stats != nullptr) {
      link->stats->undecodable++;
    }
    priv_c6link_arena_reset(link);
    return false;
  }
  if (link->stats != nullptr) {
    link->stats->rpc_in++;
  }
 
  bool stop = false;
  if (msg->msg_type == RPC_TYPE__Event) {
    internal_c6link_rpc_event(link, msg);
  } else if (msg->msg_type == RPC_TYPE__Resp) {
    stop = internal_c6link_rpc_answer(link, msg);
  } else {
    /* A request arriving at a host is a co-processor defect, not a message
       this side has any handler for. Counted, dropped, never acted on. */
    if (link->stats != nullptr) {
      link->stats->undecodable++;
    }
  }
 
  rpc__free_unpacked(msg, &alloc);
  priv_c6link_arena_reset(link);
  return stop;
}