main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_eth.h"
#include "ra8_isr.h"
#include "ra8_rsip.h"
#include "ra8_time.h"
 
#ifndef RA8_OFF_TARGET
/* Mbed TLS 4.x relocated the legacy crypto primitive headers under
 * `mbedtls/private/`. The TLS / X.509 layer headers stay at the
 * public top level. */
#include "mbedtls/net_sockets.h"
#include "mbedtls/platform.h"
#include "mbedtls/private/ctr_drbg.h"
#include "mbedtls/private/entropy.h"
#include "mbedtls/private/sha256.h"
#include "mbedtls/ssl.h"
#include "mbedtls/x509_crt.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_packet_count   = 16U,     
  k_demo_pool_bytes     = 32768U,  
  k_demo_byte_pool_size = 65536U,  
  k_demo_ip_stack       = 4096U,   
  k_demo_arp_cache      = 1024U,   
  k_demo_https_port     = 443U,    
  k_demo_recv_window    = 4096U,   
  k_demo_socket_ttl     = 64U,     
  k_demo_recv_timeout   = 200U,    
  k_demo_handshake_max  = 3000U,   
  k_demo_log_buf_bytes  = 80U,     
  k_demo_dump_bytes     = 1024U,   
  k_demo_request_buf    = 256U,    
  k_demo_response_buf   = 4096U,   
  k_demo_drbg_seed_len  = 32U,     
} 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_hostip_0  = 93U,  
  k_demo_hostip_1  = 184U, 
  k_demo_hostip_2  = 216U, 
  k_demo_hostip_3  = 34U,  
} demo_ipv4_t;

typedef enum : uint8_t {
  k_ascii_cr = 0x0DU, 
  k_ascii_lf = 0x0AU, 
} http_ascii_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 s_demo_mac[6] = {0x02U, 0x00U, 0x00U, 0x00U, 0x00U, 0x02U};

static const uint8_t s_demo_ip[4] = {k_demo_ipaddr_0,
                                     k_demo_ipaddr_1,
                                     k_demo_ipaddr_2,
                                     k_demo_ipaddr_3};

static const uint8_t s_demo_mask[4] = {k_demo_netmask_b, k_demo_netmask_b, k_demo_netmask_b, 0U};

static const uint8_t s_demo_gw[4] = {k_demo_ipaddr_0, k_demo_ipaddr_1, k_demo_ipaddr_2, 1U};

static const uint8_t s_demo_host_ip[4] = {k_demo_hostip_0,
                                          k_demo_hostip_1,
                                          k_demo_hostip_2,
                                          k_demo_hostip_3};

static const char s_demo_host_name[] = "www.example.com";

static const uint8_t s_demo_cert_pin_sha256[32] = {
  0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
  0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
  0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
};
 
#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
 * mbedtls_calloc / mbedtls_free hooks. */
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];
 
/* Mbed TLS state. Placed at file scope so the stack frame of the
 * worker thread stays well below k_demo_thread_stack. */
static mbedtls_ssl_context      s_ssl;
static mbedtls_ssl_config       s_ssl_cfg;
static mbedtls_ctr_drbg_context s_drbg;
static mbedtls_entropy_context  s_entropy;
 
static UCHAR s_request_buf[k_demo_request_buf];
static UCHAR s_response_buf[k_demo_response_buf];
static UCHAR s_tls_send_staging[k_demo_pool_bytes];
#endif /* !RA8_OFF_TARGET */

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

RA8_INTERNAL static void internal_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_demo_baud) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_board_ethernet_init() != k_ra8_ok) {
    internal_demo_panic_halt();
  }
 
  /* Bring up the RSIP engine for its TRNG entropy source (used to
   * seed Mbed TLS's CTR_DRBG). The BIST is a one-shot ~ms operation so
   * we run it here at boot, not per request. */
  const ra8_rsip_config_t rsip_cfg = {.run_bist = true};
  if (ra8_rsip_init(&rsip_cfg) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
}

RA8_INTERNAL static void internal_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);
}

RA8_INTERNAL static void internal_demo_write_bytes(const uint8_t* buf, uint32_t len)
{
  if (buf == nullptr || len == 0U) {
    return;
  }
  (void)ra8_board_uart_console_write(buf, (size_t)len);
}
 
#ifndef RA8_OFF_TARGET
RA8_INTERNAL static ULONG internal_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);
}

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

RA8_INTERNAL static UINT internal_demo_netx_bring_up(void)
{
  static CHAR s_packet_pool_name[] = "ra8_eth_pool";
  static CHAR s_ip_name[]          = "ra8_eth_ip";
 
  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;
  }
 
  ULONG ip_addr = internal_demo_pack_ip(s_demo_ip);
  ULONG ip_mask = internal_demo_pack_ip(s_demo_mask);
  s             = nx_ip_create(&s_ip,
                               s_ip_name,
                               ip_addr,
                               ip_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;
  internal_demo_pack_mac(&msw, &lsw);
  (void)nx_ip_interface_physical_address_set(&s_ip, 0U, msw, lsw, NX_TRUE);
 
  /* Default gateway so packets to www.example.com leave the LAN. */
  (void)nx_ip_gateway_address_set(&s_ip, internal_demo_pack_ip(s_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);
  return NX_SUCCESS;
}

RA8_INTERNAL static UINT internal_demo_tcp_connect(void)
{
  static CHAR s_socket_name[] = "https443";
 
  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;
  }
  ULONG host_ip = internal_demo_pack_ip(s_demo_host_ip);
  s             = nx_tcp_client_socket_connect(&s_tls_socket,
                                               host_ip,
                                               (UINT)k_demo_https_port,
                                               (ULONG)k_demo_handshake_max);
  return s;
}

RA8_INTERNAL static int internal_demo_bio_send(void* ctx, const unsigned char* buf, size_t len)
{
  (void)ctx;
  if (buf == nullptr || len == 0U) {
    return 0;
  }
  if (len > sizeof(s_tls_send_staging)) {
    return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
  }
  memcpy(s_tls_send_staging, buf, len);
  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, s_tls_send_staging, (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;
}

RA8_INTERNAL static int internal_demo_bio_recv(void* ctx, unsigned char* 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) {
    /* Should not happen with a 1568-byte pool packet, but cap. */
    copied = (ULONG)len;
  }
  return (int)copied;
}

RA8_INTERNAL static int
internal_demo_entropy_source(void* ctx, unsigned char* buf, size_t len, size_t* olen)
{
  (void)ctx;
  if (buf == nullptr || olen == nullptr) {
    return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
  }
  ra8_err_t err = ra8_rsip_trng_read((uint8_t*)buf, (uint32_t)len);
  if (err != k_ra8_ok) {
    return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
  }
  *olen = len;
  return 0;
}
 
#ifndef DEMO_DISABLE_CERT_PIN
RA8_INTERNAL static int internal_demo_verify_cert_pin(void)
{
  const mbedtls_x509_crt* peer = mbedtls_ssl_get_peer_cert(&s_ssl);
  if (peer == nullptr) {
    return -1;
  }
  uint8_t got[32];
  if (ra8_rsip_sha256(peer->raw.p, (uint32_t)peer->raw.len, got) != k_ra8_ok) {
    return -1;
  }
  if (memcmp(got, s_demo_cert_pin_sha256, sizeof(got)) != 0) {
    return -1;
  }
  return 0;
}
#endif /* !DEMO_DISABLE_CERT_PIN */

RA8_INTERNAL static int internal_demo_http_get(void)
{
  size_t      request_len     = 0U;
  const char* request_parts[] = {
    "GET / HTTP/1.1\r\nHost: ",
    s_demo_host_name,
    "\r\nConnection: close\r\nUser-Agent: ra8d2-https-client/0.1\r\n\r\n",
  };
  s_request_buf[0] = '\0';
  for (size_t i = 0U; i < (sizeof(request_parts) / sizeof(request_parts[0])); ++i) {
    const size_t part_len = strlen(request_parts[i]);
    if (part_len > (sizeof(s_request_buf) - request_len - 1U)) {
      return -1;
    }
    (void)memcpy(&s_request_buf[request_len], request_parts[i], part_len);
    request_len += part_len;
    s_request_buf[request_len] = '\0';
  }
  if (request_len == 0U) {
    return -1;
  }
  size_t written = 0U;
  while (written < request_len) {
    int rc = mbedtls_ssl_write(&s_ssl, s_request_buf + written, request_len - written);
    if (rc == MBEDTLS_ERR_SSL_WANT_READ || rc == MBEDTLS_ERR_SSL_WANT_WRITE) {
      continue;
    }
    if (rc < 0) {
      return rc;
    }
    written += (size_t)rc;
  }
 
  /* Read until we've dumped k_demo_dump_bytes of body or the peer
   * closes. */
  uint32_t body_dumped    = 0U;
  uint8_t  saw_header_end = 0U;
  uint8_t  match          = 0U; /* tracks "\r\n\r\n" run. */
  while (body_dumped < (uint32_t)k_demo_dump_bytes) {
    int rc = mbedtls_ssl_read(&s_ssl, s_response_buf, sizeof(s_response_buf));
    if (rc == MBEDTLS_ERR_SSL_WANT_READ || rc == MBEDTLS_ERR_SSL_WANT_WRITE) {
      continue;
    }
    if (rc == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY || rc == 0) {
      break;
    }
    if (rc < 0) {
      return rc;
    }
    int start = 0;
    if (saw_header_end == 0U) {
      /* Walk byte-by-byte looking for CRLFCRLF. */
      for (int i = 0; i < rc; i++) {
        uint8_t c = s_response_buf[i];
        if ((match == 0U && c == k_ascii_cr) || (match == 2U && c == k_ascii_cr)) {
          match++;
        } else if ((match == 1U && c == k_ascii_lf) || (match == 3U && c == k_ascii_lf)) {
          match++;
        } else {
          match = 0U;
        }
        if (match == 4U) {
          saw_header_end = 1U;
          start          = i + 1;
          break;
        }
      }
      if (saw_header_end == 0U) {
        continue;
      }
    }
    int      avail = rc - start;
    uint32_t take  = (uint32_t)avail;
    if (body_dumped + take > (uint32_t)k_demo_dump_bytes) {
      take = (uint32_t)k_demo_dump_bytes - body_dumped;
    }
    internal_demo_write_bytes(s_response_buf + start, take);
    body_dumped += take;
  }
  return 0;
}

RA8_INTERNAL static int internal_demo_tls_session(void)
{
  mbedtls_ssl_init(&s_ssl);
  mbedtls_ssl_config_init(&s_ssl_cfg);
 
  /* Mbed TLS 4.x removed MBEDTLS_ENTROPY_C and MBEDTLS_CTR_DRBG_C from
   * the standard build path; the SSL layer pulls random bytes from PSA
   * crypto (psa_generate_random), which the firmware wires to the RSIP
   * TRNG via the mbedtls_psa_external_get_random() implementation
   * above. The legacy mbedtls_entropy_* / mbedtls_ctr_drbg_* setup
   * dance is therefore no longer needed. We still need PSA itself
   * online; internal_demo_thread_entry calls psa_crypto_init() before this. */
  (void)internal_demo_entropy_source; /* Retained for reference; unused on 4.x. */
  (void)s_drbg;
  (void)s_entropy;
 
  if (mbedtls_ssl_config_defaults(&s_ssl_cfg,
                                  MBEDTLS_SSL_IS_CLIENT,
                                  MBEDTLS_SSL_TRANSPORT_STREAM,
                                  MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
    return -1;
  }
  /* No CA bundle is provisioned in this demo -- we authenticate the
   * peer by SHA-256 cert-pin instead. ``OPTIONAL`` lets the
   * handshake complete even with an empty trust store; the pin
   * check below is what gates the GET. */
  mbedtls_ssl_conf_authmode(&s_ssl_cfg, MBEDTLS_SSL_VERIFY_OPTIONAL);
  /* Mbed TLS 4.x removed mbedtls_ssl_conf_rng() -- the SSL layer
   * pulls random bytes from PSA crypto's psa_generate_random() now,
   * which is wired up by demo_psa_init() below via the
   * MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG hook
   * (mbedtls_psa_external_get_random). */
 
  if (mbedtls_ssl_setup(&s_ssl, &s_ssl_cfg) != 0) {
    return -1;
  }
  if (mbedtls_ssl_set_hostname(&s_ssl, s_demo_host_name) != 0) {
    return -1;
  }
  mbedtls_ssl_set_bio(&s_ssl, nullptr, internal_demo_bio_send, internal_demo_bio_recv, nullptr);
 
  /* Drive the handshake to completion. */
  int rc = 0;
  while ((rc = mbedtls_ssl_handshake(&s_ssl)) != 0) {
    if (rc != MBEDTLS_ERR_SSL_WANT_READ && rc != MBEDTLS_ERR_SSL_WANT_WRITE) {
      return rc;
    }
  }
#ifndef DEMO_DISABLE_CERT_PIN
  if (internal_demo_verify_cert_pin() != 0) {
    internal_demo_print("[https] cert pin MISMATCH -- aborting\r\n");
    return -1;
  }
  internal_demo_print("[https] handshake OK, cert pin matches, dumping body\r\n");
#else
  internal_demo_print("[https] handshake OK, cert pin DISABLED, dumping body\r\n");
#endif
  return internal_demo_http_get();
}

RA8_INTERNAL static void internal_demo_thread_entry(ULONG thread_input)
{
  (void)thread_input;
  /* Bring PSA crypto online before any TLS / X.509 work. The library
   * lazy-initialises inside the SSL layer, but doing it explicitly
   * here surfaces failures earlier and binds the RSIP-TRNG external
   * RNG hook before the handshake's first random call. */
  if (psa_crypto_init() != PSA_SUCCESS) {
    internal_demo_print("[https] psa_crypto_init failed\r\n");
    return;
  }
  internal_demo_print("[https] bringing NetX Duo up...\r\n");
  if (internal_demo_netx_bring_up() != NX_SUCCESS) {
    internal_demo_print("[https] NetX bring-up failed\r\n");
    return;
  }
  internal_demo_print("[https] connecting to www.example.com:443\r\n");
  if (internal_demo_tcp_connect() != NX_SUCCESS) {
    internal_demo_print("[https] TCP connect failed\r\n");
    return;
  }
  if (internal_demo_tls_session() != 0) {
    internal_demo_print("[https] TLS session failed\r\n");
  }
  internal_demo_print("\r\n[https] done\r\n");
}

RA8_INTERNAL static void* internal_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;
}

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

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_byte_pool_name[] = "mbedtls_pool";
  static CHAR s_thread_name[]    = "https_worker";
 
  (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(internal_demo_calloc, internal_demo_free);
 
  nx_system_initialize();
 
  (void)tx_thread_create(&s_demo_thread,
                         s_thread_name,
                         internal_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)
{
  internal_demo_setup_or_halt();
  ra8_isr_globals_enable();
  internal_demo_print("[https] booting ThreadX + NetX Duo + Mbed TLS...\r\n");
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  internal_demo_panic_halt();
}