STM32H5 running DTLS with netXduo

[skim.5]

hi, i trying DTLS on netXduo

my goal is TLS and DLTS running independently (STM32H5 is server, PC is client)

so i success mutual TLS(Ver 1.3) but failed DTLS running

i'm in situation that DTLS connection is completed at client but server is not answer about client hello(3 time ignored)

i check variables and found handler pointer is null

 - active_dtls_session->nx_secure_dtls_tls_session.nx_secure_session_cipher_handler_server == null

so i guess DTLS initialization was not completed but i don't know what do i do

i attach my code and variables please help me thank you

DTLS_SESSION_CONFIG g_dtls_session_table[1];

#pragma data_alignment=8
NX_SECURE_DTLS_SERVER dtls_server;

typedef struct {
    NX_SECURE_DTLS_SESSION sessions[1]; 
    ULONG padding; 
    UCHAR metadata[32*1024]; 
} DTLS_MEMORY_BLOCK;

NX_SECURE_DTLS_SESSION *active_dtls_session = NULL;
UCHAR dtls_reassembly_buffer[32*1024];
UCHAR dtls_client_cert_buffer[20*1024];

#pragma data_alignment=8
DTLS_MEMORY_BLOCK dtls_memory;

#pragma data_alignment=8
UCHAR dtls_verify_stack[40*1024]; // Verification workspace for mTLS

UINT dtls_active_flag = 0;
UINT dtls_connected_flag = 0;

static VOID App_UDP_Server_Thread_Entry(ULONG thread_input)
{
  UINT status;
  NX_PACKET *packet_ptr;
  NX_IP *ip_ptr = (NX_IP*)thread_input;
  UCHAR data_buffer[1500];
  ULONG data_length;

  /* Shared variables */
  ULONG src_ip;
  UINT src_port;

  /* --- 1. Resource Initialization --- */
  long found_session = 0;
  
  _nx_secure_dtls_initialize();

  /* Create DTLS server instance */
  status = _nx_secure_dtls_server_create(&dtls_server, ip_ptr, USER_UDP_SERVER_PORT, NX_IP_TIME_TO_LIVE,
                                          dtls_memory.sessions, sizeof(dtls_memory.sessions), 
                                          &nx_crypto_tls_ciphers_ecc,
                                          dtls_memory.metadata, sizeof(dtls_memory.metadata),
                                          dtls_reassembly_buffer, sizeof(dtls_reassembly_buffer),
                                          my_dtls_connect_notify, NULL);

  if (status == NX_SUCCESS) {
    uart_tx_queuePrint_create("[INFO] Server Created. Session Count: %u\r\n", dtls_server.nx_dtls_server_sessions_count);
    
    USHORT group_count = (USHORT)(sizeof(my_supported_groups) / sizeof(USHORT));
    _nx_secure_dtls_server_ecc_initialize(&dtls_server, my_supported_groups, group_count, my_curve_methods);

    /* Server Cert & Private Key Registration */
    status = _nx_secure_x509_certificate_initialize(&server_cert, (UCHAR*)cert_der, cert_len, 
                                                    NX_NULL, 0, (UCHAR*)key_der, key_len, 
                                                    NX_SECURE_X509_KEY_TYPE_EC_DER);
    if (status == NX_SUCCESS) {
      _nx_secure_dtls_server_local_certificate_add(&dtls_server, &server_cert, 1);
    }
    else{
      uart_tx_queuePrint_create("server local certificate add fail! : %u\r\n", status);
    }
  } else {
    uart_tx_queuePrint_create("DTLS Server Create Failed: 0x%02X\r\n", status);
  }

  while (1)
  {
    uart_tx_queuePrint_create("UDP/DTLS Server Ready. Waiting for TCP Signal...\r\n");
    
    /* Wait for mTLS (TCP) authentication to complete */
    tx_semaphore_get(&UDPSemaphore, TX_WAIT_FOREVER);

    /* Reset session active flag for the new connection */
    dtls_active_flag = 0;
    dtls_connected_flag = 0; 

    /* --- 2. Bind & Start Phase --- */
    _nx_secure_dtls_server_stop(&dtls_server);
    
    for (int i = 0; i < USER_SERVER_MAX_CLIENTS; i++) {
      // NX_SECURE_DTLS_SESSION *s = &dtls_server.nx_dtls_server_sessions[i];
      
      NX_SECURE_DTLS_SESSION *s = &dtls_memory.sessions[i];
      
      if (s->nx_secure_dtls_server_parent == NULL) {
        s->nx_secure_dtls_server_parent = &dtls_server;
      }
      s->nx_secure_dtls_tls_session.nx_secure_tls_packet_pool = ip_ptr->nx_ip_default_packet_pool;
    }
    status = _nx_secure_dtls_server_start(&dtls_server);
    uart_tx_queuePrint_create("DTLS Server Started. Listening on port %d...\r\n", dtls_server.nx_dtls_server_udp_socket.nx_udp_socket_port);

    if (status != NX_SUCCESS) {
      uart_tx_queuePrint_create("Server Start/Bind Failed: 0x%02X\r\n", status);
      continue;
    }
    
    uart_tx_queuePrint_create("Waiting for DTLS Handshake...\r\n");
    
    while(dtls_connected_flag == 0) {
        tx_thread_sleep(1); 
    }
    
    uart_tx_queuePrint_create("[DTLS] Starting Handshake Session in Thread...\r\n");
    status = _nx_secure_dtls_server_session_start(active_dtls_session, NX_WAIT_FOREVER);
    
    if (status != NX_SUCCESS) {
          uart_tx_queuePrint_create("[ERROR] DTLS Handshake Failed: 0x%02X\r\n", status);
          _nxe_secure_dtls_session_end(active_dtls_session, NX_NO_WAIT);
          _nx_secure_dtls_session_reset(active_dtls_session);
          dtls_connected_flag = 0;
          continue; 
    }
    else {
      uart_tx_queuePrint_create("[DTLS] Handshake Success!\r\n");
    }
    
    
    /* --- 3. Unified Data Loop --- */
    uart_tx_queuePrint_create("Entering UDP/DTLS Data Loop\r\n");
    
    while (UserTCPSocket.nx_tcp_socket_state == NX_TCP_ESTABLISHED)
    {
      if (active_dtls_session->nx_secure_dtls_tls_session.nx_secure_session_cipher_handler_server == NULL) {
          static ULONG last_warn_time = 0;
          if (tx_time_get() - last_warn_time > 200) { 
              uart_tx_queuePrint_create("[GUARD] Cipher Handler is NULL! (Session: %p)\r\n", active_dtls_session);
              last_warn_time = tx_time_get();
          }
          tx_thread_sleep(10); 
          //status = _nx_secure_dtls_session_receive(active_dtls_session, &packet_ptr, 20);
          continue; 
      }

      packet_ptr = NULL;
      status = _nx_secure_dtls_session_receive(active_dtls_session, &packet_ptr, 20);

      if (status == NX_SUCCESS)
      {
        nx_packet_data_retrieve(packet_ptr, data_buffer, &data_length);
        if(data_length < sizeof(data_buffer)) data_buffer[data_length] = '\0';
        
        if (dtls_active_flag == 0) {
          uart_tx_queuePrint_create("DTLS Handshake Success & Session Active!\r\n");
          dtls_active_flag = 1; 
        }

        src_ip = dtls_memory.sessions[0].nx_secure_dtls_remote_ip_address.nxd_ip_address.v4;
        src_port = dtls_memory.sessions[0].nx_secure_dtls_remote_port;
        
        uart_tx_queuePrint_create("\n[UDP RX] %lu.%lu.%lu.%lu:%u_%s\r\n", 
                                  (src_ip >> 24) & 0xFF, (src_ip >> 16) & 0xFF,
                                  (src_ip >> 8) & 0xFF, (src_ip & 0xFF), src_port, data_buffer);

        UDP_Server_Send_Data(&dtls_memory.sessions[0], ip_ptr->nx_ip_default_packet_pool, data_buffer, data_length);
        nx_packet_release(packet_ptr);
      }
    }

    /* --- 4. Cleanup --- */
    uart_tx_queuePrint_create("Cleaning up UDP/DTLS session...\r\n");
    _nxe_secure_dtls_session_end(&dtls_memory.sessions[0], 128);
    _nx_secure_dtls_session_reset(&dtls_memory.sessions[0]);
    _nx_secure_dtls_server_stop(&dtls_server);
    dtls_active_flag = 0;
    uart_tx_queuePrint_create("UDP Session Closed due to TCP Disconnect.\r\n");
  }
}