ra8_c6link_wifi_sta.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_c6link_wifi.h"
#include "ra8_secure.h"

typedef enum : int32_t {
  k_ra8_c6link_iface_sta   = 0, 
  k_ra8_c6link_scan_fast   = 0, 
  k_ra8_c6link_sort_signal = 0, 
  k_ra8_c6link_auth_open   = 0, 
} ra8_c6link_sta_wire_t;

RA8_INTERNAL static uint8_t internal_c6link_sta_len(const char* text, uint8_t cap)
{
  uint8_t n = 0U;
  while ((n < cap) && (text[n] != '\0')) {
    n++;
  }
  return n;
}
 
ra8_err_t ra8_c6link_sta_cfg_set(ra8_c6link_sta_cfg_t* cfg, const char* ssid, const char* pass)
{
  if ((cfg == nullptr) || (ssid == nullptr)) {
    if (cfg != nullptr) {
      ra8_secure_memzero(cfg, sizeof(*cfg));
    }
    return k_ra8_err_null_ptr;
  }
  ra8_secure_memzero(cfg, sizeof(*cfg));
 
  const uint8_t ssid_len = internal_c6link_sta_len(ssid, (uint8_t)sizeof cfg->ssid);
  if ((ssid_len == 0U) || (ssid_len > (uint8_t)k_ra8_c6link_ssid_max)) {
    return k_ra8_err_invalid_size;
  }
  const uint8_t pass_len =
    (pass == nullptr) ? 0U : internal_c6link_sta_len(pass, (uint8_t)sizeof cfg->pass);
  if (pass_len > (uint8_t)k_ra8_c6link_pass_max) {
    return k_ra8_err_invalid_size;
  }
 
  for (uint8_t i = 0U; i < ssid_len; i++) {
    cfg->ssid[i] = ssid[i];
  }
  for (uint8_t i = 0U; i < pass_len; i++) {
    cfg->pass[i] = pass[i];
  }
  cfg->ssid_len = ssid_len;
  cfg->pass_len = pass_len;
  return k_ra8_ok;
}

typedef struct ra8_c6link_sta_wire_buf {
  uint8_t ssid[k_ra8_c6link_ssid_max];   
  uint8_t pass[k_ra8_c6link_pass_max];   
  uint8_t bssid[k_ra8_c6link_mac_bytes]; 
} ra8_c6link_sta_wire_buf_t;

RA8_INTERNAL static void internal_c6link_sta_stage(ra8_c6link_sta_wire_buf_t*  buf,
                                                   const ra8_c6link_sta_cfg_t* cfg)
{
  for (uint8_t i = 0U; i < cfg->ssid_len; i++) {
    buf->ssid[i] = (uint8_t)cfg->ssid[i];
  }
  for (uint8_t i = 0U; i < cfg->pass_len; i++) {
    buf->pass[i] = (uint8_t)cfg->pass[i];
  }
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_c6link_mac_bytes; i++) {
    buf->bssid[i] = cfg->bssid.octet[i];
  }
}

RA8_INTERNAL static ra8_err_t internal_c6link_sta_set_config(ra8_c6link_t*               link,
                                                             const ra8_c6link_sta_cfg_t* cfg)
{
  WifiScanThreshold threshold;
  wifi_scan_threshold__init(&threshold);
  threshold.authmode = (int32_t)k_ra8_c6link_auth_open;
 
  WifiPmfConfig pmf;
  wifi_pmf_config__init(&pmf);
  pmf.capable = true;
 
  ra8_c6link_sta_wire_buf_t buf = {};
  internal_c6link_sta_stage(&buf, cfg);
 
  WifiStaConfig sta;
  wifi_sta_config__init(&sta);
  sta.ssid.data     = buf.ssid;
  sta.ssid.len      = (size_t)cfg->ssid_len;
  sta.password.data = buf.pass;
  sta.password.len  = (size_t)cfg->pass_len;
  sta.scan_method   = (int32_t)k_ra8_c6link_scan_fast;
  sta.sort_method   = (int32_t)k_ra8_c6link_sort_signal;
  sta.channel       = (uint32_t)cfg->channel;
  sta.bssid_set     = cfg->bssid_set;
  sta.bssid.data    = buf.bssid;
  sta.bssid.len     = cfg->bssid_set ? (size_t)k_ra8_c6link_mac_bytes : 0U;
  sta.threshold     = &threshold;
  sta.pmf_cfg       = &pmf;
 
  WifiConfig wcfg;
  wifi_config__init(&wcfg);
  wcfg.u_case = WIFI_CONFIG__U_STA;
  wcfg.sta    = &sta;
 
  RpcReqWifiSetConfig body;
  rpc__req__wifi_set_config__init(&body);
  body.iface = (int32_t)k_ra8_c6link_iface_sta;
  body.cfg   = &wcfg;
 
  Rpc req;
  rpc__init(&req);
  req.msg_type            = RPC_TYPE__Req;
  req.msg_id              = RPC_ID__Req_WifiSetConfig;
  req.payload_case        = RPC__PAYLOAD_REQ_WIFI_SET_CONFIG;
  req.req_wifi_set_config = &body;
 
  ra8_c6link_take_ctx_t take   = {.link   = link,
                                  .out    = nullptr,
                                  .rpc_id = (uint32_t)RPC_ID__Req_WifiSetConfig};
  const ra8_err_t       result = priv_c6link_rpc_call(link,
                                                      &req,
                                                      (uint32_t)RPC_ID__Resp_WifiSetConfig,
                                                      priv_c6link_take_resp,
                                                      &take);
  ra8_secure_memzero(&buf, sizeof(buf));
  return result;
}
 
ra8_err_t ra8_c6link_wifi_join(ra8_c6link_t* link, const ra8_c6link_sta_cfg_t* cfg)
{
  if ((link == nullptr) || (cfg == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
  if ((cfg->ssid_len == 0U) || (cfg->ssid_len > (uint8_t)k_ra8_c6link_ssid_max) ||
      (cfg->pass_len > (uint8_t)k_ra8_c6link_pass_max)) {
    return k_ra8_err_invalid_size;
  }
 
  const ra8_err_t configured = internal_c6link_sta_set_config(link, cfg);
  if (configured != k_ra8_ok) {
    return configured;
  }
  return priv_c6link_bare_req(link, (uint32_t)RPC_ID__Req_WifiConnect);
}

RA8_INTERNAL static ra8_err_t internal_c6link_take_mac(void* ctx, const void* msg_v)
{
  ra8_c6link_take_ctx_t* take = (ra8_c6link_take_ctx_t*)ctx;
  const Rpc*             msg  = (const Rpc*)msg_v;
  ra8_c6link_mac_t*      out  = (ra8_c6link_mac_t*)take->out;
 
  const RpcRespGetMacAddress* body = msg->resp_get_mac_address;
  if (body == nullptr) {
    return k_ra8_err_protocol_error;
  }
  const ra8_err_t reported = priv_c6link_resp(take->link, take->rpc_id, body->resp);
  if (reported != k_ra8_ok) {
    return reported;
  }
  return priv_c6link_copy_mac(out, &body->mac) ? k_ra8_ok : k_ra8_err_protocol_error;
}
 
ra8_err_t ra8_c6link_wifi_mac(ra8_c6link_t* link, ra8_c6link_mac_t* out)
{
  if ((link == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
  *out = (ra8_c6link_mac_t){};
 
  RpcReqGetMacAddress body;
  rpc__req__get_mac_address__init(&body);
  /* `Req_GetMACAddress.mode` is a `wifi_interface_t`, not a `wifi_mode_t`: the
     co-processor passes it straight to `esp_wifi_get_mac()`. Select the station
     interface (0) so the address returned is the one the radio associates with.
     `WIFI_IF_AP` (1) hands back the SoftAP address (station address plus one),
     which no access point ever sees, so DHCP for the station never completes. */
  body.mode = (int32_t)k_ra8_c6link_iface_sta;
 
  Rpc req;
  rpc__init(&req);
  req.msg_type            = RPC_TYPE__Req;
  req.msg_id              = RPC_ID__Req_GetMACAddress;
  req.payload_case        = RPC__PAYLOAD_REQ_GET_MAC_ADDRESS;
  req.req_get_mac_address = &body;
 
  ra8_c6link_take_ctx_t take = {.link   = link,
                                .out    = out,
                                .rpc_id = (uint32_t)RPC_ID__Req_GetMACAddress};
  return priv_c6link_rpc_call(link,
                              &req,
                              (uint32_t)RPC_ID__Resp_GetMACAddress,
                              internal_c6link_take_mac,
                              &take);
}

RA8_INTERNAL static ra8_err_t internal_c6link_take_ap(void* ctx, const void* msg_v)
{
  ra8_c6link_take_ctx_t* take = (ra8_c6link_take_ctx_t*)ctx;
  const Rpc*             msg  = (const Rpc*)msg_v;
  ra8_c6link_ap_info_t*  out  = (ra8_c6link_ap_info_t*)take->out;
 
  const RpcRespWifiStaGetApInfo* body = msg->resp_wifi_sta_get_ap_info;
  if (body == nullptr) {
    return k_ra8_err_protocol_error;
  }
  const ra8_err_t reported = priv_c6link_resp(take->link, take->rpc_id, body->resp);
  if (reported != k_ra8_ok) {
    return reported;
  }
  if (body->ap_record == nullptr) {
    return k_ra8_err_protocol_error;
  }
 
  const WifiApRecord* rec = body->ap_record;
  out->ssid_len           = priv_c6link_copy_str(out->ssid, (uint8_t)sizeof out->ssid, &rec->ssid);
  out->channel            = (uint8_t)rec->primary;
  out->rssi               = (int8_t)rec->rssi;
  out->authmode           = rec->authmode;
  (void)priv_c6link_copy_mac(&out->bssid, &rec->bssid);
  return k_ra8_ok;
}
 
ra8_err_t ra8_c6link_wifi_ap_info(ra8_c6link_t* link, ra8_c6link_ap_info_t* out)
{
  if ((link == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
  *out = (ra8_c6link_ap_info_t){};
 
  RpcReqWifiStaGetApInfo body;
  rpc__req__wifi_sta_get_ap_info__init(&body);
 
  Rpc req;
  rpc__init(&req);
  req.msg_type                 = RPC_TYPE__Req;
  req.msg_id                   = RPC_ID__Req_WifiStaGetApInfo;
  req.payload_case             = RPC__PAYLOAD_REQ_WIFI_STA_GET_AP_INFO;
  req.req_wifi_sta_get_ap_info = &body;
 
  ra8_c6link_take_ctx_t take = {.link   = link,
                                .out    = out,
                                .rpc_id = (uint32_t)RPC_ID__Req_WifiStaGetApInfo};
  return priv_c6link_rpc_call(link,
                              &req,
                              (uint32_t)RPC_ID__Resp_WifiStaGetApInfo,
                              internal_c6link_take_ap,
                              &take);
}