ra8_c6link_tlv.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_internal.h"
 
/* Upstream requires both endpoint names to be the same length, and the
   receive path below relies on it to accept either without a second offset
   calculation. */
static_assert(sizeof(RPC_EP_NAME_RSP) == sizeof(RPC_EP_NAME_EVT),
              "esp-hosted requires every RPC endpoint name to have one length");

RA8_INTERNAL static uint16_t
internal_c6link_tlv_tag(uint8_t* out, uint16_t at, uint8_t type, uint16_t len)
{
  out[at + (uint16_t)k_ra8_c6link_tlv_type]   = type;
  out[at + (uint16_t)k_ra8_c6link_tlv_len_lo] = (uint8_t)(len & (uint16_t)k_ra8_c6link_tlv_mask);
  out[at + (uint16_t)k_ra8_c6link_tlv_len_hi] =
    (uint8_t)((len >> (uint16_t)k_ra8_c6link_tlv_shift) & (uint16_t)k_ra8_c6link_tlv_mask);
  return (uint16_t)(at + (uint16_t)k_ra8_c6link_tlv_value);
}

RA8_INTERNAL static uint16_t internal_c6link_tlv_len(const uint8_t* buf, uint16_t at)
{
  const uint16_t lo = (uint16_t)buf[at + (uint16_t)k_ra8_c6link_tlv_len_lo];
  const uint16_t hi = (uint16_t)buf[at + (uint16_t)k_ra8_c6link_tlv_len_hi];
  return (uint16_t)(lo | (uint16_t)(hi << (uint16_t)k_ra8_c6link_tlv_shift));
}
 
RA8_PRIV ra8_err_t priv_c6link_tlv_open(uint8_t*  out,
                                        uint16_t  cap,
                                        uint16_t  proto_len,
                                        uint16_t* body_at)
{
  if ((out == nullptr) || (body_at == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *body_at = 0U;
  if ((uint32_t)cap < ((uint32_t)proto_len + (uint32_t)k_ra8_c6link_tlv_overhead)) {
    return k_ra8_err_invalid_size;
  }
 
  uint16_t at = internal_c6link_tlv_tag(out,
                                        0U,
                                        (uint8_t)k_ra8_c6link_tlv_t_epname,
                                        (uint16_t)k_ra8_c6link_tlv_ep_len);
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_c6link_tlv_ep_len; i++) {
    out[at + i] = (uint8_t)RPC_EP_NAME_RSP[i];
  }
  at       = (uint16_t)(at + (uint16_t)k_ra8_c6link_tlv_ep_len);
  *body_at = internal_c6link_tlv_tag(out, at, (uint8_t)k_ra8_c6link_tlv_t_data, proto_len);
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_c6link_tlv_named(const uint8_t* payload)
{
  bool named = true;
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_c6link_tlv_ep_len; i++) {
    const uint8_t got = payload[(uint16_t)k_ra8_c6link_tlv_value + i];
    if ((got != (uint8_t)RPC_EP_NAME_RSP[i]) && (got != (uint8_t)RPC_EP_NAME_EVT[i])) {
      named = false;
    }
  }
  return named;
}
 
RA8_PRIV const uint8_t*
priv_c6link_tlv_body(const uint8_t* payload, uint16_t len, uint16_t* proto_len)
{
  if ((payload == nullptr) || (proto_len == nullptr)) {
    return nullptr;
  }
  *proto_len = 0U;
  const uint16_t data_tag =
    (uint16_t)((uint16_t)k_ra8_c6link_tlv_value + (uint16_t)k_ra8_c6link_tlv_ep_len);
 
  if ((len < (uint16_t)k_ra8_c6link_tlv_overhead) ||
      (payload[k_ra8_c6link_tlv_type] != (uint8_t)k_ra8_c6link_tlv_t_epname) ||
      (payload[data_tag] != (uint8_t)k_ra8_c6link_tlv_t_data)) {
    return nullptr;
  }
  if (internal_c6link_tlv_len(payload, 0U) != (uint16_t)k_ra8_c6link_tlv_ep_len) {
    return nullptr;
  }
  if (!internal_c6link_tlv_named(payload)) {
    return nullptr;
  }
 
  const uint16_t body = internal_c6link_tlv_len(payload, data_tag);
  if ((body == 0U) || (((uint32_t)body + (uint32_t)k_ra8_c6link_tlv_overhead) > (uint32_t)len)) {
    return nullptr;
  }
  *proto_len = body;
  return &payload[k_ra8_c6link_tlv_overhead];
}