1 /* Include Unity header */
2 #include "unity.h"
3
4 /* Include standard libraries */
5 #include <stdlib.h>
6 #include <string.h>
7 #include <stdint.h>
8
9 #include "mock_FreeRTOS_IP.h"
10 #include "mock_FreeRTOS_IPv4.h"
11 #include "mock_FreeRTOS_Routing.h"
12 #include "mock_FreeRTOS_IP_Utils.h"
13 #include "mock_FreeRTOS_IPv4_Utils.h"
14 #include "mock_FreeRTOS_IP_Timers.h"
15 #include "mock_FreeRTOS_IP_Private.h"
16 #include "mock_FreeRTOS_ND.h"
17 #include "mock_task.h"
18 #include "mock_NetworkBufferManagement.h"
19
20 #include "FreeRTOS_ARP.h"
21
22 #include "FreeRTOS_ARP_stubs.c"
23 #include "catch_assert.h"
24
25 #include "FreeRTOSIPConfig.h"
26
27 /* =========================== EXTERN VARIABLES =========================== */
28
29 extern ARPCacheRow_t xARPCache[ ipconfigARP_CACHE_ENTRIES ];
30
31 extern NetworkBufferDescriptor_t * pxARPWaitingNetworkBuffer;
32
33 extern BaseType_t xARPHadIPClash;
34
35 /* ============================== Test Cases ============================== */
36
37 /* Helper function to reset the uxARPClashCounter variable before a test is run. It
38 * cannot be directly reset since it is declared as static. */
vResetARPClashCounter(void)39 static void vResetARPClashCounter( void )
40 {
41 ARPPacket_t xARPFrame = { 0 };
42 eFrameProcessingResult_t eResult;
43 struct xNetworkEndPoint xEndPoint = { 0 };
44 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
45
46 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
47
48 /* =================================================== */
49 /* Add settings required for ARP header to pass checks */
50 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
51 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
52 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
53 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
54 /* Different protocol length. */
55 /*xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES + 1; */
56
57 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
58 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
59
60 /* Regardless of whether this is called or not, the test should not fail. */
61 xTaskCheckForTimeOut_IgnoreAndReturn( pdTRUE );
62
63 eResult = eARPProcessPacket( &xNetworkBuffer );
64
65 /* Stop ignoring after the helper function is called. */
66 xTaskCheckForTimeOut_StopIgnore();
67 }
68
test_xCheckLoopback_NullNetworkBuffer(void)69 void test_xCheckLoopback_NullNetworkBuffer( void )
70 {
71 BaseType_t xResult;
72
73 /* bReleaseAfterSend parameter doesn't matter here. */
74 xResult = xCheckLoopback( NULL, pdFALSE );
75 TEST_ASSERT_EQUAL( pdFALSE, xResult );
76 /* =================================================== */
77 }
78
test_xCheckLoopback_DataLengthTooSmall(void)79 void test_xCheckLoopback_DataLengthTooSmall( void )
80 {
81 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
82 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
83 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
84 BaseType_t xResult;
85
86 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
87 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t ) - 1;
88
89 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
90
91 /* =================================================== */
92 /* Let the frame-type be anything else than IPv4. */
93 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
94 /* bReleaseAfterSend parameter doesn't matter here. */
95 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
96 TEST_ASSERT_EQUAL( pdFALSE, xResult );
97 /* =================================================== */
98 }
99
test_xCheckLoopback_IncorrectFrameType(void)100 void test_xCheckLoopback_IncorrectFrameType( void )
101 {
102 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
103 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
104 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
105 BaseType_t xResult;
106
107 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
108 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
109
110 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
111
112 /* =================================================== */
113 /* Let the frame-type be anything else than IPv4. */
114 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE + 1;
115 /* bReleaseAfterSend parameter doesn't matter here. */
116 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
117 TEST_ASSERT_EQUAL( pdFALSE, xResult );
118 /* =================================================== */
119 }
120
test_xCheckLoopback_NullEndPoint(void)121 void test_xCheckLoopback_NullEndPoint( void )
122 {
123 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
124 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
125 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
126 BaseType_t xResult;
127 NetworkEndPoint_t xEndPoint = { 0 };
128
129 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
130 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
131
132 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
133
134 /* =================================================== */
135 /* Let the frame-type be IPv4. */
136 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
137 /* But let the MAC address be different. */
138 memset( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, 0xAA, ipMAC_ADDRESS_LENGTH_BYTES );
139 /* bReleaseAfterSend parameter doesn't matter here. */
140 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( NULL );
141 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
142 TEST_ASSERT_EQUAL( pdFALSE, xResult );
143 /* =================================================== */
144 }
145
test_xCheckLoopback_IncorrectMACAddress(void)146 void test_xCheckLoopback_IncorrectMACAddress( void )
147 {
148 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
149 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
150 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
151 BaseType_t xResult;
152 NetworkEndPoint_t xEndPoint = { 0 };
153
154 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
155 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
156
157 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
158
159 /* =================================================== */
160 /* Let the frame-type be IPv4. */
161 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
162 /* But let the MAC address be different. */
163 memset( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, 0xAA, ipMAC_ADDRESS_LENGTH_BYTES );
164 /* bReleaseAfterSend parameter doesn't matter here. */
165 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( &xEndPoint );
166 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
167 TEST_ASSERT_EQUAL( pdFALSE, xResult );
168 /* =================================================== */
169 }
170
test_xCheckLoopback_HappyCase(void)171 void test_xCheckLoopback_HappyCase( void )
172 {
173 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
174 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
175 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
176 BaseType_t xResult;
177 NetworkEndPoint_t xEndPoint = { 0 };
178 uint8_t ucBytes[ ipMAC_ADDRESS_LENGTH_BYTES ] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
179
180 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
181 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
182
183
184 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
185
186 /* =================================================== */
187 /* Let the frame-type be IPv4. */
188 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
189 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( &xEndPoint );
190 /* Make the MAC address same. */
191 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
192 memcpy( xEndPoint.xMACAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
193 pxDuplicateNetworkBufferWithDescriptor_ExpectAndReturn( pxNetworkBuffer, pxNetworkBuffer->xDataLength, pxNetworkBuffer );
194 xSendEventStructToIPTask_IgnoreAndReturn( pdTRUE );
195
196 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
197 TEST_ASSERT_EQUAL( pdTRUE, xResult );
198 /* =================================================== */
199 }
200
test_xCheckLoopback_DuplicationFails(void)201 void test_xCheckLoopback_DuplicationFails( void )
202 {
203 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
204 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
205 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
206 BaseType_t xResult;
207 NetworkEndPoint_t xEndPoint = { 0 };
208 uint8_t ucBytes[ ipMAC_ADDRESS_LENGTH_BYTES ] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
209
210 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
211 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
212
213 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
214
215 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( &xEndPoint );
216 /* =================================================== */
217 /* Let the frame-type be IPv4. */
218 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
219 /* Make the MAC address same. */
220 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
221 memcpy( xEndPoint.xMACAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
222 /* Make buffer duplication fail. */
223 pxDuplicateNetworkBufferWithDescriptor_ExpectAndReturn( pxNetworkBuffer, pxNetworkBuffer->xDataLength, NULL );
224 xResult = xCheckLoopback( pxNetworkBuffer, pdFALSE );
225 TEST_ASSERT_EQUAL( pdTRUE, xResult );
226 /* =================================================== */
227 }
228
229
test_xCheckLoopback_SendEventToIPTaskFails(void)230 void test_xCheckLoopback_SendEventToIPTaskFails( void )
231 {
232 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
233 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
234 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
235 BaseType_t xResult;
236 NetworkEndPoint_t xEndPoint = { 0 };
237 uint8_t ucBytes[ ipMAC_ADDRESS_LENGTH_BYTES ] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
238
239 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
240 pxNetworkBuffer->xDataLength = sizeof( IPPacket_t );
241
242 IPPacket_t * pxIPPacket = ( IPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );
243
244
245 FreeRTOS_FindEndPointOnMAC_ExpectAnyArgsAndReturn( &xEndPoint );
246 /* =================================================== */
247 /* Let the frame-type be IPv4. */
248 pxIPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
249 /* Make the MAC address same. */
250 memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
251 memcpy( xEndPoint.xMACAddress.ucBytes, ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
252
253 xSendEventStructToIPTask_IgnoreAndReturn( pdFALSE );
254 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
255
256 xResult = xCheckLoopback( pxNetworkBuffer, pdTRUE );
257 TEST_ASSERT_EQUAL( pdTRUE, xResult );
258 /* =================================================== */
259 }
260
test_eARPProcessPacket_DifferentHardwareAddress(void)261 void test_eARPProcessPacket_DifferentHardwareAddress( void )
262 {
263 ARPPacket_t xARPFrame = { 0 };
264 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
265 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
266 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
267 eFrameProcessingResult_t eResult;
268
269 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
270
271 /* =================================================== */
272 /* Different Hardware address. */
273 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET + 1;
274 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
275
276 /* When the local IP address is 0, we should not process any ARP Packets. */
277 *ipLOCAL_IP_ADDRESS_POINTER = 0UL;
278 eResult = eARPProcessPacket( pxNetworkBuffer );
279 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
280 /* =================================================== */
281 }
282
test_eARPProcessPacket_DifferentProtocolType(void)283 void test_eARPProcessPacket_DifferentProtocolType( void )
284 {
285 ARPPacket_t xARPFrame = { 0 };
286 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
287 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
288 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
289 eFrameProcessingResult_t eResult;
290
291 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
292
293 /* =================================================== */
294 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
295 /* Different protocol type */
296 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE + 1;
297 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
298
299 /* When the local IP address is 0, we should not process any ARP Packets. */
300 *ipLOCAL_IP_ADDRESS_POINTER = 0UL;
301 eResult = eARPProcessPacket( pxNetworkBuffer );
302 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
303 /* =================================================== */
304 }
305
test_eARPProcessPacket_DifferentHardwareLength(void)306 void test_eARPProcessPacket_DifferentHardwareLength( void )
307 {
308 ARPPacket_t xARPFrame = { 0 };
309 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
310 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
311 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
312 eFrameProcessingResult_t eResult;
313
314 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
315
316 /* =================================================== */
317 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
318 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
319 /* Different MAC address length. */
320 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES + 1;
321 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
322
323 /* When the local IP address is 0, we should not process any ARP Packets. */
324 *ipLOCAL_IP_ADDRESS_POINTER = 0UL;
325 eResult = eARPProcessPacket( pxNetworkBuffer );
326 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
327 /* =================================================== */
328 }
329
test_eARPProcessPacket_DifferentProtocolLength(void)330 void test_eARPProcessPacket_DifferentProtocolLength( void )
331 {
332 ARPPacket_t xARPFrame = { 0 };
333 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
334 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
335 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
336 eFrameProcessingResult_t eResult;
337
338 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
339
340 /* =================================================== */
341 /* Add settings required for ARP header to pass checks */
342 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
343 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
344 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
345 /* Different protocol length. */
346 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES + 1;
347 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
348
349 /* When the local IP address is 0, we should not process any ARP Packets. */
350 *ipLOCAL_IP_ADDRESS_POINTER = 0UL;
351 eResult = eARPProcessPacket( pxNetworkBuffer );
352 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
353 /* =================================================== */
354 }
355
test_eARPProcessPacket_SourceMACIsBroadcast(void)356 void test_eARPProcessPacket_SourceMACIsBroadcast( void )
357 {
358 ARPPacket_t xARPFrame = { 0 };
359 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
360 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
361 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
362 eFrameProcessingResult_t eResult;
363 NetworkEndPoint_t xEndPoint = { 0 };
364
365 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
366
367 /* =================================================== */
368 /* Add settings required for ARP header to pass checks */
369 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
370 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
371 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
372 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
373 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
374
375 /* Copy the broadcast MAC address into the sender hardware address. */
376 memcpy( &( xARPFrame.xARPHeader.xSenderHardwareAddress ), &xBroadcastMACAddress, sizeof( MACAddress_t ) );
377 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
378
379 eResult = eARPProcessPacket( pxNetworkBuffer );
380 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
381 /* =================================================== */
382 }
383
test_eARPProcessPacket_SourceMACIsMulticast(void)384 void test_eARPProcessPacket_SourceMACIsMulticast( void )
385 {
386 ARPPacket_t xARPFrame = { 0 };
387 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
388 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
389 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
390 eFrameProcessingResult_t eResult;
391 NetworkEndPoint_t xEndPoint = { 0 };
392
393 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
394
395 /* =================================================== */
396 /* Add settings required for ARP header to pass checks */
397 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
398 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
399 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
400 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
401
402 xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes[ 0 ] = 0x01;
403 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
404
405 eResult = eARPProcessPacket( pxNetworkBuffer );
406 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
407 /* =================================================== */
408 }
409
test_eARPProcessPacket_IPIsLocalLoopBack(void)410 void test_eARPProcessPacket_IPIsLocalLoopBack( void )
411 {
412 ARPPacket_t xARPFrame = { 0 };
413 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
414 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
415 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
416 eFrameProcessingResult_t eResult;
417 NetworkEndPoint_t xEndPoint = { 0 };
418
419 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
420
421 /* =================================================== */
422 /* Add settings required for ARP header to pass checks */
423 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
424 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
425 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
426 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
427
428 uint32_t ulSenderProtocolAddress = FreeRTOS_htonl( ipFIRST_LOOPBACK_IPv4 + 10 );
429
430 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress,
431 &ulSenderProtocolAddress,
432 sizeof( ulSenderProtocolAddress ) );
433 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
434
435 eResult = eARPProcessPacket( pxNetworkBuffer );
436 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
437 /* =================================================== */
438 }
439
test_eARPProcessPacket_SenderIPLessThanLoopBack(void)440 void test_eARPProcessPacket_SenderIPLessThanLoopBack( void )
441 {
442 ARPPacket_t xARPFrame = { 0 };
443 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
444 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
445 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
446 eFrameProcessingResult_t eResult;
447 NetworkEndPoint_t xEndPoint = { 0 };
448
449 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
450
451 /* =================================================== */
452 /* Add settings required for ARP header to pass checks */
453 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
454 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
455 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
456 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
457
458 uint32_t ulSenderProtocolAddress = FreeRTOS_htonl( ipFIRST_LOOPBACK_IPv4 - 10 );
459
460 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress,
461 &ulSenderProtocolAddress,
462 sizeof( ulSenderProtocolAddress ) );
463 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
464 pxNetworkBuffer->pxEndPoint = &xEndPoint;
465
466 eResult = eARPProcessPacket( pxNetworkBuffer );
467 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
468 /* =================================================== */
469 }
470
test_eARPProcessPacket_LocalIPisZero(void)471 void test_eARPProcessPacket_LocalIPisZero( void )
472 {
473 ARPPacket_t xARPFrame = { 0 };
474 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
475 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
476 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
477 eFrameProcessingResult_t eResult;
478 NetworkEndPoint_t xEndPoint = { 0 };
479
480 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
481
482 /* =================================================== */
483 /* Add settings required for ARP header to pass checks */
484 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
485 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
486 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
487 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
488 memset( &xARPFrame.xARPHeader.ucSenderProtocolAddress, 0xC0, sizeof( xARPFrame.xARPHeader.ucSenderProtocolAddress ) );
489 xARPFrame.xARPHeader.ulTargetProtocolAddress = 0xC0C0C0C0;
490 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
491 pxNetworkBuffer->pxEndPoint = &xEndPoint;
492 xEndPoint.ipv4_settings.ulIPAddress = 0;
493
494 eResult = eARPProcessPacket( pxNetworkBuffer );
495 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
496 /* =================================================== */
497 }
498
test_eARPProcessPacket_InvalidOperation(void)499 void test_eARPProcessPacket_InvalidOperation( void )
500 {
501 ARPPacket_t xARPFrame = { 0 };
502 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
503 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
504 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
505 eFrameProcessingResult_t eResult;
506 NetworkEndPoint_t xEndPoint = { 0 };
507
508 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
509 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
510
511 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
512 /* =================================================== */
513 /* Add settings required for ARP header to pass checks */
514 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
515 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
516 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
517 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
518 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
519 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
520
521 /* What if some invalid option is sent in the ARP Packet? */
522 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
523 /* Add invalid operation */
524 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST | ipARP_REPLY;
525 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
526 pxNetworkBuffer->pxEndPoint = &xEndPoint;
527
528 eResult = eARPProcessPacket( pxNetworkBuffer );
529 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
530 }
531
test_eARPProcessPacket_Request_DifferentIP(void)532 void test_eARPProcessPacket_Request_DifferentIP( void )
533 {
534 ARPPacket_t xARPFrame = { 0 };
535 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
536 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
537 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
538 eFrameProcessingResult_t eResult;
539 NetworkEndPoint_t xEndPoint = { 0 };
540
541 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
542
543 /* Process an ARP request, but not meant for this node. */
544 /* Add settings required for ARP header to pass checks */
545 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
546 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
547 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
548 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
549
550 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
551 /* Fill in the request option. */
552 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
553 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
554 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
555 pxNetworkBuffer->pxEndPoint = &xEndPoint;
556 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
557
558 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( 1 );
559 eResult = eARPProcessPacket( pxNetworkBuffer );
560 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
561 /* =================================================== */
562 }
563
test_eARPProcessPacket_Request_SenderMACSameAsLocalMAC(void)564 void test_eARPProcessPacket_Request_SenderMACSameAsLocalMAC( void )
565 {
566 ARPPacket_t xARPFrame = { 0 };
567 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
568 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
569 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
570 eFrameProcessingResult_t eResult;
571 NetworkEndPoint_t xEndPoint = { 0 };
572
573 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
574
575 /* Process an ARP request, but not meant for this node. */
576 /* Add settings required for ARP header to pass checks */
577 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
578 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
579 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
580 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
581
582 memset( ipLOCAL_MAC_ADDRESS, 0x22, sizeof( MACAddress_t ) );
583 memcpy( &( xARPFrame.xARPHeader.xSenderHardwareAddress ), ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) );
584
585 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
586 /* Fill in the request option. */
587 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
588 xARPFrame.xARPHeader.ulTargetProtocolAddress = xEndPoint.ipv4_settings.ulIPAddress;
589 pxNetworkBuffer->pucEthernetBuffer = &xARPFrame;
590 pxNetworkBuffer->pxEndPoint = &xEndPoint;
591 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
592
593 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( 1 );
594 eResult = eARPProcessPacket( pxNetworkBuffer );
595 TEST_ASSERT_EQUAL( eReturnEthernetFrame, eResult );
596 }
597
test_eARPProcessPacket_Request_SenderAndTargetDifferent(void)598 void test_eARPProcessPacket_Request_SenderAndTargetDifferent( void )
599 {
600 ARPPacket_t xARPFrame = { 0 };
601 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
602 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
603 uint8_t ucBuffer[ sizeof( IPPacket_t ) + ipBUFFER_PADDING ];
604 eFrameProcessingResult_t eResult;
605 NetworkEndPoint_t xEndPoint = { 0 };
606
607 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
608
609 /* =================================================== */
610 /* Add settings required for ARP header to pass checks */
611 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
612 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
613 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
614 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
615
616 /* Process an ARP request - meant for this node with target and source different. */
617 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
618 /* Fill in the request option. */
619 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
620 xARPFrame.xARPHeader.ulTargetProtocolAddress = xEndPoint.ipv4_settings.ulIPAddress;
621 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
622 /* Make sure the the destination and source IP addresses are different. */
623 xARPFrame.xARPHeader.ucSenderProtocolAddress[ 0 ]++;
624
625 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
626
627 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
628 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
629 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
630 xNetworkBuffer.pxEndPoint = &xEndPoint;
631 pxNetworkBuffer->pxEndPoint = &xEndPoint;
632
633 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( 1 );
634 eResult = eARPProcessPacket( pxNetworkBuffer );
635 TEST_ASSERT_EQUAL( eReturnEthernetFrame, eResult );
636 /* =================================================== */
637
638 /* Fill in the request option. */
639
640 memcpy( &( xEndPoint.xMACAddress.ucBytes ), &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), ipMAC_ADDRESS_LENGTH_BYTES );
641 xEndPoint.ipv4_settings.ulIPAddress = xARPFrame.xARPHeader.ulTargetProtocolAddress;
642 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
643
644 eResult = eARPProcessPacket( &xNetworkBuffer );
645 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
646 }
647
test_eARPProcessPacket_Request_SenderAndTargetSame(void)648 void test_eARPProcessPacket_Request_SenderAndTargetSame( void )
649 {
650 ARPPacket_t xARPFrame = { 0 };
651 eFrameProcessingResult_t eResult;
652 NetworkInterface_t xInterface;
653 struct xNetworkEndPoint xEndPoint = { 0 };
654 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
655
656 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
657
658 /* =================================================== */
659 /* Add settings required for ARP header to pass checks */
660 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
661 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
662 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
663 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
664
665 /* Process an ARP request - meant for this node with target and source same. */
666 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
667 /* Fill in the request option. */
668 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
669 xARPFrame.xARPHeader.ulTargetProtocolAddress = xEndPoint.ipv4_settings.ulIPAddress;
670 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
671
672 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
673
674 /* Reset the private variable uxARPClashCounter. */
675 vResetARPClashCounter();
676
677 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, NULL );
678
679 /* The value returned doesn't matter as this will determine when would the
680 * next timeout for Gratuitous ARP occur. And for this unit-test, that doesn't
681 * matter. */
682 xTaskGetTickCount_ExpectAndReturn( 100 );
683
684 /* This function will setup the timeout which is used to limit the number of defensive
685 * ARPs. */
686 vTaskSetTimeOutState_ExpectAnyArgs();
687 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
688
689 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
690 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
691 xNetworkBuffer.pxEndPoint = &xEndPoint;
692 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
693
694 eResult = eARPProcessPacket( &xNetworkBuffer );
695 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
696 /* =================================================== */
697 }
698
699 /**
700 * @brief This function verify receiving Gratuitous ARP packet
701 * and updating the ARP cache with respect to the new ARP request.
702 */
test_eARPProcessPacket_Request_GratuitousARP(void)703 void test_eARPProcessPacket_Request_GratuitousARP( void )
704 {
705 ARPPacket_t xARPFrame = { 0 };
706 eFrameProcessingResult_t eResult;
707 NetworkInterface_t xInterface;
708 struct xNetworkEndPoint xEndPoint = { 0 };
709 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
710 uint32_t ulTargetIP = 0xAACCDDBB;
711
712 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
713 memset( xARPCache, 0, sizeof( xARPCache ) );
714
715 /* =================================================== */
716 /* Add settings required for ARP header to pass checks */
717 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
718 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
719 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
720 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
721
722 /* Process an ARP request - meant for this node with target and source same. */
723 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
724 /* Fill in the request option. */
725 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
726 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
727 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
728
729 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
730
731 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
732 xARPCache[ 0 ].ucAge = 1;
733 xARPCache[ 0 ].ucValid = pdTRUE;
734 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x34, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
735 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
736
737 memset( &( xARPFrame.xARPHeader.xTargetHardwareAddress.ucBytes ), 0xff, sizeof( MACAddress_t ) );
738
739 /* Reset the private variable uxARPClashCounter. */
740 vResetARPClashCounter();
741
742 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
743 xIsIPv4Multicast_ExpectAndReturn( ulTargetIP, 0UL );
744 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
745 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
746
747 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
748 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
749 xNetworkBuffer.pxEndPoint = &xEndPoint;
750 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
751
752 eResult = eARPProcessPacket( &xNetworkBuffer );
753 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
754 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
755 TEST_ASSERT_EQUAL( ipconfigMAX_ARP_AGE, xARPCache[ 0 ].ucAge );
756 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
757 TEST_ASSERT_EQUAL( &xEndPoint, xARPCache[ 0 ].pxEndPoint );
758 TEST_ASSERT_EQUAL_MEMORY( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
759 /* =================================================== */
760 }
761
762 /**
763 * @brief This function verify receiving Gratuitous ARP packet
764 * and updating the ARP cache with respect to the new ARP request
765 * where there is no change in the MAC address compared to what is present
766 * in the ARP cache.
767 */
test_eARPProcessPacket_Request_GratuitousARP_MACUnchanged(void)768 void test_eARPProcessPacket_Request_GratuitousARP_MACUnchanged( void )
769 {
770 ARPPacket_t xARPFrame = { 0 };
771 eFrameProcessingResult_t eResult;
772 NetworkInterface_t xInterface;
773 struct xNetworkEndPoint xEndPoint = { 0 };
774 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
775 uint32_t ulTargetIP = 0xAACCDDBB;
776
777 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
778 memset( xARPCache, 0, sizeof( xARPCache ) );
779
780 /* =================================================== */
781 /* Add settings required for ARP header to pass checks */
782 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
783 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
784 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
785 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
786
787 /* Process an ARP request - meant for this node with target and source same. */
788 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
789 /* Fill in the request option. */
790 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
791 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
792 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
793
794 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
795
796 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
797 xARPCache[ 0 ].ucAge = 1;
798 xARPCache[ 0 ].ucValid = pdTRUE;
799 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
800 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
801
802 /* Reset the private variable uxARPClashCounter. */
803 vResetARPClashCounter();
804
805 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
806 xIsIPv4Multicast_ExpectAndReturn( ulTargetIP, 0UL );
807 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
808 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
809
810 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
811 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
812 xNetworkBuffer.pxEndPoint = &xEndPoint;
813 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
814
815 eResult = eARPProcessPacket( &xNetworkBuffer );
816 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
817 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
818 TEST_ASSERT_EQUAL( ipconfigMAX_ARP_AGE, xARPCache[ 0 ].ucAge );
819 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
820 TEST_ASSERT_EQUAL( &xEndPoint, xARPCache[ 0 ].pxEndPoint );
821 TEST_ASSERT_EQUAL_MEMORY( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
822 /* =================================================== */
823 }
824
825 /**
826 * @brief This function verify receiving Gratuitous ARP packet
827 * but the sender protocol address is outside the subnet.
828 */
test_eARPProcessPacket_Request_GratuitousARP_OutOfSubnetIP(void)829 void test_eARPProcessPacket_Request_GratuitousARP_OutOfSubnetIP( void )
830 {
831 ARPPacket_t xARPFrame = { 0 };
832 eFrameProcessingResult_t eResult;
833 NetworkInterface_t xInterface;
834 struct xNetworkEndPoint xEndPoint = { 0 };
835 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
836 uint32_t ulTargetIP = 0xAACCDDBB;
837
838 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
839 memset( xARPCache, 0, sizeof( xARPCache ) );
840
841 /* =================================================== */
842 /* Add settings required for ARP header to pass checks */
843 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
844 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
845 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
846 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
847
848 /* Process an ARP request - meant for this node with target and source same. */
849 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
850 xEndPoint.ipv4_settings.ulNetMask = 0xFFFF0000;
851 /* Fill in the request option. */
852 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
853 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
854 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
855
856 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
857
858 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
859 xARPCache[ 0 ].ucAge = 1;
860 xARPCache[ 0 ].ucValid = pdTRUE;
861 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
862 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
863
864 /* Reset the private variable uxARPClashCounter. */
865 vResetARPClashCounter();
866
867 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
868 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
869 xNetworkBuffer.pxEndPoint = &xEndPoint;
870 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
871
872 eResult = eARPProcessPacket( &xNetworkBuffer );
873 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
874 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
875 TEST_ASSERT_EQUAL( 1, xARPCache[ 0 ].ucAge );
876 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
877 TEST_ASSERT_EQUAL( &xEndPoint, xARPCache[ 0 ].pxEndPoint );
878 TEST_ASSERT_EQUAL_MEMORY( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
879 /* =================================================== */
880 }
881
882 /**
883 * @brief This function verify receiving Gratuitous ARP packet
884 * but the new MAC address matches with the MAC address of the
885 * endpoint.
886 */
test_eARPProcessPacket_Request_GratuitousARP_MACMatchesWithEndpoint(void)887 void test_eARPProcessPacket_Request_GratuitousARP_MACMatchesWithEndpoint( void )
888 {
889 ARPPacket_t xARPFrame = { 0 };
890 eFrameProcessingResult_t eResult;
891 NetworkInterface_t xInterface;
892 struct xNetworkEndPoint xEndPoint = { 0 };
893 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
894 uint32_t ulTargetIP = 0xAACCDDBB;
895
896 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
897 memset( xARPCache, 0, sizeof( xARPCache ) );
898
899 /* =================================================== */
900 /* Add settings required for ARP header to pass checks */
901 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
902 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
903 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
904 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
905
906 /* Process an ARP request - meant for this node with target and source same. */
907 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
908 xEndPoint.ipv4_settings.ulNetMask = 0;
909 memset( xEndPoint.xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
910 /* Fill in the request option. */
911 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
912 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
913 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
914
915 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
916
917 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
918 xARPCache[ 0 ].ucAge = 1;
919 xARPCache[ 0 ].ucValid = pdTRUE;
920 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
921 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
922
923 /* Reset the private variable uxARPClashCounter. */
924 vResetARPClashCounter();
925
926 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
927 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
928 xNetworkBuffer.pxEndPoint = &xEndPoint;
929 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
930
931 eResult = eARPProcessPacket( &xNetworkBuffer );
932 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
933 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
934 TEST_ASSERT_EQUAL( 1, xARPCache[ 0 ].ucAge );
935 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
936 TEST_ASSERT_EQUAL( &xEndPoint, xARPCache[ 0 ].pxEndPoint );
937 TEST_ASSERT_EQUAL_MEMORY( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
938 /* =================================================== */
939 }
940
941 /**
942 * @brief This function verify receiving Gratuitous ARP packet
943 * but the target MAC address in the ARP request is not a
944 * broadcast address.
945 */
test_eARPProcessPacket_Request_GratuitousARP_TargetHWAddressNotBroadcast(void)946 void test_eARPProcessPacket_Request_GratuitousARP_TargetHWAddressNotBroadcast( void )
947 {
948 ARPPacket_t xARPFrame = { 0 };
949 eFrameProcessingResult_t eResult;
950 NetworkInterface_t xInterface;
951 struct xNetworkEndPoint xEndPoint = { 0 };
952 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
953 uint32_t ulTargetIP = 0xAACCDDBB;
954
955 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
956 memset( xARPCache, 0, sizeof( xARPCache ) );
957
958 /* =================================================== */
959 /* Add settings required for ARP header to pass checks */
960 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
961 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
962 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
963 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
964
965 /* Process an ARP request - meant for this node with target and source same. */
966 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
967 xEndPoint.ipv4_settings.ulNetMask = 0;
968 memset( xEndPoint.xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
969 /* Fill in the request option. */
970 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
971 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
972 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
973
974 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
975 memset( &( xARPFrame.xARPHeader.xTargetHardwareAddress.ucBytes ), 0x11, sizeof( MACAddress_t ) );
976
977 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
978 xARPCache[ 0 ].ucAge = 1;
979 xARPCache[ 0 ].ucValid = pdTRUE;
980 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x22, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
981 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
982
983 /* Reset the private variable uxARPClashCounter. */
984 vResetARPClashCounter();
985
986 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
987 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
988 xNetworkBuffer.pxEndPoint = &xEndPoint;
989 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
990
991 eResult = eARPProcessPacket( &xNetworkBuffer );
992 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
993 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
994 TEST_ASSERT_EQUAL( 1, xARPCache[ 0 ].ucAge );
995 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
996 TEST_ASSERT_EQUAL( &xEndPoint, xARPCache[ 0 ].pxEndPoint );
997 TEST_ASSERT_EQUAL_MEMORY( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
998 /* =================================================== */
999 }
1000
1001
1002 /**
1003 * @brief This function verify receiving Gratuitous ARP packet
1004 * but the packet is received in a different endpoint compared
1005 * to the entry present in the ARP cache. Hence its supposed to
1006 * be not updated in the ARP cache.
1007 */
test_eARPProcessPacket_Request_GratuitousARP_NonMatchingEndpoint(void)1008 void test_eARPProcessPacket_Request_GratuitousARP_NonMatchingEndpoint( void )
1009 {
1010 ARPPacket_t xARPFrame = { 0 };
1011 eFrameProcessingResult_t eResult;
1012 NetworkInterface_t xInterface;
1013 struct xNetworkEndPoint xEndPoint = { 0 };
1014 struct xNetworkEndPoint xEndPoint2 = { 0 };
1015 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1016 uint32_t ulTargetIP = 0xAACCDDBB;
1017 uint8_t ucMAC[ 6 ] = { 0x34, 0x34, 0x34, 0x34, 0x34, 0x34 };
1018
1019 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1020 memset( xARPCache, 0, sizeof( xARPCache ) );
1021
1022 /* =================================================== */
1023 /* Add settings required for ARP header to pass checks */
1024 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1025 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1026 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1027 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1028
1029 /* Process an ARP request - meant for this node with target and source same. */
1030 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
1031 /* Fill in the request option. */
1032 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
1033 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
1034 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1035
1036 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
1037
1038 xARPCache[ 0 ].ulIPAddress = ulTargetIP;
1039 xARPCache[ 0 ].ucAge = 1;
1040 xARPCache[ 0 ].ucValid = pdTRUE;
1041 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x34, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
1042 xARPCache[ 0 ].pxEndPoint = &xEndPoint2;
1043
1044 /* Reset the private variable uxARPClashCounter. */
1045 vResetARPClashCounter();
1046
1047 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
1048 xIsIPv4Multicast_ExpectAndReturn( ulTargetIP, 0UL );
1049 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
1050
1051 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1052 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1053 xNetworkBuffer.pxEndPoint = &xEndPoint;
1054 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1055
1056 eResult = eARPProcessPacket( &xNetworkBuffer );
1057 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1058 TEST_ASSERT_EQUAL( ulTargetIP, xARPCache[ 0 ].ulIPAddress );
1059 TEST_ASSERT_EQUAL( 1, xARPCache[ 0 ].ucAge );
1060 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
1061 TEST_ASSERT_EQUAL( &xEndPoint2, xARPCache[ 0 ].pxEndPoint );
1062 TEST_ASSERT_EQUAL_MEMORY( ucMAC, xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
1063 /* =================================================== */
1064 }
1065
1066 /**
1067 * @brief This function verify receiving Gratuitous ARP packet
1068 * but the ARP cache doesn't have an entry for the IP in the
1069 * ARP request.
1070 */
test_eARPProcessPacket_Request_GratuitousARP_NonMatchingIP(void)1071 void test_eARPProcessPacket_Request_GratuitousARP_NonMatchingIP( void )
1072 {
1073 ARPPacket_t xARPFrame = { 0 };
1074 eFrameProcessingResult_t eResult;
1075 NetworkInterface_t xInterface;
1076 struct xNetworkEndPoint xEndPoint = { 0 };
1077 struct xNetworkEndPoint xEndPoint2 = { 0 };
1078 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1079 uint32_t ulTargetIP = 0xAACCDDBB;
1080 uint8_t ucMAC[ 6 ] = { 0x34, 0x34, 0x34, 0x34, 0x34, 0x34 };
1081
1082 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1083 memset( xARPCache, 0, sizeof( xARPCache ) );
1084
1085 /* =================================================== */
1086 /* Add settings required for ARP header to pass checks */
1087 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1088 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1089 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1090 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1091
1092 /* Process an ARP request - meant for this node with target and source same. */
1093 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
1094 /* Fill in the request option. */
1095 xARPFrame.xARPHeader.usOperation = ipARP_REQUEST;
1096 xARPFrame.xARPHeader.ulTargetProtocolAddress = ulTargetIP;
1097 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1098
1099 memset( &( xARPFrame.xARPHeader.xSenderHardwareAddress.ucBytes ), 0x22, sizeof( MACAddress_t ) );
1100
1101 xARPCache[ 0 ].ulIPAddress = 0xAABBCCDF;
1102 xARPCache[ 0 ].ucAge = 1;
1103 xARPCache[ 0 ].ucValid = pdTRUE;
1104 memset( xARPCache[ 0 ].xMACAddress.ucBytes, 0x34, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
1105 xARPCache[ 0 ].pxEndPoint = &xEndPoint2;
1106
1107 /* Reset the private variable uxARPClashCounter. */
1108 vResetARPClashCounter();
1109
1110 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
1111 xIsIPv4Multicast_ExpectAndReturn( ulTargetIP, 0UL );
1112 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
1113
1114 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1115 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1116 xNetworkBuffer.pxEndPoint = &xEndPoint;
1117 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1118
1119 eResult = eARPProcessPacket( &xNetworkBuffer );
1120 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1121 TEST_ASSERT_EQUAL( 0xAABBCCDF, xARPCache[ 0 ].ulIPAddress );
1122 TEST_ASSERT_EQUAL( 1, xARPCache[ 0 ].ucAge );
1123 TEST_ASSERT_EQUAL( pdTRUE, xARPCache[ 0 ].ucValid );
1124 TEST_ASSERT_EQUAL( &xEndPoint2, xARPCache[ 0 ].pxEndPoint );
1125 TEST_ASSERT_EQUAL_MEMORY( ucMAC, xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xARPCache[ 0 ].xMACAddress.ucBytes ) );
1126 /* =================================================== */
1127 }
1128
test_eARPProcessPacket_Reply_TargetIPSameAsLocalIP(void)1129 void test_eARPProcessPacket_Reply_TargetIPSameAsLocalIP( void )
1130 {
1131 ARPPacket_t xARPFrame = { 0 };
1132 eFrameProcessingResult_t eResult;
1133 NetworkInterface_t xInterface;
1134 struct xNetworkEndPoint xEndPoint = { 0 };
1135 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1136
1137 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1138 memset( xARPCache, 0, sizeof( xARPCache ) );
1139
1140 /* Process an ARP request, but not meant for this node. */
1141 /* Add settings required for ARP header to pass checks */
1142 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1143 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1144 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1145 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1146
1147 memset( ipLOCAL_MAC_ADDRESS, 0x22, sizeof( MACAddress_t ) );
1148 memcpy( &( xARPFrame.xARPHeader.xSenderHardwareAddress ), ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) );
1149
1150 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1151 /* Fill in the request option. */
1152 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1153 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER;
1154
1155 uint32_t ulSenderProtocolAddress = 0xFFAAEEBB;
1156
1157 memcpy( &( xARPFrame.xARPHeader.ucSenderProtocolAddress ), &ulSenderProtocolAddress, sizeof( uint32_t ) );
1158
1159 /* Reset the private variable uxARPClashCounter. */
1160 vResetARPClashCounter();
1161
1162 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
1163
1164 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1165 xEndPoint.ipv4_settings.ulIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
1166 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1167 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1168 xNetworkBuffer.pxEndPoint = &xEndPoint;
1169
1170 eResult = eARPProcessPacket( &xNetworkBuffer );
1171 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1172 TEST_ASSERT_EQUAL( pdTRUE, xIsIPInARPCache( ulSenderProtocolAddress ) );
1173 /* =================================================== */
1174 }
1175
test_eARPProcessPacket_Reply_TargetIPNotSameAsLocalIP_ButEntryInCache(void)1176 void test_eARPProcessPacket_Reply_TargetIPNotSameAsLocalIP_ButEntryInCache( void )
1177 {
1178 ARPPacket_t xARPFrame = { 0 };
1179 eFrameProcessingResult_t eResult;
1180 NetworkInterface_t xInterface;
1181 struct xNetworkEndPoint xEndPoint = { 0 };
1182 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1183
1184 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1185 memset( xARPCache, 0, sizeof( xARPCache ) );
1186
1187 /* Process an ARP request, but not meant for this node. */
1188 /* Add settings required for ARP header to pass checks */
1189 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1190 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1191 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1192 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1193
1194 memset( ipLOCAL_MAC_ADDRESS, 0x22, sizeof( MACAddress_t ) );
1195 memcpy( &( xARPFrame.xARPHeader.xSenderHardwareAddress ), ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) );
1196
1197 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1198 /* Fill in the request option. */
1199 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1200 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 1;
1201
1202 uint32_t ulSenderProtocolAddress = 0xFFAAEEBB;
1203
1204 memcpy( &( xARPFrame.xARPHeader.ucSenderProtocolAddress ), &ulSenderProtocolAddress, sizeof( uint32_t ) );
1205
1206 xARPCache[ 0 ].ulIPAddress = ulSenderProtocolAddress;
1207 xARPCache[ 0 ].ucAge = 1;
1208 xARPCache[ 0 ].ucValid = 1;
1209
1210 /* Reset the private variable uxARPClashCounter. */
1211 vResetARPClashCounter();
1212
1213 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
1214
1215 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1216 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1217 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1218 xNetworkBuffer.pxEndPoint = &xEndPoint;
1219
1220 eResult = eARPProcessPacket( &xNetworkBuffer );
1221 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1222 TEST_ASSERT_EQUAL( pdTRUE, xIsIPInARPCache( ulSenderProtocolAddress ) );
1223 TEST_ASSERT_EQUAL( ipconfigMAX_ARP_AGE, xARPCache[ 0 ].ucAge );
1224 /* =================================================== */
1225 }
1226
1227
test_eARPProcessPacket_Reply_SenderAndTargetSame(void)1228 void test_eARPProcessPacket_Reply_SenderAndTargetSame( void )
1229 {
1230 ARPPacket_t xARPFrame = { 0 };
1231 eFrameProcessingResult_t eResult;
1232 NetworkInterface_t xInterface;
1233 struct xNetworkEndPoint xEndPoint = { 0 }, xEndPoint_2 = { 0 };
1234 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1235
1236 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1237
1238 /* =================================================== */
1239 /* Add settings required for ARP header to pass checks */
1240 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1241 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1242 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1243 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1244
1245 /* Process an ARP reply - meant for this node with target and source same. */
1246 xEndPoint.ipv4_settings.ulIPAddress = 0xAABBCCDD;
1247 /* Fill in the request option. */
1248 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1249 xARPFrame.xARPHeader.ulTargetProtocolAddress = xEndPoint.ipv4_settings.ulIPAddress;
1250 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1251
1252 /* Reset the private variable uxARPClashCounter. */
1253 vResetARPClashCounter();
1254
1255 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1256 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1257 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1258 xNetworkBuffer.pxEndPoint = &xEndPoint;
1259
1260 FreeRTOS_FirstEndPoint_ExpectAnyArgsAndReturn( NULL );
1261
1262 FreeRTOS_FindEndPointOnNetMask_IgnoreAndReturn( 1 );
1263 xTaskGetTickCount_ExpectAndReturn( 0 );
1264 vTaskSetTimeOutState_ExpectAnyArgs();
1265 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
1266
1267 /* Reset the flag. */
1268 xARPHadIPClash = pdFALSE;
1269
1270 eResult = eARPProcessPacket( &xNetworkBuffer );
1271 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1272 TEST_ASSERT_EQUAL( pdTRUE, xARPHadIPClash );
1273 /* =================================================== */
1274
1275 /* Reset the flag. */
1276 xARPHadIPClash = pdFALSE;
1277
1278 /* Let there be no timeout. Let the EndPoint be NULL */
1279 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFAIL );
1280 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
1281
1282 eResult = eARPProcessPacket( &xNetworkBuffer );
1283 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1284 TEST_ASSERT_EQUAL( pdFALSE, xARPHadIPClash );
1285 /* =================================================== */
1286
1287 /* Reset the flag. */
1288 xARPHadIPClash = pdFALSE;
1289 /* Let there be no timeout. */
1290 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFAIL );
1291 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint );
1292
1293 /* Call it again and do not expect the task functions to be called. */
1294 eResult = eARPProcessPacket( &xNetworkBuffer );
1295 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1296 TEST_ASSERT_EQUAL( pdTRUE, xARPHadIPClash );
1297 /* =================================================== */
1298
1299 /* Reset the flag. */
1300 xARPHadIPClash = pdFALSE;
1301 xEndPoint_2.ipv4_settings.ulIPAddress = xARPFrame.xARPHeader.ucSenderProtocolAddress + 0x11;
1302
1303 /* Let there be no timeout. Let the EndPoint be NULL */
1304 xTaskCheckForTimeOut_ExpectAnyArgsAndReturn( pdFAIL );
1305 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( &xEndPoint_2 );
1306
1307 eResult = eARPProcessPacket( &xNetworkBuffer );
1308 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1309 TEST_ASSERT_EQUAL( pdFALSE, xARPHadIPClash );
1310 /* =================================================== */
1311 }
1312
test_eARPProcessPacket_Reply_DifferentIP(void)1313 void test_eARPProcessPacket_Reply_DifferentIP( void )
1314 {
1315 ARPPacket_t xARPFrame = { 0 };
1316 eFrameProcessingResult_t eResult;
1317 NetworkInterface_t xInterface;
1318 struct xNetworkEndPoint xEndPoint = { 0 };
1319 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1320
1321 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1322
1323 /* =================================================== */
1324 /* Add settings required for ARP header to pass checks */
1325 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1326 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1327 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1328 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1329
1330 /* Process an ARP reply - not meant for this node. */
1331 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1332 /* Fill in the request option. */
1333 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1334 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
1335 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1336
1337 /* Reset the private variable uxARPClashCounter. */
1338 vResetARPClashCounter();
1339
1340 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1341 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1342 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1343 xNetworkBuffer.pxEndPoint = &xEndPoint;
1344
1345 eResult = eARPProcessPacket( &xNetworkBuffer );
1346 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1347 /* =================================================== */
1348 }
1349
test_eARPProcessPacket_Reply_DifferentIP_WaitingBufferNonNull(void)1350 void test_eARPProcessPacket_Reply_DifferentIP_WaitingBufferNonNull( void )
1351 {
1352 ARPPacket_t xARPFrame = { 0 };
1353 eFrameProcessingResult_t eResult;
1354 NetworkBufferDescriptor_t xLocalBuffer;
1355 uint8_t pucLocalEthernetBuffer[ 1500 ];
1356 NetworkInterface_t xInterface;
1357 struct xNetworkEndPoint xEndPoint = { 0 };
1358 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1359
1360 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1361
1362 /* Clear the buffer. */
1363 memset( pucLocalEthernetBuffer, 0, sizeof( pucLocalEthernetBuffer ) );
1364
1365 xLocalBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
1366 pxARPWaitingNetworkBuffer = &xLocalBuffer;
1367
1368 /* =================================================== */
1369 /* Add settings required for ARP header to pass checks */
1370 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1371 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1372 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1373 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1374
1375 /* Process an ARP reply - not meant for this node. */
1376 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1377 /* Fill in the request option. */
1378 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1379 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
1380 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1381
1382 /* Reset the private variable uxARPClashCounter. */
1383 vResetARPClashCounter();
1384
1385 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1386 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1387 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1388 xNetworkBuffer.pxEndPoint = &xEndPoint;
1389
1390 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1391
1392 eResult = eARPProcessPacket( &xNetworkBuffer );
1393 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1394 /* =================================================== */
1395 }
1396
test_eARPProcessPacket_Reply_WaitingBufferIncorrectHeaderSize(void)1397 void test_eARPProcessPacket_Reply_WaitingBufferIncorrectHeaderSize( void )
1398 {
1399 ARPPacket_t xARPFrame = { 0 };
1400 eFrameProcessingResult_t eResult;
1401 NetworkBufferDescriptor_t xLocalBuffer;
1402 uint8_t pucLocalEthernetBuffer[ 1500 ];
1403 NetworkInterface_t xInterface;
1404 struct xNetworkEndPoint xEndPoint = { 0 };
1405 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1406
1407 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1408
1409 /* Clear the buffer. */
1410 memset( pucLocalEthernetBuffer, 0, sizeof( pucLocalEthernetBuffer ) );
1411
1412 xLocalBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
1413 pxARPWaitingNetworkBuffer = &xLocalBuffer;
1414
1415 /* =================================================== */
1416 /* Add settings required for ARP header to pass checks */
1417 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1418 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1419 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1420 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1421
1422 /* Process an ARP reply - not meant for this node. */
1423 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1424 /* Fill in the request option. */
1425 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1426 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
1427 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1428
1429 /* Reset the private variable uxARPClashCounter. */
1430 vResetARPClashCounter();
1431
1432 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1433 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1434 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1435 xNetworkBuffer.pxEndPoint = &xEndPoint;
1436
1437 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv6_HEADER );
1438
1439 eResult = eARPProcessPacket( &xNetworkBuffer );
1440 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1441 /* =================================================== */
1442 }
1443
test_eARPProcessPacket_Reply_WaitingBufferNonNull_MatchingAddress1(void)1444 void test_eARPProcessPacket_Reply_WaitingBufferNonNull_MatchingAddress1( void )
1445 {
1446 ARPPacket_t xARPFrame = { 0 };
1447 eFrameProcessingResult_t eResult;
1448 NetworkBufferDescriptor_t xLocalBuffer;
1449 NetworkInterface_t xInterface;
1450 struct xNetworkEndPoint xEndPoint = { 0 };
1451 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1452
1453 uint8_t pucLocalEthernetBuffer[ 1500 ];
1454 IPPacket_t * pxARPWaitingIPPacket = ( ( IPPacket_t * ) pucLocalEthernetBuffer );
1455 IPHeader_t * pxARPWaitingIPHeader = &( pxARPWaitingIPPacket->xIPHeader );
1456
1457 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1458
1459 /* Clear the buffer. */
1460 memset( pucLocalEthernetBuffer, 0, sizeof( pucLocalEthernetBuffer ) );
1461
1462 xLocalBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
1463 pxARPWaitingNetworkBuffer = &xLocalBuffer;
1464
1465 /* =================================================== */
1466 /* Add settings required for ARP header to pass checks */
1467 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1468 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1469 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1470 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1471
1472 /* Process an ARP reply - not meant for this node. */
1473 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1474 /* Fill in the request option. */
1475 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1476 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
1477 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1478
1479 memcpy( &( pxARPWaitingIPHeader->ulSourceIPAddress ), xARPFrame.xARPHeader.ucSenderProtocolAddress, sizeof( pxARPWaitingIPHeader->ulSourceIPAddress ) );
1480
1481 /* Reset the private variable uxARPClashCounter. */
1482 vResetARPClashCounter();
1483
1484 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1485 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1486 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1487 xNetworkBuffer.pxEndPoint = &xEndPoint;
1488
1489 xSendEventStructToIPTask_IgnoreAndReturn( pdFAIL );
1490 vReleaseNetworkBufferAndDescriptor_Ignore();
1491 vIPSetARPResolutionTimerEnableState_Expect( pdFALSE );
1492
1493 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1494
1495 eResult = eARPProcessPacket( &xNetworkBuffer );
1496 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1497 TEST_ASSERT_EQUAL( NULL, pxARPWaitingNetworkBuffer );
1498 /* =================================================== */
1499 }
1500
test_eARPProcessPacket_Reply_WaitingBufferNonNull_MatchingAddress2(void)1501 void test_eARPProcessPacket_Reply_WaitingBufferNonNull_MatchingAddress2( void )
1502 {
1503 ARPPacket_t xARPFrame = { 0 };
1504 eFrameProcessingResult_t eResult;
1505 NetworkBufferDescriptor_t xLocalBuffer;
1506 uint8_t pucLocalEthernetBuffer[ 1500 ];
1507 NetworkInterface_t xInterface;
1508 struct xNetworkEndPoint xEndPoint = { 0 };
1509 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
1510
1511 IPPacket_t * pxARPWaitingIPPacket = ( ( IPPacket_t * ) pucLocalEthernetBuffer );
1512 IPHeader_t * pxARPWaitingIPHeader = &( pxARPWaitingIPPacket->xIPHeader );
1513
1514 memset( &xARPFrame, 0, sizeof( ARPPacket_t ) );
1515
1516 /* Clear the buffer. */
1517 memset( pucLocalEthernetBuffer, 0, sizeof( pucLocalEthernetBuffer ) );
1518
1519 xLocalBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
1520 pxARPWaitingNetworkBuffer = &xLocalBuffer;
1521
1522 /* =================================================== */
1523 /* Add settings required for ARP header to pass checks */
1524 xARPFrame.xARPHeader.usHardwareType = ipARP_HARDWARE_TYPE_ETHERNET;
1525 xARPFrame.xARPHeader.usProtocolType = ipARP_PROTOCOL_TYPE;
1526 xARPFrame.xARPHeader.ucHardwareAddressLength = ipMAC_ADDRESS_LENGTH_BYTES;
1527 xARPFrame.xARPHeader.ucProtocolAddressLength = ipIP_ADDRESS_LENGTH_BYTES;
1528
1529 /* Process an ARP reply - not meant for this node. */
1530 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCDD;
1531 /* Fill in the request option. */
1532 xARPFrame.xARPHeader.usOperation = ipARP_REPLY;
1533 xARPFrame.xARPHeader.ulTargetProtocolAddress = *ipLOCAL_IP_ADDRESS_POINTER + 0x11;
1534 memcpy( xARPFrame.xARPHeader.ucSenderProtocolAddress, &( xARPFrame.xARPHeader.ulTargetProtocolAddress ), sizeof( xARPFrame.xARPHeader.ulTargetProtocolAddress ) );
1535
1536 memcpy( &( pxARPWaitingIPHeader->ulSourceIPAddress ), xARPFrame.xARPHeader.ucSenderProtocolAddress, sizeof( pxARPWaitingIPHeader->ulSourceIPAddress ) );
1537
1538 /* Reset the private variable uxARPClashCounter. */
1539 vResetARPClashCounter();
1540
1541 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
1542 xNetworkBuffer.pucEthernetBuffer = &xARPFrame;
1543 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
1544 xNetworkBuffer.pxEndPoint = &xEndPoint;
1545
1546 xSendEventStructToIPTask_IgnoreAndReturn( pdPASS );
1547 vIPSetARPResolutionTimerEnableState_Expect( pdFALSE );
1548
1549 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1550
1551 eResult = eARPProcessPacket( &xNetworkBuffer );
1552 TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
1553 TEST_ASSERT_EQUAL( NULL, pxARPWaitingNetworkBuffer );
1554 /* =================================================== */
1555 }
1556
test_xIsIPInARPCache_NoMatchingIP(void)1557 void test_xIsIPInARPCache_NoMatchingIP( void )
1558 {
1559 uint32_t ulIPAddress = 0x1234ABCD;
1560 BaseType_t xResult;
1561
1562 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1563 {
1564 xARPCache[ x ].ulIPAddress = 0;
1565 }
1566
1567 xResult = xIsIPInARPCache( ulIPAddress );
1568
1569 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1570 }
1571
test_xIsIPInARPCache_MatchingIPButEntryInvalid(void)1572 void test_xIsIPInARPCache_MatchingIPButEntryInvalid( void )
1573 {
1574 uint32_t ulIPAddress = 0x1234ABCD;
1575 BaseType_t xResult;
1576
1577 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1578 {
1579 xARPCache[ x ].ulIPAddress = 0;
1580 xARPCache[ x ].ucValid = ( uint8_t ) pdFALSE;
1581 }
1582
1583 xARPCache[ 0 ].ulIPAddress = ulIPAddress;
1584
1585 xResult = xIsIPInARPCache( ulIPAddress );
1586
1587 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1588 }
1589
test_xIsIPInARPCache_MatchingIP1(void)1590 void test_xIsIPInARPCache_MatchingIP1( void )
1591 {
1592 uint32_t ulIPAddress = 0x1234ABCD;
1593 BaseType_t xResult;
1594
1595 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1596 {
1597 xARPCache[ x ].ulIPAddress = 0;
1598 xARPCache[ x ].ucValid = ( uint8_t ) pdTRUE;
1599 }
1600
1601 xARPCache[ 0 ].ulIPAddress = ulIPAddress;
1602
1603 xResult = xIsIPInARPCache( ulIPAddress );
1604
1605 TEST_ASSERT_EQUAL( pdTRUE, xResult );
1606 }
1607
test_xIsIPInARPCache_MatchingIP2(void)1608 void test_xIsIPInARPCache_MatchingIP2( void )
1609 {
1610 uint32_t ulIPAddress = 0x1234ABCD;
1611 BaseType_t xResult;
1612
1613 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1614 {
1615 xARPCache[ x ].ulIPAddress = 0;
1616 xARPCache[ x ].ucValid = ( uint8_t ) pdTRUE;
1617 }
1618
1619 xARPCache[ ipconfigARP_CACHE_ENTRIES - 1 ].ulIPAddress = ulIPAddress;
1620
1621 xResult = xIsIPInARPCache( ulIPAddress );
1622
1623 TEST_ASSERT_EQUAL( pdTRUE, xResult );
1624 }
1625
test_xCheckRequiresARPResolution_NotOnLocalNetwork(void)1626 void test_xCheckRequiresARPResolution_NotOnLocalNetwork( void )
1627 {
1628 struct xNetworkEndPoint xEndPoint = { 0 };
1629 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
1630 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
1631 BaseType_t xResult;
1632 NetworkInterface_t xInterface;
1633
1634 pxNetworkBuffer = &xNetworkBuffer;
1635 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1636
1637 IPPacket_t * pxIPPacket = ( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
1638 IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
1639
1640 *ipLOCAL_IP_ADDRESS_POINTER = 0xABCD1234;
1641
1642 xEndPoint.ipv4_settings.ulNetMask = 0xFFFFFF00;
1643 xNetworkBuffer.pxEndPoint = &xEndPoint;
1644
1645 /* Make sure there is no match. */
1646 pxIPHeader->ulSourceIPAddress = ~( *ipLOCAL_IP_ADDRESS_POINTER & xEndPoint.ipv4_settings.ulNetMask );
1647
1648 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1649
1650 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1651
1652 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1653 }
1654
test_xCheckRequiresARPResolution_NotOnLocalNetwork_InvalidHeader(void)1655 void test_xCheckRequiresARPResolution_NotOnLocalNetwork_InvalidHeader( void )
1656 {
1657 struct xNetworkEndPoint xEndPoint = { 0 };
1658 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
1659 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
1660 BaseType_t xResult;
1661 NetworkInterface_t xInterface;
1662
1663 pxNetworkBuffer = &xNetworkBuffer;
1664 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1665
1666 IPPacket_t * pxIPPacket = ( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
1667 IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
1668
1669 *ipLOCAL_IP_ADDRESS_POINTER = 0xABCD1234;
1670
1671 xEndPoint.ipv4_settings.ulNetMask = 0xFFFFFF00;
1672 xNetworkBuffer.pxEndPoint = &xEndPoint;
1673
1674 /* Make sure there is no match. */
1675 pxIPHeader->ulSourceIPAddress = ~( *ipLOCAL_IP_ADDRESS_POINTER & xEndPoint.ipv4_settings.ulNetMask );
1676
1677 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv6_HEADER + ipSIZE_OF_IPv4_HEADER );
1678
1679 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1680
1681 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1682 }
1683
test_xCheckRequiresARPResolution_NotOnLocalNetwork_IPv6(void)1684 void test_xCheckRequiresARPResolution_NotOnLocalNetwork_IPv6( void )
1685 {
1686 struct xNetworkEndPoint xEndPoint = { 0 };
1687 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
1688 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
1689 BaseType_t xResult;
1690 NetworkInterface_t xInterface;
1691
1692 pxNetworkBuffer = &xNetworkBuffer;
1693 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1694
1695 IPPacket_t * pxIPPacket = ( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
1696 IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
1697
1698 *ipLOCAL_IP_ADDRESS_POINTER = 0xABCD1234;
1699
1700 xEndPoint.ipv4_settings.ulNetMask = 0xFFFFFF00;
1701 xNetworkBuffer.pxEndPoint = &xEndPoint;
1702
1703 /* Make sure there is no match. */
1704 pxIPHeader->ulSourceIPAddress = ~( *ipLOCAL_IP_ADDRESS_POINTER & xEndPoint.ipv4_settings.ulNetMask );
1705
1706 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv6_HEADER );
1707
1708 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1709
1710 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1711 /* =================================================== */
1712
1713 IPPacket_IPv6_t * pxIPPacket_V6 = ( ( IPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
1714 IPHeader_IPv6_t * pxIPHeader_V6 = &( pxIPPacket_V6->xIPHeader );
1715 IPv6_Address_t * pxIPAddress = &( pxIPHeader_V6->xSourceAddress );
1716 pxIPHeader_V6->ucNextHeader = ipPROTOCOL_TCP;
1717
1718 xIPv6_GetIPType_ExpectAnyArgsAndReturn( eIPv6_LinkLocal );
1719 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
1720
1721 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1722
1723 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1724 /* =================================================== */
1725
1726 pxIPHeader_V6->ucNextHeader = ipPROTOCOL_UDP;
1727
1728 xIPv6_GetIPType_ExpectAnyArgsAndReturn( eIPv6_LinkLocal );
1729 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
1730
1731 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1732
1733 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1734 /* =================================================== */
1735
1736 xIPv6_GetIPType_ExpectAnyArgsAndReturn( eIPv6_LinkLocal );
1737 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
1738 NetworkBufferDescriptor_t xTempBuffer = { 0 };
1739 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( &xTempBuffer );
1740 vNDSendNeighbourSolicitation_Expect( &xTempBuffer, pxIPAddress );
1741
1742 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1743
1744 TEST_ASSERT_EQUAL( pdTRUE, xResult );
1745 /* =================================================== */
1746
1747 xIPv6_GetIPType_ExpectAnyArgsAndReturn( eIPv6_LinkLocal );
1748 eNDGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
1749 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1750
1751 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1752
1753 TEST_ASSERT_EQUAL( pdTRUE, xResult );
1754 /* =================================================== */
1755
1756 xIPv6_GetIPType_ExpectAnyArgsAndReturn( eIPv6_SiteLocal );
1757
1758 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1759
1760 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1761 /* =================================================== */
1762 }
1763
test_xCheckRequiresARPResolution_OnLocalNetwork_NotInCache(void)1764 void test_xCheckRequiresARPResolution_OnLocalNetwork_NotInCache( void )
1765 {
1766 struct xNetworkEndPoint xEndPoint = { 0 };
1767 NetworkInterface_t xInterface;
1768 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
1769 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
1770 BaseType_t xResult;
1771
1772 pxNetworkBuffer = &xNetworkBuffer;
1773 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1774
1775 IPPacket_t * pxIPPacket = ( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
1776 IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
1777
1778 *ipLOCAL_IP_ADDRESS_POINTER = 0xABCD1234;
1779
1780 xEndPoint.ipv4_settings.ulNetMask = 0xFFFFFF00;
1781 xNetworkBuffer.pxEndPoint = &xEndPoint;
1782
1783 /* Make sure there is a match. */
1784 pxIPHeader->ulSourceIPAddress = *ipLOCAL_IP_ADDRESS_POINTER & xEndPoint.ipv4_settings.ulNetMask;
1785 xEndPoint.ipv4_settings.ulIPAddress = *ipLOCAL_IP_ADDRESS_POINTER & xEndPoint.ipv4_settings.ulNetMask;
1786 xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
1787
1788 /* And that the IP is not in ARP cache. */
1789 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1790 {
1791 xARPCache[ x ].ulIPAddress = 0;
1792 }
1793
1794 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1795
1796 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
1797
1798 /* For this unit-test, we do not concern ourselves with whether the ARP request
1799 * is actually sent or not. Effort is all that matters. */
1800 pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
1801
1802 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
1803
1804 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1805
1806 TEST_ASSERT_EQUAL( pdTRUE, xResult );
1807 }
1808
test_xCheckRequiresARPResolution_OnLocalNetwork_InCache(void)1809 void test_xCheckRequiresARPResolution_OnLocalNetwork_InCache( void )
1810 {
1811 struct xNetworkEndPoint xEndPoint = { 0 };
1812 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
1813 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
1814 BaseType_t xResult;
1815
1816 pxNetworkBuffer = &xNetworkBuffer;
1817 pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1818
1819 IPPacket_t * pxIPPacket = ( ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
1820 IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
1821
1822 xEndPoint.ipv4_settings.ulIPAddress = 0xABCD1234;
1823 xEndPoint.ipv4_settings.ulNetMask = 0xFFFFFF00;
1824
1825 /* Make sure there is a match. */
1826 pxIPHeader->ulSourceIPAddress = xEndPoint.ipv4_settings.ulIPAddress & xEndPoint.ipv4_settings.ulNetMask;
1827
1828 xNetworkBuffer.pxEndPoint = &xEndPoint;
1829
1830 /* And that the IP is not in ARP cache. */
1831 for( uint16_t x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
1832 {
1833 xARPCache[ x ].ulIPAddress = pxIPHeader->ulSourceIPAddress;
1834 xARPCache[ x ].ucValid = ( uint8_t ) pdTRUE;
1835 }
1836
1837 uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1838
1839 xResult = xCheckRequiresARPResolution( pxNetworkBuffer );
1840
1841 TEST_ASSERT_EQUAL( pdFALSE, xResult );
1842 }
1843
1844
test_ulARPRemoveCacheEntryByMac_NoMatch(void)1845 void test_ulARPRemoveCacheEntryByMac_NoMatch( void )
1846 {
1847 uint32_t ulResult;
1848 const MACAddress_t xMACAddress = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
1849 int i;
1850 BaseType_t xEntryToCheck;
1851 uint8_t ucBuffer[ sizeof( xARPCache[ 0 ] ) ];
1852
1853 /* Catch some asserts. */
1854 catch_assert( ulARPRemoveCacheEntryByMac( NULL ) );
1855
1856 /* =================================================== */
1857 /* Make sure no entry matches. */
1858 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1859 {
1860 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1861 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
1862 }
1863
1864 ulResult = ulARPRemoveCacheEntryByMac( &xMACAddress );
1865 TEST_ASSERT_EQUAL( 0, ulResult );
1866 /* =================================================== */
1867 }
1868
test_ulARPRemoveCacheEntryByMac_OneMatchingEntry(void)1869 void test_ulARPRemoveCacheEntryByMac_OneMatchingEntry( void )
1870 {
1871 uint32_t ulResult;
1872 const MACAddress_t xMACAddress = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
1873 int i;
1874 BaseType_t xEntryToCheck;
1875 uint8_t ucBuffer[ sizeof( xARPCache[ 0 ] ) ];
1876
1877 /* =================================================== */
1878 /* Make sure only one entry matches. */
1879 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1880 {
1881 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1882 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
1883 }
1884
1885 xEntryToCheck = 1;
1886 xARPCache[ xEntryToCheck ].ulIPAddress = 0xAABBCCEE;
1887 memset( xARPCache[ xEntryToCheck ].xMACAddress.ucBytes, 0xAA, sizeof( xMACAddress.ucBytes ) );
1888 memset( ucBuffer, 0, sizeof( xARPCache[ 0 ] ) );
1889 ulResult = ulARPRemoveCacheEntryByMac( &xMACAddress );
1890 TEST_ASSERT_EQUAL( 0xAABBCCEE, ulResult );
1891 TEST_ASSERT_EQUAL( 0, memcmp( ucBuffer, &xARPCache[ xEntryToCheck ], sizeof( xARPCache[ 0 ] ) ) );
1892 }
1893
test_vARPRefreshCacheEntry_NULLMAC_NoMatchingEntry(void)1894 void test_vARPRefreshCacheEntry_NULLMAC_NoMatchingEntry( void )
1895 {
1896 MACAddress_t xMACAddress;
1897 uint32_t ulIPAddress;
1898 int i;
1899 BaseType_t xUseEntry;
1900 struct xNetworkEndPoint xEndPoint = { 0 };
1901
1902 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1903 {
1904 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1905 xARPCache[ i ].ucAge = 255;
1906 xARPCache[ i ].ucValid = pdTRUE;
1907 }
1908
1909 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
1910
1911 ulIPAddress = 0x00;
1912 /* Pass a NULL MAC Address and an IP address which will not match. */
1913 vARPRefreshCacheEntry( NULL, ulIPAddress, &xEndPoint );
1914
1915 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
1916 TEST_ASSERT_EQUAL( xARPCache[ 0 ].ucAge, ( uint8_t ) ipconfigMAX_ARP_RETRANSMISSIONS );
1917 TEST_ASSERT_EQUAL( xARPCache[ 0 ].ucValid, ( uint8_t ) pdFALSE );
1918 /* =================================================== */
1919 }
1920
test_vARPRefreshCacheEntry_NULLMAC_MatchingEntry(void)1921 void test_vARPRefreshCacheEntry_NULLMAC_MatchingEntry( void )
1922 {
1923 MACAddress_t xMACAddress;
1924 uint32_t ulIPAddress;
1925 int i;
1926 BaseType_t xUseEntry;
1927 struct xNetworkEndPoint xEndPoint = { 0 };
1928
1929 /* =================================================== */
1930 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1931 {
1932 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1933 xARPCache[ i ].ucAge = 255;
1934 xARPCache[ i ].ucValid = pdTRUE;
1935 }
1936
1937 xARPCache[ 1 ].ulIPAddress = 0xAABBCCEE;
1938
1939 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
1940
1941 ulIPAddress = 0xAABBCCEE;
1942 /* Pass a NULL MAC Address and an IP address which will match. */
1943 vARPRefreshCacheEntry( NULL, ulIPAddress, &xEndPoint );
1944
1945 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
1946 TEST_ASSERT_EQUAL( xARPCache[ 1 ].ucAge, 255 );
1947 TEST_ASSERT_EQUAL( xARPCache[ 1 ].ucValid, ( uint8_t ) pdTRUE );
1948 /* =================================================== */
1949 }
1950
test_vARPRefreshCacheEntry_MACWontMatch_IPWillMatch(void)1951 void test_vARPRefreshCacheEntry_MACWontMatch_IPWillMatch( void )
1952 {
1953 MACAddress_t xMACAddress;
1954 uint32_t ulIPAddress;
1955 int i;
1956 BaseType_t xUseEntry;
1957 struct xNetworkEndPoint xEndPoint = { 0 };
1958
1959 /* =================================================== */
1960 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1961 {
1962 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1963 xARPCache[ i ].ucAge = 255;
1964 xARPCache[ i ].ucValid = pdTRUE;
1965 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x34, sizeof( xMACAddress.ucBytes ) );
1966 }
1967
1968 xUseEntry = 1;
1969 xARPCache[ xUseEntry ].ulIPAddress = 0xAABBCCEE;
1970
1971 ulIPAddress = 0xAABBCCEE;
1972 memset( xMACAddress.ucBytes, 0x11, ipMAC_ADDRESS_LENGTH_BYTES );
1973 /* Pass a MAC Address which won't match and an IP address which will match. */
1974
1975 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
1976
1977 vARPRefreshCacheEntry( &xMACAddress, ulIPAddress, &xEndPoint );
1978
1979 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
1980 TEST_ASSERT_EQUAL_MESSAGE( ipconfigMAX_ARP_AGE, xARPCache[ xUseEntry ].ucAge, "Test 3" );
1981 TEST_ASSERT_EQUAL( ( uint8_t ) pdTRUE, xARPCache[ xUseEntry ].ucValid );
1982 TEST_ASSERT_EQUAL_MEMORY( xMACAddress.ucBytes, xARPCache[ xUseEntry ].xMACAddress.ucBytes, sizeof( xMACAddress.ucBytes ) );
1983 /* =================================================== */
1984 }
1985
test_vARPRefreshCacheEntry_MACAndIPWillMatch(void)1986 void test_vARPRefreshCacheEntry_MACAndIPWillMatch( void )
1987 {
1988 MACAddress_t xMACAddress;
1989 uint32_t ulIPAddress;
1990 int i;
1991 BaseType_t xUseEntry;
1992 struct xNetworkEndPoint xEndPoint = { 0 };
1993
1994 /* =================================================== */
1995 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
1996 {
1997 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
1998 xARPCache[ i ].ucAge = 255;
1999 xARPCache[ i ].ucValid = pdFALSE;
2000 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x34, sizeof( xMACAddress.ucBytes ) );
2001 }
2002
2003 xUseEntry = 1;
2004 xARPCache[ xUseEntry ].ulIPAddress = 0xAABBCCEE;
2005 /* Set a MAC address which will match */
2006 memset( xARPCache[ xUseEntry ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
2007
2008 ulIPAddress = 0xAABBCCEE;
2009 memset( xMACAddress.ucBytes, 0x11, ipMAC_ADDRESS_LENGTH_BYTES );
2010
2011 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2012
2013 /* Pass a MAC Address which will match and an IP address which will match too. */
2014 vARPRefreshCacheEntry( &xMACAddress, ulIPAddress, &xEndPoint );
2015
2016 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
2017 TEST_ASSERT_EQUAL_MESSAGE( ipconfigMAX_ARP_AGE, xARPCache[ xUseEntry ].ucAge, "Test 4" );
2018 TEST_ASSERT_EQUAL( ( uint8_t ) pdTRUE, xARPCache[ xUseEntry ].ucValid );
2019 TEST_ASSERT_EQUAL_MEMORY( xMACAddress.ucBytes, xARPCache[ xUseEntry ].xMACAddress.ucBytes, sizeof( xMACAddress.ucBytes ) );
2020 /* =================================================== */
2021 }
2022
2023
test_vARPRefreshCacheEntry_IPOnADifferentSubnet(void)2024 void test_vARPRefreshCacheEntry_IPOnADifferentSubnet( void )
2025 {
2026 MACAddress_t xMACAddress;
2027 uint32_t ulIPAddress;
2028 int i;
2029 BaseType_t xUseEntry;
2030 struct xNetworkEndPoint xEndPoint = { 0 };
2031
2032 /* =================================================== */
2033 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2034 {
2035 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2036 xARPCache[ i ].ucAge = 255;
2037 xARPCache[ i ].ucValid = pdFALSE;
2038 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x34, sizeof( xMACAddress.ucBytes ) );
2039 }
2040
2041 xUseEntry = 1;
2042 xARPCache[ xUseEntry ].ulIPAddress = 0xAABBCCEE;
2043 /* Set a MAC address which will match */
2044 memset( xARPCache[ xUseEntry ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
2045 /* Set a local IP address */
2046 *ipLOCAL_IP_ADDRESS_POINTER = 0xAABBCCEF;
2047
2048 /* The IP address being passed should not be on the same subnet. */
2049 ulIPAddress = 0x00BBCCEE;
2050 memset( xMACAddress.ucBytes, 0x11, ipMAC_ADDRESS_LENGTH_BYTES );
2051 /* Pass a MAC Address which will match and an IP address which will match too. */
2052
2053 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 124 );
2054 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2055
2056 vARPRefreshCacheEntry( &xMACAddress, ulIPAddress, &xEndPoint );
2057
2058 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
2059 TEST_ASSERT_EQUAL_MESSAGE( ipconfigMAX_ARP_AGE, xARPCache[ 0 ].ucAge, "Test 5" );
2060 TEST_ASSERT_EQUAL( ( uint8_t ) pdTRUE, xARPCache[ 0 ].ucValid );
2061 TEST_ASSERT_EQUAL_MEMORY( xMACAddress.ucBytes, xARPCache[ 0 ].xMACAddress.ucBytes, sizeof( xMACAddress.ucBytes ) );
2062 /* =================================================== */
2063 }
2064
test_vARPRefreshCacheEntry_IPAndMACInDifferentLocations(void)2065 void test_vARPRefreshCacheEntry_IPAndMACInDifferentLocations( void )
2066 {
2067 MACAddress_t xMACAddress;
2068 uint32_t ulIPAddress;
2069 int i;
2070 BaseType_t xUseEntry;
2071 struct xNetworkEndPoint xEndPoint = { 0 };
2072
2073 /* =================================================== */
2074 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2075 {
2076 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2077 xARPCache[ i ].ucAge = i + 1;
2078 xARPCache[ i ].ucValid = pdFALSE;
2079 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x34, sizeof( xMACAddress.ucBytes ) );
2080 }
2081
2082 xUseEntry = 0;
2083
2084 /* Make sure an entry matches. */
2085 xARPCache[ xUseEntry ].ulIPAddress = 0xAABBCCEE;
2086 ulIPAddress = 0xAABBCCEE;
2087
2088 /* Also make sure that a MAC address matches. But a different one. */
2089 memset( xARPCache[ xUseEntry + 1 ].xMACAddress.ucBytes, 0x22, sizeof( xMACAddress.ucBytes ) );
2090 memset( xMACAddress.ucBytes, 0x22, ipMAC_ADDRESS_LENGTH_BYTES );
2091
2092 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 124 );
2093 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 124 );
2094
2095 /* Pass a MAC and IP Address which won't match, but age is now a factor. */
2096 vARPRefreshCacheEntry( &xMACAddress, ulIPAddress, &xEndPoint );
2097
2098 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
2099 TEST_ASSERT_EQUAL( xARPCache[ xUseEntry + 1 ].ulIPAddress, ulIPAddress );
2100 TEST_ASSERT_EQUAL_MESSAGE( ipconfigMAX_ARP_AGE, xARPCache[ xUseEntry + 1 ].ucAge, "Test 9" );
2101 TEST_ASSERT_EQUAL( ( uint8_t ) pdTRUE, xARPCache[ xUseEntry + 1 ].ucValid );
2102
2103 uint8_t MemoryCompare[ sizeof( ARPCacheRow_t ) ];
2104
2105 memset( MemoryCompare, 0, sizeof( ARPCacheRow_t ) );
2106 TEST_ASSERT_EQUAL_MEMORY( MemoryCompare, &xARPCache[ xUseEntry ], sizeof( ARPCacheRow_t ) );
2107 /* =================================================== */
2108 }
2109
test_vARPRefreshCacheEntry_IPAndMACInDifferentLocations1(void)2110 void test_vARPRefreshCacheEntry_IPAndMACInDifferentLocations1( void )
2111 {
2112 MACAddress_t xMACAddress;
2113 uint32_t ulIPAddress;
2114 int i;
2115 BaseType_t xUseEntry;
2116 struct xNetworkEndPoint xEndPoint = { 0 };
2117
2118 /* =================================================== */
2119 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2120 {
2121 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2122 xARPCache[ i ].ucAge = i + 1;
2123 xARPCache[ i ].ucValid = pdFALSE;
2124 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x34, sizeof( xMACAddress.ucBytes ) );
2125 }
2126
2127 xUseEntry = 0;
2128
2129 /* Make sure an entry matches. */
2130 xARPCache[ xUseEntry ].ulIPAddress = 0xAABBCCEA;
2131 ulIPAddress = 0xAABBCCEE;
2132
2133 /* Also make sure that a MAC address matches. But a different one. */
2134 memset( xARPCache[ xUseEntry + 1 ].xMACAddress.ucBytes, 0x22, sizeof( xMACAddress.ucBytes ) );
2135 memset( xMACAddress.ucBytes, 0x22, ipMAC_ADDRESS_LENGTH_BYTES );
2136
2137 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
2138 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
2139
2140 /* Pass a MAC and IP Address which won't match, but age is now a factor. */
2141 vARPRefreshCacheEntry( &xMACAddress, ulIPAddress, &xEndPoint );
2142
2143 /* Since no matching entry will be found with smallest age (i.e. oldest), 0th entry will be updated to have the below details. */
2144 TEST_ASSERT_EQUAL( xARPCache[ xUseEntry + 1 ].ulIPAddress, ulIPAddress );
2145 TEST_ASSERT_EQUAL_MESSAGE( ipconfigMAX_ARP_AGE, xARPCache[ xUseEntry + 1 ].ucAge, "Test 9" );
2146 TEST_ASSERT_EQUAL( ( uint8_t ) pdTRUE, xARPCache[ xUseEntry + 1 ].ucValid );
2147 }
2148
test_eARPGetCacheEntryByMac_catchAssert(void)2149 void test_eARPGetCacheEntryByMac_catchAssert( void )
2150 {
2151 uint32_t ulIPAddress = 0x12345678, ulEntryToTest;
2152 eARPLookupResult_t eResult;
2153 MACAddress_t xMACAddress = { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 };
2154 int i;
2155 struct xNetworkInterface * xInterface;
2156
2157 /* Hit some asserts */
2158 catch_assert( eARPGetCacheEntryByMac( NULL, &ulIPAddress, &xInterface ) );
2159 catch_assert( eARPGetCacheEntryByMac( &xMACAddress, NULL, &xInterface ) );
2160 }
2161
test_eARPGetCacheEntryByMac_NullInterface(void)2162 void test_eARPGetCacheEntryByMac_NullInterface( void )
2163 {
2164 uint32_t ulIPAddress = 0x12345678, ulEntryToTest;
2165 eARPLookupResult_t eResult;
2166 MACAddress_t xMACAddress = { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 };
2167 int i;
2168 struct xNetworkInterface * xInterface;
2169
2170 /* =================================================== */
2171 /* Make sure no entry matches. */
2172 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2173 {
2174 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2175 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
2176 }
2177
2178 eResult = eARPGetCacheEntryByMac( &xMACAddress, &ulIPAddress, NULL );
2179 TEST_ASSERT_EQUAL( eARPCacheMiss, eResult );
2180 TEST_ASSERT_EQUAL( 0x12345678, ulIPAddress );
2181 /* =================================================== */
2182 }
2183
test_eARPGetCacheEntryByMac_NoMatchingEntries(void)2184 void test_eARPGetCacheEntryByMac_NoMatchingEntries( void )
2185 {
2186 uint32_t ulIPAddress = 0x12345678, ulEntryToTest;
2187 eARPLookupResult_t eResult;
2188 MACAddress_t xMACAddress = { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 };
2189 int i;
2190 struct xNetworkInterface * xInterface;
2191
2192 /* =================================================== */
2193 /* Make sure no entry matches. */
2194 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2195 {
2196 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2197 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
2198 }
2199
2200 eResult = eARPGetCacheEntryByMac( &xMACAddress, &ulIPAddress, &xInterface );
2201 TEST_ASSERT_EQUAL( eARPCacheMiss, eResult );
2202 TEST_ASSERT_EQUAL( 0x12345678, ulIPAddress );
2203 /* =================================================== */
2204 }
2205
test_eARPGetCacheEntryByMac_OneMatchingEntry(void)2206 void test_eARPGetCacheEntryByMac_OneMatchingEntry( void )
2207 {
2208 uint32_t ulIPAddress = 0x12345678, ulEntryToTest;
2209 eARPLookupResult_t eResult;
2210 MACAddress_t xMACAddress = { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 };
2211 int i;
2212 struct xNetworkInterface * xInterface;
2213
2214 /* =================================================== */
2215 /* Make sure one entry matches. */
2216 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2217 {
2218 xARPCache[ i ].ulIPAddress = 0xAABBCCDD;
2219 memset( xARPCache[ i ].xMACAddress.ucBytes, 0x11, sizeof( xMACAddress.ucBytes ) );
2220 }
2221
2222 ulEntryToTest = 1;
2223 memset( xARPCache[ ulEntryToTest ].xMACAddress.ucBytes, 0x22, sizeof( xMACAddress.ucBytes ) );
2224 xARPCache[ ulEntryToTest ].ulIPAddress = 0xAABBCCEE;
2225 eResult = eARPGetCacheEntryByMac( &xMACAddress, &ulIPAddress, &xInterface );
2226 TEST_ASSERT_EQUAL( eARPCacheHit, eResult );
2227 TEST_ASSERT_EQUAL( xARPCache[ ulEntryToTest ].ulIPAddress, ulIPAddress );
2228 /* =================================================== */
2229 eResult = eARPGetCacheEntryByMac( &xMACAddress, &ulIPAddress, NULL );
2230 TEST_ASSERT_EQUAL( eARPCacheHit, eResult );
2231 TEST_ASSERT_EQUAL( xARPCache[ ulEntryToTest ].ulIPAddress, ulIPAddress );
2232 /* =================================================== */
2233 xARPCache[ ulEntryToTest ].pxEndPoint = NULL;
2234 eResult = eARPGetCacheEntryByMac( &xMACAddress, &ulIPAddress, &xInterface );
2235 TEST_ASSERT_EQUAL( eARPCacheHit, eResult );
2236 TEST_ASSERT_EQUAL( xARPCache[ ulEntryToTest ].ulIPAddress, ulIPAddress );
2237 /* =================================================== */
2238 }
2239
test_eARPGetCacheEntry_CatchAssert(void)2240 void test_eARPGetCacheEntry_CatchAssert( void )
2241 {
2242 uint32_t ulIPAddress;
2243 MACAddress_t xMACAddress;
2244 struct xNetworkInterface * xInterface;
2245
2246 catch_assert( eARPGetCacheEntry( NULL, &xMACAddress, &xInterface ) );
2247 catch_assert( eARPGetCacheEntry( &ulIPAddress, NULL, &xInterface ) );
2248 catch_assert( eARPGetCacheEntry( &ulIPAddress, &xMACAddress, NULL ) );
2249 }
2250
test_eARPGetCacheEntry_IPMatchesBroadcastAddr(void)2251 void test_eARPGetCacheEntry_IPMatchesBroadcastAddr( void )
2252 {
2253 uint32_t ulIPAddress;
2254 MACAddress_t xMACAddress;
2255 eARPLookupResult_t eResult;
2256 uint32_t ulSavedGatewayAddress;
2257 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2258
2259 /* =================================================== */
2260 ulIPAddress = FreeRTOS_ntohl( xNetworkAddressing.ulBroadcastAddress );
2261 /* Not worried about what these functions do. */
2262 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2263 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2264 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
2265 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &pxEndPoint );
2266
2267 TEST_ASSERT_EQUAL_MESSAGE( eARPCacheHit, eResult, "Test 3" );
2268 TEST_ASSERT_EQUAL( pxEndPoint, &xEndPoint );
2269 TEST_ASSERT_EQUAL_MEMORY_MESSAGE( &xBroadcastMACAddress, &xMACAddress, sizeof( xMACAddress ), "Test 3" );
2270 /* =================================================== */
2271 }
2272
test_eARPGetCacheEntry_IPMatchesBroadcastAddr_NullEndPointOnNetMask(void)2273 void test_eARPGetCacheEntry_IPMatchesBroadcastAddr_NullEndPointOnNetMask( void )
2274 {
2275 uint32_t ulIPAddress;
2276 MACAddress_t xMACAddress;
2277 eARPLookupResult_t eResult;
2278 uint32_t ulSavedGatewayAddress;
2279 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2280
2281 /* =================================================== */
2282 ulIPAddress = FreeRTOS_ntohl( xNetworkAddressing.ulBroadcastAddress );
2283 /* Not worried about what these functions do. */
2284 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2285 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2286 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2287 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &pxEndPoint );
2288
2289 TEST_ASSERT_EQUAL( eARPCacheHit, eResult );
2290 /* =================================================== */
2291 }
2292
test_eARPGetCacheEntry_MultiCastAddr(void)2293 void test_eARPGetCacheEntry_MultiCastAddr( void )
2294 {
2295 uint32_t ulIPAddress;
2296 MACAddress_t xMACAddress;
2297 eARPLookupResult_t eResult;
2298 uint32_t ulSavedGatewayAddress;
2299 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2300
2301 /* =================================================== */
2302 ulIPAddress = FreeRTOS_ntohl( xNetworkAddressing.ulBroadcastAddress );
2303 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2304 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 1UL );
2305 vSetMultiCastIPv4MacAddress_Ignore();
2306 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, NULL );
2307
2308 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &pxEndPoint );
2309
2310 TEST_ASSERT_EQUAL( eCantSendPacket, eResult );
2311 /* =================================================== */
2312
2313 xEndPoint.bits.bIPv6 = 1;
2314 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2315 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 1UL );
2316 vSetMultiCastIPv4MacAddress_Ignore();
2317 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2318 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2319
2320 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &pxEndPoint );
2321
2322 TEST_ASSERT_EQUAL( eCantSendPacket, eResult );
2323 /* =================================================== */
2324 }
2325
test_eARPGetCacheEntry_IPMatchesOtherBroadcastAddr(void)2326 void test_eARPGetCacheEntry_IPMatchesOtherBroadcastAddr( void )
2327 {
2328 uint32_t ulIPAddress;
2329 MACAddress_t xMACAddress;
2330 eARPLookupResult_t eResult;
2331 uint32_t ulSavedGatewayAddress;
2332 struct xNetworkInterface * xInterface;
2333 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2334
2335 /* =================================================== */
2336 ulIPAddress = FreeRTOS_ntohl( ipBROADCAST_IP_ADDRESS );
2337 /* Not worried about what these functions do. */
2338 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2339 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2340 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( &xEndPoint );
2341 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2342 TEST_ASSERT_EQUAL_MESSAGE( eARPCacheHit, eResult, "Test 3" );
2343 TEST_ASSERT_EQUAL_MEMORY_MESSAGE( &xBroadcastMACAddress, &xMACAddress, sizeof( xMACAddress ), "Test 3" );
2344 /* =================================================== */
2345 }
2346
2347 /* TODO: _TJ_: For the time being test_eARPGetCacheEntry_LocalIPIsZero and test_eARPGetCacheEntry_LocalIPMatchesReceivedIP */
2348 /* test cases are removed as we need to reevaluate if those cases are required for IPv6 */
2349
test_eARPGetCacheEntry_MatchingInvalidEntry(void)2350 void test_eARPGetCacheEntry_MatchingInvalidEntry( void )
2351 {
2352 uint32_t ulIPAddress;
2353 MACAddress_t xMACAddress;
2354 eARPLookupResult_t eResult;
2355 uint32_t ulSavedGatewayAddress;
2356 struct xNetworkInterface * xInterface;
2357 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2358
2359 /* =================================================== */
2360 ulIPAddress = 0x4321;
2361 /* Make both values (IP address and local IP pointer) different. */
2362 *ipLOCAL_IP_ADDRESS_POINTER = 0x1234;
2363 /* Add the IP address in the cache so that we'll have a cache hit. */
2364 xARPCache[ 1 ].ulIPAddress = xNetworkAddressing.ulGatewayAddress;
2365 /* But reset the valid bit. */
2366 xARPCache[ 1 ].ucValid = pdFALSE;
2367 /* Not worried about what these functions do. */
2368 xEndPoint.ipv4_settings.ulGatewayAddress = xNetworkAddressing.ulGatewayAddress;
2369 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2370 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2371 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2372 FreeRTOS_FindGateWay_ExpectAnyArgsAndReturn( &xEndPoint );
2373 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2374 TEST_ASSERT_EQUAL_MESSAGE( eCantSendPacket, eResult, "Test 6" );
2375 /* =================================================== */
2376 }
2377
test_eARPGetCacheEntry_MatchingValidEntry(void)2378 void test_eARPGetCacheEntry_MatchingValidEntry( void )
2379 {
2380 uint32_t ulIPAddress;
2381 MACAddress_t xMACAddress;
2382 eARPLookupResult_t eResult;
2383 uint32_t ulSavedGatewayAddress;
2384 struct xNetworkInterface * xInterface;
2385 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2386
2387 /* =================================================== */
2388 ulIPAddress = 0x4321;
2389 /* Make both values (IP address and local IP pointer) different. */
2390 *ipLOCAL_IP_ADDRESS_POINTER = 0x1234;
2391 /* Add the IP address in the cache so that we'll have a cache hit. */
2392 xARPCache[ 1 ].ulIPAddress = xNetworkAddressing.ulGatewayAddress;
2393 /* Now try with a set valid bit. */
2394 xARPCache[ 1 ].ucValid = pdTRUE;
2395 /* Not worried about what these functions do. */
2396 xEndPoint.ipv4_settings.ulGatewayAddress = xNetworkAddressing.ulGatewayAddress;
2397 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2398 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2399 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2400 FreeRTOS_FindGateWay_ExpectAnyArgsAndReturn( &xEndPoint );
2401 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2402 TEST_ASSERT_EQUAL_MESSAGE( eARPCacheHit, eResult, "Test 7" );
2403 TEST_ASSERT_EQUAL_MEMORY_MESSAGE( &xARPCache[ 1 ].xMACAddress, &xMACAddress, sizeof( xMACAddress ), "Test 7" );
2404 /* =================================================== */
2405 }
2406
test_eARPGetCacheEntry_GatewayAddressZero(void)2407 void test_eARPGetCacheEntry_GatewayAddressZero( void )
2408 {
2409 uint32_t ulIPAddress;
2410 MACAddress_t xMACAddress;
2411 eARPLookupResult_t eResult;
2412 uint32_t ulSavedGatewayAddress;
2413 struct xNetworkInterface * xInterface;
2414 struct xNetworkEndPoint * pxEndPoint, xEndPoint;
2415
2416 /* =================================================== */
2417 for( int i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2418 {
2419 xARPCache[ i ].ucValid = ( uint8_t ) pdFALSE;
2420 }
2421
2422 *ipLOCAL_IP_ADDRESS_POINTER = 0x1234;
2423
2424 ulIPAddress = 0x4321;
2425 /* Not worried about what these functions do. */
2426 xEndPoint.ipv4_settings.ulGatewayAddress = 0;
2427 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2428 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2429 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2430 FreeRTOS_FindGateWay_ExpectAnyArgsAndReturn( NULL );
2431 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2432
2433 TEST_ASSERT_EQUAL_MESSAGE( eARPCacheMiss, eResult, "Test 9" );
2434 /* =================================================== */
2435 }
2436
test_eARPGetCacheEntry_AddressNotOnLocalAddress(void)2437 void test_eARPGetCacheEntry_AddressNotOnLocalAddress( void )
2438 {
2439 uint32_t ulIPAddress;
2440 MACAddress_t xMACAddress;
2441 eARPLookupResult_t eResult;
2442 uint32_t ulSavedGatewayAddress;
2443 struct xNetworkInterface * xInterface;
2444
2445 /* =================================================== */
2446 ulIPAddress = 0;
2447 /* Make both values (IP address and local IP pointer) different. */
2448 /* Get any address on the same netmask. */
2449 *ipLOCAL_IP_ADDRESS_POINTER = 0x00000034;
2450
2451 /* Not worried about what these functions do. */
2452 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2453 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2454 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2455 FreeRTOS_FindGateWay_ExpectAnyArgsAndReturn( NULL );
2456 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2457 TEST_ASSERT_EQUAL_MESSAGE( eCantSendPacket, eResult, "Test 11" );
2458 /* =================================================== */
2459 }
2460
test_eARPGetCacheEntry_NoCacheHit(void)2461 void test_eARPGetCacheEntry_NoCacheHit( void )
2462 {
2463 uint32_t ulIPAddress;
2464 MACAddress_t xMACAddress;
2465 eARPLookupResult_t eResult;
2466 uint32_t ulSavedGatewayAddress;
2467 struct xNetworkInterface * xInterface;
2468
2469 /* =================================================== */
2470 for( int i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2471 {
2472 xARPCache[ i ].ulIPAddress = 0;
2473 xARPCache[ i ].ucValid = ( uint8_t ) pdTRUE;
2474 }
2475
2476 ulSavedGatewayAddress = xNetworkAddressing.ulGatewayAddress;
2477 xNetworkAddressing.ulGatewayAddress = 0;
2478 /* Make IP address param == 0 */
2479 ulIPAddress = 0;
2480
2481 /* Make both values (IP address and local IP pointer) different
2482 * and on different net masks. */
2483 *ipLOCAL_IP_ADDRESS_POINTER = 0x1234;
2484 /* Not worried about what these functions do. */
2485 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2486 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2487 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( NULL );
2488 eResult = eARPGetCacheEntry( &ulIPAddress, &xMACAddress, &xInterface );
2489 xNetworkAddressing.ulGatewayAddress = ulSavedGatewayAddress;
2490 TEST_ASSERT_EQUAL( eARPCacheHit, eResult );
2491 /* =================================================== */
2492 }
2493
test_vARPAgeCache(void)2494 void test_vARPAgeCache( void )
2495 {
2496 NetworkEndPoint_t xEndPoint = { 0 };
2497 NetworkInterface_t xInterface;
2498
2499 xEndPoint.pxNext = NULL;
2500 xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
2501
2502 /* Invalidate the first cache entry. */
2503 for( int i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2504 {
2505 xARPCache[ i ].ucAge = 0;
2506 }
2507
2508 uint8_t ucEntryToCheck = 1;
2509
2510 pxNetworkEndPoints = &xEndPoint;
2511 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
2512 xEndPoint.ipv4_settings.ulIPAddress = 0x1234;
2513
2514 /* =================================================== */
2515 /* Let the value returned first time be 0 such that the variable is reset. */
2516 xTaskGetTickCount_ExpectAndReturn( 0 );
2517
2518 pxNetworkEndPoints = &xEndPoint;
2519
2520 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2521
2522 /* The function which calls 'pxGetNetworkBufferWithDescriptor' is 'FreeRTOS_OutputARPRequest'.
2523 * It doesn't return anything and will be tested separately. */
2524 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2525
2526 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2527
2528 vARPAgeCache();
2529 /* =================================================== */
2530
2531 /* / * =================================================== * / */
2532 /* / * Make second entry invalid but with age > 1. * / */
2533 xARPCache[ ucEntryToCheck ].ucAge = 1;
2534 xARPCache[ ucEntryToCheck ].ucValid = pdFALSE;
2535 /* Set an IP address */
2536 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2537
2538 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2539
2540 /* The function which calls 'pxGetNetworkBufferWithDescriptor' is 'FreeRTOS_OutputARPRequest'.
2541 * It doesn't return anything and will be tested separately. */
2542 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2543
2544 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2545
2546 /* Let the value returned first time be 100. */
2547 xTaskGetTickCount_ExpectAndReturn( 100 );
2548
2549 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2550
2551 /* The function which calls 'pxGetNetworkBufferWithDescriptor' is 'FreeRTOS_OutputARPRequest'.
2552 * It doesn't return anything and will be tested separately. */
2553 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2554
2555 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2556
2557 vARPAgeCache();
2558 /* =================================================== */
2559
2560 /* =================================================== */
2561 /* Make second entry invalid but with age > 1. */
2562 xARPCache[ ucEntryToCheck ].ucAge = 1;
2563 xARPCache[ ucEntryToCheck ].ucValid = pdTRUE;
2564 /* Set an IP address */
2565 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2566
2567 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2568
2569 /* The function which calls 'pxGetNetworkBufferWithDescriptor' is 'FreeRTOS_OutputARPRequest'.
2570 * It doesn't return anything and will be tested separately. */
2571 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2572
2573 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2574
2575 /* Let the value returned first time be 100. */
2576 xTaskGetTickCount_ExpectAndReturn( 100 );
2577
2578 vARPAgeCache();
2579 /* =================================================== */
2580
2581 /* =================================================== */
2582 /* Make second entry invalid but with age > 1. */
2583 xARPCache[ ucEntryToCheck ].ucAge = 100;
2584 xARPCache[ ucEntryToCheck ].ucValid = pdTRUE;
2585 /* Set an IP address */
2586 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2587
2588 /* This time the pxGetNetworkBuffer will be called. */
2589 /* Let the value returned third time be 100000. */
2590 xTaskGetTickCount_ExpectAndReturn( 100000 );
2591
2592 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2593
2594 /* The function which calls 'pxGetNetworkBufferWithDescriptor' is 'FreeRTOS_OutputARPRequest'.
2595 * It doesn't return anything and will be tested separately. */
2596 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2597
2598 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2599
2600 vARPAgeCache();
2601 /* =================================================== */
2602
2603 xEndPoint.bits.bEndPointUp = pdFALSE_UNSIGNED;
2604 /* Make second entry invalid but with age > 1. */
2605 xARPCache[ ucEntryToCheck ].ucAge = 100;
2606 xARPCache[ ucEntryToCheck ].ucValid = pdTRUE;
2607 /* Set an IP address */
2608 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2609
2610 xTaskGetTickCount_ExpectAndReturn( 100 );
2611
2612 vARPAgeCache();
2613 /* =================================================== */
2614
2615 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
2616 xEndPoint.ipv4_settings.ulIPAddress = 0;
2617 /* Make second entry invalid but with age > 1. */
2618 xARPCache[ ucEntryToCheck ].ucAge = 0;
2619 xARPCache[ ucEntryToCheck ].ucValid = pdTRUE;
2620 /* Set an IP address */
2621 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2622
2623 xTaskGetTickCount_ExpectAndReturn( 50000 );
2624
2625 vARPAgeCache();
2626 /* =================================================== */
2627
2628 xEndPoint.ipv4_settings.ulIPAddress = 0x1234;
2629 xEndPoint.bits.bIPv6 = pdTRUE_UNSIGNED;
2630 /* Make second entry invalid but with age > 1. */
2631 xARPCache[ ucEntryToCheck ].ucAge = 0;
2632 xARPCache[ ucEntryToCheck ].ucValid = pdTRUE;
2633 /* Set an IP address */
2634 xARPCache[ ucEntryToCheck ].ulIPAddress = 0xAAAAAAAA;
2635
2636 xTaskGetTickCount_ExpectAndReturn( 100000 );
2637
2638 FreeRTOS_OutputAdvertiseIPv6( &xEndPoint );
2639
2640 vARPAgeCache();
2641 /* =================================================== */
2642 }
2643
test_vARPSendGratuitous(void)2644 void test_vARPSendGratuitous( void )
2645 {
2646 /* The output is ignored. But we should check the input though. */
2647 xSendEventToIPTask_ExpectAndReturn( eARPTimerEvent, 0 );
2648 vARPSendGratuitous();
2649 }
2650
2651 uint32_t xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
xNetworkInterfaceOutput_ARP_STUB(NetworkInterface_t * pxInterface,NetworkBufferDescriptor_t * const pxNetworkBuffer,BaseType_t bReleaseAfterSend)2652 BaseType_t xNetworkInterfaceOutput_ARP_STUB( NetworkInterface_t * pxInterface,
2653 NetworkBufferDescriptor_t * const pxNetworkBuffer,
2654 BaseType_t bReleaseAfterSend )
2655 {
2656 xNetworkInterfaceOutput_ARP_STUB_CallCount++;
2657 return pdTRUE_UNSIGNED;
2658 }
2659
test_FreeRTOS_OutputARPRequest(void)2660 void test_FreeRTOS_OutputARPRequest( void )
2661 {
2662 NetworkEndPoint_t xEndPoint = { 0 };
2663 NetworkInterface_t xInterface;
2664 uint8_t ucBuffer[ sizeof( ARPPacket_t ) + ipBUFFER_PADDING + ipconfigETHERNET_MINIMUM_PACKET_BYTES ];
2665 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
2666 uint32_t ulIPAddress = 0xAAAAAAAA;
2667
2668 xNetworkBuffer.pucEthernetBuffer = ucBuffer;
2669 xNetworkBuffer.xDataLength = sizeof( ARPPacket_t );
2670
2671 xEndPoint.bits.bEndPointUp = pdTRUE_UNSIGNED;
2672 xEndPoint.ipv4_settings.ulIPAddress = 0x1234;
2673 xEndPoint.pxNetworkInterface = &xInterface;
2674 xEndPoint.pxNetworkInterface->pfOutput = xNetworkInterfaceOutput_ARP_STUB;
2675
2676 /* =================================================== */
2677 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2678
2679 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2680
2681 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, &xNetworkBuffer );
2682
2683 xIsCallingFromIPTask_IgnoreAndReturn( pdTRUE );
2684
2685 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2686
2687 FreeRTOS_OutputARPRequest( ulIPAddress );
2688 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 1 );
2689
2690 /* =================================================== */
2691
2692 /* =================================================== */
2693 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2694
2695 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2696
2697 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, &xNetworkBuffer );
2698
2699 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2700 xSendEventStructToIPTask_IgnoreAndReturn( pdFAIL );
2701 vReleaseNetworkBufferAndDescriptor_Expect( &xNetworkBuffer );
2702 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2703
2704 FreeRTOS_OutputARPRequest( ulIPAddress );
2705 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 0 );
2706
2707 /* =================================================== */
2708
2709 /* =================================================== */
2710 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2711 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2712
2713 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, &xNetworkBuffer );
2714 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2715 xSendEventStructToIPTask_IgnoreAndReturn( pdPASS );
2716 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2717
2718 FreeRTOS_OutputARPRequest( ulIPAddress );
2719
2720 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 0 );
2721 /* =================================================== */
2722
2723 /* =================================================== */
2724 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2725 xEndPoint.pxNetworkInterface = NULL;
2726
2727 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2728
2729 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, &xNetworkBuffer );
2730 xIsCallingFromIPTask_IgnoreAndReturn( pdTRUE );
2731
2732 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2733
2734 FreeRTOS_OutputARPRequest( ulIPAddress );
2735 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 0 );
2736 /* =================================================== */
2737
2738 xEndPoint.pxNetworkInterface = &xInterface;
2739
2740 /* =================================================== */
2741 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2742 xNetworkBuffer.xDataLength = ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES;
2743
2744 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2745
2746 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, &xNetworkBuffer );
2747 xIsCallingFromIPTask_IgnoreAndReturn( pdTRUE );
2748
2749 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2750
2751 FreeRTOS_OutputARPRequest( ulIPAddress );
2752
2753 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 1 );
2754 TEST_ASSERT_EQUAL( xNetworkBuffer.xDataLength, ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES );
2755 /* =================================================== */
2756
2757 /* =================================================== */
2758 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2759 xEndPoint.bits.bIPv6 = 1;
2760
2761 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2762 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2763
2764 FreeRTOS_OutputARPRequest( ulIPAddress );
2765 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 0 );
2766 /* =================================================== */
2767
2768 /* =================================================== */
2769 xNetworkInterfaceOutput_ARP_STUB_CallCount = 0;
2770
2771 xEndPoint.bits.bIPv6 = 0;
2772 xEndPoint.ipv4_settings.ulIPAddress = 0U;
2773
2774 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2775 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2776
2777 FreeRTOS_OutputARPRequest( ulIPAddress );
2778 TEST_ASSERT_EQUAL( xNetworkInterfaceOutput_ARP_STUB_CallCount, 0 );
2779 /* =================================================== */
2780 }
2781
2782
vStoreTimeValue(TimeOut_t * const timeout,int32_t callbacks)2783 void vStoreTimeValue( TimeOut_t * const timeout,
2784 int32_t callbacks )
2785 {
2786 timeout->xOverflowCount = 0;
2787 timeout->xTimeOnEntering = 100;
2788 }
2789
test_xARPWaitResolution_PrivateFunctionReturnsHit(void)2790 void test_xARPWaitResolution_PrivateFunctionReturnsHit( void )
2791 {
2792 uint32_t ulIPAddress = 0xAAAAAAAA;
2793 BaseType_t xResult;
2794 int i;
2795 struct xNetworkInterface * xInterface;
2796 NetworkEndPoint_t xEndPoint = { 0 };
2797
2798 /* Catch the assertion for calling from IP task. */
2799 /* =================================================== */
2800 /* Assertion on calling from IP-task */
2801 xIsCallingFromIPTask_IgnoreAndReturn( pdTRUE );
2802 catch_assert( xARPWaitResolution( ulIPAddress, 0 ) );
2803 /* =================================================== */
2804
2805
2806 /* Make the resolution pass without any attempt by making
2807 * eARPGetCacheEntry return eARPCacheHit. */
2808 /* =================================================== */
2809 /* Assertion on calling from IP-task */
2810 xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
2811 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2812 /* Not worried about what these functions do. */
2813 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2814 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 1UL );
2815 vSetMultiCastIPv4MacAddress_Ignore();
2816 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2817
2818 xResult = xARPWaitResolution( ulIPAddress, 0 );
2819 TEST_ASSERT_EQUAL( xResult, 0 );
2820 /* =================================================== */
2821 }
2822
test_xARPWaitResolution_GNWFailsNoTimeout(void)2823 void test_xARPWaitResolution_GNWFailsNoTimeout( void )
2824 {
2825 uint32_t ulIPAddress = 0xAAAAAAAA;
2826 NetworkEndPoint_t xEndPoint = { 0 };
2827 NetworkInterface_t xInterface;
2828 BaseType_t xResult;
2829 int i;
2830
2831 xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
2832 xEndPoint.ipv4_settings.ulIPAddress = 0xC0C0C0C0;
2833
2834 /* Make the resolution fail with maximum tryouts. */
2835 /* =================================================== */
2836 /* Make sure that no address matches the IP address. */
2837 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2838 {
2839 xARPCache[ i ].ulIPAddress = 0xAAAAAAAA;
2840 }
2841
2842 ulIPAddress = 0x00000031;
2843 /* Make both values (IP address and local IP pointer) different. */
2844 /* Get any address on the same netmask. */
2845 *ipLOCAL_IP_ADDRESS_POINTER = 0x00000034;
2846
2847 /* Assertion on calling from IP-task */
2848 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2849 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2850 /* Not worried about what these functions do. */
2851 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2852 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2853
2854 vTaskSetTimeOutState_Stub( vStoreTimeValue );
2855
2856 /* Make sure that there are enough stubs for all the repetitive calls. */
2857 for( i = 0; i < ipconfigMAX_ARP_RETRANSMISSIONS; i++ )
2858 {
2859 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2860 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2861 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2862 vTaskDelay_Expect( pdMS_TO_TICKS( 250U ) );
2863 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2864 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2865 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2866 xTaskCheckForTimeOut_IgnoreAndReturn( pdFALSE );
2867 }
2868
2869 xResult = xARPWaitResolution( ulIPAddress, 0 );
2870 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EADDRNOTAVAIL, xResult );
2871 /* =================================================== */
2872 }
2873
test_xARPWaitResolution(void)2874 void test_xARPWaitResolution( void )
2875 {
2876 NetworkInterface_t xInterface;
2877 NetworkEndPoint_t xEndPoint = { 0 };
2878 uint32_t ulIPAddress = 0xAAAAAAAA;
2879 BaseType_t xResult;
2880 int i;
2881
2882 xEndPoint.bits.bIPv6 = pdFALSE_UNSIGNED;
2883 xEndPoint.ipv4_settings.ulIPAddress = 0xC0C0C0C0;
2884
2885 /* Make the resolution fail after some attempts due to timeout. */
2886 /* =================================================== */
2887 /* Make sure that no address matches the IP address. */
2888 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2889 {
2890 xARPCache[ i ].ulIPAddress = 0xAAAAAAAA;
2891 }
2892
2893 ulIPAddress = 0x00000031;
2894 /* Make both values (IP address and local IP pointer) different. */
2895 /* Get any address on the same netmask. */
2896 *ipLOCAL_IP_ADDRESS_POINTER = 0x00000034;
2897
2898 /* Assertion on calling from IP-task */
2899 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2900 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2901 /* Not worried about what these functions do. */
2902 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2903 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2904
2905 vTaskSetTimeOutState_Stub( vStoreTimeValue );
2906
2907 /* Make sure that there are enough stubs for all the repetitive calls. */
2908 for( i = 0; i < ( ipconfigMAX_ARP_RETRANSMISSIONS - 1 ); i++ )
2909 {
2910 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2911 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2912 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2913 vTaskDelay_Expect( pdMS_TO_TICKS( 250U ) );
2914 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2915 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2916 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2917 xTaskCheckForTimeOut_IgnoreAndReturn( pdFALSE );
2918 }
2919
2920 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2921 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2922 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2923 vTaskDelay_Expect( pdMS_TO_TICKS( 250U ) );
2924 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2925 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2926 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2927 xTaskCheckForTimeOut_IgnoreAndReturn( pdTRUE );
2928
2929 xResult = xARPWaitResolution( ulIPAddress, 0 );
2930 TEST_ASSERT_EQUAL( -pdFREERTOS_ERRNO_EADDRNOTAVAIL, xResult );
2931 /* =================================================== */
2932
2933 /* Make the resolution pass after some attempts. */
2934 /* =================================================== */
2935 xEndPoint.bits.bIPv6 = 0;
2936
2937 /* Make sure that no address matches the IP address. */
2938 for( i = 0; i < ipconfigARP_CACHE_ENTRIES; i++ )
2939 {
2940 xARPCache[ i ].ulIPAddress = 0xAAAAAAAA;
2941 }
2942
2943 ulIPAddress = 0x00000031;
2944 /* Make both values (IP address and local IP pointer) different. */
2945 /* Get any address on the same netmask. */
2946 *ipLOCAL_IP_ADDRESS_POINTER = 0x00000034;
2947
2948 /* Assertion on calling from IP-task */
2949 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2950 xIsCallingFromIPTask_IgnoreAndReturn( pdFALSE );
2951 /* Not worried about what these functions do. */
2952 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2953 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2954
2955 vTaskSetTimeOutState_Stub( vStoreTimeValue );
2956
2957 /* Make sure that there are enough stubs for all the repetitive calls. */
2958 for( i = 0; i < ( ipconfigMAX_ARP_RETRANSMISSIONS - 2 ); i++ )
2959 {
2960 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2961 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2962 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2963 vTaskDelay_Expect( pdMS_TO_TICKS( 250U ) );
2964 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2965 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 0UL );
2966 FreeRTOS_FindEndPointOnNetMask_ExpectAnyArgsAndReturn( ( void * ) 1234 );
2967 xTaskCheckForTimeOut_IgnoreAndReturn( pdFALSE );
2968 }
2969
2970 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2971 pxGetNetworkBufferWithDescriptor_ExpectAndReturn( sizeof( ARPPacket_t ), 0, NULL );
2972 FreeRTOS_NextEndPoint_ExpectAndReturn( NULL, &xEndPoint, NULL );
2973 vTaskDelay_Expect( pdMS_TO_TICKS( 250U ) );
2974 FreeRTOS_FindEndPointOnIP_IPv4_ExpectAnyArgsAndReturn( NULL );
2975 xIsIPv4Multicast_ExpectAndReturn( ulIPAddress, 1UL );
2976 vSetMultiCastIPv4MacAddress_Ignore();
2977 FreeRTOS_FirstEndPoint_ExpectAndReturn( NULL, &xEndPoint );
2978 xTaskCheckForTimeOut_IgnoreAndReturn( pdFALSE );
2979
2980 xResult = xARPWaitResolution( ulIPAddress, 0 );
2981 TEST_ASSERT_EQUAL( 0, xResult );
2982 /* =================================================== */
2983 }
2984
test_vARPGenerateRequestPacket(void)2985 void test_vARPGenerateRequestPacket( void )
2986 {
2987 NetworkBufferDescriptor_t xNetworkBuffer = { 0 };
2988 NetworkEndPoint_t xEndPoint = { 0 };
2989
2990 NetworkBufferDescriptor_t * const pxNetworkBuffer = &xNetworkBuffer;
2991
2992
2993 uint8_t ucBuffer[ sizeof( ARPPacket_t ) + ipBUFFER_PADDING ];
2994
2995 pxNetworkBuffer->pucEthernetBuffer = ucBuffer;
2996 pxNetworkBuffer->xDataLength = sizeof( ARPPacket_t );
2997
2998 /* Catch some asserts. */
2999 catch_assert( vARPGenerateRequestPacket( NULL ) );
3000
3001 xNetworkBuffer.pxEndPoint = NULL;
3002 catch_assert( vARPGenerateRequestPacket( pxNetworkBuffer ) );
3003
3004 xNetworkBuffer.pxEndPoint = &xEndPoint;
3005 pxNetworkBuffer->xDataLength = sizeof( ARPPacket_t ) - 10;
3006 catch_assert( vARPGenerateRequestPacket( pxNetworkBuffer ) );
3007
3008 pxNetworkBuffer->xDataLength = sizeof( ARPPacket_t );
3009 vARPGenerateRequestPacket( pxNetworkBuffer );
3010 }
3011
3012
test_FreeRTOS_ClearARP(void)3013 void test_FreeRTOS_ClearARP( void )
3014 {
3015 struct xNetworkEndPoint xEndPoint = { 0 };
3016 uint8_t ucArray[ sizeof( xARPCache ) ];
3017
3018 memset( ucArray, 0, sizeof( xARPCache ) );
3019
3020 FreeRTOS_ClearARP( NULL );
3021 TEST_ASSERT_EQUAL_MEMORY( ucArray, xARPCache, sizeof( xARPCache ) );
3022 }
3023
test_FreeRTOS_ClearARP_validEndPoint_Match(void)3024 void test_FreeRTOS_ClearARP_validEndPoint_Match( void )
3025 {
3026 struct xNetworkEndPoint xEndPoint = { 0 }, * pxEndPoint = &xEndPoint;
3027 uint8_t ucArray[ sizeof( xARPCache ) ];
3028
3029 xEndPoint.bits.bIPv6 = 0;
3030
3031 xARPCache[ 0 ].pxEndPoint = &xEndPoint;
3032 memset( ucArray, 0, sizeof( xARPCache ) );
3033
3034 FreeRTOS_ClearARP( pxEndPoint );
3035 TEST_ASSERT_EQUAL_MEMORY( ucArray, &xARPCache[ 0 ], sizeof( ARPCacheRow_t ) );
3036 }
3037
test_FreeRTOS_ClearARP_validEndPoint_NoMatch(void)3038 void test_FreeRTOS_ClearARP_validEndPoint_NoMatch( void )
3039 {
3040 struct xNetworkEndPoint xEndPoint = { 0 }, * pxEndPoint = &xEndPoint;
3041 uint8_t ucArray[ sizeof( xARPCache ) ];
3042
3043 memset( ucArray, 0, sizeof( xARPCache ) );
3044
3045 FreeRTOS_ClearARP( pxEndPoint );
3046 TEST_ASSERT_EQUAL_MEMORY( ucArray, xARPCache, sizeof( xARPCache ) );
3047 }
3048
test_FreeRTOS_PrintARPCache(void)3049 void test_FreeRTOS_PrintARPCache( void )
3050 {
3051 int x;
3052
3053 for( x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
3054 {
3055 /* Anything except 0. */
3056 xARPCache[ x ].ulIPAddress = 0xAA;
3057 /* Anything except 0. */
3058 xARPCache[ x ].ucAge = x;
3059 }
3060
3061 /* Nothing to actually unit-test here. */
3062 FreeRTOS_PrintARPCache();
3063
3064 for( x = 0; x < ipconfigARP_CACHE_ENTRIES; x++ )
3065 {
3066 /* Anything except 0. */
3067 xARPCache[ x ].ulIPAddress = 0x00;
3068 /* Anything except 0. */
3069 xARPCache[ x ].ucAge = x;
3070 }
3071
3072 /* Nothing to actually unit-test here. */
3073 FreeRTOS_PrintARPCache();
3074 }
3075
3076 /**
3077 * @brief Check if vARPRefreshCacheEntryAge executes normally when pointer of MAC address is NULL.
3078 */
test_vARPRefreshCacheEntryAge_NullMAC(void)3079 void test_vARPRefreshCacheEntryAge_NullMAC( void )
3080 {
3081 vARPRefreshCacheEntryAge( NULL, 0U );
3082 }
3083
3084 /**
3085 * @brief Check if vARPRefreshCacheEntryAge update the age of matching ARP cache correctly.
3086 */
test_vARPRefreshCacheEntryAge_MatchIPMaychMAC(void)3087 void test_vARPRefreshCacheEntryAge_MatchIPMaychMAC( void )
3088 {
3089 MACAddress_t xTargetMACAddress = { { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 } };
3090 uint32_t ulTargetIPAddress = 0x12345678U;
3091 BaseType_t xHitCacheIndex = ipconfigARP_CACHE_ENTRIES - 1;
3092
3093 memset( xARPCache, 0, sizeof( xARPCache ) );
3094
3095 xARPCache[ xHitCacheIndex ].ulIPAddress = ulTargetIPAddress;
3096 memcpy( xARPCache[ xHitCacheIndex ].xMACAddress.ucBytes, xTargetMACAddress.ucBytes, sizeof( MACAddress_t ) );
3097 xARPCache[ xHitCacheIndex ].ucAge = ipconfigMAX_ARP_AGE - 1U;
3098
3099 vARPRefreshCacheEntryAge( &xTargetMACAddress, ulTargetIPAddress );
3100
3101 TEST_ASSERT_EQUAL_UINT16( ipconfigMAX_ARP_AGE, xARPCache[ xHitCacheIndex ].ucAge );
3102 }
3103
3104 /**
3105 * @brief Test the scenario that no cache matches.
3106 */
test_vARPRefreshCacheEntryAge_NotFound(void)3107 void test_vARPRefreshCacheEntryAge_NotFound( void )
3108 {
3109 MACAddress_t xTargetMACAddress = { { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 } };
3110 uint32_t ulTargetIPAddress = 0x12345678U;
3111 BaseType_t xCacheIndex;
3112
3113 memset( xARPCache, 0, sizeof( xARPCache ) );
3114
3115 xARPCache[ 0 ].ulIPAddress = ulTargetIPAddress;
3116
3117 memcpy( xARPCache[ 1 ].xMACAddress.ucBytes, xTargetMACAddress.ucBytes, sizeof( MACAddress_t ) );
3118
3119 vARPRefreshCacheEntryAge( &xTargetMACAddress, ulTargetIPAddress );
3120
3121 for( xCacheIndex = 0; xCacheIndex < ipconfigARP_CACHE_ENTRIES; xCacheIndex++ )
3122 {
3123 TEST_ASSERT_EQUAL_UINT16( 0, xARPCache[ xCacheIndex ].ucAge );
3124 }
3125 }
3126
