1 /*
2 * FreeRTOS+TCP <DEVELOPMENT BRANCH>
3 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * http://aws.amazon.com/freertos
25 * http://www.FreeRTOS.org
26 */
27 /* Include Unity header */
28 #include "unity.h"
29
30 /* Include standard libraries */
31 #include <stdlib.h>
32 #include <string.h>
33 #include <stdint.h>
34
35 #include "mock_FreeRTOS_IP.h"
36 #include "mock_FreeRTOS_Routing.h"
37 #include "mock_FreeRTOS_Sockets.h"
38 #include "mock_FreeRTOS_IP_Private.h"
39 #include "mock_FreeRTOS_DNS_Networking.h"
40 #include "mock_task.h"
41 #include "mock_list.h"
42 #include "mock_queue.h"
43
44 #include "mock_FreeRTOS_DNS_Callback.h"
45 #include "mock_FreeRTOS_DNS_Cache.h"
46 #include "mock_FreeRTOS_DNS_Parser.h"
47 #include "mock_FreeRTOS_DNS_Networking.h"
48 #include "mock_NetworkBufferManagement.h"
49 #include "FreeRTOS_DNS.h"
50
51
52 #include "catch_assert.h"
53
54 #include "FreeRTOSIPConfig.h"
55 #include "FreeRTOS_DNS_stubs.c"
56
57 /* =========================== EXTERN VARIABLES =========================== */
58
59 #define LLMNR_ADDRESS "freertos"
60 #define LOCAL_ADDRESS "freertos.local"
61 #define GOOD_ADDRESS "www.freertos.org"
62 #define BAD_ADDRESS "this is a bad address"
63 #define DOTTED_IPV4_ADDRESS "192.168.0.1"
64 #define DOTTED_IPV4_ADDRESS_UINT32 ( 0x0100A8C0 )
65 #define DOTTED_IPv6_ADDRESS "2001::1"
66
67 IPv6_Address_t xIPv6Address = { { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
68
69 typedef void (* FOnDNSEvent ) ( const char * /* pcName */,
70 void * /* pvSearchID */,
71 struct freertos_addrinfo * /* pxAddressInfo */ );
72
73 extern IPPreference_t xDNS_IP_Preference;
74
75 /* ============================ Unity Fixtures ============================ */
76
77 /**
78 * @brief calls at the beginning of each test case
79 */
setUp(void)80 void setUp( void )
81 {
82 xDNS_IP_Preference = xPreferenceIPv4;
83 callback_called = 0;
84 isMallocFail = false;
85 }
86
87 /* ============================== Test Cases ============================== */
88
89 /**
90 * @brief Ensures all corresponding initialisation modules are called
91 */
test_vDNSInitialise(void)92 void test_vDNSInitialise( void )
93 {
94 vDNSCallbackInitialise_Expect();
95 vDNSInitialise();
96 }
97
98 /**
99 * @brief Ensures when a network buffer cannot be allocated a zero is returned
100 */
test_FreeRTOS_gethostbyname_FailAllocateNetworkBuffer(void)101 void test_FreeRTOS_gethostbyname_FailAllocateNetworkBuffer( void )
102 {
103 uint32_t ret;
104 NetworkEndPoint_t xEndPoint = { 0 };
105 struct xSOCKET xDNSSocket;
106
107 xEndPoint.bits.bIPv6 = 0;
108 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
109 xEndPoint.ipv4_settings.ucDNSIndex = 0;
110 xDNSSocket.usLocalPort = 0;
111
112 DNS_BindSocket_IgnoreAndReturn( 0 );
113
114 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
115 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
116 xApplicationGetRandomNumber_IgnoreAndReturn( pdTRUE );
117
118 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
119 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
120 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
121
122 /* in prvGetHostByName */
123 /* in prvGetPayloadBuffer */
124
125 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
126 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
127 DNS_CloseSocket_ExpectAnyArgs();
128
129 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
130
131 TEST_ASSERT_EQUAL( 0, ret );
132 }
133
134 /**
135 * @brief ensure that when a NULL address is received a zero is returned
136 */
test_FreeRTOS_gethostbyname_FailNullAddress(void)137 void test_FreeRTOS_gethostbyname_FailNullAddress( void )
138 {
139 uint32_t ret;
140
141 ret = FreeRTOS_gethostbyname( NULL );
142 TEST_ASSERT_EQUAL( 0, ret );
143 }
144
145 /**
146 * @brief ensure that when the function receives a long (longer than
147 * ipconfigDNS_CACHE_NAME_LENGTH ) hostname, a zero is returned
148 */
test_FreeRTOS_gethostbyname_FailLongAddress(void)149 void test_FreeRTOS_gethostbyname_FailLongAddress( void )
150 {
151 uint32_t ret;
152 char address[ ipconfigDNS_CACHE_NAME_LENGTH + 3 ];
153
154 memset( address, 'a', ipconfigDNS_CACHE_NAME_LENGTH );
155 address[ ipconfigDNS_CACHE_NAME_LENGTH + 3 ] = '\0';
156
157
158 ret = FreeRTOS_gethostbyname( address );
159 TEST_ASSERT_EQUAL( 0, ret );
160 }
161
162 /**
163 * @brief Ensures that when the supplied address is in the dotted format, it is
164 * translated to the numerical form and no lookup is performed
165 */
test_FreeRTOS_gethostbyname_SuccessDotAddress(void)166 void test_FreeRTOS_gethostbyname_SuccessDotAddress( void )
167 {
168 uint32_t ret;
169
170 FreeRTOS_inet_addr_ExpectAndReturn( DOTTED_IPV4_ADDRESS, 12345 );
171
172 xApplicationGetRandomNumber_IgnoreAndReturn( pdTRUE );
173 ulChar2u32_IgnoreAndReturn( 12345 );
174 ret = FreeRTOS_gethostbyname( DOTTED_IPV4_ADDRESS );
175 TEST_ASSERT_EQUAL( 12345, ret );
176 }
177
178 /**
179 * @brief Ensures that if the address is not in the dotted form and found in the cache,
180 * it is returned to the caller
181 */
test_FreeRTOS_gethostbyname_SuccessAddressInCache(void)182 void test_FreeRTOS_gethostbyname_SuccessAddressInCache( void )
183 {
184 uint32_t ret;
185
186 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
187 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 12345 );
188
189 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
190 TEST_ASSERT_EQUAL( 12345, ret );
191 }
192
193
194 /**
195 * @brief Ensures that the code can handle when the client can't create a socket
196 */
test_FreeRTOS_gethostbyname_FailNullSocket(void)197 void test_FreeRTOS_gethostbyname_FailNullSocket( void )
198 {
199 uint32_t ret;
200 NetworkBufferDescriptor_t xNetworkBuffer;
201 uint32_t ulNumber = 0;
202
203 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
204 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
205 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
206 xApplicationGetRandomNumber_ReturnThruPtr_pulNumber( &ulNumber );
207
208 DNS_CreateSocket_ExpectAnyArgsAndReturn( NULL );
209
210 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
211 TEST_ASSERT_EQUAL( 0, ret );
212 }
213
214 /**
215 * @brief Ensures that when the dns request fails the function returns zero to
216 * the caller
217 */
test_FreeRTOS_gethostbyname_FailSendDNSRequest(void)218 void test_FreeRTOS_gethostbyname_FailSendDNSRequest( void )
219 {
220 int i;
221 uint32_t ret;
222 uint32_t ulNumber = 0;
223 NetworkBufferDescriptor_t xNetworkBuffer;
224 NetworkEndPoint_t xEndPoint = { 0 };
225 struct xSOCKET xDNSSocket;
226
227 xEndPoint.bits.bIPv6 = 0;
228 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
229 xEndPoint.ipv4_settings.ucDNSIndex = 0;
230 xNetworkBuffer.xDataLength = 2280;
231 xDNSSocket.usLocalPort = 0;
232
233 xNetworkBuffer.pucEthernetBuffer = malloc( 2280 + ipBUFFER_PADDING );
234 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
235
236 DNS_BindSocket_IgnoreAndReturn( 0 );
237 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
238 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
239 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
240 xApplicationGetRandomNumber_ReturnThruPtr_pulNumber( &ulNumber );
241
242 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
243
244 /* prvGetHostByNameOp */
245 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
246 {
247 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
248 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
249
250 /* in prvGetHostByName */
251 /* in prvGetPayloadBuffer */
252 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
253 /* back in prvGetHostByName */
254 /* prvFillSockAddress */
255 /* back prvGetHostByNameOp */
256 DNS_SendRequest_ExpectAnyArgsAndReturn( pdFAIL );
257 vReleaseNetworkBufferAndDescriptor_ExpectAnyArgs();
258 }
259
260 /* back in prvGetHostByName */
261 DNS_CloseSocket_ExpectAnyArgs();
262
263 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
264 TEST_ASSERT_EQUAL( 0, ret );
265
266 xNetworkBuffer.pucEthernetBuffer -= ipBUFFER_PADDING;
267 free( xNetworkBuffer.pucEthernetBuffer );
268 }
269
270 /**
271 * @brief Ensures when reading the dns reply fails, the test would try the set
272 * number of times, and return zero to the caller
273 */
test_FreeRTOS_gethostbyname_FailReadDNSReplyNull(void)274 void test_FreeRTOS_gethostbyname_FailReadDNSReplyNull( void )
275 {
276 uint32_t ret;
277 int i;
278 NetworkBufferDescriptor_t xNetworkBuffer;
279 struct xDNSBuffer xReceiveBuffer;
280 NetworkEndPoint_t xEndPoint = { 0 };
281 struct xSOCKET xDNSSocket;
282
283 xEndPoint.bits.bIPv6 = 0;
284 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
285 xEndPoint.ipv4_settings.ucDNSIndex = 0;
286 xReceiveBuffer.pucPayloadBuffer = NULL;
287 xReceiveBuffer.uxPayloadLength = 0;
288 xNetworkBuffer.xDataLength = 2280;
289 xNetworkBuffer.pucEthernetBuffer = malloc( 2280 + ipBUFFER_PADDING );
290 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
291 xDNSSocket.usLocalPort = 0;
292
293 DNS_BindSocket_IgnoreAndReturn( 0 );
294 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
295 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
296 FreeRTOS_inet_addr_ExpectAndReturn( LLMNR_ADDRESS, 0 );
297 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
298 xApplicationGetRandomNumber_IgnoreAndReturn( pdTRUE );
299 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
300
301 /* prvGetHostByNameOp */
302 /* prvFillSockAddress */
303 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
304 {
305 /* in prvGetHostByName */
306 /* in prvGetPayloadBuffer */
307 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
308 /* back in prvGetHostByName */
309 /* back prvGetHostByNameOp */
310 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
311
312 DNS_ReadReply_ExpectAnyArgsAndReturn( 0 );
313 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
314 }
315
316 /* back in prvGetHostByName */
317 DNS_CloseSocket_ExpectAnyArgs();
318
319 ret = FreeRTOS_gethostbyname( LLMNR_ADDRESS );
320 TEST_ASSERT_EQUAL( 0, ret );
321
322 xNetworkBuffer.pucEthernetBuffer -= ipBUFFER_PADDING;
323 free( xNetworkBuffer.pucEthernetBuffer );
324 }
325
326 /**
327 * @brief Ensure that a bad parse of a DNS packet causes the return to be zero
328 */
test_FreeRTOS_gethostbyname_FailSendDNSReplyZero(void)329 void test_FreeRTOS_gethostbyname_FailSendDNSReplyZero( void )
330 {
331 int i;
332 uint32_t ret;
333 NetworkBufferDescriptor_t xNetworkBuffer;
334 struct xDNSBuffer xReceiveBuffer;
335 uint32_t ulNumber = 0;
336 NetworkEndPoint_t xEndPoint = { 0 };
337 struct xSOCKET xDNSSocket;
338 uint8_t pucPayloadBuffer_Arr[ 300 ];
339
340 uint8_t buffer[ 2280 + ipBUFFER_PADDING ];
341
342 xEndPoint.bits.bIPv6 = 0;
343 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
344 xEndPoint.ipv4_settings.ucDNSIndex = 0;
345 xReceiveBuffer.pucPayloadBuffer = pucPayloadBuffer_Arr;
346 xReceiveBuffer.uxPayloadLength = 300;
347 memset( xReceiveBuffer.pucPayloadBuffer, 0x00, 300 );
348 DNSMessage_t * header = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
349
350 header->usIdentifier = 0;
351
352 xNetworkBuffer.xDataLength = 2280;
353 xNetworkBuffer.pucEthernetBuffer = buffer;
354 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
355 xNetworkBuffer.pxEndPoint = &xEndPoint;
356 xDNSSocket.usLocalPort = 0;
357
358 DNS_BindSocket_IgnoreAndReturn( 0 );
359 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
360 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
361 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
362 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
363 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
364 xApplicationGetRandomNumber_ReturnThruPtr_pulNumber( &ulNumber );
365 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
366
367 /* prvGetHostByNameOp */
368 /* prvFillSockAddress */
369 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
370 {
371 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
372 /* back prvGetHostByNameOp */
373 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
374 DNS_ReadReply_ExpectAnyArgsAndReturn( 0 );
375 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
376
377 FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
378 }
379
380 /* back in prvGetHostByName */
381 DNS_CloseSocket_ExpectAnyArgs();
382
383 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
384 TEST_ASSERT_EQUAL( 0, ret );
385
386 xNetworkBuffer.pucEthernetBuffer -= ipBUFFER_PADDING;
387 }
388
389 /**
390 * @brief Successful case, Ensures that the parsed DNS packet's IP address is
391 * returned to the caller
392 */
test_FreeRTOS_gethostbyname_Success(void)393 void test_FreeRTOS_gethostbyname_Success( void )
394 {
395 uint32_t ret;
396 NetworkBufferDescriptor_t xNetworkBuffer;
397 struct xDNSBuffer xReceiveBuffer;
398 uint32_t ulNumber = 343;
399 NetworkEndPoint_t xEndPoint = { 0 };
400 struct xSOCKET xDNSSocket;
401
402 uint8_t buffer[ 2280 + ipBUFFER_PADDING ];
403
404 xEndPoint.bits.bIPv6 = 0;
405 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
406 xEndPoint.ipv4_settings.ucDNSIndex = 0;
407 xReceiveBuffer.pucPayloadBuffer = malloc( 300 );
408 xReceiveBuffer.uxPayloadLength = 300;
409 memset( xReceiveBuffer.pucPayloadBuffer, 0x00, 300 );
410 DNSMessage_t * header = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
411
412 header->usIdentifier = 0;
413 xDNSSocket.usLocalPort = 0;
414
415 xNetworkBuffer.xDataLength = 2280;
416 xNetworkBuffer.pucEthernetBuffer = buffer;
417 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
418 memset( xNetworkBuffer.pucEthernetBuffer, 0x00, 2280 );
419
420 DNS_BindSocket_IgnoreAndReturn( 0 );
421 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
422 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
423 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
424 xApplicationGetRandomNumber_ReturnThruPtr_pulNumber( &ulNumber );
425
426 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
427 /* in prvGetHostByName */
428 /* in prvGetPayloadBuffer */
429 /* prvGetHostByNameOp */
430 /*FreeRTOS_GetAddressConfiguration_ExpectAnyArgs(); */
431 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
432 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
433 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
434 /* prvFillSockAddress */
435 /* back prvGetHostByNameOp */
436 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
437 DNS_ReadReply_ExpectAnyArgsAndReturn( 4 );
438 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
439 /* prvDNSReply */
440 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 12345 );
441 FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
442
443 /* back in prvGetHostByName */
444 DNS_CloseSocket_Ignore();
445
446 ret = FreeRTOS_gethostbyname( GOOD_ADDRESS );
447 TEST_ASSERT_EQUAL( 12345, ret );
448
449 xNetworkBuffer.pucEthernetBuffer -= ipBUFFER_PADDING;
450 free( xReceiveBuffer.pucPayloadBuffer );
451 }
452
453 /**
454 * @brief Ensures that DNS_ParseDNSReply is called, this function always returns
455 * pdFAIL
456 * @warning Function not really tested besides code coverage
457 */
test_ulDNSHandlePacket_Success(void)458 void test_ulDNSHandlePacket_Success( void )
459 {
460 uint32_t ret;
461 NetworkBufferDescriptor_t xNetworkBuffer;
462
463 xNetworkBuffer.xDataLength = sizeof( UDPPacket_t ) + sizeof( DNSMessage_t );
464 xNetworkBuffer.pucEthernetBuffer = malloc( sizeof( UDPPacket_t ) +
465 sizeof( DNSMessage_t ) );
466
467 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
468 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 0 );
469
470 ret = ulDNSHandlePacket( &xNetworkBuffer );
471 TEST_ASSERT_EQUAL( pdFAIL, ret );
472 free( xNetworkBuffer.pucEthernetBuffer );
473 }
474
475 /**
476 * @brief This function always returns pdFAIL
477 * @warning Function not really tested besides code coverage
478 */
test_ulDNSHandlePacket_FailSmallBuffer(void)479 void test_ulDNSHandlePacket_FailSmallBuffer( void )
480 {
481 uint32_t ret;
482 NetworkBufferDescriptor_t xNetworkBuffer;
483
484 xNetworkBuffer.xDataLength = sizeof( UDPPacket_t ) - 2;
485 xNetworkBuffer.pucEthernetBuffer = malloc( sizeof( UDPPacket_t ) - 2 );
486
487 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
488
489 ret = ulDNSHandlePacket( &xNetworkBuffer );
490 TEST_ASSERT_EQUAL( pdFAIL, ret );
491 free( xNetworkBuffer.pucEthernetBuffer );
492 }
493
494 /**
495 * @brief Always returns pdFAIL, trying different scenarios to have move
496 * coverage
497 * @warning Function not really tested besides code coverage
498 */
test_ulDNSHandlePacket_FailSmallBuffer2(void)499 void test_ulDNSHandlePacket_FailSmallBuffer2( void )
500 {
501 uint32_t ret;
502 NetworkBufferDescriptor_t xNetworkBuffer;
503
504 xNetworkBuffer.xDataLength = sizeof( UDPPacket_t ) + 2;
505 xNetworkBuffer.pucEthernetBuffer = malloc( sizeof( UDPPacket_t ) + 2 );
506
507 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
508
509 ret = ulDNSHandlePacket( &xNetworkBuffer );
510 TEST_ASSERT_EQUAL( pdFAIL, ret );
511 free( xNetworkBuffer.pucEthernetBuffer );
512 }
513
514 /**
515 * @brief Make sure function release the allocated buffer from DNS_ParseDNSReply
516 */
test_ulDNSHandlePacket_FreeBuffer(void)517 void test_ulDNSHandlePacket_FreeBuffer( void )
518 {
519 uint32_t ret;
520 NetworkBufferDescriptor_t xNetworkBuffer;
521 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
522 struct freertos_addrinfo * pxAddress;
523
524 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
525 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
526
527 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
528
529 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
530 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
531
532 pxAddress = ( struct freertos_addrinfo * ) pvPortMalloc( sizeof( struct freertos_addrinfo ) );
533 memset( pxAddress, 0, sizeof( struct freertos_addrinfo ) );
534
535 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
536 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 0 );
537 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxAddress );
538
539 ret = ulDNSHandlePacket( &xNetworkBuffer );
540 TEST_ASSERT_EQUAL( pdFAIL, ret );
541 }
542
543 /**
544 * @brief Functions always returns pdFAIL
545 * @warning Function not really tested besides code coverage
546 */
test_ulNBNSHandlePacket_Success(void)547 void test_ulNBNSHandlePacket_Success( void )
548 {
549 uint32_t ret;
550 NetworkBufferDescriptor_t xNetworkBuffer;
551 size_t uxBytesNeeded = sizeof( UDPPacket_t ) + sizeof( NBNSRequest_t );
552
553 xNetworkBuffer.xDataLength = uxBytesNeeded;
554 xNetworkBuffer.pucEthernetBuffer = malloc( uxBytesNeeded );
555
556 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
557 DNS_TreatNBNS_ExpectAnyArgs();
558
559 ret = ulNBNSHandlePacket( &xNetworkBuffer );
560 TEST_ASSERT_EQUAL( pdFAIL, ret );
561 free( xNetworkBuffer.pucEthernetBuffer );
562 }
563
564 /**
565 * @brief Functions always returns pdFAIL
566 * @warning Function not really tested besides code coverage
567 */
test_ulNBNSHandlePacket_FailSmallBuffer(void)568 void test_ulNBNSHandlePacket_FailSmallBuffer( void )
569 {
570 uint32_t ret;
571 NetworkBufferDescriptor_t xNetworkBuffer;
572 size_t uxBytesNeeded = sizeof( UDPPacket_t ) + sizeof( NBNSRequest_t );
573
574 xNetworkBuffer.xDataLength = uxBytesNeeded - 5;
575 xNetworkBuffer.pucEthernetBuffer = malloc( uxBytesNeeded - 5 );
576
577 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
578
579 ret = ulNBNSHandlePacket( &xNetworkBuffer );
580 TEST_ASSERT_EQUAL( pdFAIL, ret );
581
582 free( xNetworkBuffer.pucEthernetBuffer );
583 }
584
585 /**
586 * @brief Ensures that vDNSCheckCallback is called
587 */
test_FreeRTOS_gethostbyname_CancelSuccess(void)588 void test_FreeRTOS_gethostbyname_CancelSuccess( void )
589 {
590 void * pvSearchID = NULL;
591
592 vDNSCheckCallBack_ExpectAnyArgs();
593 FreeRTOS_gethostbyname_cancel( pvSearchID );
594 }
595
596
597 /**
598 * @brief Ensures that if pCallback is not null and the hostname is not in the
599 * cache, the application support random number generation,
600 * the callback function is set
601 */
test_FreeRTOS_gethostbyname_a_SetCallback(void)602 void test_FreeRTOS_gethostbyname_a_SetCallback( void )
603 {
604 uint32_t ret;
605 int pvSearchID = 32;
606 NetworkBufferDescriptor_t xNetworkBuffer;
607 struct xSOCKET xDNSSocket;
608
609 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
610 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
611 xApplicationGetRandomNumber_IgnoreAndReturn( pdTRUE );
612 vDNSSetCallBack_ExpectAnyArgs();
613 DNS_CreateSocket_ExpectAnyArgsAndReturn( NULL );
614
615 ret = FreeRTOS_gethostbyname_a( GOOD_ADDRESS,
616 dns_callback,
617 &pvSearchID,
618 0 );
619 TEST_ASSERT_EQUAL( 0, ret );
620 TEST_ASSERT_EQUAL( 0, callback_called );
621 }
622
623 /**
624 * @brief Ensures that if the application has no random number generation
625 * support, and ip is zero, no action is performed
626 */
test_FreeRTOS_gethostbyname_a_NoSetCallback(void)627 void test_FreeRTOS_gethostbyname_a_NoSetCallback( void )
628 {
629 uint32_t ret;
630 int pvSearchID = 32;
631 NetworkBufferDescriptor_t xNetworkBuffer;
632
633 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
634 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
635 xApplicationGetRandomNumber_IgnoreAndReturn( pdFALSE );
636
637 ret = FreeRTOS_gethostbyname_a( GOOD_ADDRESS,
638 dns_callback,
639 &pvSearchID,
640 0 );
641 TEST_ASSERT_EQUAL( 0, ret );
642 TEST_ASSERT_EQUAL( 0, callback_called );
643 }
644
645
646 /**
647 * @brief Ensures that if the function receives a callback, and ip address is
648 * not zero, the callback is called
649 */
test_FreeRTOS_gethostbyname_a_Callback(void)650 void test_FreeRTOS_gethostbyname_a_Callback( void )
651 {
652 uint32_t ret;
653 int pvSearchID = 32;
654
655 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
656 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 5 );
657 xApplicationGetRandomNumber_IgnoreAndReturn( pdTRUE );
658
659 ret = FreeRTOS_gethostbyname_a( GOOD_ADDRESS,
660 dns_callback,
661 &pvSearchID,
662 0 );
663 TEST_ASSERT_EQUAL( 5, ret );
664 TEST_ASSERT_EQUAL( 1, callback_called );
665 }
666
667 /**
668 * @brief Ensures that if vDNSSetCallBack is called the client is put in
669 * asynchronous mode, and only one retry is performed by calling
670 * prvGetHostByNameOp instead of prvGetHostByNameOp_WithRetry
671 */
test_FreeRTOS_gethostbyname_a_NoCallbackRetryOnce(void)672 void test_FreeRTOS_gethostbyname_a_NoCallbackRetryOnce( void )
673 {
674 uint32_t ret;
675 uint32_t ulNumber = 34;
676 int pvSearchID = 32;
677 NetworkEndPoint_t xEndPoint = { 0 };
678 NetworkBufferDescriptor_t xNetworkBuffer;
679 struct xDNSBuffer xReceiveBuffer;
680 struct xSOCKET xDNSSocket;
681 size_t uxBytesNeeded = sizeof( UDPPacket_t ) + sizeof( NBNSRequest_t );
682
683 xNetworkBuffer.pucEthernetBuffer = malloc( uxBytesNeeded + ipBUFFER_PADDING );
684 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
685 xNetworkBuffer.xDataLength = uxBytesNeeded;
686 xReceiveBuffer.pucPayloadBuffer = malloc( 300 );
687 xReceiveBuffer.uxPayloadLength = 300;
688 ( void ) memset( xNetworkBuffer.pucEthernetBuffer, 0x00, uxBytesNeeded );
689 ( void ) memset( xReceiveBuffer.pucPayloadBuffer, 0x00, 300 );
690 DNSMessage_t * header = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
691
692 header->usIdentifier = 12;
693 xDNSSocket.usLocalPort = 0;
694 xEndPoint.bits.bIPv6 = pdFALSE;
695 xEndPoint.ipv4_settings.ucDNSIndex = 0;
696 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = 0xC0C0C0C0;
697
698 DNS_BindSocket_IgnoreAndReturn( 0 );
699 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
700 Prepare_CacheLookup_ExpectAnyArgsAndReturn( 0 );
701 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
702 xApplicationGetRandomNumber_ReturnThruPtr_pulNumber( &ulNumber );
703 vDNSSetCallBack_ExpectAnyArgs();
704
705 /* in prvGetHostByName */
706 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
707 /* prvGetHostByNameOp */
708 /* prvFillSockAddress */
709 /* in prvSendBuffer */
710 /* in prvGetPayloadBuffer */
711
712 FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
713 FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
714
715 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
716
717 /* back in prvSendBuffer */
718 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
719
720 /* back in prvGetHostByNameOp */
721 DNS_ReadReply_ExpectAnyArgsAndReturn( 4 );
722 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
723 /* prvDNSReply */
724 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 12345 );
725 FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
726
727 /* back in prvGetHostByName */
728 DNS_CloseSocket_ExpectAnyArgs();
729
730 ret = FreeRTOS_gethostbyname_a( GOOD_ADDRESS,
731 dns_callback,
732 &pvSearchID,
733 0 );
734 TEST_ASSERT_EQUAL( 12345, ret );
735 TEST_ASSERT_EQUAL( 0, callback_called );
736
737 free( xNetworkBuffer.pucEthernetBuffer - ipBUFFER_PADDING );
738 free( xReceiveBuffer.pucPayloadBuffer );
739 }
740
741 /**
742 * @brief NULL input
743 */
test_FreeRTOS_getaddrinfo_NullInput(void)744 void test_FreeRTOS_getaddrinfo_NullInput( void )
745 {
746 BaseType_t xReturn;
747
748 xReturn = FreeRTOS_getaddrinfo( "Domain", "Service", NULL, NULL );
749
750 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
751 }
752
753 /**
754 * @brief Unknown family in preferences
755 */
test_FreeRTOS_getaddrinfo_a_UnknownHintFamily(void)756 void test_FreeRTOS_getaddrinfo_a_UnknownHintFamily( void )
757 {
758 BaseType_t xReturn;
759 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
760 struct freertos_addrinfo xHint, * pxHint = &xHint;
761
762 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
763 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
764
765 xHint.ai_family = FREERTOS_AF_INET6 + 1;
766
767 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
768
769 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EINVAL, xReturn );
770 TEST_ASSERT_EQUAL( NULL, pxAddress );
771 }
772
773 /**
774 * @brief IP address found with IPv4 address input
775 */
test_FreeRTOS_getaddrinfo_a_IPv4AddressFound(void)776 void test_FreeRTOS_getaddrinfo_a_IPv4AddressFound( void )
777 {
778 BaseType_t xReturn;
779 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
780 struct freertos_addrinfo xHint, * pxHint = &xHint;
781
782 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
783 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
784
785 xHint.ai_family = FREERTOS_AF_INET4;
786
787 FreeRTOS_inet_addr_ExpectAndReturn( DOTTED_IPV4_ADDRESS, DOTTED_IPV4_ADDRESS_UINT32 );
788 ulChar2u32_IgnoreAndReturn( DOTTED_IPV4_ADDRESS_UINT32 );
789
790 xReturn = FreeRTOS_getaddrinfo_a( DOTTED_IPV4_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
791
792 TEST_ASSERT_EQUAL( 0, xReturn );
793 TEST_ASSERT_EQUAL( 1, callback_called );
794 TEST_ASSERT_EQUAL( FREERTOS_AF_INET4, pxAddress->ai_family );
795 TEST_ASSERT_EQUAL( DOTTED_IPV4_ADDRESS_UINT32, FreeRTOS_htonl( pxAddress->ai_addr->sin_address.ulIP_IPv4 ) );
796 TEST_ASSERT_EQUAL( ipSIZE_OF_IPv4_ADDRESS, pxAddress->ai_addrlen );
797 }
798
799 /**
800 * @brief IP address found with IPv6 address input
801 */
test_FreeRTOS_getaddrinfo_a_IPv6AddressFound(void)802 void test_FreeRTOS_getaddrinfo_a_IPv6AddressFound( void )
803 {
804 BaseType_t xReturn;
805 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
806 struct freertos_addrinfo xHint, * pxHint = &xHint;
807
808 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
809 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
810
811 xHint.ai_family = FREERTOS_AF_INET6;
812
813 FreeRTOS_inet_pton6_ExpectAndReturn( DOTTED_IPv6_ADDRESS, NULL, 1 );
814 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
815 FreeRTOS_inet_pton6_ReturnMemThruPtr_pvDestination( &xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
816
817 xReturn = FreeRTOS_getaddrinfo_a( DOTTED_IPv6_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
818
819 TEST_ASSERT_EQUAL( 0, xReturn );
820 TEST_ASSERT_EQUAL( 1, callback_called );
821 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
822 TEST_ASSERT_EQUAL_MEMORY( xIPv6Address.ucBytes, pxAddress->ai_addr->sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
823 TEST_ASSERT_EQUAL( ipSIZE_OF_IPv6_ADDRESS, pxAddress->ai_addrlen );
824 }
825
826 /**
827 * @brief IP address found with IPv4 domain input
828 */
test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheFound(void)829 void test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheFound( void )
830 {
831 BaseType_t xReturn;
832 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
833 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
834
835 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
836 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
837
838 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
839
840 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
841 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, DOTTED_IPV4_ADDRESS_UINT32 );
842 Prepare_CacheLookup_ReturnMemThruPtr_ppxAddressInfo( &pxExpectedAddress, sizeof( struct freertos_addrinfo ) );
843
844 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", NULL, &pxAddress, dns_callback, NULL, 0U );
845
846 TEST_ASSERT_EQUAL( 0, xReturn );
847 TEST_ASSERT_EQUAL( 1, callback_called );
848 TEST_ASSERT_EQUAL( FREERTOS_AF_INET4, pxAddress->ai_family );
849 }
850
851 /**
852 * @brief IP address found with IPv6 domain input
853 */
test_FreeRTOS_getaddrinfo_a_IPv6DomainCacheFound(void)854 void test_FreeRTOS_getaddrinfo_a_IPv6DomainCacheFound( void )
855 {
856 BaseType_t xReturn;
857 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
858 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
859 struct freertos_addrinfo xHint, * pxHint = &xHint;
860
861 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
862 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
863 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
864
865 xHint.ai_family = FREERTOS_AF_INET6;
866
867 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
868
869 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
870 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
871 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 1 );
872 Prepare_CacheLookup_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
873
874 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
875
876 TEST_ASSERT_EQUAL( 0, xReturn );
877 TEST_ASSERT_EQUAL( 1, callback_called );
878 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
879 }
880
881 /**
882 * @brief IP address not found with IPv4 domain input. But we get unique identifier from random.
883 */
test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheMiss_Random(void)884 void test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheMiss_Random( void )
885 {
886 BaseType_t xReturn;
887 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
888 uint32_t ulRandom = 0x1234U;
889
890 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
891
892 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
893 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
894 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
895 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
896 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
897 DNS_CreateSocket_ExpectAndReturn( 0U, NULL );
898
899 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", NULL, &pxAddress, dns_callback, NULL, 0U );
900
901 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
902 }
903
904 /**
905 * @brief IP address not found with IPv6 domain input. But we get unique identifier from random.
906 */
test_FreeRTOS_getaddrinfo_a_IPv6DomainCacheMiss_Random(void)907 void test_FreeRTOS_getaddrinfo_a_IPv6DomainCacheMiss_Random( void )
908 {
909 BaseType_t xReturn;
910 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
911 struct freertos_addrinfo xHint, * pxHint = &xHint;
912 uint32_t ulRandom = 0x1234U;
913
914 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
915 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
916
917 xHint.ai_family = FREERTOS_AF_INET6;
918
919 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
920 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
921 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
922 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
923 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
924 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
925 DNS_CreateSocket_ExpectAndReturn( 0U, NULL );
926
927 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
928
929 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
930 }
931
932 /**
933 * @brief Try to get IP address through network but no valid endpoint found
934 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_EndPointNotFound(void)935 void test_FreeRTOS_getaddrinfo_a_IPv6Random_EndPointNotFound( void )
936 {
937 BaseType_t xReturn;
938 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
939 struct freertos_addrinfo xHint, * pxHint = &xHint;
940 uint32_t ulRandom = 0x1234U;
941 struct xSOCKET xDNSSocket;
942 NetworkEndPoint_t xEndPoint;
943
944 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
945 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
946 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
947 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
948
949 xEndPoint.bits.bIPv6 = pdFALSE;
950
951 xHint.ai_family = FREERTOS_AF_INET6;
952
953 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
954 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
955 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
956 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
957 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
958 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
959
960 /* In prvGetHostByName */
961 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
962 /* In prvGetHostByNameOp */
963 /* In prvFillSockAddress */
964 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
965 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
966 DNS_CloseSocket_Expect( &xDNSSocket );
967
968 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
969
970 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
971 }
972
973 /**
974 * @brief IPv4 socket bind fail with domain name containing dot
975 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_BindFailWithDot(void)976 void test_FreeRTOS_getaddrinfo_a_IPv4Random_BindFailWithDot( void )
977 {
978 BaseType_t xReturn;
979 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
980 struct freertos_addrinfo xHint, * pxHint = &xHint;
981 uint32_t ulRandom = 0x1234U;
982 struct xSOCKET xDNSSocket;
983 NetworkEndPoint_t xEndPoint[ 4 ];
984
985 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
986 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
987 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
988 memset( &xEndPoint[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
989 memset( &xEndPoint[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
990 memset( &xEndPoint[ 2 ], 0, sizeof( NetworkEndPoint_t ) );
991 memset( &xEndPoint[ 3 ], 0, sizeof( NetworkEndPoint_t ) );
992
993 xEndPoint[ 0 ].bits.bIPv6 = pdTRUE;
994
995 xEndPoint[ 1 ].bits.bIPv6 = pdFALSE;
996 xEndPoint[ 1 ].ipv4_settings.ucDNSIndex = 0;
997 xEndPoint[ 1 ].ipv4_settings.ulDNSServerAddresses[ 0 ] = 0U;
998
999 xEndPoint[ 2 ].bits.bIPv6 = pdFALSE;
1000 xEndPoint[ 2 ].ipv4_settings.ucDNSIndex = 0;
1001 xEndPoint[ 2 ].ipv4_settings.ulDNSServerAddresses[ 0 ] = ipBROADCAST_IP_ADDRESS;
1002
1003 xEndPoint[ 3 ].bits.bIPv6 = pdFALSE;
1004 xEndPoint[ 3 ].ipv4_settings.ucDNSIndex = 0;
1005 xEndPoint[ 3 ].ipv4_settings.ulDNSServerAddresses[ 0 ] = DOTTED_IPV4_ADDRESS_UINT32;
1006
1007 xHint.ai_family = FREERTOS_AF_INET4;
1008
1009 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
1010 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1011 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1012 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1013 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1014
1015 /* In prvGetHostByName */
1016 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1017 /* In prvGetHostByNameOp */
1018 /* In prvFillSockAddress */
1019 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ] );
1020 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ], &xEndPoint[ 1 ] );
1021 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 1 ], &xEndPoint[ 2 ] );
1022 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 2 ], &xEndPoint[ 3 ] );
1023 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, -1 );
1024 DNS_CloseSocket_Expect( &xDNSSocket );
1025
1026 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1027
1028 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1029 }
1030
1031 /**
1032 * @brief IPv6 socket bind fail with domain name containing dot
1033 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_BindFailWithDot(void)1034 void test_FreeRTOS_getaddrinfo_a_IPv6Random_BindFailWithDot( void )
1035 {
1036 BaseType_t xReturn;
1037 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1038 struct freertos_addrinfo xHint, * pxHint = &xHint;
1039 uint32_t ulRandom = 0x1234U;
1040 struct xSOCKET xDNSSocket;
1041 NetworkEndPoint_t xEndPoint[ 5 ];
1042
1043 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1044 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1045 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1046 memset( &xEndPoint[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
1047 memset( &xEndPoint[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
1048 memset( &xEndPoint[ 2 ], 0, sizeof( NetworkEndPoint_t ) );
1049 memset( &xEndPoint[ 3 ], 0, sizeof( NetworkEndPoint_t ) );
1050 memset( &xEndPoint[ 4 ], 0, sizeof( NetworkEndPoint_t ) );
1051
1052 xEndPoint[ 0 ].bits.bIPv6 = pdFALSE;
1053
1054 xEndPoint[ 1 ].bits.bIPv6 = pdTRUE;
1055 xEndPoint[ 1 ].ipv6_settings.ucDNSIndex = 0;
1056 xEndPoint[ 1 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 0 ] = 0U;
1057 xEndPoint[ 1 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 1 ] = 1U;
1058
1059 xEndPoint[ 2 ].bits.bIPv6 = pdTRUE;
1060 xEndPoint[ 2 ].ipv6_settings.ucDNSIndex = 0;
1061 xEndPoint[ 2 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 0 ] = 1U;
1062 xEndPoint[ 2 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 1 ] = 0U;
1063
1064 xEndPoint[ 3 ].bits.bIPv6 = pdTRUE;
1065 xEndPoint[ 3 ].ipv6_settings.ucDNSIndex = 0;
1066 xEndPoint[ 3 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 0 ] = 0U;
1067 xEndPoint[ 3 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes[ 1 ] = 0U;
1068
1069 xEndPoint[ 4 ].bits.bIPv6 = pdTRUE;
1070 xEndPoint[ 4 ].ipv6_settings.ucDNSIndex = 0;
1071 memcpy( xEndPoint[ 4 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1072
1073 xHint.ai_family = FREERTOS_AF_INET6;
1074
1075 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
1076 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1077 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1078 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1079 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1080 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1081
1082 /* In prvGetHostByName */
1083 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1084 /* In prvGetHostByNameOp */
1085 /* In prvFillSockAddress */
1086 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ] );
1087 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ], &xEndPoint[ 1 ] );
1088 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 1 ], &xEndPoint[ 2 ] );
1089 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 2 ], &xEndPoint[ 3 ] );
1090 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 3 ], &xEndPoint[ 4 ] );
1091 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, -1 );
1092 DNS_CloseSocket_Expect( &xDNSSocket );
1093
1094 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1095
1096 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1097 }
1098
1099 /**
1100 * @brief IPv4 socket bind fail with domain name doesn't contain dot
1101 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_BindFailWODot(void)1102 void test_FreeRTOS_getaddrinfo_a_IPv4Random_BindFailWODot( void )
1103 {
1104 BaseType_t xReturn;
1105 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1106 struct freertos_addrinfo xHint, * pxHint = &xHint;
1107 uint32_t ulRandom = 0x1234U;
1108 struct xSOCKET xDNSSocket;
1109 NetworkEndPoint_t xEndPoint[ 2 ];
1110
1111 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1112 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1113 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1114 memset( &xEndPoint[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
1115 memset( &xEndPoint[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
1116
1117 xEndPoint[ 0 ].bits.bIPv6 = pdTRUE;
1118
1119 xEndPoint[ 1 ].bits.bIPv6 = pdFALSE;
1120 xEndPoint[ 1 ].ipv4_settings.ucDNSIndex = 0;
1121 xEndPoint[ 1 ].ipv4_settings.ulDNSServerAddresses[ 0 ] = DOTTED_IPV4_ADDRESS_UINT32;
1122
1123 xHint.ai_family = FREERTOS_AF_INET4;
1124
1125 FreeRTOS_inet_addr_ExpectAndReturn( LLMNR_ADDRESS, 0 );
1126 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1127 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1128 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1129 vDNSSetCallBack_Expect( LLMNR_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1130
1131 /* In prvGetHostByName */
1132 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1133 /* In prvGetHostByNameOp */
1134 /* In prvFillSockAddress */
1135 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ] );
1136 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ], &xEndPoint[ 1 ] );
1137 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, -1 );
1138 DNS_CloseSocket_Expect( &xDNSSocket );
1139
1140 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1141
1142 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1143 }
1144
1145 /**
1146 * @brief IPv6 socket bind fail with domain name doesn't contain dot
1147 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_BindFailWODot(void)1148 void test_FreeRTOS_getaddrinfo_a_IPv6Random_BindFailWODot( void )
1149 {
1150 BaseType_t xReturn;
1151 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1152 struct freertos_addrinfo xHint, * pxHint = &xHint;
1153 uint32_t ulRandom = 0x1234U;
1154 struct xSOCKET xDNSSocket;
1155 NetworkEndPoint_t xEndPoint[ 2 ];
1156
1157 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1158 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1159 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1160 memset( &xEndPoint[ 0 ], 0, sizeof( NetworkEndPoint_t ) );
1161 memset( &xEndPoint[ 1 ], 0, sizeof( NetworkEndPoint_t ) );
1162
1163 xEndPoint[ 0 ].bits.bIPv6 = pdFALSE;
1164
1165 xEndPoint[ 1 ].bits.bIPv6 = pdTRUE;
1166 memcpy( xEndPoint[ 1 ].ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1167
1168 xHint.ai_family = FREERTOS_AF_INET6;
1169
1170 FreeRTOS_inet_pton6_ExpectAndReturn( LLMNR_ADDRESS, NULL, 0 );
1171 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1172 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1173 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1174 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1175 vDNSSetCallBack_Expect( LLMNR_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1176
1177 /* In prvGetHostByName */
1178 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1179 /* In prvGetHostByNameOp */
1180 /* In prvFillSockAddress */
1181 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ] );
1182 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint[ 0 ], &xEndPoint[ 1 ] );
1183 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, -1 );
1184 DNS_CloseSocket_Expect( &xDNSSocket );
1185
1186 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1187
1188 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1189 }
1190
1191 /**
1192 * @brief Assertion happens when DNS server index is equal to or greater than maximum in IPv4 endpoint.
1193 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_InvalidDNSServerIndex(void)1194 void test_FreeRTOS_getaddrinfo_a_IPv4Random_InvalidDNSServerIndex( void )
1195 {
1196 BaseType_t xReturn;
1197 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1198 struct freertos_addrinfo xHint, * pxHint = &xHint;
1199 uint32_t ulRandom = 0x1234U;
1200 struct xSOCKET xDNSSocket;
1201 NetworkEndPoint_t xEndPoint;
1202
1203 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1204 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1205 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1206 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1207
1208 xEndPoint.bits.bIPv6 = pdFALSE;
1209 xEndPoint.ipv4_settings.ucDNSIndex = ipconfigENDPOINT_DNS_ADDRESS_COUNT;
1210
1211 xHint.ai_family = FREERTOS_AF_INET4;
1212
1213 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
1214 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1215 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1216 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1217 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1218
1219 /* In prvGetHostByName */
1220 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1221 /* In prvGetHostByNameOp */
1222 /* In prvFillSockAddress */
1223 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1224
1225 catch_assert( FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U ) );
1226 }
1227
1228 /**
1229 * @brief Assertion happens when DNS server index is equal to or greater than maximum in IPv6 endpoint.
1230 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_InvalidDNSServerIndex(void)1231 void test_FreeRTOS_getaddrinfo_a_IPv6Random_InvalidDNSServerIndex( void )
1232 {
1233 BaseType_t xReturn;
1234 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1235 struct freertos_addrinfo xHint, * pxHint = &xHint;
1236 uint32_t ulRandom = 0x1234U;
1237 struct xSOCKET xDNSSocket;
1238 NetworkEndPoint_t xEndPoint;
1239
1240 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1241 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1242 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1243 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1244
1245 xEndPoint.bits.bIPv6 = pdTRUE;
1246 xEndPoint.ipv6_settings.ucDNSIndex = ipconfigENDPOINT_DNS_ADDRESS_COUNT;
1247
1248 xHint.ai_family = FREERTOS_AF_INET6;
1249
1250 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
1251 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1252 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1253 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1254 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1255 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1256
1257 /* In prvGetHostByName */
1258 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1259 /* In prvGetHostByNameOp */
1260 /* In prvFillSockAddress */
1261 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1262
1263 catch_assert( FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U ) );
1264 }
1265
1266 /**
1267 * @brief Run DNS query with unknown DNS preference
1268 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_UnknownPreference(void)1269 void test_FreeRTOS_getaddrinfo_a_IPv4Random_UnknownPreference( void )
1270 {
1271 BaseType_t xReturn;
1272 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1273 struct freertos_addrinfo xHint, * pxHint = &xHint;
1274 uint32_t ulRandom = 0x1234U;
1275 struct xSOCKET xDNSSocket;
1276 NetworkEndPoint_t xEndPoint;
1277
1278 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1279 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1280 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1281 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1282
1283 xEndPoint.bits.bIPv6 = pdFALSE;
1284 xEndPoint.ipv6_settings.ucDNSIndex = 0;
1285
1286 xHint.ai_family = FREERTOS_AF_INET4;
1287
1288 xDNS_IP_Preference = xPreferenceNone;
1289
1290 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
1291 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1292 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1293 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1294 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1295
1296 /* In prvGetHostByName */
1297 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1298 /* In prvGetHostByNameOp */
1299 /* In prvFillSockAddress */
1300 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1301 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
1302 DNS_CloseSocket_Expect( &xDNSSocket );
1303
1304 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1305
1306 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1307 }
1308
1309 /**
1310 * @brief Get the IP address from prvGetHostByName successfully
1311 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_DNSReplySuccess(void)1312 void test_FreeRTOS_getaddrinfo_a_IPv6Random_DNSReplySuccess( void )
1313 {
1314 BaseType_t xReturn;
1315 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1316 struct freertos_addrinfo xHint, * pxHint = &xHint;
1317 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1318 uint32_t ulRandom = 0x1234U;
1319 struct xSOCKET xDNSSocket;
1320 NetworkEndPoint_t xEndPoint;
1321 NetworkBufferDescriptor_t xNetworkBuffer;
1322 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1323 struct xDNSBuffer xReceiveBuffer;
1324 DNSMessage_t * pxDNSMessageHeader = NULL;
1325
1326 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1327 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1328 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1329 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1330 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1331 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1332 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1333 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1334
1335 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1336
1337 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1338 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1339
1340 xEndPoint.bits.bIPv6 = pdTRUE;
1341 xEndPoint.ipv6_settings.ucDNSIndex = 0;
1342 memcpy( xEndPoint.ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1343
1344 xHint.ai_family = FREERTOS_AF_INET6;
1345 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
1346
1347 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1348 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1349
1350 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1351 pxDNSMessageHeader->usIdentifier = ulRandom;
1352
1353 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
1354 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1355 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1356 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1357 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1358 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1359
1360 /* In prvGetHostByName */
1361 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
1362 /* In prvGetHostByNameOp */
1363 /* In prvFillSockAddress */
1364 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1365
1366 /* Back prvGetHostByNameOp */
1367 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, 0 );
1368 /* In prvSendBuffer */
1369 /* In prvGetPayloadBuffer */
1370 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1371 /* Back prvSendBuffer */
1372 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1373 /* Back prvGetHostByNameOp */
1374 DNS_ReadReply_ExpectAnyArgsAndReturn( ipconfigNETWORK_MTU );
1375 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
1376 /* In prvDNSReply */
1377 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 1 );
1378 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
1379 /* Back prvGetHostByNameOp */
1380 FreeRTOS_ReleaseUDPPayloadBuffer_Expect( xReceiveBuffer.pucPayloadBuffer );
1381
1382 /* Back prvGetHostByName */
1383 DNS_CloseSocket_Expect( &xDNSSocket );
1384
1385 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1386
1387 TEST_ASSERT_EQUAL( 0, xReturn );
1388 TEST_ASSERT_EQUAL( 0, callback_called );
1389 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
1390 }
1391
1392 /**
1393 * @brief Get the IP address from prvGetHostByName fail and retry exhausted
1394 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_RetryExhaust(void)1395 void test_FreeRTOS_getaddrinfo_a_IPv6Random_RetryExhaust( void )
1396 {
1397 BaseType_t xReturn;
1398 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1399 struct freertos_addrinfo xHint, * pxHint = &xHint;
1400 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1401 uint32_t ulRandom = 0x1234U;
1402 struct xSOCKET xDNSSocket;
1403 NetworkEndPoint_t xEndPoint;
1404 NetworkBufferDescriptor_t xNetworkBuffer;
1405 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1406 struct xDNSBuffer xReceiveBuffer;
1407 DNSMessage_t * pxDNSMessageHeader = NULL;
1408 int i;
1409
1410 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1411 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1412 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1413 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1414 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1415 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1416 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1417 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1418
1419 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1420
1421 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1422 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1423
1424 xEndPoint.bits.bIPv6 = pdTRUE;
1425 xEndPoint.ipv6_settings.ucDNSIndex = 0;
1426 memcpy( xEndPoint.ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1427
1428 xHint.ai_family = FREERTOS_AF_INET6;
1429 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
1430
1431 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1432 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1433
1434 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1435 pxDNSMessageHeader->usIdentifier = ulRandom;
1436
1437 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
1438 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1439 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1440 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1441 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1442
1443 /* In prvGetHostByName */
1444 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1445
1446 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
1447 {
1448 /* In prvGetHostByNameOp */
1449 /* In prvFillSockAddress */
1450 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1451
1452 /* Back prvGetHostByNameOp */
1453 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, 0 );
1454 /* In prvSendBuffer */
1455 /* In prvGetPayloadBuffer */
1456 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1457 /* Back prvSendBuffer */
1458 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1459 /* Back prvGetHostByNameOp */
1460 DNS_ReadReply_ExpectAnyArgsAndReturn( -pdFREERTOS_ERRNO_EWOULDBLOCK );
1461 }
1462
1463 /* Back prvGetHostByName */
1464 DNS_CloseSocket_Expect( &xDNSSocket );
1465
1466 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, NULL, NULL, 0U );
1467
1468 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1469 TEST_ASSERT_EQUAL( 0, callback_called );
1470 }
1471
1472 /**
1473 * @brief Get the IPv4 address from prvGetHostByName for .local domain successfully
1474 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_LocalDNSSuccess(void)1475 void test_FreeRTOS_getaddrinfo_a_IPv4Random_LocalDNSSuccess( void )
1476 {
1477 BaseType_t xReturn;
1478 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1479 struct freertos_addrinfo xHint, * pxHint = &xHint;
1480 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1481 uint32_t ulRandom = 0x1234U;
1482 struct xSOCKET xDNSSocket;
1483 NetworkEndPoint_t xEndPoint;
1484 NetworkBufferDescriptor_t xNetworkBuffer;
1485 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1486 struct xDNSBuffer xReceiveBuffer;
1487 DNSMessage_t * pxDNSMessageHeader = NULL;
1488 int i;
1489 struct freertos_sockaddr xExpectedSockAddress, * pxExpectedSockAddress = &xExpectedSockAddress;
1490
1491 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1492 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1493 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1494 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1495 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1496 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1497 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1498 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1499 memset( &xExpectedSockAddress, 0, sizeof( struct freertos_sockaddr ) );
1500
1501 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1502
1503 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1504 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1505
1506 xEndPoint.bits.bIPv6 = pdFALSE;
1507 xEndPoint.ipv4_settings.ucDNSIndex = 0;
1508 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = DOTTED_IPV4_ADDRESS_UINT32;
1509
1510 xHint.ai_family = FREERTOS_AF_INET4;
1511 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
1512
1513 xExpectedSockAddress.sin_port = FreeRTOS_htons( ipMDNS_PORT );
1514
1515 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1516 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER;
1517
1518 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1519 pxDNSMessageHeader->usIdentifier = ulRandom;
1520
1521 FreeRTOS_inet_addr_ExpectAndReturn( LOCAL_ADDRESS, 0 );
1522 Prepare_CacheLookup_ExpectAndReturn( LOCAL_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1523 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1524 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1525 vDNSSetCallBack_Expect( LOCAL_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1526
1527 /* In prvGetHostByName */
1528 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1529
1530 /* In prvGetHostByNameOp */
1531 /* In prvFillSockAddress */
1532 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1533
1534 /* Back prvGetHostByNameOp */
1535 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, FreeRTOS_htons( ipMDNS_PORT ), 0 );
1536 /* In prvSendBuffer */
1537 /* In prvGetPayloadBuffer */
1538 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1539 /* Back prvSendBuffer */
1540 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1541 /* Back prvGetHostByNameOp */
1542 DNS_ReadReply_ExpectAnyArgsAndReturn( ipconfigNETWORK_MTU );
1543 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
1544 DNS_ReadReply_ReturnThruPtr_xAddress( pxExpectedSockAddress );
1545 /* In prvDNSReply */
1546 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 1 );
1547 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
1548 /* Back prvGetHostByNameOp */
1549 FreeRTOS_ReleaseUDPPayloadBuffer_Expect( xReceiveBuffer.pucPayloadBuffer );
1550
1551 /* Back prvGetHostByName */
1552 DNS_CloseSocket_Expect( &xDNSSocket );
1553
1554 xReturn = FreeRTOS_getaddrinfo_a( LOCAL_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1555
1556 TEST_ASSERT_EQUAL( 0, xReturn );
1557 TEST_ASSERT_EQUAL( 0, callback_called );
1558 TEST_ASSERT_EQUAL( FREERTOS_AF_INET4, pxAddress->ai_family );
1559 }
1560
1561 /**
1562 * @brief Get the IPv6 address from prvGetHostByName for .local domain successfully
1563 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_LocalDNSSuccess(void)1564 void test_FreeRTOS_getaddrinfo_a_IPv6Random_LocalDNSSuccess( void )
1565 {
1566 BaseType_t xReturn;
1567 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1568 struct freertos_addrinfo xHint, * pxHint = &xHint;
1569 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1570 uint32_t ulRandom = 0x1234U;
1571 struct xSOCKET xDNSSocket;
1572 NetworkEndPoint_t xEndPoint;
1573 NetworkBufferDescriptor_t xNetworkBuffer;
1574 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1575 struct xDNSBuffer xReceiveBuffer;
1576 DNSMessage_t * pxDNSMessageHeader = NULL;
1577 int i;
1578
1579 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1580 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1581 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1582 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1583 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1584 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1585 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1586 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1587
1588 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1589
1590 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1591 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1592
1593 xEndPoint.bits.bIPv6 = pdTRUE;
1594 xEndPoint.ipv6_settings.ucDNSIndex = 0;
1595 memcpy( xEndPoint.ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1596
1597 xHint.ai_family = FREERTOS_AF_INET6;
1598 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
1599
1600 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1601 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1602
1603 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1604 pxDNSMessageHeader->usIdentifier = ulRandom;
1605
1606 FreeRTOS_inet_pton6_ExpectAndReturn( LOCAL_ADDRESS, NULL, 0 );
1607 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1608 Prepare_CacheLookup_ExpectAndReturn( LOCAL_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1609 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1610 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1611 vDNSSetCallBack_Expect( LOCAL_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1612
1613 /* In prvGetHostByName */
1614 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1615
1616 /* In prvGetHostByNameOp */
1617 /* In prvFillSockAddress */
1618 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1619
1620 /* Back prvGetHostByNameOp */
1621 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, FreeRTOS_htons( ipMDNS_PORT ), 0 );
1622 /* In prvSendBuffer */
1623 /* In prvGetPayloadBuffer */
1624 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1625 /* Back prvSendBuffer */
1626 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1627 /* Back prvGetHostByNameOp */
1628 DNS_ReadReply_ExpectAnyArgsAndReturn( ipconfigNETWORK_MTU );
1629 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
1630 /* In prvDNSReply */
1631 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 1 );
1632 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
1633 /* Back prvGetHostByNameOp */
1634 FreeRTOS_ReleaseUDPPayloadBuffer_Expect( xReceiveBuffer.pucPayloadBuffer );
1635
1636 /* Back prvGetHostByName */
1637 DNS_CloseSocket_Expect( &xDNSSocket );
1638
1639 xReturn = FreeRTOS_getaddrinfo_a( LOCAL_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1640
1641 TEST_ASSERT_EQUAL( 0, xReturn );
1642 TEST_ASSERT_EQUAL( 0, callback_called );
1643 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
1644 }
1645
1646 /**
1647 * @brief Unknown DNS preference in local DNS query
1648 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_LocalDNSUnknownPreference(void)1649 void test_FreeRTOS_getaddrinfo_a_IPv4Random_LocalDNSUnknownPreference( void )
1650 {
1651 BaseType_t xReturn;
1652 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1653 struct freertos_addrinfo xHint, * pxHint = &xHint;
1654 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1655 uint32_t ulRandom = 0x1234U;
1656 struct xSOCKET xDNSSocket;
1657 NetworkEndPoint_t xEndPoint;
1658 NetworkBufferDescriptor_t xNetworkBuffer;
1659 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1660 struct xDNSBuffer xReceiveBuffer;
1661 DNSMessage_t * pxDNSMessageHeader = NULL;
1662 int i;
1663
1664 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1665 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1666 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1667 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1668 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1669 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1670 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1671 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1672
1673 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1674
1675 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1676 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1677
1678 xEndPoint.bits.bIPv6 = pdFALSE;
1679 xEndPoint.ipv4_settings.ucDNSIndex = 0;
1680 xEndPoint.ipv4_settings.ulDNSServerAddresses[ 0 ] = DOTTED_IPV4_ADDRESS_UINT32;
1681
1682 xHint.ai_family = FREERTOS_AF_INET4;
1683 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
1684
1685 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1686 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER;
1687
1688 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1689 pxDNSMessageHeader->usIdentifier = ulRandom;
1690
1691 xDNS_IP_Preference = xPreferenceNone;
1692
1693 FreeRTOS_inet_addr_ExpectAndReturn( LOCAL_ADDRESS, 0 );
1694 Prepare_CacheLookup_ExpectAndReturn( LOCAL_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1695 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1696 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1697 vDNSSetCallBack_Expect( LOCAL_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1698
1699 /* In prvGetHostByName */
1700 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1701
1702 /* Back prvGetHostByName */
1703 DNS_CloseSocket_Expect( &xDNSSocket );
1704
1705 xReturn = FreeRTOS_getaddrinfo_a( LOCAL_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1706
1707 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1708 TEST_ASSERT_EQUAL( 0, callback_called );
1709 }
1710
1711 /**
1712 * @brief Get the IPv6 address from prvGetHostByName for LLMNR successfully
1713 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRDNSSuccess(void)1714 void test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRDNSSuccess( void )
1715 {
1716 BaseType_t xReturn;
1717 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1718 struct freertos_addrinfo xHint, * pxHint = &xHint;
1719 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1720 uint32_t ulRandom = 0x1234U;
1721 struct xSOCKET xDNSSocket;
1722 NetworkEndPoint_t xEndPoint;
1723 NetworkBufferDescriptor_t xNetworkBuffer;
1724 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1725 struct xDNSBuffer xReceiveBuffer;
1726 DNSMessage_t * pxDNSMessageHeader = NULL;
1727 int i;
1728
1729 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1730 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1731 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1732 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1733 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1734 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1735 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1736 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1737
1738 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1739
1740 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1741 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1742
1743 xEndPoint.bits.bIPv6 = pdTRUE;
1744 xEndPoint.ipv6_settings.ucDNSIndex = 0;
1745 memcpy( xEndPoint.ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
1746
1747 xHint.ai_family = FREERTOS_AF_INET6;
1748 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
1749
1750 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1751 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1752
1753 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1754 pxDNSMessageHeader->usIdentifier = ulRandom;
1755
1756 FreeRTOS_inet_pton6_ExpectAndReturn( LLMNR_ADDRESS, NULL, 0 );
1757 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1758 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1759 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1760 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1761 vDNSSetCallBack_Expect( LLMNR_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1762
1763 /* In prvGetHostByName */
1764 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1765
1766 /* In prvGetHostByNameOp */
1767 /* In prvFillSockAddress */
1768 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1769
1770 /* Back prvGetHostByNameOp */
1771 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, 0 );
1772 /* In prvSendBuffer */
1773 /* In prvGetPayloadBuffer */
1774 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1775 /* Back prvSendBuffer */
1776 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1777 /* Back prvGetHostByNameOp */
1778 DNS_ReadReply_ExpectAnyArgsAndReturn( ipconfigNETWORK_MTU );
1779 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
1780 /* In prvDNSReply */
1781 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 1 );
1782 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
1783 /* Back prvGetHostByNameOp */
1784 FreeRTOS_ReleaseUDPPayloadBuffer_Expect( xReceiveBuffer.pucPayloadBuffer );
1785
1786 /* Back prvGetHostByName */
1787 DNS_CloseSocket_Expect( &xDNSSocket );
1788
1789 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1790
1791 TEST_ASSERT_EQUAL( 0, xReturn );
1792 TEST_ASSERT_EQUAL( 0, callback_called );
1793 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
1794 }
1795
1796 /**
1797 * @brief No endpoint available for LLMNR DNS query
1798 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRDNSNoEndPoint(void)1799 void test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRDNSNoEndPoint( void )
1800 {
1801 BaseType_t xReturn;
1802 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1803 struct freertos_addrinfo xHint, * pxHint = &xHint;
1804 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1805 uint32_t ulRandom = 0x1234U;
1806 struct xSOCKET xDNSSocket;
1807 NetworkBufferDescriptor_t xNetworkBuffer;
1808 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1809 struct xDNSBuffer xReceiveBuffer;
1810 DNSMessage_t * pxDNSMessageHeader = NULL;
1811 int i;
1812
1813 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1814 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1815 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1816 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1817 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1818 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1819 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1820
1821 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1822
1823 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1824 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1825
1826 xHint.ai_family = FREERTOS_AF_INET6;
1827 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
1828
1829 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1830 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1831
1832 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1833 pxDNSMessageHeader->usIdentifier = ulRandom;
1834
1835 FreeRTOS_inet_pton6_ExpectAndReturn( LLMNR_ADDRESS, NULL, 0 );
1836 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
1837 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
1838 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1839 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1840 vDNSSetCallBack_Expect( LLMNR_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
1841
1842 /* In prvGetHostByName */
1843 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1844
1845 /* In prvGetHostByNameOp */
1846 /* In prvFillSockAddress */
1847 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, NULL );
1848
1849 /* Back prvGetHostByName */
1850 DNS_CloseSocket_Expect( &xDNSSocket );
1851
1852 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1853
1854 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1855 TEST_ASSERT_EQUAL( 0, callback_called );
1856 }
1857
1858 /**
1859 * @brief Unknown DNS preference in LLMNR DNS query
1860 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_LLMNRDNSUnknownPreference(void)1861 void test_FreeRTOS_getaddrinfo_a_IPv4Random_LLMNRDNSUnknownPreference( void )
1862 {
1863 BaseType_t xReturn;
1864 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1865 struct freertos_addrinfo xHint, * pxHint = &xHint;
1866 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1867 uint32_t ulRandom = 0x1234U;
1868 struct xSOCKET xDNSSocket;
1869 NetworkEndPoint_t xEndPoint;
1870 NetworkBufferDescriptor_t xNetworkBuffer;
1871 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1872 struct xDNSBuffer xReceiveBuffer;
1873 DNSMessage_t * pxDNSMessageHeader = NULL;
1874 int i;
1875
1876 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1877 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1878 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1879 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1880 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1881 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1882 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1883 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1884
1885 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1886
1887 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1888 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1889
1890 xEndPoint.bits.bIPv6 = pdFALSE;
1891
1892 xHint.ai_family = FREERTOS_AF_INET4;
1893 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
1894
1895 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1896 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
1897
1898 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1899 pxDNSMessageHeader->usIdentifier = ulRandom;
1900
1901 xDNS_IP_Preference = xPreferenceNone;
1902
1903 FreeRTOS_inet_addr_ExpectAndReturn( LLMNR_ADDRESS, 0 );
1904 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1905 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1906 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1907 vDNSSetCallBack_Expect( LLMNR_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdFALSE );
1908
1909 /* In prvGetHostByName */
1910 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1911
1912 /* In prvGetHostByNameOp */
1913 /* In prvFillSockAddress */
1914
1915 /* Back prvGetHostByName */
1916 DNS_CloseSocket_Expect( &xDNSSocket );
1917
1918 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
1919
1920 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1921 TEST_ASSERT_EQUAL( 0, callback_called );
1922 }
1923
1924 /**
1925 * @brief Fail to get the IPv4 address from prvGetHostByName for LLMNR
1926 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_LLMNRFail(void)1927 void test_FreeRTOS_getaddrinfo_a_IPv4Random_LLMNRFail( void )
1928 {
1929 BaseType_t xReturn;
1930 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
1931 struct freertos_addrinfo xHint, * pxHint = &xHint;
1932 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
1933 uint32_t ulRandom = 0x1234U;
1934 struct xSOCKET xDNSSocket;
1935 NetworkEndPoint_t xEndPoint;
1936 NetworkBufferDescriptor_t xNetworkBuffer;
1937 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
1938 struct xDNSBuffer xReceiveBuffer;
1939 DNSMessage_t * pxDNSMessageHeader = NULL;
1940 int i;
1941
1942 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
1943 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
1944 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
1945 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
1946 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1947 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1948 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
1949 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
1950
1951 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
1952
1953 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
1954 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
1955
1956 xEndPoint.bits.bIPv6 = pdFALSE;
1957
1958 xHint.ai_family = FREERTOS_AF_INET4;
1959 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
1960
1961 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
1962 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER;
1963
1964 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
1965 pxDNSMessageHeader->usIdentifier = ulRandom;
1966
1967 FreeRTOS_inet_addr_ExpectAndReturn( LLMNR_ADDRESS, 0 );
1968 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET4, &pxAddress, 0 );
1969 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
1970 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
1971
1972 /* In prvGetHostByName */
1973 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
1974
1975 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
1976 {
1977 /* In prvGetHostByNameOp */
1978 /* In prvFillSockAddress */
1979 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1980
1981 /* Back prvGetHostByNameOp */
1982 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, 0 );
1983 /* In prvSendBuffer */
1984 /* In prvGetPayloadBuffer */
1985 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1986 /* Back prvSendBuffer */
1987 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
1988 /* Back prvGetHostByNameOp */
1989 DNS_ReadReply_ExpectAnyArgsAndReturn( 0 );
1990 }
1991
1992 /* Back prvGetHostByName */
1993 DNS_CloseSocket_Expect( &xDNSSocket );
1994
1995 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, NULL, NULL, 0U );
1996
1997 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
1998 TEST_ASSERT_EQUAL( 0, callback_called );
1999 }
2000
2001 /**
2002 * @brief Fail to get the IPv6 address from prvGetHostByName for LLMNR
2003 */
test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRFail(void)2004 void test_FreeRTOS_getaddrinfo_a_IPv6Random_LLMNRFail( void )
2005 {
2006 BaseType_t xReturn;
2007 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
2008 struct freertos_addrinfo xHint, * pxHint = &xHint;
2009 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
2010 uint32_t ulRandom = 0x1234U;
2011 struct xSOCKET xDNSSocket;
2012 NetworkEndPoint_t xEndPoint;
2013 NetworkBufferDescriptor_t xNetworkBuffer;
2014 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
2015 struct xDNSBuffer xReceiveBuffer;
2016 DNSMessage_t * pxDNSMessageHeader = NULL;
2017 int i;
2018
2019 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
2020 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
2021 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
2022 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
2023 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
2024 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
2025 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
2026 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
2027
2028 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
2029
2030 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
2031 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
2032
2033 xEndPoint.bits.bIPv6 = pdTRUE;
2034
2035 xHint.ai_family = FREERTOS_AF_INET6;
2036 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
2037
2038 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
2039 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
2040
2041 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
2042 pxDNSMessageHeader->usIdentifier = ulRandom;
2043
2044 FreeRTOS_inet_pton6_ExpectAndReturn( LLMNR_ADDRESS, NULL, 0 );
2045 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
2046 Prepare_CacheLookup_ExpectAndReturn( LLMNR_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
2047 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
2048 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
2049
2050 /* In prvGetHostByName */
2051 DNS_CreateSocket_ExpectAnyArgsAndReturn( &xDNSSocket );
2052
2053 for( i = 0; i < ipconfigDNS_REQUEST_ATTEMPTS; i++ )
2054 {
2055 /* In prvGetHostByNameOp */
2056 /* In prvFillSockAddress */
2057 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2058
2059 /* Back prvGetHostByNameOp */
2060 DNS_BindSocket_ExpectAndReturn( &xDNSSocket, 0U, 0 );
2061 /* In prvSendBuffer */
2062 /* In prvGetPayloadBuffer */
2063 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
2064 /* Back prvSendBuffer */
2065 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
2066 /* Back prvGetHostByNameOp */
2067 DNS_ReadReply_ExpectAnyArgsAndReturn( 0 );
2068 }
2069
2070 /* Back prvGetHostByName */
2071 DNS_CloseSocket_Expect( &xDNSSocket );
2072
2073 xReturn = FreeRTOS_getaddrinfo_a( LLMNR_ADDRESS, "Service", pxHint, &pxAddress, NULL, NULL, 0U );
2074
2075 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOENT, xReturn );
2076 TEST_ASSERT_EQUAL( 0, callback_called );
2077 }
2078
2079 /**
2080 * @brief IP address found with IPv4 domain input but the address returned is NULL.
2081 */
test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheFoundButNull(void)2082 void test_FreeRTOS_getaddrinfo_a_IPv4DomainCacheFoundButNull( void )
2083 {
2084 BaseType_t xReturn;
2085 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
2086 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
2087
2088 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
2089 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
2090
2091 xExpectedAddress.ai_family = FREERTOS_AF_INET4;
2092
2093 FreeRTOS_inet_addr_ExpectAndReturn( GOOD_ADDRESS, 0 );
2094 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET4, &pxAddress, DOTTED_IPV4_ADDRESS_UINT32 );
2095
2096 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", NULL, &pxAddress, dns_callback, NULL, 0U );
2097
2098 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_ENOMEM, xReturn );
2099 }
2100
2101 /**
2102 * @brief Get the IP address from prvGetHostByName successfully
2103 */
test_FreeRTOS_getaddrinfo_a_IPv4Random_PortSpecified(void)2104 void test_FreeRTOS_getaddrinfo_a_IPv4Random_PortSpecified( void )
2105 {
2106 BaseType_t xReturn;
2107 struct freertos_addrinfo xAddress, * pxAddress = &xAddress;
2108 struct freertos_addrinfo xHint, * pxHint = &xHint;
2109 struct freertos_addrinfo xExpectedAddress, * pxExpectedAddress = &xExpectedAddress;
2110 uint32_t ulRandom = 0x1234U;
2111 struct xSOCKET xDNSSocket;
2112 NetworkEndPoint_t xEndPoint;
2113 NetworkBufferDescriptor_t xNetworkBuffer;
2114 uint8_t ucEtherBuffer[ ipconfigNETWORK_MTU + ipBUFFER_PADDING ];
2115 struct xDNSBuffer xReceiveBuffer;
2116 DNSMessage_t * pxDNSMessageHeader = NULL;
2117 uint16_t usExpectPort = 0x1234;
2118
2119 memset( &xAddress, 0, sizeof( struct freertos_addrinfo ) );
2120 memset( &xHint, 0, sizeof( struct freertos_addrinfo ) );
2121 memset( &xExpectedAddress, 0, sizeof( struct freertos_addrinfo ) );
2122 memset( &xDNSSocket, 0, sizeof( struct xSOCKET ) );
2123 memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
2124 memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
2125 memset( &ucEtherBuffer, 0, sizeof( ucEtherBuffer ) );
2126 memset( &xReceiveBuffer, 0, sizeof( struct xDNSBuffer ) );
2127
2128 xNetworkBuffer.xDataLength = ipconfigNETWORK_MTU;
2129
2130 xNetworkBuffer.pucEthernetBuffer = ucEtherBuffer;
2131 xNetworkBuffer.pucEthernetBuffer += ipBUFFER_PADDING;
2132
2133 xEndPoint.bits.bIPv6 = pdTRUE;
2134 xEndPoint.ipv6_settings.ucDNSIndex = 0;
2135 memcpy( xEndPoint.ipv6_settings.xDNSServerAddresses[ 0 ].ucBytes, xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
2136
2137 xHint.ai_family = FREERTOS_AF_INET6;
2138 xExpectedAddress.ai_family = FREERTOS_AF_INET6;
2139
2140 xReceiveBuffer.pucPayloadBuffer = ucEtherBuffer;
2141 xReceiveBuffer.pucPayloadBuffer += ipBUFFER_PADDING + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_UDP_HEADER;
2142
2143 pxDNSMessageHeader = ( DNSMessage_t * ) xReceiveBuffer.pucPayloadBuffer;
2144 pxDNSMessageHeader->usIdentifier = ulRandom;
2145
2146 xDNSSocket.usLocalPort = FreeRTOS_htons( usExpectPort );
2147
2148 FreeRTOS_inet_pton6_ExpectAndReturn( GOOD_ADDRESS, NULL, 0 );
2149 FreeRTOS_inet_pton6_IgnoreArg_pvDestination();
2150 Prepare_CacheLookup_ExpectAndReturn( GOOD_ADDRESS, FREERTOS_AF_INET6, &pxAddress, 0 );
2151 xApplicationGetRandomNumber_ExpectAnyArgsAndReturn( pdTRUE );
2152 xApplicationGetRandomNumber_ReturnMemThruPtr_pulNumber( &ulRandom, sizeof( uint32_t ) );
2153 vDNSSetCallBack_Expect( GOOD_ADDRESS, NULL, dns_callback, 0U, ulRandom, pdTRUE );
2154
2155 /* In prvGetHostByName */
2156 DNS_CreateSocket_ExpectAndReturn( 0U, &xDNSSocket );
2157 /* In prvGetHostByNameOp */
2158 /* In prvFillSockAddress */
2159 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2160
2161 /* In prvSendBuffer */
2162 /* In prvGetPayloadBuffer */
2163 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
2164 /* Back prvSendBuffer */
2165 DNS_SendRequest_ExpectAnyArgsAndReturn( pdPASS );
2166 /* Back prvGetHostByNameOp */
2167 DNS_ReadReply_ExpectAnyArgsAndReturn( ipconfigNETWORK_MTU );
2168 DNS_ReadReply_ReturnThruPtr_pxReceiveBuffer( &xReceiveBuffer );
2169 /* In prvDNSReply */
2170 DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 1 );
2171 DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxExpectedAddress );
2172 /* Back prvGetHostByNameOp */
2173 FreeRTOS_ReleaseUDPPayloadBuffer_Expect( xReceiveBuffer.pucPayloadBuffer );
2174
2175 /* Back prvGetHostByName */
2176 DNS_CloseSocket_Expect( &xDNSSocket );
2177
2178 xReturn = FreeRTOS_getaddrinfo_a( GOOD_ADDRESS, "Service", pxHint, &pxAddress, dns_callback, NULL, 0U );
2179
2180 TEST_ASSERT_EQUAL( 0, xReturn );
2181 TEST_ASSERT_EQUAL( 0, callback_called );
2182 TEST_ASSERT_EQUAL( FREERTOS_AF_INET6, pxAddress->ai_family );
2183 }
2184
2185 /**
2186 * @brief No memory available for malloc.
2187 */
test_pxNew_AddrInfo_MallocFail(void)2188 void test_pxNew_AddrInfo_MallocFail( void )
2189 {
2190 struct freertos_addrinfo * pxAddress;
2191
2192 isMallocFail = true;
2193
2194 pxAddress = pxNew_AddrInfo( GOOD_ADDRESS, FREERTOS_AF_INET4, NULL );
2195
2196 TEST_ASSERT_EQUAL( NULL, pxAddress );
2197 }
2198
2199 /**
2200 * @brief Unknown family input.
2201 */
test_pxNew_AddrInfo_UnknownFamily(void)2202 void test_pxNew_AddrInfo_UnknownFamily( void )
2203 {
2204 struct freertos_addrinfo * pxAddress;
2205
2206 pxAddress = pxNew_AddrInfo( GOOD_ADDRESS, FREERTOS_AF_INET4 + 1, NULL );
2207
2208 TEST_ASSERT_EQUAL( NULL, pxAddress );
2209 }
2210
2211 /**
2212 * @brief Input with NULL pointer.
2213 */
test_FreeRTOS_freeaddrinfo_NullInput(void)2214 void test_FreeRTOS_freeaddrinfo_NullInput( void )
2215 {
2216 FreeRTOS_freeaddrinfo( NULL );
2217 }
2218
