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 
28 
29 /* Include Unity header */
30 #include "unity.h"
31 
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36 
37 #include "mock_task.h"
38 #include "mock_list.h"
39 
40 /* This must come after list.h is included (in this case, indirectly
41  * by mock_list.h). */
42 #include "mock_queue.h"
43 #include "mock_event_groups.h"
44 
45 #include "mock_FreeRTOS_Routing.h"
46 #include "mock_FreeRTOS_IP_Private.h"
47 #include "mock_FreeRTOS_IP.h"
48 #include "mock_FreeRTOS_IP_Timers.h"
49 #include "mock_NetworkBufferManagement.h"
50 
51 #include "catch_assert.h"
52 #include "FreeRTOS_ND.h"
53 #include "FreeRTOS_RA_stubs.c"
54 
55 /* ===========================  EXTERN VARIABLES  =========================== */
56 
57 /** The default value for the IPv6-field 'ucVersionTrafficClass'. */
58 #define raDEFAULT_VERSION_TRAFFIC_CLASS     0x60U
59 /** The default value for the IPv6-field 'ucHopLimit'. */
60 #define raDEFAULT_HOP_LIMIT                 255U
61 
62 #define raHeaderBytesRS                     ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + sizeof( ICMPRouterSolicitation_IPv6_t ) )
63 #define raHeaderBytesRA                     ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + sizeof( ICMPRouterAdvertisement_IPv6_t ) )
64 
65 /* Define an option length to be used in all test cases */
66 #define raPrefixOptionlen                   8
67 
68 /** @brief Options that can be sent in a ROuter Advertisement packet. */
69 #define ndICMP_SOURCE_LINK_LAYER_ADDRESS    1
70 #define ndICMP_TARGET_LINK_LAYER_ADDRESS    2
71 #define ndICMP_PREFIX_INFORMATION           3
72 #define ndICMP_REDIRECTED_HEADER            4
73 #define ndICMP_MTU_OPTION                   5
74 
75 #define eRAStateUnkown                      7
76 
77 /* Setting IPv6 address as "fe80::7009" */
78 const IPv6_Address_t xDefaultIPAddress =
79 {
80     0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x09
82 };
83 
84 /* =============================== Test Cases =============================== */
85 
86 /**
87  * @brief This function verify sending an Router Solicitation ICMPv6
88  *        message With a NULL Endpoint.
89  */
test_vNDSendRouterSolicitation_NullEndpoint(void)90 void test_vNDSendRouterSolicitation_NullEndpoint( void )
91 {
92     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
93     IPv6_Address_t * pxIPAddress;
94 
95     pxNetworkBuffer = &xNetworkBuffer;
96     pxNetworkBuffer->pxEndPoint = NULL;
97 
98     catch_assert( vNDSendRouterSolicitation( pxNetworkBuffer, pxIPAddress ) );
99 }
100 
101 /**
102  * @brief This function verify sending an Router Solicitation ICMPv6 message
103  *        With a bIPv6 not set in Endpoint.
104  */
test_vNDSendRouterSolicitation_FalsebIPv6(void)105 void test_vNDSendRouterSolicitation_FalsebIPv6( void )
106 {
107     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
108     NetworkEndPoint_t xEndPoint;
109     IPv6_Address_t * pxIPAddress, xIPAddress;
110 
111     pxNetworkBuffer = &xNetworkBuffer;
112     pxNetworkBuffer->pxEndPoint = &xEndPoint;
113     xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
114 
115     catch_assert( vNDSendRouterSolicitation( pxNetworkBuffer, pxIPAddress ) );
116 }
117 
118 /**
119  * @brief This function verify sending an Router Solicitation ICMPv6 message
120  *        And RA was not able to find a Link-local address.
121  */
test_vNDSendRouterSolicitation_xHasLocal0(void)122 void test_vNDSendRouterSolicitation_xHasLocal0( void )
123 {
124     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
125     NetworkEndPoint_t xEndPoint;
126     IPv6_Address_t xIPAddress;
127     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
128     IPHeader_IPv6_t xIPHeader;
129 
130     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
131     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
132     memset( &xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
133     pxNetworkBuffer = &xNetworkBuffer;
134     pxICMPPacket = &xICMPPacket;
135     pxNetworkBuffer->xDataLength = raHeaderBytesRS - 1;
136     pxNetworkBuffer->pxEndPoint = &xEndPoint;
137     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
138     xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
139     pxICMPPacket->xIPHeader = xIPHeader;
140 
141     memset( &xEndPoint.ipv6_settings, 0, sizeof( IPV6Parameters_t ) );
142     memset( &pxICMPPacket->xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
143 
144     /* Link-Local unicast address prefixed FE80::/10 */
145     xEndPoint.ipv6_settings.xIPAddress.ucBytes[ 0 ] = 0xfeU;
146 
147     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
148     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
149 
150     pxDuplicateNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
151 
152     vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
153 
154     vNDSendRouterSolicitation( pxNetworkBuffer, &xIPAddress );
155 }
156 
157 /**
158  * @brief This function verify sending an Router Solicitation ICMPv6 message
159  *        And RA was able to find a Link-local address.
160  */
test_vNDSendRouterSolicitation_xHasLocal1(void)161 void test_vNDSendRouterSolicitation_xHasLocal1( void )
162 {
163     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
164     NetworkEndPoint_t xEndPoint;
165     IPv6_Address_t xIPAddress;
166     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
167     IPHeader_IPv6_t xIPHeader;
168 
169     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
170     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
171     memset( &xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
172 
173     pxNetworkBuffer = &xNetworkBuffer;
174     pxICMPPacket = &xICMPPacket;
175     pxNetworkBuffer->xDataLength = raHeaderBytesRS - 1;
176     pxNetworkBuffer->pxEndPoint = &xEndPoint;
177     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
178     xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
179     pxICMPPacket->xIPHeader = xIPHeader;
180 
181     memset( &xEndPoint.ipv6_settings, 0, sizeof( IPV6Parameters_t ) );
182     memset( &pxICMPPacket->xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
183 
184     /* Link-Local unicast address prefixed FE80::/10 */
185     xEndPoint.ipv6_settings.xIPAddress.ucBytes[ 0 ] = 0xfeU;
186     xEndPoint.ipv6_settings.xIPAddress.ucBytes[ 1 ] = 0x80U;
187 
188     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
189     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
190 
191     pxDuplicateNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
192 
193     vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
194 
195     vNDSendRouterSolicitation( pxNetworkBuffer, &xIPAddress );
196 }
197 
198 /**
199  * @brief This function verify sending an Router Solicitation ICMPv6 message
200  *        With a pxDescriptor being NULL.
201  */
test_vNDSendRouterSolicitation_NullDesc(void)202 void test_vNDSendRouterSolicitation_NullDesc( void )
203 {
204     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
205     NetworkEndPoint_t xEndPoint;
206     IPv6_Address_t xIPAddress;
207     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
208     IPHeader_IPv6_t xIPHeader;
209 
210     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
211     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
212     memset( &xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
213 
214     pxNetworkBuffer = &xNetworkBuffer;
215     pxICMPPacket = &xICMPPacket;
216     pxNetworkBuffer->xDataLength = raHeaderBytesRS - 1;
217     pxNetworkBuffer->pxEndPoint = &xEndPoint;
218     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
219     xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
220     pxICMPPacket->xIPHeader = xIPHeader;
221 
222     memset( &xEndPoint.ipv6_settings, 0, sizeof( IPV6Parameters_t ) );
223     memset( &pxICMPPacket->xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
224 
225     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
226     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
227 
228     pxDuplicateNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
229 
230     vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
231 
232     vNDSendRouterSolicitation( pxNetworkBuffer, &xIPAddress );
233 }
234 
235 /**
236  * @brief This function verify successfully sending an
237  *        ICMPv6 message of the type: Router Solicitation
238  */
test_vNDSendRouterSolicitation_HappyPath(void)239 void test_vNDSendRouterSolicitation_HappyPath( void )
240 {
241     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
242     NetworkEndPoint_t xEndPoint;
243     IPv6_Address_t xIPAddress;
244     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
245     IPHeader_IPv6_t xIPHeader;
246 
247     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
248     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
249     memset( &xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
250 
251     pxNetworkBuffer = &xNetworkBuffer;
252     pxICMPPacket = &xICMPPacket;
253     pxNetworkBuffer->xDataLength = raHeaderBytesRS + 1;
254     pxNetworkBuffer->pxEndPoint = &xEndPoint;
255     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
256     xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
257     pxICMPPacket->xIPHeader = xIPHeader;
258 
259     memset( &xEndPoint.ipv6_settings, 0, sizeof( IPV6Parameters_t ) );
260     memset( &pxICMPPacket->xIPHeader, 0, sizeof( IPHeader_IPv6_t ) );
261 
262     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
263     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
264 
265     usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC );
266     vReturnEthernetFrame_ExpectAnyArgs();
267 
268     vNDSendRouterSolicitation( pxNetworkBuffer, &xIPAddress );
269 
270     TEST_ASSERT_EQUAL( raDEFAULT_VERSION_TRAFFIC_CLASS, pxICMPPacket->xIPHeader.ucVersionTrafficClass );
271     TEST_ASSERT_EQUAL( FreeRTOS_htons( sizeof( ICMPRouterSolicitation_IPv6_t ) ), pxICMPPacket->xIPHeader.usPayloadLength );
272     TEST_ASSERT_EQUAL( ipPROTOCOL_ICMP_IPv6, pxICMPPacket->xIPHeader.ucNextHeader );
273     TEST_ASSERT_EQUAL( raDEFAULT_HOP_LIMIT, pxICMPPacket->xIPHeader.ucHopLimit );
274 }
275 
276 /**
277  * @brief This function verify received Neighbour Advertisement message
278  *        without EndPoint.
279  */
test_vReceiveNA_NoEndPoint(void)280 void test_vReceiveNA_NoEndPoint( void )
281 {
282     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
283     NetworkEndPoint_t xEndPoint;
284     ICMPPacket_IPv6_t xICMPPacket;
285 
286     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
287     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
288 
289     pxNetworkBuffer = &xNetworkBuffer;
290 
291     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
292 
293     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( NULL );
294 
295     vReceiveNA( pxNetworkBuffer );
296 
297     TEST_ASSERT_EQUAL( 0, xEndPoint.xRAData.bits.bIPAddressInUse );
298 }
299 
300 /**
301  * @brief This function verify received Neighbour Advertisement message
302  *        to see that the chosen IP-address is not in use.
303  */
test_vReceiveNA_bIPAddressNotInUse1(void)304 void test_vReceiveNA_bIPAddressNotInUse1( void )
305 {
306     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
307     NetworkEndPoint_t xEndPoint;
308     ICMPPacket_IPv6_t xICMPPacket;
309 
310     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
311     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
312     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
313 
314     pxNetworkBuffer = &xNetworkBuffer;
315     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
316     xEndPoint.bits.bWantRA = pdFALSE_UNSIGNED;
317 
318     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
319 
320     FreeRTOS_NextEndPoint_ExpectAnyArgsAndReturn( NULL );
321 
322     vReceiveNA( pxNetworkBuffer );
323 
324     TEST_ASSERT_EQUAL( 0, xEndPoint.xRAData.bits.bIPAddressInUse );
325 }
326 
327 /**
328  * @brief This function verify received Neighbour Advertisement message
329  *        to see that the chosen IP-address is not in use.
330  */
test_vReceiveNA_bIPAddressNotInUse2(void)331 void test_vReceiveNA_bIPAddressNotInUse2( void )
332 {
333     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
334     NetworkEndPoint_t xEndPoint;
335     ICMPPacket_IPv6_t xICMPPacket;
336 
337     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
338     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
339     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
340 
341     pxNetworkBuffer = &xNetworkBuffer;
342     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
343     xEndPoint.bits.bWantRA = pdTRUE_UNSIGNED;
344 
345     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
346     FreeRTOS_NextEndPoint_ExpectAnyArgsAndReturn( NULL );
347 
348     vReceiveNA( pxNetworkBuffer );
349 
350     TEST_ASSERT_EQUAL( 0, xEndPoint.xRAData.bits.bIPAddressInUse );
351 }
352 
353 /**
354  * @brief This function verify received Neighbour Advertisement message
355  *        to see that the chosen IP-address is not in use.
356  */
test_vReceiveNA_bIPAddressNotInUse3(void)357 void test_vReceiveNA_bIPAddressNotInUse3( void )
358 {
359     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
360     NetworkEndPoint_t xEndPoint;
361     ICMPPacket_IPv6_t xICMPPacket;
362 
363     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
364     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
365     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
366 
367     pxNetworkBuffer = &xNetworkBuffer;
368     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
369     xEndPoint.bits.bWantRA = pdTRUE_UNSIGNED;
370     xEndPoint.xRAData.eRAState = eRAStateIPWait;
371 
372     memset( xEndPoint.ipv6_settings.xIPAddress.ucBytes, 0, ipSIZE_OF_IPv6_ADDRESS );
373     memset( xICMPPacket.xICMPHeaderIPv6.xIPv6Address.ucBytes, 1, ipSIZE_OF_IPv6_ADDRESS );
374     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
375     FreeRTOS_NextEndPoint_ExpectAnyArgsAndReturn( NULL );
376 
377     vReceiveNA( pxNetworkBuffer );
378 
379     TEST_ASSERT_EQUAL( 0, xEndPoint.xRAData.bits.bIPAddressInUse );
380 }
381 
382 /**
383  * @brief This function verify received Neighbour Advertisement message
384  *        to see that the chosen IP-address is not in use.
385  */
test_vReceiveNA_bIPAddressNotInUse4(void)386 void test_vReceiveNA_bIPAddressNotInUse4( void )
387 {
388     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
389     NetworkEndPoint_t xEndPoint;
390     ICMPPacket_IPv6_t xICMPPacket;
391     IPv6_Address_t xIPAddress;
392 
393     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
394     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
395     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
396 
397     pxNetworkBuffer = &xNetworkBuffer;
398     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
399     xEndPoint.xRAData.eRAState = eRAStateWait;
400 
401     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
402     FreeRTOS_NextEndPoint_ExpectAnyArgsAndReturn( NULL );
403 
404     vReceiveNA( pxNetworkBuffer );
405 
406     TEST_ASSERT_EQUAL( 0, xEndPoint.xRAData.bits.bIPAddressInUse );
407 }
408 
409 /**
410  * @brief This function verify received Neighbour Advertisement message
411  *        to see that the chosen IP-address is already in use.
412  */
test_vReceiveNA_bIPAddressInUse(void)413 void test_vReceiveNA_bIPAddressInUse( void )
414 {
415     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
416     NetworkEndPoint_t xEndPoint;
417     ICMPPacket_IPv6_t xICMPPacket;
418     IPv6_Address_t xIPAddress;
419 
420     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
421     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
422     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
423 
424     pxNetworkBuffer = &xNetworkBuffer;
425     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
426     xEndPoint.bits.bWantRA = pdTRUE_UNSIGNED;
427     xEndPoint.xRAData.eRAState = eRAStateIPWait;
428 
429     /* Setting IPv6 address as "fe80::7009" */
430     memcpy( &xIPAddress, &xDefaultIPAddress, sizeof( IPv6_Address_t ) );
431 
432     memcpy( xEndPoint.ipv6_settings.xIPAddress.ucBytes, xIPAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
433     memcpy( xICMPPacket.xICMPHeaderIPv6.xIPv6Address.ucBytes, xIPAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
434 
435     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( &xEndPoint );
436 
437     vDHCP_RATimerReload_ExpectAnyArgs();
438 
439     FreeRTOS_NextEndPoint_ExpectAnyArgsAndReturn( NULL );
440 
441     vReceiveNA( pxNetworkBuffer );
442 
443     TEST_ASSERT_EQUAL( 1, xEndPoint.xRAData.bits.bIPAddressInUse );
444 }
445 
446 /**
447  * @brief This function verify the handling
448  *        of incorrect data length.
449  */
test_vReceiveRA_IncorrectDataLength(void)450 void test_vReceiveRA_IncorrectDataLength( void )
451 {
452     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
453 
454     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
455 
456     pxNetworkBuffer = &xNetworkBuffer;
457     /* Setting incorrect data length */
458     pxNetworkBuffer->xDataLength = raHeaderBytesRA - 1;
459 
460     vReceiveRA( pxNetworkBuffer );
461 }
462 
463 /**
464  * @brief This function verify the handling
465  *        of Advertisement Lifetime as zero.
466  */
test_vReceiveRA_ZeroAdvertisementLifetime(void)467 void test_vReceiveRA_ZeroAdvertisementLifetime( void )
468 {
469     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
470     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
471     ICMPPacket_IPv6_t xICMPPacket;
472 
473     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
474     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
475 
476     pxNetworkBuffer = &xNetworkBuffer;
477     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) ( uint8_t * ) &xICMPPacket;
478     pxNetworkBuffer->xDataLength = raHeaderBytesRA + 1;
479 
480     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
481     pxAdvertisement->usLifetime = 0;
482 
483     vReceiveRA( pxNetworkBuffer );
484 }
485 
486 /**
487  * @brief This function verify the handling
488  *        of NULL pxInterface.
489  */
test_vReceiveRA_NullpxInterface(void)490 void test_vReceiveRA_NullpxInterface( void )
491 {
492     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
493     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
494     ICMPPacket_IPv6_t xICMPPacket;
495 
496     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
497     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
498 
499     pxNetworkBuffer = &xNetworkBuffer;
500     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
501     pxNetworkBuffer->xDataLength = raHeaderBytesRA + 1;
502     pxNetworkBuffer->pxInterface = NULL;
503 
504     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
505     pxAdvertisement->usLifetime = 1;
506 
507     catch_assert( vReceiveRA( pxNetworkBuffer ) );
508 }
509 
510 /**
511  * @brief This function verify NULL ICMP prefix
512  *        option pointer as no options field.
513  */
test_vReceiveRA_NullICMPPrefix(void)514 void test_vReceiveRA_NullICMPPrefix( void )
515 {
516     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
517     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
518     NetworkInterface_t xInterface;
519     ICMPPacket_IPv6_t xICMPPacket;
520 
521     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
522     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
523 
524     pxNetworkBuffer = &xNetworkBuffer;
525     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
526     pxNetworkBuffer->xDataLength = raHeaderBytesRA;
527     pxNetworkBuffer->pxInterface = &xInterface;
528 
529     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
530     pxAdvertisement->usLifetime = 1;
531 
532     vReceiveRA( pxNetworkBuffer );
533 }
534 
535 /**
536  * @brief This function verify ICMP prefix option with
537  *        options present with data length as zero.
538  */
test_vReceiveRA_NullICMPPrefix_ZeroOptionLength(void)539 void test_vReceiveRA_NullICMPPrefix_ZeroOptionLength( void )
540 {
541     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
542     ICMPPacket_IPv6_t xICMPPacket;
543     NetworkInterface_t xInterface;
544     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
545     uint8_t * pucBytes;
546     ICMPPrefixOption_IPv6_t * pxPrefixOption;
547     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
548 
549     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
550     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
551 
552     pxNetworkBuffer = &xNetworkBuffer;
553     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
554     pxNetworkBuffer->pxInterface = &xInterface;
555     /* Data Length to be less than expected */
556     pxNetworkBuffer->xDataLength = raHeaderBytesRA + 10;
557     uxNeededSize = raHeaderBytesRA;
558 
559     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
560     pxAdvertisement->usLifetime = 1;
561 
562     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
563     pxPrefixOption->ucType = ndICMP_PREFIX_INFORMATION;
564     /* Number of Options present - 8-byte blocks. */
565     uxOptionsLength = 2;
566     pxPrefixOption->ucLength = 0;
567 
568     vReceiveRA( pxNetworkBuffer );
569 }
570 
571 /**
572  * @brief This function verify ICMP prefix option with
573  *        options present but data length less than the
574  *        required data length by option field.
575  */
test_vReceiveRA_NullICMPPrefix_NotEnoughBytes(void)576 void test_vReceiveRA_NullICMPPrefix_NotEnoughBytes( void )
577 {
578     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
579     ICMPPacket_IPv6_t xICMPPacket;
580     NetworkInterface_t xInterface;
581     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
582     uint8_t * pucBytes;
583     ICMPPrefixOption_IPv6_t * pxPrefixOption;
584     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
585 
586     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
587     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
588 
589     pxNetworkBuffer = &xNetworkBuffer;
590     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
591     pxNetworkBuffer->pxInterface = &xInterface;
592     /* Data Length to be less than expected */
593     pxNetworkBuffer->xDataLength = raHeaderBytesRA + 10;
594     uxNeededSize = raHeaderBytesRA;
595 
596     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
597     pxAdvertisement->usLifetime = 1;
598 
599     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
600     pxPrefixOption->ucType = ndICMP_PREFIX_INFORMATION;
601     /* Number of Options present - 8-byte blocks. */
602     uxOptionsLength = 2;
603     pxPrefixOption->ucLength = uxOptionsLength;
604 
605     vReceiveRA( pxNetworkBuffer );
606 }
607 
608 /**
609  * @brief This function verify ICMP prefix option with
610  *        options present as ndICMP_SOURCE_LINK_LAYER_ADDRESS.
611  */
test_vReceiveRA_ValidICMPPrefix_Option1(void)612 void test_vReceiveRA_ValidICMPPrefix_Option1( void )
613 {
614     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
615     ICMPPacket_IPv6_t xICMPPacket;
616     NetworkInterface_t xInterface;
617     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
618     uint8_t * pucBytes;
619     ICMPPrefixOption_IPv6_t * pxPrefixOption;
620     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
621 
622     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
623     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
624     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
625 
626     pxNetworkBuffer = &xNetworkBuffer;
627     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
628     pxNetworkBuffer->pxInterface = &xInterface;
629     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
630     uxNeededSize = raHeaderBytesRA;
631 
632     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
633     pxAdvertisement->usLifetime = 1;
634 
635     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
636     pxPrefixOption->ucType = ndICMP_SOURCE_LINK_LAYER_ADDRESS;
637     /* Only 1 option */
638     pxPrefixOption->ucLength = 1;
639 
640     vReceiveRA( pxNetworkBuffer );
641 }
642 
643 /**
644  * @brief This function verify ICMP prefix option with
645  *        options present as ndICMP_TARGET_LINK_LAYER_ADDRESS.
646  */
test_vReceiveRA_ValidICMPPrefix_Option2(void)647 void test_vReceiveRA_ValidICMPPrefix_Option2( void )
648 {
649     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
650     ICMPPacket_IPv6_t xICMPPacket;
651     NetworkInterface_t xInterface;
652     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
653     uint8_t * pucBytes;
654     NetworkEndPoint_t xEndPoint;
655     ICMPPrefixOption_IPv6_t * pxPrefixOption;
656     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
657 
658     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
659     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
660     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
661 
662     pxNetworkBuffer = &xNetworkBuffer;
663     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
664     pxNetworkBuffer->pxInterface = &xInterface;
665     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
666     uxNeededSize = raHeaderBytesRA;
667 
668     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
669     pxAdvertisement->usLifetime = 1;
670 
671     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
672     pxPrefixOption->ucType = ndICMP_TARGET_LINK_LAYER_ADDRESS;
673     /* Only 1 option */
674     pxPrefixOption->ucLength = 1;
675 
676     vReceiveRA( pxNetworkBuffer );
677 }
678 
679 /**
680  * @brief This function verify ICMP prefix option with
681  *        options present as ndICMP_PREFIX_INFORMATION.
682  */
test_vReceiveRA_ValidICMPPrefix_Option3(void)683 void test_vReceiveRA_ValidICMPPrefix_Option3( void )
684 {
685     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
686     ICMPPacket_IPv6_t xICMPPacket;
687     NetworkInterface_t xInterface;
688     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
689     uint8_t * pucBytes;
690     NetworkEndPoint_t xEndPoint;
691     ICMPPrefixOption_IPv6_t * pxPrefixOption;
692     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
693 
694     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
695     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
696     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
697 
698     pxNetworkBuffer = &xNetworkBuffer;
699     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
700     pxNetworkBuffer->pxInterface = &xInterface;
701     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
702     uxNeededSize = raHeaderBytesRA;
703 
704     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
705     pxAdvertisement->usLifetime = 1;
706 
707     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
708     pxPrefixOption->ucType = ndICMP_PREFIX_INFORMATION;
709     /* Only 1 option */
710     pxPrefixOption->ucLength = 1;
711 
712 
713     xEndPoint.bits.bWantRA = pdFALSE_UNSIGNED;
714 
715     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
716     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
717 
718     vReceiveRA( pxNetworkBuffer );
719 }
720 
721 
722 /**
723  * @brief This function verify ICMP prefix option with
724  *        options present as ndICMP_TARGET_LINK_LAYER_ADDRESS.
725  */
test_vReceiveRA_ValidICMPPrefix_Option4(void)726 void test_vReceiveRA_ValidICMPPrefix_Option4( void )
727 {
728     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
729     ICMPPacket_IPv6_t xICMPPacket;
730     NetworkInterface_t xInterface;
731     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
732     uint8_t * pucBytes;
733     ICMPPrefixOption_IPv6_t * pxPrefixOption;
734     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
735 
736     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
737     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
738     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
739 
740     pxNetworkBuffer = &xNetworkBuffer;
741     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
742     pxNetworkBuffer->pxInterface = &xInterface;
743     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
744     uxNeededSize = raHeaderBytesRA;
745 
746     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
747     pxAdvertisement->usLifetime = 1;
748 
749     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
750     pxPrefixOption->ucType = ndICMP_REDIRECTED_HEADER;
751     /* Only 1 option */
752     pxPrefixOption->ucLength = 1;
753 
754     vReceiveRA( pxNetworkBuffer );
755 }
756 
757 /**
758  * @brief This function verify ICMP prefix option with
759  *        options present as ndICMP_TARGET_LINK_LAYER_ADDRESS.
760  */
test_vReceiveRA_ValidICMPPrefix_Option5(void)761 void test_vReceiveRA_ValidICMPPrefix_Option5( void )
762 {
763     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
764     ICMPPacket_IPv6_t xICMPPacket;
765     NetworkInterface_t xInterface;
766     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
767     uint8_t * pucBytes;
768     ICMPPrefixOption_IPv6_t * pxPrefixOption;
769     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
770 
771     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
772     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
773     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
774 
775     pxNetworkBuffer = &xNetworkBuffer;
776     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
777     pxNetworkBuffer->pxInterface = &xInterface;
778     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
779     uxNeededSize = raHeaderBytesRA;
780     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
781     pxAdvertisement->usLifetime = pdTRUE_UNSIGNED;
782 
783     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
784     pxPrefixOption->ucType = ndICMP_MTU_OPTION;
785     /* Only 1 option */
786     pxPrefixOption->ucLength = 1;
787 
788     ulChar2u32_ExpectAnyArgsAndReturn( 0x12345678 );
789 
790     vReceiveRA( pxNetworkBuffer );
791 }
792 
793 /**
794  * @brief This function verify ICMP prefix option with
795  *        options present as default case.
796  */
test_vReceiveRA_ValidICMPPrefix_Option6(void)797 void test_vReceiveRA_ValidICMPPrefix_Option6( void )
798 {
799     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
800     ICMPPacket_IPv6_t xICMPPacket;
801     NetworkInterface_t xInterface;
802     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
803     uint8_t * pucBytes;
804     ICMPPrefixOption_IPv6_t * pxPrefixOption;
805     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
806 
807     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
808     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
809     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
810 
811     pxNetworkBuffer = &xNetworkBuffer;
812     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
813     pxNetworkBuffer->pxInterface = &xInterface;
814     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
815     uxNeededSize = raHeaderBytesRA;
816     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
817     pxAdvertisement->usLifetime = pdTRUE_UNSIGNED;
818 
819     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
820     pxPrefixOption->ucType = eRAStateUnkown;
821 
822     /* Only 1 option */
823     pxPrefixOption->ucLength = 1;
824 
825     vReceiveRA( pxNetworkBuffer );
826 }
827 
828 /**
829  * @brief This function verify ICMP prefix option with
830  *        options present as ndICMP_TARGET_LINK_LAYER_ADDRESS.
831  */
test_vReceiveRA_ValidICMPPrefix_IncorrectOption(void)832 void test_vReceiveRA_ValidICMPPrefix_IncorrectOption( void )
833 {
834     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
835     ICMPPacket_IPv6_t xICMPPacket;
836     NetworkInterface_t xInterface;
837     NetworkEndPoint_t xEndPoint;
838     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
839     uint8_t * pucBytes;
840     ICMPPrefixOption_IPv6_t * pxPrefixOption;
841 
842     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
843     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
844     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
845     memset( &xEndPoint, 0, sizeof( NetworkInterface_t ) );
846 
847     pxNetworkBuffer = &xNetworkBuffer;
848     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
849     pxNetworkBuffer->pxInterface = &xInterface;
850     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
851     uxNeededSize = raHeaderBytesRA;
852 
853     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
854     pxPrefixOption->ucType = 0;
855     /* Only 1 option */
856     pxPrefixOption->ucLength = 1;
857 
858     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
859     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
860 
861     vReceiveRA( pxNetworkBuffer );
862 }
863 
864 /**
865  * @brief This function verify vReceiveRA success case.
866  */
test_vReceiveRA_vRAProcesss(void)867 void test_vReceiveRA_vRAProcesss( void )
868 {
869     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
870     ICMPPacket_IPv6_t xICMPPacket;
871     NetworkInterface_t xInterface;
872     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
873     uint8_t * pucBytes;
874     NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
875     ICMPPrefixOption_IPv6_t * pxPrefixOption;
876     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
877 
878     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
879     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
880     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
881     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
882 
883     pxNetworkBuffer = &xNetworkBuffer;
884     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
885     pxNetworkBuffer->pxInterface = &xInterface;
886     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
887     uxNeededSize = raHeaderBytesRA;
888     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
889     pxAdvertisement->usLifetime = pdTRUE_UNSIGNED;
890 
891     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
892     pxPrefixOption->ucType = ndICMP_PREFIX_INFORMATION;
893     /* Only 1 option */
894     pxPrefixOption->ucLength = 1;
895 
896     pxEndPoint->bits.bWantRA = pdTRUE_UNSIGNED;
897 
898     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( pxEndPoint );
899     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
900 
901     vReceiveRA( pxNetworkBuffer );
902 }
903 
904 /**
905  * @brief This function verify vReceiveRA success case.
906  */
test_vReceiveRA_vRAProcess(void)907 void test_vReceiveRA_vRAProcess( void )
908 {
909     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer, xNetworkBuffer2;
910     ICMPPacket_IPv6_t xICMPPacket;
911     NetworkInterface_t xInterface;
912     size_t uxIndex = 0U, uxNeededSize, uxOptionsLength;
913     uint8_t * pucBytes;
914     NetworkEndPoint_t xEndPoint, * pxEndPoint = &xEndPoint;
915     ICMPPrefixOption_IPv6_t * pxPrefixOption;
916     ICMPRouterAdvertisement_IPv6_t * pxAdvertisement;
917 
918     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
919     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
920     memset( &xInterface, 0, sizeof( NetworkInterface_t ) );
921     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
922 
923     pxNetworkBuffer = &xNetworkBuffer;
924     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
925     pxNetworkBuffer->pxInterface = &xInterface;
926     pxNetworkBuffer->xDataLength = raHeaderBytesRA + raPrefixOptionlen;
927     uxNeededSize = raHeaderBytesRA;
928     pxAdvertisement = ( ( ICMPRouterAdvertisement_IPv6_t * ) &( xICMPPacket.xICMPHeaderIPv6 ) );
929     pxAdvertisement->usLifetime = pdTRUE_UNSIGNED;
930 
931     pxPrefixOption = ( ICMPPrefixOption_IPv6_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
932     pxPrefixOption->ucType = ndICMP_PREFIX_INFORMATION;
933     /* Only 1 option */
934     pxPrefixOption->ucLength = 1;
935 
936 
937     pxEndPoint->bits.bWantRA = pdTRUE_UNSIGNED;
938     pxEndPoint->xRAData.eRAState = eRAStateWait;
939 
940     FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( pxEndPoint );
941     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
942 
943     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
944     vDHCP_RATimerReload_ExpectAnyArgs();
945 
946     vReceiveRA( pxNetworkBuffer );
947 
948 
949     TEST_ASSERT_EQUAL( pxEndPoint->ipv6_settings.uxPrefixLength, pxPrefixOption->ucPrefixLength );
950     TEST_ASSERT_EQUAL( pdTRUE_UNSIGNED, pxEndPoint->xRAData.bits.bRouterReplied );
951     TEST_ASSERT_EQUAL( 0, pxEndPoint->xRAData.uxRetryCount );
952     TEST_ASSERT_EQUAL( FreeRTOS_ntohl( pxPrefixOption->ulPreferredLifeTime ), pxEndPoint->xRAData.ulPreferredLifeTime );
953     TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, pxEndPoint->xRAData.bits.bIPAddressInUse );
954     TEST_ASSERT_EQUAL( eRAStateIPWait, pxEndPoint->xRAData.eRAState );
955 }
956 
957 /**
958  *  @brief This function verify RA state machine
959  *         with RA NULL endpoint.
960  */
test_vRAProcess_NullEndPoint(void)961 void test_vRAProcess_NullEndPoint( void )
962 {
963     NetworkEndPoint_t * pxEndPoint = NULL;
964     IPv6_Address_t xIPAddress;
965 
966     catch_assert( vRAProcess( pdTRUE, pxEndPoint ) );
967 }
968 
969 /**
970  *  @brief This function verify RA state machine with RA wait state
971  *         as eRAStateApply {Set during RA_Init}
972  *         And failed to get network buffer.
973  */
test_vRAProcess_eRAStateApply1(void)974 void test_vRAProcess_eRAStateApply1( void )
975 {
976     NetworkEndPoint_t xEndPoint, * pxEndPoint;
977     IPv6_Address_t xIPAddress;
978 
979     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
980     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
981 
982     pxEndPoint = &xEndPoint;
983 
984     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
985     vDHCP_RATimerReload_ExpectAnyArgs();
986 
987     /* pdTRUE for vRAProcessInit */
988     vRAProcess( pdTRUE, &xEndPoint );
989 
990     TEST_ASSERT_EQUAL( eRAStateWait, xEndPoint.xRAData.eRAState );
991 }
992 
993 /**
994  *  @brief This function verify RA state machine with RA wait state as
995  *         eRAStateApply {Set during RA_Init}
996  *         And Send an ICMPv6 message of the type: Router Solicitation.
997  */
test_vRAProcess_eRAStateApply2(void)998 void test_vRAProcess_eRAStateApply2( void )
999 {
1000     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1001     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1002     IPv6_Address_t xIPAddress;
1003     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
1004 
1005     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1006     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
1007     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1008     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1009 
1010     pxEndPoint = &xEndPoint;
1011     pxNetworkBuffer = &xNetworkBuffer;
1012 
1013     pxICMPPacket = &xICMPPacket;
1014     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
1015 
1016     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1017     pxEndPoint->bits.bIPv6 = pdTRUE_UNSIGNED;
1018 
1019     pxGetNetworkBufferWithDescriptor_ExpectAndReturn( raHeaderBytesRS, 0, &xNetworkBuffer );
1020     FreeRTOS_FirstEndPoint_IgnoreAndReturn( &xEndPoint );
1021     FreeRTOS_NextEndPoint_IgnoreAndReturn( NULL );
1022     pxDuplicateNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1023     /*usGenerateProtocolChecksum_ExpectAnyArgsAndReturn( ipCORRECT_CRC ); */
1024     /*vReturnEthernetFrame_ExpectAnyArgs(); */
1025 
1026     vReleaseNetworkBufferAndDescriptor_Expect( &xNetworkBuffer );
1027 
1028     vDHCP_RATimerReload_ExpectAnyArgs();
1029 
1030     /* pdFALSE for vRAProcessInit */
1031     vRAProcess( pdTRUE, &xEndPoint );
1032 
1033     TEST_ASSERT_EQUAL( eRAStateWait, xEndPoint.xRAData.eRAState );
1034 }
1035 
1036 /**
1037  *  @brief This function verify RA state machine with RA wait state as
1038  *         eRAStateLease.
1039  */
test_vRAProcess_eRAStateLease(void)1040 void test_vRAProcess_eRAStateLease( void )
1041 {
1042     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1043     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1044     IPv6_Address_t xIPAddress;
1045     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
1046 
1047     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1048     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
1049     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1050     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1051 
1052     pxEndPoint = &xEndPoint;
1053     pxNetworkBuffer = &xNetworkBuffer;
1054 
1055     pxICMPPacket = &xICMPPacket;
1056     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
1057 
1058     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1059     pxEndPoint->bits.bIPv6 = pdTRUE_UNSIGNED;
1060     pxEndPoint->xRAData.eRAState = eRAStateLease;
1061 
1062     vDHCP_RATimerReload_ExpectAnyArgs();
1063 
1064     vRAProcess( pdFALSE, &xEndPoint );
1065 
1066     TEST_ASSERT_EQUAL( eRAStateApply, xEndPoint.xRAData.eRAState );
1067     TEST_ASSERT_EQUAL( 0, pxEndPoint->xRAData.uxRetryCount );
1068 }
1069 
1070 /**
1071  *  @brief This function verify RA state machine with RA wait state as
1072  *         unexpected.
1073  */
test_vRAProcess_UndefinedState(void)1074 void test_vRAProcess_UndefinedState( void )
1075 {
1076     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1077     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1078     IPv6_Address_t xIPAddress;
1079     ICMPPacket_IPv6_t * pxICMPPacket, xICMPPacket;
1080 
1081     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1082     memset( &xICMPPacket, 0, sizeof( ICMPPacket_IPv6_t ) );
1083     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1084     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1085 
1086     pxEndPoint = &xEndPoint;
1087     pxNetworkBuffer = &xNetworkBuffer;
1088 
1089     pxICMPPacket = &xICMPPacket;
1090     pxNetworkBuffer->pucEthernetBuffer = ( uint8_t * ) &xICMPPacket;
1091 
1092     pxEndPoint->bits.bIPv6 = pdTRUE_UNSIGNED;
1093     /* Unexpected state */
1094     pxEndPoint->xRAData.eRAState = eRAStateUnkown;
1095 
1096     vDHCP_RATimerReload_ExpectAnyArgs();
1097 
1098     vRAProcess( pdFALSE, &xEndPoint );
1099 
1100     TEST_ASSERT_EQUAL( eRAStateUnkown, xEndPoint.xRAData.eRAState );
1101 }
1102 
1103 /**
1104  *  @brief This function verify RA state machine with RA wait state as eRAStateWait.
1105  */
test_vRAProcess_eRAStateWait(void)1106 void test_vRAProcess_eRAStateWait( void )
1107 {
1108     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1109     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1110     IPv6_Address_t xIPAddress;
1111 
1112     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1113     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1114     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1115 
1116     pxNetworkBuffer = &xNetworkBuffer;
1117     pxEndPoint = &xEndPoint;
1118 
1119     pxEndPoint->xRAData.eRAState = eRAStateWait;
1120 
1121     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1122     vDHCP_RATimerReload_ExpectAnyArgs();
1123 
1124     /* pdFALSE Indicating vRAProcessInit is already done */
1125     vRAProcess( pdFALSE, &xEndPoint );
1126 
1127     TEST_ASSERT_EQUAL( eRAStateWait, xEndPoint.xRAData.eRAState );
1128 }
1129 
1130 /**
1131  *  @brief This function verify RA state machine with RA wait state as eRAStateWait.
1132  *         Router Solicitation has been sent, waited for a reply, but no came and
1133  *         the retry count becomes more that ipconfigRA_SEARCH_COUNT.
1134  */
test_vRAProcess_eRAStateWait_RetryExceed(void)1135 void test_vRAProcess_eRAStateWait_RetryExceed( void )
1136 {
1137     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1138     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1139     IPv6_Address_t xIPAddress;
1140     UBaseType_t retry = ( UBaseType_t ) ipconfigRA_SEARCH_COUNT;
1141 
1142     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1143     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1144     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1145 
1146     pxNetworkBuffer = &xNetworkBuffer;
1147     pxEndPoint = &xEndPoint;
1148     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1149 
1150     pxEndPoint->xRAData.eRAState = eRAStateWait;
1151     pxEndPoint->xRAData.uxRetryCount = ( UBaseType_t ) ipconfigRA_SEARCH_COUNT;
1152 
1153     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xNetworkBuffer );
1154     vDHCP_RATimerReload_ExpectAnyArgs();
1155 
1156     /* pdFALSE Indicating vRAProcessInit is already done */
1157     vRAProcess( pdFALSE, &xEndPoint );
1158 
1159     TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, pxEndPoint->xRAData.bits.bRouterReplied );
1160     TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, pxEndPoint->xRAData.uxRetryCount );
1161     TEST_ASSERT_EQUAL( eRAStateIPWait, xEndPoint.xRAData.eRAState );
1162 }
1163 
1164 /**
1165  *  @brief This function verify RA state machine with RA wait state as eRAStateIPWait.
1166  *         With bIPAddressInUse True which implies Another device has
1167  *         responded with the same IPv4 address.
1168  */
test_vRAProcess_eRAStateIPWait_AddressInUse(void)1169 void test_vRAProcess_eRAStateIPWait_AddressInUse( void )
1170 {
1171     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1172     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1173     IPv6_Address_t xIPAddress;
1174 
1175     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1176     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1177     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1178 
1179     pxNetworkBuffer = &xNetworkBuffer;
1180     pxEndPoint = &xEndPoint;
1181     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1182 
1183     pxEndPoint->xRAData.eRAState = eRAStateIPWait;
1184     pxEndPoint->xRAData.bits.bIPAddressInUse = pdTRUE_UNSIGNED;
1185 
1186     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1187     vDHCP_RATimerReload_ExpectAnyArgs();
1188 
1189     /* pdFALSE Indicating vRAProcessInit is already done */
1190     vRAProcess( pdFALSE, &xEndPoint );
1191 
1192     TEST_ASSERT_EQUAL( pdFALSE_UNSIGNED, pxEndPoint->xRAData.uxRetryCount );
1193     TEST_ASSERT_EQUAL( eRAStateIPWait, xEndPoint.xRAData.eRAState );
1194 }
1195 
1196 /**
1197  *  @brief This function verify RA state machine with RA wait state as eRAStateIPWait,
1198  *         With retry.
1199  */
test_vRAProcess_eRAStateIPWait_Retry(void)1200 void test_vRAProcess_eRAStateIPWait_Retry( void )
1201 {
1202     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1203     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1204     IPv6_Address_t xIPAddress;
1205 
1206     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1207     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1208     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1209 
1210     pxNetworkBuffer = &xNetworkBuffer;
1211     pxEndPoint = &xEndPoint;
1212     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1213 
1214     pxEndPoint->xRAData.eRAState = eRAStateIPWait;
1215     pxEndPoint->xRAData.uxRetryCount = 0;
1216 
1217     pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1218     vDHCP_RATimerReload_ExpectAnyArgs();
1219 
1220     /* pdFALSE Indicating vRAProcessInit is already done */
1221     vRAProcess( pdFALSE, &xEndPoint );
1222 
1223     TEST_ASSERT_EQUAL( 1U, pxEndPoint->xRAData.uxRetryCount );
1224     TEST_ASSERT_EQUAL( eRAStateIPWait, xEndPoint.xRAData.eRAState );
1225 }
1226 
1227 /**
1228  *  @brief This function verify RA state machine with RA wait state as eRAStateIPWait.
1229  *         And Obtained configuration from a router.
1230  */
test_vRAProcess_eRAStateIPWait_RASuccess(void)1231 void test_vRAProcess_eRAStateIPWait_RASuccess( void )
1232 {
1233     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1234     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1235     IPv6_Address_t xIPAddress;
1236 
1237     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1238     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1239     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1240 
1241     pxNetworkBuffer = &xNetworkBuffer;
1242     pxEndPoint = &xEndPoint;
1243     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1244 
1245     pxEndPoint->xRAData.eRAState = eRAStateIPWait;
1246     pxEndPoint->xRAData.uxRetryCount = ipconfigRA_IP_TEST_COUNT;
1247     /* Obtained configuration from a router. */
1248     pxEndPoint->xRAData.bits.bRouterReplied = pdTRUE_UNSIGNED;
1249 
1250     vIPNetworkUpCalls_Expect( &xEndPoint );
1251     vIPSetDHCP_RATimerEnableState_Expect( &xEndPoint, pdFALSE );
1252 
1253     /* pdFALSE Indicating vRAProcessInit is already done */
1254     vRAProcess( pdFALSE, &xEndPoint );
1255 
1256     TEST_ASSERT_EQUAL( eRAStateLease, xEndPoint.xRAData.eRAState );
1257 }
1258 
1259 /**
1260  *  @brief This function verify RA state machine with RA wait state
1261  *         as eRAStateIPWait.
1262  *         Using the default network parameters.
1263  */
test_vRAProcess_eRAStateIPWait_UsingDefaultAddress(void)1264 void test_vRAProcess_eRAStateIPWait_UsingDefaultAddress( void )
1265 {
1266     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1267     NetworkEndPoint_t xEndPoint, * pxEndPoint;
1268     IPv6_Address_t xIPAddress;
1269 
1270     memset( &xNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1271     memset( &xIPAddress, 0, sizeof( IPv6_Address_t ) );
1272     memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1273 
1274     pxNetworkBuffer = &xNetworkBuffer;
1275     pxEndPoint = &xEndPoint;
1276     memset( pxEndPoint, 0, sizeof( NetworkEndPoint_t ) );
1277 
1278     pxEndPoint->xRAData.eRAState = eRAStateIPWait;
1279     pxEndPoint->xRAData.uxRetryCount = ipconfigRA_IP_TEST_COUNT;
1280     /* Using the default network parameters. */
1281     pxEndPoint->xRAData.bits.bRouterReplied = pdFALSE_UNSIGNED;
1282 
1283     vIPNetworkUpCalls_Expect( &xEndPoint );
1284     vIPSetDHCP_RATimerEnableState_Expect( &xEndPoint, pdFALSE );
1285 
1286     /* pdFALSE Indicating vRAProcessInit is already done */
1287     vRAProcess( pdFALSE, &xEndPoint );
1288 
1289     TEST_ASSERT_EQUAL( eRAStateFailed, xEndPoint.xRAData.eRAState );
1290 }
1291