1 /* This test concentrates on DTLS connections. */
2
3 #include "nx_api.h"
4 #include "nx_secure_dtls_api.h"
5 #include "test_ca_cert.c"
6 #include "test_device_cert.c"
7
8 extern VOID test_control_return(UINT status);
9
10
11 #if !defined(NX_SECURE_TLS_CLIENT_DISABLED) && !defined(NX_SECURE_TLS_SERVER_DISABLED) && defined(NX_SECURE_ENABLE_DTLS)
12 #define NUM_PACKETS 24
13 #define PACKET_SIZE 1536
14 #define PACKET_POOL_SIZE (NUM_PACKETS * (PACKET_SIZE + sizeof(NX_PACKET)))
15 #define THREAD_STACK_SIZE 1024
16 #define ARP_CACHE_SIZE 1024
17 #define BUFFER_SIZE 64
18 #define METADATA_SIZE 16000
19 #define CERT_BUFFER_SIZE (2048 + sizeof(NX_SECURE_X509_CERT))
20 #define PSK "simple_psk"
21 #define PSK_IDENTITY "psk_indentity"
22 #define PSK_HINT "psk_hint"
23 #define SERVER_PORT 4433
24 #define WRONG_SERVER_PORT 4434
25
26 /* Number of DTLS sessions to apply to DTLS server. */
27 #define NUM_SERVER_SESSIONS 2
28
29
30 /* Define the ThreadX and NetX object control blocks... */
31
32 static TX_THREAD thread_0;
33 static TX_THREAD thread_1;
34 static NX_PACKET_POOL pool_0;
35 static NX_IP ip_0;
36 #ifdef FEATURE_NX_IPV6
37 static NXD_ADDRESS address_0;
38 #endif /* FEATURE_NX_IPV6 */
39 static UINT error_counter;
40
41 static NX_UDP_SOCKET client_socket_0;
42 static NX_SECURE_DTLS_SESSION dtls_client_session_0;
43 static NX_SECURE_DTLS_SERVER dtls_server_0;
44 static NX_SECURE_X509_CERT client_trusted_ca;
45 static NX_SECURE_X509_CERT server_local_certificate;
46 extern const NX_SECURE_TLS_CRYPTO
47 nx_crypto_tls_ciphers;
48
49 static ULONG pool_0_memory[PACKET_POOL_SIZE / sizeof(ULONG)];
50 static ULONG thread_0_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
51 static ULONG thread_1_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
52 static ULONG ip_0_stack[THREAD_STACK_SIZE / sizeof(ULONG)];
53 static ULONG arp_cache[ARP_CACHE_SIZE];
54 static UCHAR client_metadata[METADATA_SIZE];
55 static UCHAR server_metadata[METADATA_SIZE * NUM_SERVER_SESSIONS];
56 static UCHAR client_cert_buffer[CERT_BUFFER_SIZE];
57
58 static UCHAR request_buffer[BUFFER_SIZE];
59 static UCHAR response_buffer[BUFFER_SIZE];
60 static UCHAR tls_packet_buffer[2][4000 * NUM_SERVER_SESSIONS];
61
62 /* Session buffer for DTLS server. Must be equal to the size of NX_SECURE_DTLS_SESSION times the
63 number of desired DTLS sessions. */
64 static UCHAR server_session_buffer[sizeof(NX_SECURE_DTLS_SESSION) * NUM_SERVER_SESSIONS];
65
66 /* Define thread prototypes. */
67
68 static VOID ntest_0_entry(ULONG thread_input);
69 static VOID ntest_1_entry(ULONG thread_input);
70 extern VOID _nx_ram_network_driver_1500(struct NX_IP_DRIVER_STRUCT *driver_req);
71
72 static TX_SEMAPHORE semaphore_receive;
73 static TX_SEMAPHORE semaphore_connect;
74
75
76 /* Define what the initial system looks like. */
77
78 #define ERROR_COUNTER() __ERROR_COUNTER(__FILE__, __LINE__)
79
__ERROR_COUNTER(UCHAR * file,UINT line)80 static VOID __ERROR_COUNTER(UCHAR *file, UINT line)
81 {
82 printf("\nError on line %d in %s\n", line, file);
83 error_counter++;
84 }
85
86 #ifdef CTEST
87 void test_application_define(void *first_unused_memory);
test_application_define(void * first_unused_memory)88 void test_application_define(void *first_unused_memory)
89 #else
90 VOID nx_secure_dtls_basic_test_application_define(void *first_unused_memory)
91 #endif
92 {
93 UINT status;
94 CHAR *pointer;
95
96
97 error_counter = 0;
98
99
100 /* Setup the working pointer. */
101 pointer = (CHAR *) first_unused_memory;
102
103 /* Create the server thread. */
104 tx_thread_create(&thread_0, "thread 0", ntest_0_entry, 0,
105 thread_0_stack, sizeof(thread_0_stack),
106 7, 7, TX_NO_TIME_SLICE, TX_AUTO_START);
107
108 /* Create the client thread. */
109 tx_thread_create(&thread_1, "thread 1", ntest_1_entry, 0,
110 thread_1_stack, sizeof(thread_1_stack),
111 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
112
113 tx_semaphore_create(&semaphore_receive, "semaphore receive", 0);
114 tx_semaphore_create(&semaphore_connect, "semaphore connect", 0);
115
116 /* Initialize the NetX system. */
117 nx_system_initialize();
118
119 /* Create a packet pool. */
120 status = nx_packet_pool_create(&pool_0, "NetX Main Packet Pool", PACKET_SIZE,
121 pool_0_memory, PACKET_POOL_SIZE);
122 if (status)
123 {
124 ERROR_COUNTER();
125 }
126
127 /* Create an IP instance. */
128 status = nx_ip_create(&ip_0, "NetX IP Instance 0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL,
129 &pool_0, _nx_ram_network_driver_1500,
130 ip_0_stack, sizeof(ip_0_stack), 1);
131 if (status)
132 {
133 ERROR_COUNTER();
134 }
135
136 /* Enable ARP and supply ARP cache memory for IP Instance 0. */
137 status = nx_arp_enable(&ip_0, (VOID *)arp_cache, sizeof(arp_cache));
138 if (status)
139 {
140 ERROR_COUNTER();
141 }
142
143 /* Enable UDP traffic. */
144 status = nx_udp_enable(&ip_0);
145 if (status)
146 {
147 ERROR_COUNTER();
148 }
149
150 nx_secure_tls_initialize();
151 nx_secure_dtls_initialize();
152
153 #ifdef FEATURE_NX_IPV6
154 /* Enable IPv6 traffic. */
155 status = nxd_ipv6_enable(&ip_0);
156 if (status)
157 {
158 ERROR_COUNTER();
159 }
160
161 /* Enable ICMP processing. */
162 status = nxd_icmp_enable(&ip_0);
163 if (status)
164 {
165 ERROR_COUNTER();
166 }
167
168
169 /* Set address with global address. */
170 address_0.nxd_ip_version = NX_IP_VERSION_V6;
171 address_0.nxd_ip_address.v6[0] = 0x20010000;
172 address_0.nxd_ip_address.v6[1] = 0x00000000;
173 address_0.nxd_ip_address.v6[2] = 0x00000000;
174 address_0.nxd_ip_address.v6[3] = 0x00000002;
175
176 status = nxd_ipv6_address_set(&ip_0, 0, &address_0, 64, NX_NULL);
177 if (status)
178 {
179 ERROR_COUNTER();
180 }
181 #endif /* FEATURE_NX_IPV6 */
182 }
183
client_dtls_setup(NX_SECURE_DTLS_SESSION * dtls_session_ptr)184 static VOID client_dtls_setup(NX_SECURE_DTLS_SESSION *dtls_session_ptr)
185 {
186 UINT status;
187
188 status = nx_secure_dtls_session_create(dtls_session_ptr,
189 &nx_crypto_tls_ciphers,
190 client_metadata,
191 sizeof(client_metadata),
192 tls_packet_buffer[0], sizeof(tls_packet_buffer[0]),
193 1, client_cert_buffer, sizeof(client_cert_buffer));
194 if (status)
195 {
196 ERROR_COUNTER();
197 }
198
199 status = nx_secure_x509_certificate_initialize(&client_trusted_ca,
200 test_ca_cert_der,
201 test_ca_cert_der_len, NX_NULL, 0, NULL, 0, NX_SECURE_X509_KEY_TYPE_NONE);
202 if (status)
203 {
204 ERROR_COUNTER();
205 }
206
207 status = nx_secure_dtls_session_trusted_certificate_add(dtls_session_ptr, &client_trusted_ca, 1);
208 if (status)
209 {
210 ERROR_COUNTER();
211 }
212
213
214
215 #if defined(NX_SECURE_ENABLE_PSK_CIPHERSUITES) || defined(NX_SECURE_ENABLE_ECJPAKE_CIPHERSUITE)
216 /* For PSK ciphersuites, add a PSK and identity hint. */
217 nx_secure_dtls_psk_add(dtls_session_ptr, PSK, strlen(PSK),
218 PSK_IDENTITY, strlen(PSK_IDENTITY), PSK_HINT, strlen(PSK_HINT));
219 #endif
220 }
221
222
223 /* Notification flags for DTLS server connect/receive. */
224 static UINT server_connect_notify_flag = NX_FALSE;
225 static UINT server_receive_notify_flag = NX_FALSE;
226
227 static NX_SECURE_DTLS_SESSION *connect_session;
228 static NX_SECURE_DTLS_SESSION *receive_session;
229
230 /* Connect notify callback for DTLS server - notifies the application thread that
231 a DTLS connection is ready to kickoff a handshake. */
server_connect_notify(NX_SECURE_DTLS_SESSION * dtls_session,NXD_ADDRESS * ip_address,UINT port)232 static UINT server_connect_notify(NX_SECURE_DTLS_SESSION *dtls_session, NXD_ADDRESS *ip_address, UINT port)
233 {
234 /* Drop connections if one is in progress. Better way would be to have
235 * an array of pointers to DTLS sessions and check the port/IP address
236 * to see if it's an existing connection. Application thread then loops
237 * through array servicing each session.
238 */
239 if (server_connect_notify_flag == NX_FALSE)
240 {
241 server_connect_notify_flag = NX_TRUE;
242 connect_session = dtls_session;
243 tx_semaphore_put(&semaphore_connect);
244 }
245
246 return(NX_SUCCESS);
247 }
248
249 /* Receive notify callback for DTLS server - notifies the application thread that
250 we have received a DTLS record over an established DTLS session. */
server_receive_notify(NX_SECURE_DTLS_SESSION * dtls_session)251 static UINT server_receive_notify(NX_SECURE_DTLS_SESSION *dtls_session)
252 {
253
254 /* Drop records if more come in while processing one. Better would be to
255 service each session in a queue. */
256 if (server_receive_notify_flag == NX_FALSE)
257 {
258 server_receive_notify_flag = NX_TRUE;
259 receive_session = dtls_session;
260 tx_semaphore_put(&semaphore_receive);
261 }
262
263 return(NX_SUCCESS);
264 }
265
266
server_dtls_setup(NX_SECURE_DTLS_SERVER * dtls_server_ptr)267 static VOID server_dtls_setup(NX_SECURE_DTLS_SERVER *dtls_server_ptr)
268 {
269 UINT status;
270 UINT i;
271
272 status = nx_secure_dtls_server_create(dtls_server_ptr, &ip_0, SERVER_PORT, NX_IP_PERIODIC_RATE,
273 server_session_buffer, sizeof(server_session_buffer),
274 &nx_crypto_tls_ciphers, server_metadata, sizeof(server_metadata),
275 tls_packet_buffer[1], sizeof(tls_packet_buffer[1]),
276 server_connect_notify, server_receive_notify);
277 if (status)
278 {
279 ERROR_COUNTER();
280 }
281
282 memset(&server_local_certificate, 0, sizeof(server_local_certificate));
283 status = nx_secure_x509_certificate_initialize(&server_local_certificate,
284 test_device_cert_der, test_device_cert_der_len,
285 NX_NULL, 0, test_device_cert_key_der,
286 test_device_cert_key_der_len, NX_SECURE_X509_KEY_TYPE_RSA_PKCS1_DER);
287 if (status)
288 {
289 ERROR_COUNTER();
290 }
291
292 status = nx_secure_dtls_server_local_certificate_add(dtls_server_ptr, &server_local_certificate, 1);
293 if (status)
294 {
295 ERROR_COUNTER();
296 }
297
298 #if defined(NX_SECURE_ENABLE_PSK_CIPHERSUITES) || defined(NX_SECURE_ENABLE_ECJPAKE_CIPHERSUITE)
299
300 for (i = 0; i < dtls_server_ptr -> nx_dtls_server_sessions_count; i++)
301 {
302
303 /* For PSK ciphersuites, add a PSK and identity hint. */
304 nx_secure_dtls_psk_add(&dtls_server_ptr -> nx_dtls_server_sessions[i], PSK, strlen(PSK),
305 PSK_IDENTITY, strlen(PSK_IDENTITY), PSK_HINT, strlen(PSK_HINT));
306 }
307
308 #endif
309 }
310
ntest_0_entry(ULONG thread_input)311 static void ntest_0_entry(ULONG thread_input)
312 {
313 UINT status;
314 UINT i;
315 ULONG response_length;
316 NX_PACKET *packet_ptr;
317
318 /* Print out test information banner. */
319 printf("NetX Secure Test: DTLS Basic Test....................................");
320
321 server_dtls_setup(&dtls_server_0);
322
323 /* Start DTLS session. */
324 status = nx_secure_dtls_server_start(&dtls_server_0);
325 if (status)
326 {
327 printf("Error in starting DTLS server: 0x%02X\n", status);
328 ERROR_COUNTER();
329 }
330
331 /* Wait for connection attempt. */
332 tx_semaphore_get(&semaphore_connect, NX_IP_PERIODIC_RATE);
333 server_connect_notify_flag = NX_FALSE;
334
335 status = nx_secure_dtls_server_session_start(connect_session, NX_WAIT_FOREVER);
336
337 if(status)
338 {
339 printf("Error in establishing DTLS server session: 0x%02X\n", status);
340 ERROR_COUNTER();
341 }
342
343 /* Wait for records to be received. */
344 tx_semaphore_get(&semaphore_receive, NX_IP_PERIODIC_RATE);
345
346 status = nx_secure_dtls_session_receive(receive_session,
347 &packet_ptr, NX_WAIT_FOREVER);
348 if (status)
349 {
350 printf("Error in DTLS server session receive: 0x%02X\n", status);
351 ERROR_COUNTER();
352 }
353
354 server_receive_notify_flag = NX_FALSE;
355
356 nx_packet_data_retrieve(packet_ptr, response_buffer, &response_length);
357 nx_packet_release(packet_ptr);
358
359 if ((response_length != sizeof(request_buffer)) ||
360 memcmp(request_buffer, response_buffer, response_length))
361 {
362 printf("Received data did not match expected in DTLS Server: %s\n", __FILE__);
363 ERROR_COUNTER();
364 }
365
366 for(i = 0; i < NUM_SERVER_SESSIONS; ++i)
367 {
368 if(dtls_server_0.nx_dtls_server_sessions[i].nx_secure_dtls_session_in_use)
369 {
370 status = nx_secure_dtls_session_end(&dtls_server_0.nx_dtls_server_sessions[i], NX_IP_PERIODIC_RATE);
371 if(status)
372 {
373 ERROR_COUNTER();
374 }
375 }
376 }
377
378 #ifdef FEATURE_NX_IPV6
379
380 /* Wait for connection attempt. */
381 tx_semaphore_get(&semaphore_connect, NX_IP_PERIODIC_RATE);
382 server_connect_notify_flag = NX_FALSE;
383
384 /* Start DTLS session. */
385 status = nx_secure_dtls_server_session_start(connect_session, NX_WAIT_FOREVER);
386 if (status)
387 {
388 ERROR_COUNTER();
389 }
390
391 /* Wait for records to be received. */
392 tx_semaphore_get(&semaphore_receive, NX_IP_PERIODIC_RATE);
393
394 status = nx_secure_dtls_session_receive(receive_session, &packet_ptr, NX_WAIT_FOREVER);
395 if (status)
396 {
397 ERROR_COUNTER();
398 }
399
400 server_receive_notify_flag = NX_FALSE;
401
402 nx_packet_data_retrieve(packet_ptr, response_buffer, &response_length);
403 nx_packet_release(packet_ptr);
404 if ((response_length != sizeof(request_buffer)) ||
405 memcmp(request_buffer, response_buffer, response_length))
406 {
407 ERROR_COUNTER();
408 }
409
410 for(i = 0; i < NUM_SERVER_SESSIONS; ++i)
411 {
412 if(dtls_server_0.nx_dtls_server_sessions[i].nx_secure_dtls_session_in_use)
413 {
414 status = nx_secure_dtls_session_end(&dtls_server_0.nx_dtls_server_sessions[i], NX_IP_PERIODIC_RATE);
415 if(status)
416 {
417 ERROR_COUNTER();
418 }
419 }
420
421 }
422
423 #endif
424
425 tx_thread_suspend(&thread_0);
426
427 /* Shutdown DTLS server. */
428 nx_secure_dtls_server_stop(&dtls_server_0);
429
430 /* Check packet leak. */
431 if (pool_0.nx_packet_pool_available != pool_0.nx_packet_pool_total)
432 {
433 ERROR_COUNTER();
434 }
435
436 /* Delete server. */
437 nx_secure_dtls_server_delete(&dtls_server_0);
438
439 /* Check invalid packet release count. */
440 if (pool_0.nx_packet_pool_invalid_releases != 0)
441 {
442 ERROR_COUNTER();
443 }
444
445 if (error_counter)
446 {
447 printf("ERROR!\n");
448 test_control_return(1);
449 }
450 else
451 {
452 printf("SUCCESS!\n");
453 test_control_return(0);
454 }
455 }
456
ntest_1_entry(ULONG thread_input)457 static void ntest_1_entry(ULONG thread_input)
458 {
459 UINT i;
460 UINT status;
461 NX_PACKET *packet_ptr;
462 NXD_ADDRESS server_address;
463
464 for (i = 0; i < sizeof(request_buffer); i++)
465 {
466 request_buffer[i] = i;
467 response_buffer[i] = 0;
468 }
469
470 server_address.nxd_ip_version = NX_IP_VERSION_V4;
471 server_address.nxd_ip_address.v4 = IP_ADDRESS(127, 0, 0, 1);
472
473 /* Create UDP socket. */
474 status = nx_udp_socket_create(&ip_0, &client_socket_0, "Client socket", NX_IP_NORMAL,
475 NX_DONT_FRAGMENT, 0x80, 5);
476 if (status)
477 {
478 ERROR_COUNTER();
479 }
480
481 status = nx_udp_socket_bind(&client_socket_0, NX_ANY_PORT, NX_NO_WAIT);
482 if (status)
483 {
484 ERROR_COUNTER();
485 }
486
487 client_dtls_setup(&dtls_client_session_0);
488
489 /* Start DTLS session. */
490 status = nx_secure_dtls_client_session_start(&dtls_client_session_0, &client_socket_0, &server_address, SERVER_PORT, NX_WAIT_FOREVER);
491 if (status)
492 {
493 ERROR_COUNTER();
494 }
495
496 /* Prepare packet to send. */
497 status = nx_packet_allocate(&pool_0, &packet_ptr, NX_UDP_PACKET, NX_NO_WAIT);
498 if (status)
499 {
500 ERROR_COUNTER();
501 }
502
503 packet_ptr -> nx_packet_prepend_ptr += NX_SECURE_DTLS_RECORD_HEADER_SIZE;
504 packet_ptr -> nx_packet_append_ptr = packet_ptr -> nx_packet_prepend_ptr;
505
506 status = nx_packet_data_append(packet_ptr, request_buffer, sizeof(request_buffer),
507 &pool_0, NX_NO_WAIT);
508 if (status)
509 {
510 ERROR_COUNTER();
511 }
512
513 /* Test send with wrong port. */
514 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
515 &server_address, WRONG_SERVER_PORT);
516 if (!status)
517 {
518 ERROR_COUNTER();
519 }
520
521 /* Test send with wrong IP. */
522 server_address.nxd_ip_address.v4 = IP_ADDRESS(1, 0, 0, 1);
523 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
524 &server_address, SERVER_PORT);
525 if (!status)
526 {
527 ERROR_COUNTER();
528 }
529
530 /* Test send with wrong IP version. */
531 server_address.nxd_ip_version = NX_IP_VERSION_V6;
532 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
533 &server_address, SERVER_PORT);
534 if (!status)
535 {
536 ERROR_COUNTER();
537 }
538 server_address.nxd_ip_version = NX_IP_VERSION_V4;
539 server_address.nxd_ip_address.v4 = IP_ADDRESS(127, 0, 0, 1);
540
541 /* Send the packet. */
542 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
543 &server_address, SERVER_PORT);
544 if (status)
545 {
546 ERROR_COUNTER();
547 }
548
549 /* Prepare packet to send. */
550 status = nx_packet_allocate(&pool_0, &packet_ptr, NX_UDP_PACKET, NX_NO_WAIT);
551 if (status)
552 {
553 ERROR_COUNTER();
554 }
555
556 packet_ptr->nx_packet_prepend_ptr += NX_SECURE_DTLS_RECORD_HEADER_SIZE;
557 packet_ptr->nx_packet_append_ptr = packet_ptr->nx_packet_prepend_ptr;
558
559 status = nx_packet_data_append(packet_ptr, request_buffer, sizeof(request_buffer),
560 &pool_0, NX_NO_WAIT);
561 if (status)
562 {
563 ERROR_COUNTER();
564 }
565
566 /* Test 64-bit sequence number overflow. */
567 dtls_client_session_0.nx_secure_dtls_tls_session.nx_secure_tls_local_sequence_number[0] = 0xFFFFFFFF;
568 dtls_client_session_0.nx_secure_dtls_tls_session.nx_secure_tls_local_sequence_number[1] = 0xFFFFFFFF;
569
570 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
571 &server_address, SERVER_PORT);
572 if (status != NX_NOT_SUCCESSFUL)
573 {
574 ERROR_COUNTER();
575 }
576
577 nx_packet_release(packet_ptr);
578
579
580 status = nx_secure_dtls_session_end(&dtls_client_session_0, NX_IP_PERIODIC_RATE);
581 if(status)
582 {
583 ERROR_COUNTER();
584 }
585
586 nx_secure_dtls_session_delete(&dtls_client_session_0);
587
588 #ifdef FEATURE_NX_IPV6
589
590 server_address.nxd_ip_version = NX_IP_VERSION_V6;
591 server_address.nxd_ip_address.v6[0] = 0;
592 server_address.nxd_ip_address.v6[1] = 0;
593 server_address.nxd_ip_address.v6[2] = 0;
594 server_address.nxd_ip_address.v6[3] = 1;
595
596 client_dtls_setup(&dtls_client_session_0);
597
598 /* Start DTLS session. */
599 status = nx_secure_dtls_client_session_start(&dtls_client_session_0, &client_socket_0, &server_address, SERVER_PORT, NX_WAIT_FOREVER);
600 if (status)
601 {
602 ERROR_COUNTER();
603 }
604
605 /* Prepare packet to send. */
606 status = nx_packet_allocate(&pool_0, &packet_ptr, NX_UDP_PACKET, NX_NO_WAIT);
607 if (status)
608 {
609 ERROR_COUNTER();
610 }
611
612 packet_ptr->nx_packet_prepend_ptr += NX_SECURE_DTLS_RECORD_HEADER_SIZE;
613 packet_ptr->nx_packet_append_ptr = packet_ptr->nx_packet_prepend_ptr;
614
615 status = nx_packet_data_append(packet_ptr, request_buffer, sizeof(request_buffer), &pool_0, NX_NO_WAIT);
616 if (status)
617 {
618 ERROR_COUNTER();
619 }
620
621
622 /* Test send with wrong IP. */
623 server_address.nxd_ip_address.v6[3] = 2;
624 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
625 &server_address, SERVER_PORT);
626 if (!status)
627 {
628 ERROR_COUNTER();
629 }
630
631 server_address.nxd_ip_address.v6[2] = 2;
632 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
633 &server_address, SERVER_PORT);
634 if (!status)
635 {
636 ERROR_COUNTER();
637 }
638
639 server_address.nxd_ip_address.v6[1] = 2;
640 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
641 &server_address, SERVER_PORT);
642 if (!status)
643 {
644 ERROR_COUNTER();
645 }
646
647 server_address.nxd_ip_address.v6[0] = 2;
648 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
649 &server_address, SERVER_PORT);
650 if (!status)
651 {
652 ERROR_COUNTER();
653 }
654 server_address.nxd_ip_version = NX_IP_VERSION_V6;
655 server_address.nxd_ip_address.v6[0] = 0;
656 server_address.nxd_ip_address.v6[1] = 0;
657 server_address.nxd_ip_address.v6[2] = 0;
658 server_address.nxd_ip_address.v6[3] = 1;
659
660 /* Send the packet. */
661 status = nx_secure_dtls_session_send(&dtls_client_session_0, packet_ptr,
662 &server_address, SERVER_PORT);
663 if (status)
664 {
665 ERROR_COUNTER();
666 }
667
668 nx_secure_dtls_session_end(&dtls_client_session_0, NX_NO_WAIT);
669
670 nx_secure_dtls_session_delete(&dtls_client_session_0);
671 #endif
672
673 nx_udp_socket_unbind(&client_socket_0);
674
675 nx_udp_socket_delete(&client_socket_0);
676
677 tx_thread_resume(&thread_0);
678 }
679 #else
680 #ifdef CTEST
681 void test_application_define(void *first_unused_memory);
test_application_define(void * first_unused_memory)682 void test_application_define(void *first_unused_memory)
683 #else
684 VOID nx_secure_dtls_basic_test_application_define(void *first_unused_memory)
685 #endif
686 {
687
688 /* Print out test information banner. */
689 printf("NetX Secure Test: DTLS Basic Test....................................N/A\n");
690 test_control_return(3);
691 }
692 #endif
693
