/***************************************************************************/
/* Copyright (c) 2024 Microsoft Corporation                                */
/* Copyright (c) 2026 Eclipse ThreadX contributors                         */
/*                                                                         */
/* This program and the accompanying materials are made available under    */
/* the terms of the MIT License which is available at                      */
/* https://opensource.org/licenses/MIT.                                    */
/*                                                                         */
/* SPDX-License-Identifier: MIT                                            */
/***************************************************************************/

/* This test concentrates on fragmented TLS handshake message across multiple TLS records
(e.g. when a certificate message is splitted into multiple fragments).
The Cipher Suite used was TLS_RSA_WITH_AES_128_GCM_SHA256 (0x009c). */

#include   "nx_api.h"
#include   "nx_secure_tls_api.h"
//#include   "test_ca_cert.c"
#include   "nx_secure_tls.h"
#include   "tls_test_utility.h"

extern VOID    test_control_return(UINT status);


#if !defined(NX_SECURE_TLS_CLIENT_DISABLED) && defined(NX_SECURE_ENABLE_AEAD_CIPHER) && !defined(NX_SECURE_DISABLE_X509)
#define NUM_PACKETS                 24
#define PACKET_SIZE                 1536
#define PACKET_POOL_SIZE            (NUM_PACKETS * (PACKET_SIZE + sizeof(NX_PACKET)))
#define THREAD_STACK_SIZE           1024
#define ARP_CACHE_SIZE              1024
#define METADATA_SIZE               16000
#define SERVER_PORT                 4433

#define TLS_OFFSET                  54
#define TLS_PACKET_BUFFER_SZ        60000

/* Define the ThreadX and NetX object control blocks...  */

static TX_THREAD                thread_0;
static TX_THREAD                thread_1;
static NX_PACKET_POOL           pool_0;
static NX_IP                    ip_0;
static UINT                     error_counter;

static NX_TCP_SOCKET            client_socket_0;
static NX_TCP_SOCKET            server_socket_0;
static NX_SECURE_TLS_SESSION    tls_client_session_0;
static NX_SECURE_X509_CERT      client_trusted_ca;
extern const NX_SECURE_TLS_CRYPTO
                                nx_crypto_tls_ciphers;

extern const NX_SECURE_TLS_CRYPTO nx_crypto_tls_ciphers_ecc;
extern const USHORT nx_crypto_ecc_supported_groups[];
extern const NX_CRYPTO_METHOD *nx_crypto_ecc_curves[];
extern const UINT nx_crypto_ecc_supported_groups_size;

static ULONG                    pool_0_memory[PACKET_POOL_SIZE / sizeof(ULONG)];
static ULONG                    thread_0_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
static ULONG                    thread_1_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
static ULONG                    ip_0_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
static ULONG                    arp_cache[ARP_CACHE_SIZE];
static UCHAR                    client_metadata[METADATA_SIZE];

static UCHAR                    tls_packet_buffer[TLS_PACKET_BUFFER_SZ];
static UCHAR                    remote_server_certs_buffer[(sizeof(NX_SECURE_X509_CERT) + 2000) * 3];

static UCHAR clientkeyexchange[128];

/* frame1 consists of server_hello, and certificate(fragment). */
static UCHAR frame1[] = {
  0xc8, 0x34, 0x8e, 0x43, 0xfe, 0x7b, 0x74, 0xb6,
  0xb6, 0x40, 0x93, 0x2d, 0x08, 0x00, 0x45, 0x00,
  0x05, 0x5a, 0x55, 0x62, 0x40, 0x00, 0xf0, 0x06,
  0xc2, 0xa6, 0x40, 0x27, 0x68, 0x71, 0xc0, 0xa8,
  0x04, 0x54, 0x01, 0xbb, 0x6e, 0xfa, 0x26, 0x7e,
  0x7f, 0x14, 0xa2, 0x28, 0x2a, 0xbd, 0x50, 0x18,
  0x01, 0xff, 0xe7, 0xc3, 0x00, 0x00,

  /* ServerHello */
  0x16, 0x03, 0x03, 0x00, 0x60,
  0x02, 0x00, 0x00, 0x5c, 0x03,
  0x03, 0x5f, 0xda, 0xaf, 0x70, 0xb3, 0xe8, 0x41,
  0xc7, 0x32, 0xe1, 0x41, 0xb3, 0x81, 0x9b, 0xcb,
  0x77, 0xe2, 0x77, 0x86, 0xb7, 0x7a, 0xa8, 0x25,
  0xaa, 0x13, 0x59, 0xd7, 0xf0, 0xa2, 0xff, 0x40,
  0x0b, 0x20, 0x71, 0x67, 0x3f, 0x14, 0xe0, 0x04,
  0x1f, 0x2d, 0x73, 0x4a, 0x7e, 0x5c, 0xf4, 0x90,
  0x21, 0xb6, 0x8f, 0x5f, 0x8b, 0xef, 0xd4, 0xcb,
  0xf3, 0xb6, 0xb4, 0x1d, 0x2b, 0x73, 0x0f, 0xe8,
  0xde, 0x0d, 0x00, 0x9c, 0x00, 0x00, 0x14, 0xff,
  0x01, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x0b,
  0x00, 0x09, 0x08, 0x68, 0x74, 0x74, 0x70, 0x2f,
  0x31, 0x2e, 0x31, 

  /* Certificate */
  //0x16, 0x03, 0x03, 0x0a, 0xe6,
  0x16, 0x03, 0x03, 0x04, 0xcd,
  0x0b, 0x00, 0x0a, 0xe2, 0x00,
  0x0a, 0xdf, 0x00, 0x06, 0x41, 0x30, 0x82, 0x06,
  0x3d, 0x30, 0x82, 0x05, 0x25, 0xa0, 0x03, 0x02,
  0x01, 0x02, 0x02, 0x10, 0x04, 0x5b, 0xb9, 0xf4,
  0x68, 0xcd, 0xce, 0xe0, 0x1c, 0x77, 0xa2, 0x5c,
  0x18, 0x75, 0x4f, 0x52, 0x30, 0x0d, 0x06, 0x09,
  0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
  0x0b, 0x05, 0x00, 0x30, 0x4d, 0x31, 0x0b, 0x30,
  0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02,
  0x55, 0x53, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03,
  0x55, 0x04, 0x0a, 0x13, 0x0c, 0x44, 0x69, 0x67,
  0x69, 0x43, 0x65, 0x72, 0x74, 0x20, 0x49, 0x6e,
  0x63, 0x31, 0x27, 0x30, 0x25, 0x06, 0x03, 0x55,
  0x04, 0x03, 0x13, 0x1e, 0x44, 0x69, 0x67, 0x69,
  0x43, 0x65, 0x72, 0x74, 0x20, 0x53, 0x48, 0x41,
  0x32, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65,
  0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20,
  0x43, 0x41, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30,
  0x30, 0x37, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30,
  0x30, 0x30, 0x5a, 0x17, 0x0d, 0x32, 0x31, 0x30,
  0x37, 0x32, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30,
  0x30, 0x5a, 0x30, 0x77, 0x31, 0x0b, 0x30, 0x09,
  0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55,
  0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55,
  0x04, 0x08, 0x13, 0x0a, 0x43, 0x61, 0x6c, 0x69,
  0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31, 0x14,
  0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13,
  0x0b, 0x46, 0x6f, 0x73, 0x74, 0x65, 0x72, 0x20,
  0x43, 0x69, 0x74, 0x79, 0x31, 0x15, 0x30, 0x13,
  0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0c, 0x51,
  0x75, 0x61, 0x6c, 0x79, 0x73, 0x2c, 0x20, 0x49,
  0x6e, 0x63, 0x2e, 0x31, 0x26, 0x30, 0x24, 0x06,
  0x03, 0x55, 0x04, 0x03, 0x13, 0x1d, 0x71, 0x61,
  0x67, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e,
  0x71, 0x67, 0x33, 0x2e, 0x61, 0x70, 0x70, 0x73,
  0x2e, 0x71, 0x75, 0x61, 0x6c, 0x79, 0x73, 0x2e,
  0x63, 0x6f, 0x6d, 0x30, 0x82, 0x01, 0x22, 0x30,
  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
  0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
  0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02,
  0x82, 0x01, 0x01, 0x00, 0xa7, 0x55, 0xc4, 0x0d,
  0xe2, 0xa6, 0x1d, 0xb5, 0x90, 0x2f, 0x1a, 0x0d,
  0x7e, 0x40, 0x16, 0x68, 0x00, 0xed, 0x05, 0xea,
  0x45, 0x1f, 0xc0, 0xbf, 0x1b, 0xf2, 0xd6, 0x57,
  0x70, 0x7b, 0x76, 0x91, 0x4a, 0xaf, 0xc0, 0xdf,
  0xb9, 0x5c, 0x19, 0x63, 0xda, 0x33, 0xc4, 0xb1,
  0xa5, 0xbd, 0x8c, 0xbe, 0x1c, 0xb0, 0x06, 0x89,
  0x2e, 0x3c, 0xa5, 0x39, 0xf2, 0x91, 0xf0, 0x09,
  0xfd, 0x15, 0xaa, 0x0f, 0xd3, 0x06, 0x3d, 0x3d,
  0x2e, 0x44, 0x49, 0xa4, 0x60, 0x0c, 0x74, 0xd0,
  0xd8, 0x51, 0x58, 0xed, 0xa0, 0x25, 0xae, 0xf0,
  0xf8, 0x98, 0x38, 0xeb, 0x29, 0x62, 0x0b, 0x33,
  0xa6, 0x83, 0x9b, 0x5e, 0xdf, 0x9b, 0x4e, 0x68,
  0xf3, 0x8c, 0x65, 0xa8, 0xb7, 0xa8, 0xa2, 0xa9,
  0x80, 0x0d, 0x40, 0x67, 0xd5, 0x81, 0x37, 0x06,
  0x21, 0x86, 0xc3, 0x9f, 0x19, 0x58, 0x7a, 0xc3,
  0x85, 0xf9, 0x6b, 0xc7, 0x9e, 0x5e, 0xb8, 0x3a,
  0x47, 0xce, 0xba, 0xca, 0x43, 0x66, 0xa1, 0xfc,
  0x9b, 0x5d, 0xcd, 0x10, 0x87, 0xc8, 0x10, 0x5d,
  0xd9, 0x6c, 0x91, 0xf9, 0x17, 0x8f, 0x6c, 0x15,
  0x0c, 0xaa, 0x4d, 0xd3, 0x40, 0x20, 0x79, 0x69,
  0x9e, 0x80, 0xaf, 0x9f, 0xf1, 0x6e, 0x2a, 0x76,
  0xd2, 0xaa, 0x1e, 0x33, 0x0f, 0xb6, 0x8f, 0xbd,
  0x66, 0x4e, 0xcb, 0x0a, 0xd9, 0x26, 0x64, 0x31,
  0x37, 0x7e, 0x98, 0xe5, 0x58, 0xa1, 0x36, 0xe7,
  0x6e, 0x0e, 0x61, 0xc7, 0xc9, 0xf7, 0x74, 0xf8,
  0x26, 0x76, 0xe6, 0xc7, 0x45, 0x4a, 0x5f, 0xed,
  0x65, 0x81, 0xae, 0x9a, 0x10, 0xae, 0xdc, 0xc5,
  0x45, 0x8c, 0x8f, 0xf4, 0x7c, 0x27, 0xcf, 0xdc,
  0x2f, 0xc8, 0xea, 0x19, 0x50, 0xa7, 0x03, 0x80,
  0xd3, 0x83, 0x0b, 0x66, 0x90, 0xc6, 0xe2, 0xa2,
  0x38, 0xd4, 0xc8, 0xe4, 0x90, 0x68, 0x2a, 0x37,
  0x41, 0x16, 0x0c, 0x79, 0x02, 0x03, 0x01, 0x00,
  0x01, 0xa3, 0x82, 0x02, 0xed, 0x30, 0x82, 0x02,
  0xe9, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
  0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x0f, 0x80,
  0x61, 0x1c, 0x82, 0x31, 0x61, 0xd5, 0x2f, 0x28,
  0xe7, 0x8d, 0x46, 0x38, 0xb4, 0x2c, 0xe1, 0xc6,
  0xd9, 0xe2, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d,
  0x0e, 0x04, 0x16, 0x04, 0x14, 0xf5, 0x81, 0x28,
  0x67, 0xfc, 0x26, 0x1e, 0x75, 0xf0, 0x95, 0x76,
  0x3f, 0xbb, 0x1a, 0xcf, 0x5f, 0x72, 0xf5, 0x51,
  0x86, 0x30, 0x28, 0x06, 0x03, 0x55, 0x1d, 0x11,
  0x04, 0x21, 0x30, 0x1f, 0x82, 0x1d, 0x71, 0x61,
  0x67, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e,
  0x71, 0x67, 0x33, 0x2e, 0x61, 0x70, 0x70, 0x73,
  0x2e, 0x71, 0x75, 0x61, 0x6c, 0x79, 0x73, 0x2e,
  0x63, 0x6f, 0x6d, 0x30, 0x0e, 0x06, 0x03, 0x55,
  0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03,
  0x02, 0x05, 0xa0, 0x30, 0x1d, 0x06, 0x03, 0x55,
  0x1d, 0x25, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08,
  0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01,
  0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07,
  0x03, 0x02, 0x30, 0x6b, 0x06, 0x03, 0x55, 0x1d,
  0x1f, 0x04, 0x64, 0x30, 0x62, 0x30, 0x2f, 0xa0,
  0x2d, 0xa0, 0x2b, 0x86, 0x29, 0x68, 0x74, 0x74,
  0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x72, 0x6c, 0x33,
  0x2e, 0x64, 0x69, 0x67, 0x69, 0x63, 0x65, 0x72,
  0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x73,
  0x63, 0x61, 0x2d, 0x73, 0x68, 0x61, 0x32, 0x2d,
  0x67, 0x36, 0x2e, 0x63, 0x72, 0x6c, 0x30, 0x2f,
  0xa0, 0x2d, 0xa0, 0x2b, 0x86, 0x29, 0x68, 0x74,
  0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x72, 0x6c,
  0x34, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63, 0x65,
  0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73,
  0x73, 0x63, 0x61, 0x2d, 0x73, 0x68, 0x61, 0x32,
  0x2d, 0x67, 0x36, 0x2e, 0x63, 0x72, 0x6c, 0x30,
  0x4c, 0x06, 0x03, 0x55, 0x1d, 0x20, 0x04, 0x45,
  0x30, 0x43, 0x30, 0x37, 0x06, 0x09, 0x60, 0x86,
  0x48, 0x01, 0x86, 0xfd, 0x6c, 0x01, 0x01, 0x30,
  0x2a, 0x30, 0x28, 0x06, 0x08, 0x2b, 0x06, 0x01,
  0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1c, 0x68,
  0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77,
  0x77, 0x77, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63,
  0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
  0x43, 0x50, 0x53, 0x30, 0x08, 0x06, 0x06, 0x67,
  0x81, 0x0c, 0x01, 0x02, 0x02, 0x30, 0x7c, 0x06,
  0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01,
  0x01, 0x04, 0x70, 0x30, 0x6e, 0x30, 0x24, 0x06,
  0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30,
  0x01, 0x86, 0x18, 0x68, 0x74, 0x74, 0x70, 0x3a,
  0x2f, 0x2f, 0x6f, 0x63, 0x73, 0x70, 0x2e, 0x64,
  0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e,
  0x63, 0x6f, 0x6d, 0x30, 0x46, 0x06, 0x08, 0x2b,
  0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86,
  0x3a, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
  0x63, 0x61, 0x63, 0x65, 0x72, 0x74, 0x73, 0x2e,
  0x64, 0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74,
  0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x44, 0x69, 0x67,
  0x69, 0x43, 0x65, 0x72, 0x74, 0x53, 0x48, 0x41,
  0x32, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x53,
  0x65, 0x72, 0x76, 0x65, 0x72, 0x43, 0x41, 0x2e,
  0x63, 0x72, 0x74, 0x30, 0x0c, 0x06, 0x03, 0x55,
  0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30,
  0x00, 0x30, 0x82, 0x01, 0x05, 0x06, 0x0a, 0x2b,
  0x06, 0x01, 0x04, 0x01, 0xd6, 0x79, 0x02, 0x04,
  0x02, 0x04, 0x81, 0xf6, 0x04, 0x81, 0xf3, 0x00,
  0xf1, 0x00, 0x76, 0x00, 0xf6, 0x5c, 0x94, 0x2f,
  0xd1, 0x77, 0x30, 0x22, 0x14, 0x54, 0x18, 0x08,
  0x30, 0x94, 0x56, 0x8e, 0xe3, 0x4d, 0x13, 0x19,
  0x33, 0xbf, 0xdf, 0x0c, 0x2f, 0x20, 0x0b, 0xcc,
  0x4e, 0xf1, 0x64, 0xe3, 0x00, 0x00, 0x01, 0x73,
  0x5d, 0x09, 0x0b, 0xa5, 0x00, 0x00, 0x04, 0x03,
  0x00, 0x47, 0x30, 0x45, 0x02, 0x20, 0x25, 0x8f,
  0x35, 0xa6, 0x9b, 0x78, 0x3c, 0x92, 0x7c, 0xaf,
  0xc3, 0x5e, 0xaf, 0xb6, 0x8f, 0x5f, 0x37, 0x2e,
  0x6b, 0xaa, 0x7c, 0x5f, 0x20, 0xf1, 0x5b, 0x36,
  0x4e, 0xf1, 0x2b, 0xfe, 0x02, 0xf0, 0x02, 0x21,
  0x00, 0xb7, 0x66, 0x09, 0xdc, 0xc3, 0x41, 0x56,
  0xc2, 0x19, 0x12, 0x5b, 0x0d, 0xd8, 0xd8, 0x0d,
  0x49, 0x0b, 0x25, 0x8f, 0x81, 0xda, 0x5d, 0xf4,
  0x73, 0xd1, 0xe3, 0xa4, 0x6b, 0xfd, 0x72, 0xbc,
  0x0e, 0x00, 0x77, 0x00, 0x5c, 0xdc, 0x43, 0x92,
  0xfe, 0xe6, 0xab, 0x45, 0x44, 0xb1, 0x5e, 0x9a
};

UINT frame1_len = 1389;

/* Frame 2 consists of certificate(continuation). */
static UCHAR frame2[] = {
  0xc8, 0x34, 0x8e, 0x43, 0xfe, 0x7b, 0x74, 0xb6,
  0xb6, 0x40, 0x93, 0x2d, 0x08, 0x00, 0x45, 0x00,
  0x05, 0x5a, 0x55, 0x64, 0x40, 0x00, 0xf0, 0x06,
  0xc2, 0xa4, 0x40, 0x27, 0x68, 0x71, 0xc0, 0xa8,
  0x04, 0x54, 0x01, 0xbb, 0x6e, 0xfa, 0x26, 0x7e,
  0x84, 0x46, 0xa2, 0x28, 0x2a, 0xbd, 0x50, 0x18,
  0x01, 0xff, 0x5b, 0xb9, 0x00, 0x00,
  
  0x16, 0x03, 0x03, 0x06, 0x19,
  
  0xd4, 0x56,
  0xe6, 0x10, 0x37, 0xfb, 0xd5, 0xfa, 0x47, 0xdc,
  0xa1, 0x73, 0x94, 0xb2, 0x5e, 0xe6, 0xf6, 0xc7,
  0x0e, 0xca, 0x00, 0x00, 0x01, 0x73, 0x5d, 0x09,
  0x0b, 0x57, 0x00, 0x00, 0x04, 0x03, 0x00, 0x48,
  0x30, 0x46, 0x02, 0x21, 0x00, 0xc7, 0xc7, 0x1d,
  0x39, 0x95, 0x0f, 0x89, 0x9c, 0x10, 0x24, 0x53,
  0x8c, 0xbb, 0x36, 0x90, 0x71, 0xd5, 0x57, 0x2f,
  0xf1, 0xce, 0xd2, 0x97, 0xd0, 0xaf, 0xfb, 0x9e,
  0x45, 0x24, 0x8a, 0xd4, 0x4b, 0x02, 0x21, 0x00,
  0xae, 0x3b, 0x45, 0x00, 0x81, 0x5b, 0x6e, 0x4c,
  0xf9, 0x2c, 0x34, 0x40, 0x29, 0x53, 0xba, 0xaf,
  0x9e, 0xdf, 0x71, 0xfb, 0xd9, 0x5c, 0xd4, 0xf2,
  0xe2, 0xc7, 0xb2, 0x39, 0xec, 0x25, 0xb3, 0x5b,
  0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
  0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03,
  0x82, 0x01, 0x01, 0x00, 0x47, 0x62, 0xf5, 0x4b,
  0xb2, 0xd4, 0x5b, 0x1a, 0x54, 0xf0, 0x77, 0xd2,
  0xad, 0xdc, 0xf5, 0x39, 0x22, 0x75, 0xc8, 0xb0,
  0x61, 0x38, 0x7f, 0x68, 0x3d, 0x40, 0xa3, 0xc3,
  0xc8, 0x9c, 0xe9, 0x57, 0x64, 0x78, 0x56, 0xad,
  0x87, 0x48, 0x07, 0x5c, 0x6c, 0xd5, 0xc1, 0xde,
  0x71, 0xc1, 0xa3, 0xd7, 0xc6, 0x42, 0x6e, 0x4c,
  0xf3, 0xd7, 0x9a, 0xd2, 0xe2, 0x03, 0xf6, 0x31,
  0xa3, 0x14, 0x6f, 0xd8, 0x1d, 0xa4, 0x26, 0xc0,
  0xc4, 0xb8, 0x6d, 0x4a, 0xe0, 0x61, 0x64, 0x02,
  0x11, 0xd0, 0x0d, 0xb0, 0xf5, 0x26, 0xe1, 0xd6,
  0x9d, 0x05, 0x3a, 0x7c, 0x21, 0xcc, 0xba, 0xe6,
  0x43, 0x3a, 0x06, 0xd2, 0x02, 0x94, 0x9d, 0xc9,
  0x25, 0x6b, 0xe9, 0xb6, 0xff, 0xa1, 0x90, 0x57,
  0xfe, 0x03, 0x39, 0x96, 0xe5, 0x32, 0x94, 0xdf,
  0x96, 0x1c, 0x2e, 0xc6, 0xb1, 0xfa, 0x79, 0x46,
  0x0c, 0xe9, 0x8d, 0x45, 0x98, 0x5c, 0x00, 0xe3,
  0xe8, 0x07, 0x09, 0x7d, 0xbb, 0xca, 0x53, 0x63,
  0x41, 0x91, 0x71, 0x67, 0x27, 0x79, 0x82, 0xb7,
  0x8b, 0x53, 0x2e, 0x60, 0x3b, 0xd1, 0x26, 0x30,
  0x53, 0xde, 0x58, 0x66, 0x0d, 0x69, 0x5b, 0x4b,
  0xd1, 0x0f, 0xf4, 0xc4, 0xce, 0x3f, 0xa8, 0xdc,
  0xcb, 0x3e, 0xbf, 0x36, 0xf4, 0x83, 0x31, 0x48,
  0xa1, 0x52, 0x9d, 0xdb, 0xb7, 0xd3, 0xdd, 0x61,
  0x48, 0x13, 0xa7, 0x43, 0xaa, 0xde, 0x6b, 0x22,
  0x89, 0x1b, 0xa2, 0x4b, 0xb2, 0x91, 0xde, 0xa3,
  0xe8, 0x3f, 0x1e, 0xd7, 0x06, 0x22, 0x15, 0x3e,
  0x85, 0x74, 0x48, 0x67, 0x33, 0x3f, 0x16, 0x11,
  0xf9, 0x8b, 0x64, 0x17, 0x83, 0x7a, 0x3e, 0xcb,
  0x8f, 0xae, 0x07, 0xa3, 0x6a, 0x77, 0xa2, 0x7b,
  0x33, 0x5a, 0xe3, 0xde, 0xa6, 0xad, 0x33, 0x45,
  0x0c, 0x52, 0xb7, 0x94, 0xd7, 0x91, 0xc4, 0x31,
  0xbf, 0x33, 0xfb, 0xd7, 0x00, 0x04, 0x98, 0x30,
  0x82, 0x04, 0x94, 0x30, 0x82, 0x03, 0x7c, 0xa0,
  0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x01, 0xfd,
  0xa3, 0xeb, 0x6e, 0xca, 0x75, 0xc8, 0x88, 0x43,
  0x8b, 0x72, 0x4b, 0xcf, 0xbc, 0x91, 0x30, 0x0d,
  0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
  0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x61, 0x31,
  0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06,
  0x13, 0x02, 0x55, 0x53, 0x31, 0x15, 0x30, 0x13,
  0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0c, 0x44,
  0x69, 0x67, 0x69, 0x43, 0x65, 0x72, 0x74, 0x20,
  0x49, 0x6e, 0x63, 0x31, 0x19, 0x30, 0x17, 0x06,
  0x03, 0x55, 0x04, 0x0b, 0x13, 0x10, 0x77, 0x77,
  0x77, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63, 0x65,
  0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x20,
  0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
  0x17, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72,
  0x74, 0x20, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c,
  0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41,
  0x30, 0x1e, 0x17, 0x0d, 0x31, 0x33, 0x30, 0x33,
  0x30, 0x38, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30,
  0x5a, 0x17, 0x0d, 0x32, 0x33, 0x30, 0x33, 0x30,
  0x38, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x5a,
  0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03,
  0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31,
  0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a,
  0x13, 0x0c, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65,
  0x72, 0x74, 0x20, 0x49, 0x6e, 0x63, 0x31, 0x27,
  0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
  0x1e, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72,
  0x74, 0x20, 0x53, 0x48, 0x41, 0x32, 0x20, 0x53,
  0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x53, 0x65,
  0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x41, 0x30,
  0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a,
  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
  0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30,
  0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00,
  0xdc, 0xae, 0x58, 0x90, 0x4d, 0xc1, 0xc4, 0x30,
  0x15, 0x90, 0x35, 0x5b, 0x6e, 0x3c, 0x82, 0x15,
  0xf5, 0x2c, 0x5c, 0xbd, 0xe3, 0xdb, 0xff, 0x71,
  0x43, 0xfa, 0x64, 0x25, 0x80, 0xd4, 0xee, 0x18,
  0xa2, 0x4d, 0xf0, 0x66, 0xd0, 0x0a, 0x73, 0x6e,
  0x11, 0x98, 0x36, 0x17, 0x64, 0xaf, 0x37, 0x9d,
  0xfd, 0xfa, 0x41, 0x84, 0xaf, 0xc7, 0xaf, 0x8c,
  0xfe, 0x1a, 0x73, 0x4d, 0xcf, 0x33, 0x97, 0x90,
  0xa2, 0x96, 0x87, 0x53, 0x83, 0x2b, 0xb9, 0xa6,
  0x75, 0x48, 0x2d, 0x1d, 0x56, 0x37, 0x7b, 0xda,
  0x31, 0x32, 0x1a, 0xd7, 0xac, 0xab, 0x06, 0xf4,
  0xaa, 0x5d, 0x4b, 0xb7, 0x47, 0x46, 0xdd, 0x2a,
  0x93, 0xc3, 0x90, 0x2e, 0x79, 0x80, 0x80, 0xef,
  0x13, 0x04, 0x6a, 0x14, 0x3b, 0xb5, 0x9b, 0x92,
  0xbe, 0xc2, 0x07, 0x65, 0x4e, 0xfc, 0xda, 0xfc,
  0xff, 0x7a, 0xae, 0xdc, 0x5c, 0x7e, 0x55, 0x31,
  0x0c, 0xe8, 0x39, 0x07, 0xa4, 0xd7, 0xbe, 0x2f,
  0xd3, 0x0b, 0x6a, 0xd2, 0xb1, 0xdf, 0x5f, 0xfe,
  0x57, 0x74, 0x53, 0x3b, 0x35, 0x80, 0xdd, 0xae,
  0x8e, 0x44, 0x98, 0xb3, 0x9f, 0x0e, 0xd3, 0xda,
  0xe0, 0xd7, 0xf4, 0x6b, 0x29, 0xab, 0x44, 0xa7,
  0x4b, 0x58, 0x84, 0x6d, 0x92, 0x4b, 0x81, 0xc3,
  0xda, 0x73, 0x8b, 0x12, 0x97, 0x48, 0x90, 0x04,
  0x45, 0x75, 0x1a, 0xdd, 0x37, 0x31, 0x97, 0x92,
  0xe8, 0xcd, 0x54, 0x0d, 0x3b, 0xe4, 0xc1, 0x3f,
  0x39, 0x5e, 0x2e, 0xb8, 0xf3, 0x5c, 0x7e, 0x10,
  0x8e, 0x86, 0x41, 0x00, 0x8d, 0x45, 0x66, 0x47,
  0xb0, 0xa1, 0x65, 0xce, 0xa0, 0xaa, 0x29, 0x09,
  0x4e, 0xf3, 0x97, 0xeb, 0xe8, 0x2e, 0xab, 0x0f,
  0x72, 0xa7, 0x30, 0x0e, 0xfa, 0xc7, 0xf4, 0xfd,
  0x14, 0x77, 0xc3, 0xa4, 0x5b, 0x28, 0x57, 0xc2,
  0xb3, 0xf9, 0x82, 0xfd, 0xb7, 0x45, 0x58, 0x9b,
  0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01,
  0x5a, 0x30, 0x82, 0x01, 0x56, 0x30, 0x12, 0x06,
  0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
  0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01,
  0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f,
  0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01,
  0x86, 0x30, 0x34, 0x06, 0x08, 0x2b, 0x06, 0x01,
  0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x28, 0x30,
  0x26, 0x30, 0x24, 0x06, 0x08, 0x2b, 0x06, 0x01,
  0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x18, 0x68,
  0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x63,
  0x73, 0x70, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63,
  0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x30,
  0x7b, 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x74,
  0x30, 0x72, 0x30, 0x37, 0xa0, 0x35, 0xa0, 0x33,
  0x86, 0x31, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
  0x2f, 0x63, 0x72, 0x6c, 0x33, 0x2e, 0x64, 0x69,
  0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e, 0x63,
  0x6f, 0x6d, 0x2f, 0x44, 0x69, 0x67, 0x69, 0x43,
  0x65, 0x72, 0x74, 0x47, 0x6c, 0x6f, 0x62, 0x61,
  0x6c, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x41, 0x2e,
  0x63, 0x72, 0x6c, 0x30, 0x37, 0xa0, 0x35, 0xa0,
  0x33, 0x86, 0x31, 0x68, 0x74, 0x74, 0x70, 0x3a,
  0x2f, 0x2f, 0x63, 0x72, 0x6c, 0x34, 0x2e, 0x64,
  0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e,
  0x63, 0x6f, 0x6d, 0x2f, 0x44, 0x69, 0x67, 0x69,
  0x43, 0x65, 0x72, 0x74, 0x47, 0x6c, 0x6f, 0x62,
  0x61, 0x6c, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x41,
  0x2e, 0x63, 0x72, 0x6c, 0x30, 0x3d, 0x06, 0x03,
  0x55, 0x1d, 0x20, 0x04, 0x36, 0x30, 0x34, 0x30,
  0x32, 0x06, 0x04, 0x55, 0x1d, 0x20, 0x00, 0x30,
  0x2a, 0x30, 0x28, 0x06, 0x08, 0x2b, 0x06, 0x01,
  0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1c, 0x68,
  0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77,
  0x77, 0x77, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63,
  0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
  0x43, 0x50, 0x53, 0x30, 0x1d, 0x06, 0x03, 0x55,
  0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x0f, 0x80,
  0x61, 0x1c, 0x82, 0x31, 0x61, 0xd5, 0x2f, 0x28,
  0xe7, 0x8d, 0x46, 0x38, 0xb4, 0x2c, 0xe1, 0xc6,
  0xd9, 0xe2, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d,
  0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x03,
  0xde, 0x50, 0x35, 0x56, 0xd1, 0x4c, 0xbb, 0x66,
  0xf0, 0xa3, 0xe2, 0x1b, 0x1b, 0xc3, 0x97, 0xb2,
  0x3d, 0xd1, 0x55, 0x30, 0x0d, 0x06, 0x09, 0x2a,
  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
  0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x23,
  0x3e, 0xdf, 0x4b, 0xd2, 0x31, 0x42, 0xa5, 0xb6,
  0x7e, 0x42, 0x5c, 0x1a, 0x44, 0xcc, 0x69, 0xd1,
  0x68, 0xb4, 0x5d, 0x4b, 0xe0, 0x04, 0x21, 0x6c
};
unsigned int frame2_len = 1389;

/* Frame 3 consists of certificate(continuation), server_hello_done. */
static UCHAR frame3[] = {
  0xc8, 0x34, 0x8e, 0x43, 0xfe, 0x7b, 0x74, 0xb6,
  0xb6, 0x40, 0x93, 0x2d, 0x08, 0x00, 0x45, 0x00,
  0x01, 0x13, 0x55, 0x66, 0x40, 0x00, 0xf0, 0x06,
  0xc6, 0xe9, 0x40, 0x27, 0x68, 0x71, 0xc0, 0xa8,
  0x04, 0x54, 0x01, 0xbb, 0x6e, 0xfa, 0x26, 0x7e,
  0x89, 0x78, 0xa2, 0x28, 0x2a, 0xbd, 0x50, 0x18,
  0x01, 0xff, 0x9a, 0x1f, 0x00, 0x00,

  0x4b, 0xe2,
  0x6d, 0xcc, 0xb1, 0xe0, 0x97, 0x8f, 0xa6, 0x53,
  0x09, 0xcd, 0xaa, 0x2a, 0x65, 0xe5, 0x39, 0x4f,
  0x1e, 0x83, 0xa5, 0x6e, 0x5c, 0x98, 0xa2, 0x24,
  0x26, 0xe6, 0xfb, 0xa1, 0xed, 0x93, 0xc7, 0x2e,
  0x02, 0xc6, 0x4d, 0x4a, 0xbf, 0xb0, 0x42, 0xdf,
  0x78, 0xda, 0xb3, 0xa8, 0xf9, 0x6d, 0xff, 0x21,
  0x85, 0x53, 0x36, 0x60, 0x4c, 0x76, 0xce, 0xec,
  0x38, 0xdc, 0xd6, 0x51, 0x80, 0xf0, 0xc5, 0xd6,
  0xe5, 0xd4, 0x4d, 0x27, 0x64, 0xab, 0x9b, 0xc7,
  0x3e, 0x71, 0xfb, 0x48, 0x97, 0xb8, 0x33, 0x6d,
  0xc9, 0x13, 0x07, 0xee, 0x96, 0xa2, 0x1b, 0x18,
  0x15, 0xf6, 0x5c, 0x4c, 0x40, 0xed, 0xb3, 0xc2,
  0xec, 0xff, 0x71, 0xc1, 0xe3, 0x47, 0xff, 0xd4,
  0xb9, 0x00, 0xb4, 0x37, 0x42, 0xda, 0x20, 0xc9,
  0xea, 0x6e, 0x8a, 0xee, 0x14, 0x06, 0xae, 0x7d,
  0xa2, 0x59, 0x98, 0x88, 0xa8, 0x1b, 0x6f, 0x2d,
  0xf4, 0xf2, 0xc9, 0x14, 0x5f, 0x26, 0xcf, 0x2c,
  0x8d, 0x7e, 0xed, 0x37, 0xc0, 0xa9, 0xd5, 0x39,
  0xb9, 0x82, 0xbf, 0x19, 0x0c, 0xea, 0x34, 0xaf,
  0x00, 0x21, 0x68, 0xf8, 0xad, 0x73, 0xe2, 0xc9,
  0x32, 0xda, 0x38, 0x25, 0x0b, 0x55, 0xd3, 0x9a,
  0x1d, 0xf0, 0x68, 0x86, 0xed, 0x2e, 0x41, 0x34,
  0xef, 0x7c, 0xa5, 0x50, 0x1d, 0xbf, 0x3a, 0xf9,
  0xd3, 0xc1, 0x08, 0x0c, 0xe6, 0xed, 0x1e, 0x8a,
  0x58, 0x25, 0xe4, 0xb8, 0x77, 0xad, 0x2d, 0x6e,
  0xf5, 0x52, 0xdd, 0xb4, 0x74, 0x8f, 0xab, 0x49,
  0x2e, 0x9d, 0x3b, 0x93, 0x34, 0x28, 0x1f, 0x78,
  0xce, 0x94, 0xea, 0xc7, 0xbd, 0xd3, 0xc9, 0x6d,
  0x1c, 0xde, 0x5c, 0x32, 0xf3,

  /* Server Hello Done */
  0x16, 0x03, 0x03, 0x00, 0x04, 0x0e, 0x00, 0x00,
  0x00
};
unsigned int frame3_len = 294;

char ca_cert_der[] = {
  0x30, 0x82, 0x04, 0x94, 0x30, 0x82, 0x03, 0x7c,
  0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0x01,
  0xfd, 0xa3, 0xeb, 0x6e, 0xca, 0x75, 0xc8, 0x88,
  0x43, 0x8b, 0x72, 0x4b, 0xcf, 0xbc, 0x91, 0x30,
  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
  0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x61,
  0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
  0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x15, 0x30,
  0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0c,
  0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72, 0x74,
  0x20, 0x49, 0x6e, 0x63, 0x31, 0x19, 0x30, 0x17,
  0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x10, 0x77,
  0x77, 0x77, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63,
  0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x31,
  0x20, 0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, 0x03,
  0x13, 0x17, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65,
  0x72, 0x74, 0x20, 0x47, 0x6c, 0x6f, 0x62, 0x61,
  0x6c, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43,
  0x41, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x33, 0x30,
  0x33, 0x30, 0x38, 0x31, 0x32, 0x30, 0x30, 0x30,
  0x30, 0x5a, 0x17, 0x0d, 0x32, 0x33, 0x30, 0x33,
  0x30, 0x38, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30,
  0x5a, 0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06,
  0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53,
  0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04,
  0x0a, 0x13, 0x0c, 0x44, 0x69, 0x67, 0x69, 0x43,
  0x65, 0x72, 0x74, 0x20, 0x49, 0x6e, 0x63, 0x31,
  0x27, 0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03,
  0x13, 0x1e, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65,
  0x72, 0x74, 0x20, 0x53, 0x48, 0x41, 0x32, 0x20,
  0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x53,
  0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x41,
  0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09,
  0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
  0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00,
  0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
  0x00, 0xdc, 0xae, 0x58, 0x90, 0x4d, 0xc1, 0xc4,
  0x30, 0x15, 0x90, 0x35, 0x5b, 0x6e, 0x3c, 0x82,
  0x15, 0xf5, 0x2c, 0x5c, 0xbd, 0xe3, 0xdb, 0xff,
  0x71, 0x43, 0xfa, 0x64, 0x25, 0x80, 0xd4, 0xee,
  0x18, 0xa2, 0x4d, 0xf0, 0x66, 0xd0, 0x0a, 0x73,
  0x6e, 0x11, 0x98, 0x36, 0x17, 0x64, 0xaf, 0x37,
  0x9d, 0xfd, 0xfa, 0x41, 0x84, 0xaf, 0xc7, 0xaf,
  0x8c, 0xfe, 0x1a, 0x73, 0x4d, 0xcf, 0x33, 0x97,
  0x90, 0xa2, 0x96, 0x87, 0x53, 0x83, 0x2b, 0xb9,
  0xa6, 0x75, 0x48, 0x2d, 0x1d, 0x56, 0x37, 0x7b,
  0xda, 0x31, 0x32, 0x1a, 0xd7, 0xac, 0xab, 0x06,
  0xf4, 0xaa, 0x5d, 0x4b, 0xb7, 0x47, 0x46, 0xdd,
  0x2a, 0x93, 0xc3, 0x90, 0x2e, 0x79, 0x80, 0x80,
  0xef, 0x13, 0x04, 0x6a, 0x14, 0x3b, 0xb5, 0x9b,
  0x92, 0xbe, 0xc2, 0x07, 0x65, 0x4e, 0xfc, 0xda,
  0xfc, 0xff, 0x7a, 0xae, 0xdc, 0x5c, 0x7e, 0x55,
  0x31, 0x0c, 0xe8, 0x39, 0x07, 0xa4, 0xd7, 0xbe,
  0x2f, 0xd3, 0x0b, 0x6a, 0xd2, 0xb1, 0xdf, 0x5f,
  0xfe, 0x57, 0x74, 0x53, 0x3b, 0x35, 0x80, 0xdd,
  0xae, 0x8e, 0x44, 0x98, 0xb3, 0x9f, 0x0e, 0xd3,
  0xda, 0xe0, 0xd7, 0xf4, 0x6b, 0x29, 0xab, 0x44,
  0xa7, 0x4b, 0x58, 0x84, 0x6d, 0x92, 0x4b, 0x81,
  0xc3, 0xda, 0x73, 0x8b, 0x12, 0x97, 0x48, 0x90,
  0x04, 0x45, 0x75, 0x1a, 0xdd, 0x37, 0x31, 0x97,
  0x92, 0xe8, 0xcd, 0x54, 0x0d, 0x3b, 0xe4, 0xc1,
  0x3f, 0x39, 0x5e, 0x2e, 0xb8, 0xf3, 0x5c, 0x7e,
  0x10, 0x8e, 0x86, 0x41, 0x00, 0x8d, 0x45, 0x66,
  0x47, 0xb0, 0xa1, 0x65, 0xce, 0xa0, 0xaa, 0x29,
  0x09, 0x4e, 0xf3, 0x97, 0xeb, 0xe8, 0x2e, 0xab,
  0x0f, 0x72, 0xa7, 0x30, 0x0e, 0xfa, 0xc7, 0xf4,
  0xfd, 0x14, 0x77, 0xc3, 0xa4, 0x5b, 0x28, 0x57,
  0xc2, 0xb3, 0xf9, 0x82, 0xfd, 0xb7, 0x45, 0x58,
  0x9b, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82,
  0x01, 0x5a, 0x30, 0x82, 0x01, 0x56, 0x30, 0x12,
  0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff,
  0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02,
  0x01, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d,
  0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02,
  0x01, 0x86, 0x30, 0x34, 0x06, 0x08, 0x2b, 0x06,
  0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x28,
  0x30, 0x26, 0x30, 0x24, 0x06, 0x08, 0x2b, 0x06,
  0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x18,
  0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6f,
  0x63, 0x73, 0x70, 0x2e, 0x64, 0x69, 0x67, 0x69,
  0x63, 0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d,
  0x30, 0x7b, 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04,
  0x74, 0x30, 0x72, 0x30, 0x37, 0xa0, 0x35, 0xa0,
  0x33, 0x86, 0x31, 0x68, 0x74, 0x74, 0x70, 0x3a,
  0x2f, 0x2f, 0x63, 0x72, 0x6c, 0x33, 0x2e, 0x64,
  0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e,
  0x63, 0x6f, 0x6d, 0x2f, 0x44, 0x69, 0x67, 0x69,
  0x43, 0x65, 0x72, 0x74, 0x47, 0x6c, 0x6f, 0x62,
  0x61, 0x6c, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x41,
  0x2e, 0x63, 0x72, 0x6c, 0x30, 0x37, 0xa0, 0x35,
  0xa0, 0x33, 0x86, 0x31, 0x68, 0x74, 0x74, 0x70,
  0x3a, 0x2f, 0x2f, 0x63, 0x72, 0x6c, 0x34, 0x2e,
  0x64, 0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74,
  0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x44, 0x69, 0x67,
  0x69, 0x43, 0x65, 0x72, 0x74, 0x47, 0x6c, 0x6f,
  0x62, 0x61, 0x6c, 0x52, 0x6f, 0x6f, 0x74, 0x43,
  0x41, 0x2e, 0x63, 0x72, 0x6c, 0x30, 0x3d, 0x06,
  0x03, 0x55, 0x1d, 0x20, 0x04, 0x36, 0x30, 0x34,
  0x30, 0x32, 0x06, 0x04, 0x55, 0x1d, 0x20, 0x00,
  0x30, 0x2a, 0x30, 0x28, 0x06, 0x08, 0x2b, 0x06,
  0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1c,
  0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f,
  0x77, 0x77, 0x77, 0x2e, 0x64, 0x69, 0x67, 0x69,
  0x63, 0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f, 0x6d,
  0x2f, 0x43, 0x50, 0x53, 0x30, 0x1d, 0x06, 0x03,
  0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x0f,
  0x80, 0x61, 0x1c, 0x82, 0x31, 0x61, 0xd5, 0x2f,
  0x28, 0xe7, 0x8d, 0x46, 0x38, 0xb4, 0x2c, 0xe1,
  0xc6, 0xd9, 0xe2, 0x30, 0x1f, 0x06, 0x03, 0x55,
  0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
  0x03, 0xde, 0x50, 0x35, 0x56, 0xd1, 0x4c, 0xbb,
  0x66, 0xf0, 0xa3, 0xe2, 0x1b, 0x1b, 0xc3, 0x97,
  0xb2, 0x3d, 0xd1, 0x55, 0x30, 0x0d, 0x06, 0x09,
  0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
  0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00,
  0x23, 0x3e, 0xdf, 0x4b, 0xd2, 0x31, 0x42, 0xa5,
  0xb6, 0x7e, 0x42, 0x5c, 0x1a, 0x44, 0xcc, 0x69,
  0xd1, 0x68, 0xb4, 0x5d, 0x4b, 0xe0, 0x04, 0x21,
  0x6c, 0x4b, 0xe2, 0x6d, 0xcc, 0xb1, 0xe0, 0x97,
  0x8f, 0xa6, 0x53, 0x09, 0xcd, 0xaa, 0x2a, 0x65,
  0xe5, 0x39, 0x4f, 0x1e, 0x83, 0xa5, 0x6e, 0x5c,
  0x98, 0xa2, 0x24, 0x26, 0xe6, 0xfb, 0xa1, 0xed,
  0x93, 0xc7, 0x2e, 0x02, 0xc6, 0x4d, 0x4a, 0xbf,
  0xb0, 0x42, 0xdf, 0x78, 0xda, 0xb3, 0xa8, 0xf9,
  0x6d, 0xff, 0x21, 0x85, 0x53, 0x36, 0x60, 0x4c,
  0x76, 0xce, 0xec, 0x38, 0xdc, 0xd6, 0x51, 0x80,
  0xf0, 0xc5, 0xd6, 0xe5, 0xd4, 0x4d, 0x27, 0x64,
  0xab, 0x9b, 0xc7, 0x3e, 0x71, 0xfb, 0x48, 0x97,
  0xb8, 0x33, 0x6d, 0xc9, 0x13, 0x07, 0xee, 0x96,
  0xa2, 0x1b, 0x18, 0x15, 0xf6, 0x5c, 0x4c, 0x40,
  0xed, 0xb3, 0xc2, 0xec, 0xff, 0x71, 0xc1, 0xe3,
  0x47, 0xff, 0xd4, 0xb9, 0x00, 0xb4, 0x37, 0x42,
  0xda, 0x20, 0xc9, 0xea, 0x6e, 0x8a, 0xee, 0x14,
  0x06, 0xae, 0x7d, 0xa2, 0x59, 0x98, 0x88, 0xa8,
  0x1b, 0x6f, 0x2d, 0xf4, 0xf2, 0xc9, 0x14, 0x5f,
  0x26, 0xcf, 0x2c, 0x8d, 0x7e, 0xed, 0x37, 0xc0,
  0xa9, 0xd5, 0x39, 0xb9, 0x82, 0xbf, 0x19, 0x0c,
  0xea, 0x34, 0xaf, 0x00, 0x21, 0x68, 0xf8, 0xad,
  0x73, 0xe2, 0xc9, 0x32, 0xda, 0x38, 0x25, 0x0b,
  0x55, 0xd3, 0x9a, 0x1d, 0xf0, 0x68, 0x86, 0xed,
  0x2e, 0x41, 0x34, 0xef, 0x7c, 0xa5, 0x50, 0x1d,
  0xbf, 0x3a, 0xf9, 0xd3, 0xc1, 0x08, 0x0c, 0xe6,
  0xed, 0x1e, 0x8a, 0x58, 0x25, 0xe4, 0xb8, 0x77,
  0xad, 0x2d, 0x6e, 0xf5, 0x52, 0xdd, 0xb4, 0x74,
  0x8f, 0xab, 0x49, 0x2e, 0x9d, 0x3b, 0x93, 0x34,
  0x28, 0x1f, 0x78, 0xce, 0x94, 0xea, 0xc7, 0xbd,
  0xd3, 0xc9, 0x6d, 0x1c, 0xde, 0x5c, 0x32, 0xf3
};
unsigned int ca_cert_der_len = 1176;

static UCHAR  client_random_bytes[] = {
  0x5f, 0xda, 0xae, 0xf0, 0x23, 0x33, 0xa9, 0x53,
  0xaf, 0xe1, 0xbd, 0x43, 0x18, 0x3b, 0x71, 0x9a,
  0x9b, 0x27, 0x2f, 0x4b, 0x00, 0x3b, 0x78, 0x6e,
  0x45, 0x34, 0x9e, 0xfd, 0x4b, 0x2f, 0xad, 0xde
};
unsigned int client_random_bytes_len = 32;

/* Define thread prototypes.  */
static VOID    ntest_0_entry(ULONG thread_input);
static VOID    ntest_1_entry(ULONG thread_input);
extern VOID    _nx_ram_network_driver_1500(struct NX_IP_DRIVER_STRUCT *driver_req);


/* Define what the initial system looks like.  */


static VOID _error_print(char *file, unsigned int line)
{
    printf("Error at %s:%d\n", file, line);
    error_counter++;
}
#define ERROR_COUNTER() _error_print(__FILE__, __LINE__);

#ifdef CTEST
void test_application_define(void *first_unused_memory);
void test_application_define(void *first_unused_memory)
#else
VOID    nx_secure_tls_handshake_fragmentation_test_application_define(void *first_unused_memory)
#endif
{
UINT     status;
CHAR    *pointer;


    error_counter = 0;


    /* Setup the working pointer.  */
    pointer =  (CHAR *) first_unused_memory;

    /* Create the server thread.  */
    tx_thread_create(&thread_0, "thread 0", ntest_0_entry, 0,
                     thread_0_stack, sizeof(thread_0_stack),
                     7, 7, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Create the client thread.  */
    tx_thread_create(&thread_1, "thread 1", ntest_1_entry, 0,
                     thread_1_stack, sizeof(thread_1_stack),
                     8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Initialize the NetX system.  */
    nx_system_initialize();

    /* Create a packet pool.  */
    status =  nx_packet_pool_create(&pool_0, "NetX Main Packet Pool", PACKET_SIZE,
                                    pool_0_memory, PACKET_POOL_SIZE);
    if (status)
    {
        ERROR_COUNTER();
    }

    /* Create an IP instance.  */
    status = nx_ip_create(&ip_0, "NetX IP Instance 0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL,
                          &pool_0, _nx_ram_network_driver_1500,
                          ip_0_stack, sizeof(ip_0_stack), 1);
    if (status)
    {
        ERROR_COUNTER();
    }

    /* Enable ARP and supply ARP cache memory for IP Instance 0.  */
    status =  nx_arp_enable(&ip_0, (VOID *)arp_cache, sizeof(arp_cache));
    if (status)
    {
        ERROR_COUNTER();
    }

    /* Enable TCP traffic.  */
    status =  nx_tcp_enable(&ip_0);
    if (status)
    {
        ERROR_COUNTER();
    }

    nx_secure_tls_initialize();
}

static VOID client_tls_setup(NX_SECURE_TLS_SESSION *tls_session_ptr)
{
UINT status;

    status = nx_secure_tls_session_create(tls_session_ptr,
                                          &nx_crypto_tls_ciphers,
                                          client_metadata,
                                          sizeof(client_metadata));
    if (status)
    {
        ERROR_COUNTER();
    }

    status = nx_secure_x509_certificate_initialize(&client_trusted_ca,
                                                   ca_cert_der,
                                                   ca_cert_der_len, NX_NULL, 0, NULL, 0, NX_SECURE_X509_KEY_TYPE_NONE);
    if (status)
    {
        ERROR_COUNTER();
    }

    status = nx_secure_tls_trusted_certificate_add(tls_session_ptr,
                                                   &client_trusted_ca);
    if (status)
    {
        ERROR_COUNTER();
    }

}


static void ntest_0_entry(ULONG thread_input)
{
UINT i;
UINT status;
ULONG response_length;
NX_PACKET *send_packet_1;
NX_PACKET *send_packet_2;
NX_PACKET *send_packet_3;
NX_PACKET *receive_packet;
ULONG      bytes_copied;

    /* Print out test information banner.  */
    printf("NetX Secure Test:   TLS Handshake Fragmentation Test...............");

    /* Create TCP socket. */
    status = nx_tcp_socket_create(&ip_0, &server_socket_0, "Server socket", NX_IP_NORMAL,
                                  NX_DONT_FRAGMENT, NX_IP_TIME_TO_LIVE, 8192, NX_NULL, NX_NULL);
    if (status)
    {
        ERROR_COUNTER();
    }

    status = nx_tcp_server_socket_listen(&ip_0, SERVER_PORT, &server_socket_0, 5, NX_NULL);
    if (status)
    {
        ERROR_COUNTER();
    }

    for (i = 0; i < 1; i++)
    {

        /* Make sure client thread is ready. */
        tx_thread_suspend(&thread_0);


        status = nx_tcp_server_socket_accept(&server_socket_0, NX_WAIT_FOREVER);
        if (status)
        {
            ERROR_COUNTER();
        }

        /* Receive ClientHello. */
        status = nx_tcp_socket_receive(&server_socket_0, &receive_packet, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        /* Release the ClientHello packet. */
        nx_packet_release(receive_packet);

		    /* send packet_1: server_hello, and certificate(fragment)  */
        status = nx_packet_allocate(&pool_0, &send_packet_1, NX_IPv4_TCP_PACKET, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

		    status = nx_packet_data_append(send_packet_1, frame1 + TLS_OFFSET, frame1_len - TLS_OFFSET, &pool_0, NX_WAIT_FOREVER);
		    EXPECT_EQ(NX_SUCCESS, status);

        status = nx_tcp_socket_send(&server_socket_0, send_packet_1, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

		    /* send packet_2: certificate(continuation)  */
		    status = nx_packet_allocate(&pool_0, &send_packet_2, NX_IPv4_TCP_PACKET, NX_WAIT_FOREVER);
		    EXPECT_EQ(NX_SUCCESS, status);

		    status = nx_packet_data_append(send_packet_2, frame2 + TLS_OFFSET, frame2_len - TLS_OFFSET, &pool_0, NX_WAIT_FOREVER);
		    EXPECT_EQ(NX_SUCCESS, status);

        status = nx_tcp_socket_send(&server_socket_0, send_packet_2, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);


        /* send packet_3: certificate(continuation), server_hello_done  */
        status = nx_packet_allocate(&pool_0, &send_packet_3, NX_IPv4_TCP_PACKET, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        status = nx_packet_data_append(send_packet_3, frame3 + TLS_OFFSET, frame3_len - TLS_OFFSET, &pool_0, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        status = nx_tcp_socket_send(&server_socket_0, send_packet_3, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        /* Receive ClientKeyExchange*/
        status = nx_tcp_socket_receive(&server_socket_0, &receive_packet, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        /* Receive ChangeCipher */
        status = nx_tcp_socket_receive(&server_socket_0, &receive_packet, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        /* Receive TLS Finish */
        status = nx_tcp_socket_receive(&server_socket_0, &receive_packet, NX_WAIT_FOREVER);
        EXPECT_EQ(NX_SUCCESS, status);

        nx_tcp_socket_disconnect(&server_socket_0, NX_NO_WAIT);
        nx_tcp_server_socket_unaccept(&server_socket_0);
        nx_tcp_server_socket_relisten(&ip_0, SERVER_PORT, &server_socket_0);
    }

    tx_thread_sleep(10);

    if (error_counter)
    {
        printf("ERROR!\n");
        test_control_return(1);
    }
    else
    {
        printf("SUCCESS!\n");
        test_control_return(0);
    }
}

/* This is almost the copy of _nx_secure_tls_session_start(), execpt that we manually set clientHello_andom into tls_session,
    which is used to calculate the hash and verify public key by nx_secure_process_server_key_exchange().*/
UINT ntest_nx_secure_tls_session_start(NX_SECURE_TLS_SESSION *tls_session, NX_TCP_SOCKET *tcp_socket,
                                  UINT wait_option)
{
UINT       status = NX_NOT_SUCCESSFUL;
UINT       error_return;
#ifndef NX_SECURE_TLS_CLIENT_DISABLED
NX_PACKET *send_packet;
#endif

    /* Get the protection. */
    tx_mutex_get(&_nx_secure_tls_protection, TX_WAIT_FOREVER);

    /* Assign the packet pool from which TLS will allocate internal message packets. */
    tls_session -> nx_secure_tls_packet_pool = tcp_socket -> nx_tcp_socket_ip_ptr -> nx_ip_default_packet_pool;

    /* Assign the TCP socket to the TLS session. */
    tls_session -> nx_secure_tls_tcp_socket = tcp_socket;

    /* Reset the record queue. */
    tls_session -> nx_secure_record_queue_header = NX_NULL;
    tls_session -> nx_secure_record_decrypted_packet = NX_NULL;

    /* Make sure we are starting with a fresh session. */
    tls_session -> nx_secure_tls_local_session_active = 0;
    tls_session -> nx_secure_tls_remote_session_active = 0;
    tls_session -> nx_secure_tls_received_remote_credentials = NX_FALSE;

    /* Reset alert tracking. */
    tls_session -> nx_secure_tls_received_alert_level = 0;
    tls_session -> nx_secure_tls_received_alert_value = 0;


    /* See if this is a TCP server started with listen/accept, or a TCP client started with connect. */
    if (tcp_socket -> nx_tcp_socket_client_type)
    {
        /* The TCP socket is a client, so our TLS session is a TLS Client. */
        tls_session -> nx_secure_tls_socket_type = NX_SECURE_TLS_SESSION_TYPE_CLIENT;
    }
    else
    {
        /* This session is now being treated as a server - indicate that fact to the TLS stack. */
        tls_session -> nx_secure_tls_socket_type = NX_SECURE_TLS_SESSION_TYPE_SERVER;
    }

#if (NX_SECURE_TLS_TLS_1_3_ENABLED)
    /* Initialize TLS 1.3 cryptographic primitives. */
    if(tls_session->nx_secure_tls_1_3)
    {
        status = _nx_secure_tls_1_3_crypto_init(tls_session);

        if(status != NX_SUCCESS)
        {

            /* Release the protection. */
            tx_mutex_put(&_nx_secure_tls_protection);
            return(status);
        }
    }
#endif

    /* Now process the handshake depending on the TLS session type. */
#ifndef NX_SECURE_TLS_CLIENT_DISABLED
    if (tls_session -> nx_secure_tls_socket_type == NX_SECURE_TLS_SESSION_TYPE_CLIENT)
    {

        /* Allocate a handshake packet so we can send the ClientHello. */
        status = _nx_secure_tls_allocate_handshake_packet(tls_session, tls_session -> nx_secure_tls_packet_pool, &send_packet, wait_option);

        if (status != NX_SUCCESS)
        {

            /* Release the protection. */
            tx_mutex_put(&_nx_secure_tls_protection);
            return(status);
        }

        /* Populate our packet with clienthello data. */
        status = _nx_secure_tls_send_clienthello(tls_session, send_packet);

        if (status == NX_SUCCESS)
        {

            /* Manally update nx_secure_tls_client_random. */
            memcpy(tls_session->nx_secure_tls_key_material.nx_secure_tls_client_random, client_random_bytes, client_random_bytes_len);

            /* Send the ClientHello to kick things off. */
            status = _nx_secure_tls_send_handshake_record(tls_session, send_packet, NX_SECURE_TLS_CLIENT_HELLO, wait_option);
        }

        /* If anything after the allocate fails, we need to release our packet. */
        if (status != NX_SUCCESS)
        {

            /* Release the protection. */
            tx_mutex_put(&_nx_secure_tls_protection);
            nx_secure_tls_packet_release(send_packet);
            return(status);
        }
    }
#endif

    /* Release the protection. */
    tx_mutex_put(&_nx_secure_tls_protection);

    /* Now handle our incoming handshake messages. Continue processing until the handshake is complete
       or an error/timeout occurs. */
    status = _nx_secure_tls_handshake_process(tls_session, wait_option);

    if ((status == NX_CONTINUE) && (wait_option == 0))
    {
        
        /* It is non blocking mode. */
        return(NX_CONTINUE);
    }

    if(status != NX_SUCCESS)
    {
        /* Save the return status before resetting the TLS session. */
        error_return = status;

        /* Reset the TLS state so this socket can be reused. */
        status = _nx_secure_tls_session_reset(tls_session);

        if(status != NX_SUCCESS)
        {
            return(status);
        }

        return(error_return);
    }

    return(status);
}

static void ntest_1_entry(ULONG thread_input)
{
UINT i;
UINT status;
NXD_ADDRESS server_address;

    server_address.nxd_ip_version = NX_IP_VERSION_V4;
    server_address.nxd_ip_address.v4 = IP_ADDRESS(127, 0, 0, 1);

    /* Create TCP socket. */
    status = nx_tcp_socket_create(&ip_0, &client_socket_0, "Client socket", NX_IP_NORMAL,
                                  NX_DONT_FRAGMENT, NX_IP_TIME_TO_LIVE, 8192, NX_NULL, NX_NULL);
    if (status)
    {
        ERROR_COUNTER();
    }

    status = nx_tcp_client_socket_bind(&client_socket_0, NX_ANY_PORT, NX_NO_WAIT);
    if (status)
    {
        ERROR_COUNTER();
    }


    for (i = 0; i < 1; i++)
    {

        /* Let server thread run first. */
        tx_thread_resume(&thread_0);

        client_tls_setup(&tls_client_session_0);

        status = _nx_secure_tls_session_packet_buffer_set(&tls_client_session_0, tls_packet_buffer,
                                                          TLS_PACKET_BUFFER_SZ);
        if (status)
        {
            ERROR_COUNTER();
        }

        status = nxd_tcp_client_socket_connect(&client_socket_0, &server_address, SERVER_PORT,
                                               NX_WAIT_FOREVER);
        if (status)
        {
            ERROR_COUNTER();
        }

        /* Start TLS session. */
        status = ntest_nx_secure_tls_session_start(&tls_client_session_0, &client_socket_0,
                                             NX_WAIT_FOREVER);

        /* For the sake of test simpicity, we didn't let server thread send following messages to client thread
            after it received FINISHED message from client, but let server thread just close TCP connection directly,
            so here ntest_nx_secure_tls_session_start() returned NX_NOT_CONNECTED. */
        EXPECT_EQ(NX_NOT_CONNECTED, status);

        nx_secure_tls_session_end(&tls_client_session_0, NX_NO_WAIT);
        nx_secure_tls_session_delete(&tls_client_session_0);

        nx_tcp_socket_disconnect(&client_socket_0, NX_NO_WAIT);
    }
}


#else
#ifdef CTEST
void test_application_define(void *first_unused_memory);
void test_application_define(void *first_unused_memory)
#else
VOID    nx_secure_tls_handshake_fragmentation_test_application_define(void *first_unused_memory)
#endif
{

    /* Print out test information banner.  */
    printf("NetX Secure Test:   TLS Handshake Fragmentation Test...............N/A\n");
    test_control_return(3);
}
#endif