main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_rsip.h"
#include "ra8_time.h"
#include "ra8_tls.h"
 
#ifndef RA8_OFF_TARGET
#include "mbedtls/net_sockets.h"
#include "mbedtls/platform.h"
#include "mbedtls/ssl.h"
#include "nx_api.h"
#include "nx_ether_driver_ra8_eth.h"
#include "psa/crypto.h"
#include "tx_api.h"
#endif

typedef enum : uint32_t {
  k_demo_baud           = 115200U, 
  k_demo_thread_stack   = 16384U,  
  k_demo_ip_thread_pri  = 1U,      
  k_demo_app_thread_pri = 8U,      
  k_demo_packet_size    = 1568U,   
  k_demo_pool_bytes     = 32768U,  
  k_demo_byte_pool_size = 65536U,  
  k_demo_ip_stack       = 4096U,   
  k_demo_arp_cache      = 1024U,   
  k_demo_tls_port       = 4433U,   
  k_demo_recv_window    = 4096U,   
  k_demo_socket_ttl     = 64U,     
  k_demo_recv_timeout   = 200U,    
  k_demo_connect_ticks  = 3000U,   
  k_demo_handshake_max  = 20000U,  
  k_demo_io_max         = 4000U,   
  k_demo_line_buf       = 160U,    
  k_demo_record_cap     = 64U,     
  k_demo_mtu            = 128U,    
  k_demo_verify_unset =
    0xFFFFFFFFU, 
} demo_config_t;

typedef enum : uint8_t {
  k_demo_ip_oct_a = 0U, 
  k_demo_ip_oct_b = 1U, 
  k_demo_ip_oct_c = 2U, 
  k_demo_ip_oct_d = 3U, 
} demo_ip_octet_t;

typedef enum : uint8_t {
  k_demo_ip_shift_a = 24U, 
  k_demo_ip_shift_b = 16U, 
  k_demo_ip_shift_c = 8U,  
  k_demo_ip_shift_d = 0U,  
} demo_ip_shift_t;

typedef enum : uint8_t {
  k_demo_mac_msw_shift_b0 = 8U,  
  k_demo_mac_msw_shift_b1 = 0U,  
  k_demo_mac_lsw_shift_b2 = 24U, 
  k_demo_mac_lsw_shift_b3 = 16U, 
  k_demo_mac_lsw_shift_b4 = 8U,  
  k_demo_mac_lsw_shift_b5 = 0U,  
} demo_mac_word_shift_t;

typedef enum : uint16_t {
  k_demo_ipaddr_0  = 192U, 
  k_demo_ipaddr_1  = 168U, 
  k_demo_ipaddr_2  = 1U,   
  k_demo_ipaddr_3  = 42U,  
  k_demo_netmask_b = 255U, 
  k_demo_gw_3      = 1U,   
} demo_ipv4_t;

typedef enum : uint8_t {
  k_demo_mac_idx_0 = 0U, 
  k_demo_mac_idx_1 = 1U, 
  k_demo_mac_idx_2 = 2U, 
  k_demo_mac_idx_3 = 3U, 
  k_demo_mac_idx_4 = 4U, 
  k_demo_mac_idx_5 = 5U, 
} demo_mac_idx_t;

static const uint8_t k_demo_mac[6] = {0x02U, 0x00U, 0x00U, 0x00U, 0x00U, 0x03U};

static const uint8_t k_demo_ip[4] = {(uint8_t)k_demo_ipaddr_0,
                                     (uint8_t)k_demo_ipaddr_1,
                                     (uint8_t)k_demo_ipaddr_2,
                                     (uint8_t)k_demo_ipaddr_3};

static const uint8_t k_demo_mask[4] = {(uint8_t)k_demo_netmask_b,
                                       (uint8_t)k_demo_netmask_b,
                                       (uint8_t)k_demo_netmask_b,
                                       0U};

static const uint8_t k_demo_gw[4] = {(uint8_t)k_demo_ipaddr_0,
                                     (uint8_t)k_demo_ipaddr_1,
                                     (uint8_t)k_demo_ipaddr_2,
                                     (uint8_t)k_demo_gw_3};

static const char k_demo_server_name[] = "endpoint.test";

static const uint8_t k_demo_record[] = "PING over ra8_tls\n";
 
#ifndef RA8_OFF_TARGET
/* NetX Duo state. ThreadX requires statically-allocated control blocks
 * (NASA Power of 10 Rule 3 -- no dynamic memory). */
static NX_PACKET_POOL s_packet_pool;
static NX_IP          s_ip;
static NX_TCP_SOCKET  s_tls_socket;
static UCHAR          s_pool_memory[k_demo_pool_bytes];
static ULONG          s_ip_stack[k_demo_ip_stack / sizeof(ULONG)];
static ULONG          s_arp_cache[k_demo_arp_cache / sizeof(ULONG)];
 
/* ThreadX worker thread + a byte pool that backs Mbed TLS's calloc/free. */
static TX_THREAD    s_demo_thread;
static UCHAR        s_demo_stack[k_demo_thread_stack];
static TX_BYTE_POOL s_byte_pool;
static UCHAR        s_byte_pool_memory[k_demo_byte_pool_size];
static CHAR s_packet_pool_name[] = "ra8_eth_pool";
static CHAR s_ip_name[]          = "ra8_eth_ip";
static CHAR s_socket_name[]      = "tls4433";
static CHAR s_byte_pool_name[]   = "mbedtls_pool";
static CHAR s_thread_name[]      = "tls_worker";
#endif /* !RA8_OFF_TARGET */

static void demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_demo_baud) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_ethernet_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  const ra8_rsip_config_t rsip_cfg = {.run_bist = true};
  if (ra8_rsip_init(&rsip_cfg) != k_ra8_ok) {
    demo_panic_halt();
  }
}

static void demo_print(const char* s)
{
  if (s == (const char*)0) {
    return;
  }
  size_t len = strlen(s);
  (void)ra8_board_uart_console_write((const uint8_t*)s, len);
}
 
#ifndef RA8_OFF_TARGET
static ULONG demo_pack_ip(const uint8_t* octets)
{
  return (((ULONG)octets[k_demo_ip_oct_a]) << (ULONG)k_demo_ip_shift_a) |
         (((ULONG)octets[k_demo_ip_oct_b]) << (ULONG)k_demo_ip_shift_b) |
         (((ULONG)octets[k_demo_ip_oct_c]) << (ULONG)k_demo_ip_shift_c) |
         (((ULONG)octets[k_demo_ip_oct_d]) << (ULONG)k_demo_ip_shift_d);
}

static void demo_pack_mac(ULONG* msw, ULONG* lsw)
{
  *msw = (((ULONG)k_demo_mac[k_demo_mac_idx_0]) << (ULONG)k_demo_mac_msw_shift_b0) |
         (((ULONG)k_demo_mac[k_demo_mac_idx_1]) << (ULONG)k_demo_mac_msw_shift_b1);
  *lsw = (((ULONG)k_demo_mac[k_demo_mac_idx_2]) << (ULONG)k_demo_mac_lsw_shift_b2) |
         (((ULONG)k_demo_mac[k_demo_mac_idx_3]) << (ULONG)k_demo_mac_lsw_shift_b3) |
         (((ULONG)k_demo_mac[k_demo_mac_idx_4]) << (ULONG)k_demo_mac_lsw_shift_b4) |
         (((ULONG)k_demo_mac[k_demo_mac_idx_5]) << (ULONG)k_demo_mac_lsw_shift_b5);
}

psa_status_t mbedtls_psa_external_get_random(mbedtls_psa_external_random_context_t* context,
                                             uint8_t*                               output,
                                             size_t                                 output_size,
                                             size_t*                                output_length)
{
  (void)context;
  if (output == nullptr || output_length == nullptr) {
    return PSA_ERROR_INVALID_ARGUMENT;
  }
  if (ra8_rsip_trng_read((uint8_t*)output, (uint32_t)output_size) != k_ra8_ok) {
    return PSA_ERROR_HARDWARE_FAILURE;
  }
  *output_length = output_size;
  return PSA_SUCCESS;
}

static void* demo_calloc(size_t n, size_t size)
{
  if ((n == 0U) || (size == 0U)) {
    return nullptr;
  }
  if (n > (SIZE_MAX / size)) {
    return nullptr;
  }
  const size_t total = n * size;
  VOID*        p     = NX_NULL;
  if (tx_byte_allocate(&s_byte_pool, &p, (ULONG)total, TX_NO_WAIT) != TX_SUCCESS) {
    return nullptr;
  }
  (void)memset((void*)p, 0, total);
  return p;
}

static void demo_free(void* p)
{
  if (p == nullptr) {
    return;
  }
  (void)tx_byte_release(p);
}

static int tls_bio_send(void* ctx, const uint8_t* buf, size_t len)
{
  (void)ctx;
  if (buf == nullptr || len == 0U) {
    return 0;
  }
  NX_PACKET* pkt = NX_NULL;
  UINT       s   = nx_packet_allocate(&s_packet_pool, &pkt, NX_TCP_PACKET, NX_WAIT_FOREVER);
  if (s != NX_SUCCESS || pkt == NX_NULL) {
    return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
  }
  s =
    nx_packet_data_append(pkt, (VOID*)(uintptr_t)buf, (ULONG)len, &s_packet_pool, NX_WAIT_FOREVER);
  if (s != NX_SUCCESS) {
    (void)nx_packet_release(pkt);
    return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
  }
  s = nx_tcp_socket_send(&s_tls_socket, pkt, (ULONG)k_demo_recv_timeout);
  if (s != NX_SUCCESS) {
    (void)nx_packet_release(pkt);
    if (s == NX_NO_PACKET || s == NX_WINDOW_OVERFLOW) {
      return MBEDTLS_ERR_SSL_WANT_WRITE;
    }
    return MBEDTLS_ERR_NET_SEND_FAILED;
  }
  return (int)len;
}

static int tls_bio_recv(void* ctx, uint8_t* buf, size_t len)
{
  (void)ctx;
  if (buf == nullptr || len == 0U) {
    return 0;
  }
  NX_PACKET* pkt = NX_NULL;
  UINT       s   = nx_tcp_socket_receive(&s_tls_socket, &pkt, (ULONG)k_demo_recv_timeout);
  if (s == NX_NO_PACKET) {
    return MBEDTLS_ERR_SSL_WANT_READ;
  }
  if (s != NX_SUCCESS || pkt == NX_NULL) {
    return MBEDTLS_ERR_NET_RECV_FAILED;
  }
  ULONG copied = 0U;
  (void)nx_packet_data_retrieve(pkt, (VOID*)buf, &copied);
  (void)nx_packet_release(pkt);
  if (copied > (ULONG)len) {
    copied = (ULONG)len;
  }
  return (int)copied;
}

static UINT demo_netx_bring_up(void)
{
  UINT s = nx_packet_pool_create(&s_packet_pool,
                                 s_packet_pool_name,
                                 (ULONG)k_demo_packet_size,
                                 s_pool_memory,
                                 (ULONG)sizeof(s_pool_memory));
  if (s != NX_SUCCESS) {
    return s;
  }
  nx_ether_driver_ra8_eth_set_mac(k_demo_mac);
 
  s = nx_ip_create(&s_ip,
                   s_ip_name,
                   demo_pack_ip(k_demo_ip),
                   demo_pack_ip(k_demo_mask),
                   &s_packet_pool,
                   nx_ether_driver_ra8_eth,
                   (VOID*)s_ip_stack,
                   (ULONG)sizeof(s_ip_stack),
                   (UINT)k_demo_ip_thread_pri);
  if (s != NX_SUCCESS) {
    return s;
  }
  ULONG msw = 0U;
  ULONG lsw = 0U;
  demo_pack_mac(&msw, &lsw);
  (void)nx_ip_interface_physical_address_set(&s_ip, 0U, msw, lsw, NX_TRUE);
  (void)nx_ip_gateway_address_set(&s_ip, demo_pack_ip(k_demo_gw));
 
  s = nx_arp_enable(&s_ip, (VOID*)s_arp_cache, (ULONG)sizeof(s_arp_cache));
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_tcp_enable(&s_ip);
  if (s != NX_SUCCESS) {
    return s;
  }
  (void)nx_icmp_enable(&s_ip);
  /* Fragment oversized datagrams into in-spec frames under the 128-byte MTU. */
  (void)nx_ip_fragment_enable(&s_ip);
  return NX_SUCCESS;
}

static UINT demo_tcp_connect(void)
{
  UINT s = nx_tcp_socket_create(&s_ip,
                                &s_tls_socket,
                                s_socket_name,
                                NX_IP_NORMAL,
                                NX_FRAGMENT_OKAY,
                                (UINT)k_demo_socket_ttl,
                                (ULONG)k_demo_recv_window,
                                NX_NULL,
                                NX_NULL);
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_tcp_client_socket_bind(&s_tls_socket, NX_ANY_PORT, NX_WAIT_FOREVER);
  if (s != NX_SUCCESS) {
    return s;
  }
  return nx_tcp_client_socket_connect(&s_tls_socket,
                                      demo_pack_ip(k_demo_gw),
                                      (UINT)k_demo_tls_port,
                                      (ULONG)k_demo_connect_ticks);
}

static ra8_err_t demo_handshake(ra8_tls_session_t session)
{
  for (uint32_t i = 0U; i < (uint32_t)k_demo_handshake_max; ++i) {
    ra8_err_t err = ra8_tls_handshake(session);
    if (err != k_ra8_err_would_block) {
      return err;
    }
  }
  return k_ra8_err_timeout;
}

static ra8_err_t demo_exchange(ra8_tls_session_t session, uint8_t* got, size_t got_cap)
{
  if (got == nullptr || got_cap == 0U) {
    return k_ra8_err_invalid_arg;
  }
  size_t    sent = 0U;
  ra8_err_t err  = k_ra8_err_would_block;
  for (uint32_t i = 0U; (i < (uint32_t)k_demo_io_max) && (err == k_ra8_err_would_block); ++i) {
    err = ra8_tls_send(session, k_demo_record, sizeof(k_demo_record) - 1U, &sent);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  size_t got_n = 0U;
  err          = k_ra8_err_would_block;
  for (uint32_t i = 0U; (i < (uint32_t)k_demo_io_max) && (err == k_ra8_err_would_block); ++i) {
    err = ra8_tls_recv(session, got, got_cap, &got_n);
  }
  return err;
}

static void demo_report(ra8_tls_session_t session)
{
  uint16_t id                              = 0U;
  char     name[k_ra8_tls_cipher_name_cap] = {};
  uint32_t flags                           = (uint32_t)k_demo_verify_unset;
  (void)ra8_tls_get_cipher_suite(session, &id, name, sizeof(name));
  (void)ra8_tls_get_verify_result(session, &flags);
 
  demo_print("[tls] cipher=");
  demo_print(name);
  demo_print((flags == 0U) ? " verify=OK\r\n" : " verify=UNVERIFIED\r\n");
}

static ra8_err_t demo_run_tls(void)
{
  uint16_t mss = 0U;
  if (ra8_tls_mss_clamp((uint16_t)k_demo_mtu, &mss) != k_ra8_ok) {
    return k_ra8_err_invalid_arg;
  }
  demo_print("[tls] MSS clamp applied\r\n");
 
  ra8_err_t err = ra8_tls_global_init();
  if (err != k_ra8_ok) {
    return err;
  }
 
  ra8_tls_session_cfg_t cfg = {};
  cfg.bio_send              = tls_bio_send;
  cfg.bio_recv              = tls_bio_recv;
  cfg.bio_ctx               = &s_tls_socket;
  cfg.server_name           = k_demo_server_name;
  /* The test endpoint typically presents a self-signed cert; report the
   * verification result rather than aborting the exchange. */
  cfg.verify_mode = k_ra8_tls_verify_optional;
 
  ra8_tls_session_t session = nullptr;
  err                       = ra8_tls_session_open(&session, &cfg);
  if (err != k_ra8_ok) {
    (void)ra8_tls_global_deinit();
    return err;
  }
 
  err = demo_handshake(session);
  if (err == k_ra8_ok) {
    uint8_t got[k_demo_record_cap] = {};
    err                            = demo_exchange(session, got, sizeof(got));
    demo_report(session);
  }
 
  (void)ra8_tls_session_close(session);
  (void)ra8_tls_global_deinit();
  return err;
}

static void demo_thread_entry(ULONG thread_input)
{
  (void)thread_input;
  if (psa_crypto_init() != PSA_SUCCESS) {
    demo_print("[tls] psa_crypto_init failed\r\n");
    return;
  }
  demo_print("[tls] bringing NetX Duo up...\r\n");
  if (demo_netx_bring_up() != NX_SUCCESS) {
    demo_print("[tls] NetX bring-up failed\r\n");
    return;
  }
  demo_print("[tls] connecting to 192.168.1.1:4433\r\n");
  if (demo_tcp_connect() != NX_SUCCESS) {
    demo_print("[tls] TCP connect failed\r\n");
    return;
  }
  if (demo_run_tls() != k_ra8_ok) {
    demo_print("[tls] session failed\r\n");
  }
  demo_print("[tls] done\r\n");
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  (void)tx_byte_pool_create(&s_byte_pool,
                            s_byte_pool_name,
                            s_byte_pool_memory,
                            (ULONG)sizeof(s_byte_pool_memory));
  mbedtls_platform_set_calloc_free(demo_calloc, demo_free);
 
  nx_system_initialize();
 
  (void)tx_thread_create(&s_demo_thread,
                         s_thread_name,
                         demo_thread_entry,
                         0U,
                         s_demo_stack,
                         (ULONG)sizeof(s_demo_stack),
                         (UINT)k_demo_app_thread_pri,
                         (UINT)k_demo_app_thread_pri,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */

void main(void)
{
  demo_setup_or_halt();
  ra8_isr_globals_enable();
  demo_print("[tls] booting ThreadX + NetX Duo + ra8_tls...\r\n");
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  demo_panic_halt();
}