1 /*
2  * FreeRTOS+TCP V3.1.0
3  * Copyright (C) 2022 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
4  *
5  * SPDX-License-Identifier: MIT
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
8  * this software and associated documentation files (the "Software"), to deal in
9  * the Software without restriction, including without limitation the rights to
10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11  * the Software, and to permit persons to whom the Software is furnished to do so,
12  * subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23  *
24  * http://aws.amazon.com/freertos
25  * http://www.FreeRTOS.org
26  */
27 
28 
29 /* Include Unity header */
30 #include "unity.h"
31 
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36 
37 #include "mock_task.h"
38 #include "mock_list.h"
39 
40 /* This must come after list.h is included (in this case, indirectly
41  * by mock_list.h). */
42 #include "mock_IP_DiffConfig_list_macros.h"
43 #include "mock_queue.h"
44 #include "mock_event_groups.h"
45 
46 #include "mock_FreeRTOS_IP_Private.h"
47 #include "mock_FreeRTOS_IP_Utils.h"
48 #include "mock_FreeRTOS_IP_Timers.h"
49 #include "mock_FreeRTOS_TCP_IP.h"
50 #include "mock_FreeRTOS_ICMP.h"
51 #include "mock_FreeRTOS_ARP.h"
52 #include "mock_NetworkBufferManagement.h"
53 #include "mock_NetworkInterface.h"
54 #include "mock_FreeRTOS_DHCP.h"
55 #include "mock_FreeRTOS_Sockets.h"
56 #include "mock_FreeRTOS_DNS.h"
57 #include "mock_FreeRTOS_Stream_Buffer.h"
58 #include "mock_FreeRTOS_TCP_WIN.h"
59 #include "mock_FreeRTOS_UDP_IP.h"
60 
61 #include "FreeRTOS_IP.h"
62 
63 #include "FreeRTOS_IP_stubs.c"
64 #include "catch_assert.h"
65 
66 #include "FreeRTOSIPConfig.h"
67 
68 void prvIPTask( void * pvParameters );
69 void prvProcessIPEventsAndTimers( void );
70 eFrameProcessingResult_t prvProcessIPPacket( IPPacket_t * pxIPPacket,
71                                              NetworkBufferDescriptor_t * const pxNetworkBuffer );
72 void prvProcessEthernetPacket( NetworkBufferDescriptor_t * const pxNetworkBuffer );
73 eFrameProcessingResult_t prvAllowIPPacket( const IPPacket_t * const pxIPPacket,
74                                            const NetworkBufferDescriptor_t * const pxNetworkBuffer,
75                                            UBaseType_t uxHeaderLength );
76 
77 extern BaseType_t xIPTaskInitialised;
78 extern BaseType_t xNetworkDownEventPending;
79 extern BaseType_t xNetworkUp;
80 extern UBaseType_t uxQueueMinimumSpace;
81 
82 static uint8_t ReleaseTCPPayloadBuffer[ 1500 ];
83 static BaseType_t ReleaseTCPPayloadBufferxByteCount = 100;
StubuxStreamBufferGetPtr_ReturnBadAddress(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)84 static size_t StubuxStreamBufferGetPtr_ReturnBadAddress( StreamBuffer_t * pxBuffer,
85                                                          uint8_t ** ppucData,
86                                                          int lCounter )
87 {
88     *ppucData = &ReleaseTCPPayloadBuffer[ 150 ];
89 
90     return 0xFFFFFF;
91 }
92 
StubuxStreamBufferGetPtr_ReturnIncorrectSize(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)93 static size_t StubuxStreamBufferGetPtr_ReturnIncorrectSize( StreamBuffer_t * pxBuffer,
94                                                             uint8_t ** ppucData,
95                                                             int lCounter )
96 {
97     *ppucData = &ReleaseTCPPayloadBuffer[ 0 ];
98 
99     return( ReleaseTCPPayloadBufferxByteCount >> 1 );
100 }
101 
StubuxStreamBufferGetPtr_ReturnCorrectVals(StreamBuffer_t * pxBuffer,uint8_t ** ppucData,int lCounter)102 static size_t StubuxStreamBufferGetPtr_ReturnCorrectVals( StreamBuffer_t * pxBuffer,
103                                                           uint8_t ** ppucData,
104                                                           int lCounter )
105 {
106     *ppucData = &ReleaseTCPPayloadBuffer[ 0 ];
107 
108     return ReleaseTCPPayloadBufferxByteCount;
109 }
110 
vSetIPTaskHandle(TaskHandle_t xTaskHandleToSet)111 static void vSetIPTaskHandle( TaskHandle_t xTaskHandleToSet )
112 {
113     const uint8_t ucIPAddress[ ipIP_ADDRESS_LENGTH_BYTES ];
114     const uint8_t ucNetMask[ ipIP_ADDRESS_LENGTH_BYTES ];
115     const uint8_t ucGatewayAddress[ ipIP_ADDRESS_LENGTH_BYTES ];
116     const uint8_t ucDNSServerAddress[ ipIP_ADDRESS_LENGTH_BYTES ];
117     const uint8_t ucMACAddress[ ipMAC_ADDRESS_LENGTH_BYTES ];
118 
119     vPreCheckConfigs_Expect();
120 
121     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
122         xQueueGenericCreateStatic_ExpectAnyArgsAndReturn( ( QueueHandle_t ) 0x1234ABCD );
123     #else
124         xQueueGenericCreate_ExpectAnyArgsAndReturn( ( QueueHandle_t ) 0x1234ABCD );
125     #endif /* configSUPPORT_STATIC_ALLOCATION */
126 
127     #if ( configQUEUE_REGISTRY_SIZE > 0 )
128         vQueueAddToRegistry_ExpectAnyArgs();
129     #endif
130 
131     xNetworkBuffersInitialise_ExpectAndReturn( pdPASS );
132 
133     vNetworkSocketsInit_Expect();
134 
135     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
136         xTaskCreateStatic_ExpectAnyArgsAndReturn( xTaskHandleToSet );
137     #else
138         xTaskCreate_ReturnThruPtr_pxCreatedTask( xTaskHandleToSet );
139     #endif
140 
141     FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
142 }
143 
test_prvProcessIPEventsAndTimers_NoEventReceived(void)144 void test_prvProcessIPEventsAndTimers_NoEventReceived( void )
145 {
146     vCheckNetworkTimers_Expect();
147 
148     xCalculateSleepTime_ExpectAndReturn( 0 );
149 
150     /* No event received. */
151     xQueueReceive_ExpectAnyArgsAndReturn( pdFALSE );
152 
153     prvProcessIPEventsAndTimers();
154 }
155 
test_prvProcessIPEventsAndTimers_eNetworkDownEvent(void)156 void test_prvProcessIPEventsAndTimers_eNetworkDownEvent( void )
157 {
158     IPStackEvent_t xReceivedEvent;
159     BaseType_t xQueueReturn = 100;
160 
161     xReceivedEvent.eEventType = eNetworkDownEvent;
162 
163     xNetworkUp = pdTRUE;
164 
165     uxQueueMinimumSpace = xQueueReturn - 10;
166 
167     vCheckNetworkTimers_Expect();
168 
169     xCalculateSleepTime_ExpectAndReturn( 0 );
170 
171     xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
172     xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
173 
174     uxQueueSpacesAvailable_ExpectAnyArgsAndReturn( xQueueReturn );
175 
176     prvProcessNetworkDownEvent_Expect();
177 
178     prvProcessIPEventsAndTimers();
179 
180     TEST_ASSERT_EQUAL( pdFALSE, xNetworkUp );
181     TEST_ASSERT_EQUAL( xQueueReturn - 10, uxQueueMinimumSpace );
182 }
183 
test_prvProcessIPEventsAndTimers_eNetworkRxEventNULL_LessSpace(void)184 void test_prvProcessIPEventsAndTimers_eNetworkRxEventNULL_LessSpace( void )
185 {
186     IPStackEvent_t xReceivedEvent;
187     BaseType_t xQueueReturn = 100;
188 
189     xReceivedEvent.eEventType = eNetworkRxEvent;
190     xReceivedEvent.pvData = NULL;
191 
192     uxQueueMinimumSpace = xQueueReturn - 10;
193 
194     vCheckNetworkTimers_Expect();
195 
196     xCalculateSleepTime_ExpectAndReturn( 0 );
197 
198     xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
199     xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
200 
201     uxQueueSpacesAvailable_ExpectAnyArgsAndReturn( xQueueReturn );
202 
203     prvProcessIPEventsAndTimers();
204 
205     TEST_ASSERT_EQUAL( xQueueReturn - 10, uxQueueMinimumSpace );
206 }
207 
test_prvProcessIPEventsAndTimers_eNetworkRxEvent_MoreSpace(void)208 void test_prvProcessIPEventsAndTimers_eNetworkRxEvent_MoreSpace( void )
209 {
210     IPStackEvent_t xReceivedEvent;
211     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
212     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
213     BaseType_t xQueueReturn = 100;
214 
215     pxNetworkBuffer = &xNetworkBuffer;
216     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
217     pxNetworkBuffer->xDataLength = sizeof( EthernetHeader_t ) - 1;
218     pxNetworkBuffer->pxNextBuffer = NULL;
219 
220     xReceivedEvent.eEventType = eNetworkRxEvent;
221     xReceivedEvent.pvData = pxNetworkBuffer;
222 
223     uxQueueMinimumSpace = xQueueReturn + 10;
224 
225     vCheckNetworkTimers_Expect();
226 
227     xCalculateSleepTime_ExpectAndReturn( 0 );
228 
229     xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
230     xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
231 
232     uxQueueSpacesAvailable_ExpectAnyArgsAndReturn( xQueueReturn );
233 
234     vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
235 
236     prvProcessIPEventsAndTimers();
237 
238     TEST_ASSERT_EQUAL( xQueueReturn, uxQueueMinimumSpace );
239 }
240 
test_prvProcessIPEventsAndTimers_eSocketSelectEvent(void)241 void test_prvProcessIPEventsAndTimers_eSocketSelectEvent( void )
242 {
243     IPStackEvent_t xReceivedEvent;
244     SocketSelectMessage_t xData;
245     BaseType_t xQueueReturn = 100;
246 
247     memset( &xData, 0, sizeof( xData ) );
248     xData.pxSocketSet = ( void * ) 0xFFAABBCC;
249     xData.xTaskhandle = ( void * ) 0xABCDABCD;
250 
251     xReceivedEvent.eEventType = eSocketSelectEvent;
252     xReceivedEvent.pvData = ( void * ) &xData;
253 
254     vCheckNetworkTimers_Expect();
255 
256     xCalculateSleepTime_ExpectAndReturn( 0 );
257 
258     xQueueReceive_ExpectAnyArgsAndReturn( pdTRUE );
259     xQueueReceive_ReturnMemThruPtr_pvBuffer( &xReceivedEvent, sizeof( xReceivedEvent ) );
260 
261     uxQueueSpacesAvailable_ExpectAnyArgsAndReturn( xQueueReturn );
262 
263     vSocketSelect_Expect( ( SocketSelect_t * ) 0xFFAABBCC );
264     xTaskGenericNotify_ExpectAndReturn( ( TaskHandle_t ) 0xABCDABCD, 0, ( 0 ), eIncrement, NULL, pdPASS );
265 
266     prvProcessIPEventsAndTimers();
267 }
268 
269 TaskHandle_t IPInItHappyPath_xTaskHandleToSet = ( TaskHandle_t ) 0xCDBA9087;
StubxTaskCreate(TaskFunction_t pxTaskCode,const char * const pcName,const configSTACK_DEPTH_TYPE usStackDepth,void * const pvParameters,UBaseType_t uxPriority,TaskHandle_t * const pxCreatedTask)270 static BaseType_t StubxTaskCreate( TaskFunction_t pxTaskCode,
271                                    const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
272                                    const configSTACK_DEPTH_TYPE usStackDepth,
273                                    void * const pvParameters,
274                                    UBaseType_t uxPriority,
275                                    TaskHandle_t * const pxCreatedTask )
276 {
277     *pxCreatedTask = IPInItHappyPath_xTaskHandleToSet;
278     return pdPASS;
279 }
280 
test_FreeRTOS_IPInit_HappyPath(void)281 void test_FreeRTOS_IPInit_HappyPath( void )
282 {
283     const uint8_t ucIPAddress[ ipIP_ADDRESS_LENGTH_BYTES ] = { 0xC0, 0xB0, 0xAB, 0x12 };
284     const uint8_t ucNetMask[ ipIP_ADDRESS_LENGTH_BYTES ] = { 0xC1, 0xB2, 0xAC, 0x13 };
285     const uint8_t ucGatewayAddress[ ipIP_ADDRESS_LENGTH_BYTES ] = { 0xC2, 0xB3, 0xAC, 0x14 };
286     const uint8_t ucDNSServerAddress[ ipIP_ADDRESS_LENGTH_BYTES ] = { 0xC3, 0xB4, 0xAD, 0x15 };
287     const uint8_t ucMACAddress[ ipMAC_ADDRESS_LENGTH_BYTES ] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
288     BaseType_t xReturn;
289     QueueHandle_t ulPointerToQueue = ( QueueHandle_t ) 0x1234ABCD;
290 
291 
292     /* Set the local IP to something other than 0. */
293     *ipLOCAL_IP_ADDRESS_POINTER = 0xABCD;
294 
295     /* Clear default values. */
296     memset( &xDefaultAddressing, 0, sizeof( xDefaultAddressing ) );
297     memset( &xNetworkAddressing, 0, sizeof( xDefaultAddressing ) );
298 
299     vPreCheckConfigs_Expect();
300 
301     xQueueGenericCreate_ExpectAndReturn( ipconfigEVENT_QUEUE_LENGTH, sizeof( IPStackEvent_t ), 0U, ulPointerToQueue );
302 
303     #if ( configQUEUE_REGISTRY_SIZE > 0 )
304         vQueueAddToRegistry_Expect( ulPointerToQueue, "NetEvnt" );
305     #endif
306 
307     xNetworkBuffersInitialise_ExpectAndReturn( pdPASS );
308 
309     vNetworkSocketsInit_Expect();
310 
311     xTaskCreate_Stub( StubxTaskCreate );
312 
313     xReturn = FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
314 
315     TEST_ASSERT_EQUAL( pdPASS, xReturn );
316     TEST_ASSERT_EQUAL( FreeRTOS_inet_addr_quick( ucIPAddress[ 0 ], ucIPAddress[ 1 ], ucIPAddress[ 2 ], ucIPAddress[ 3 ] ), xNetworkAddressing.ulDefaultIPAddress );
317     TEST_ASSERT_EQUAL( FreeRTOS_inet_addr_quick( ucNetMask[ 0 ], ucNetMask[ 1 ], ucNetMask[ 2 ], ucNetMask[ 3 ] ), xNetworkAddressing.ulNetMask );
318     TEST_ASSERT_EQUAL( FreeRTOS_inet_addr_quick( ucGatewayAddress[ 0 ], ucGatewayAddress[ 1 ], ucGatewayAddress[ 2 ], ucGatewayAddress[ 3 ] ), xNetworkAddressing.ulGatewayAddress );
319     TEST_ASSERT_EQUAL( FreeRTOS_inet_addr_quick( ucDNSServerAddress[ 0 ], ucDNSServerAddress[ 1 ], ucDNSServerAddress[ 2 ], ucDNSServerAddress[ 3 ] ), xNetworkAddressing.ulDNSServerAddress );
320     TEST_ASSERT_EQUAL( ( ( xNetworkAddressing.ulDefaultIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask ), xNetworkAddressing.ulBroadcastAddress );
321     TEST_ASSERT_EQUAL_MEMORY( &xDefaultAddressing, &xNetworkAddressing, sizeof( xDefaultAddressing ) );
322     TEST_ASSERT_EQUAL( 0, *ipLOCAL_IP_ADDRESS_POINTER );
323     TEST_ASSERT_EQUAL_MEMORY( ucMACAddress, ipLOCAL_MAC_ADDRESS, ( size_t ) ipMAC_ADDRESS_LENGTH_BYTES );
324     TEST_ASSERT_EQUAL( IPInItHappyPath_xTaskHandleToSet, FreeRTOS_GetIPTaskHandle() );
325 }
326 
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBufferAssert(void)327 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBufferAssert( void )
328 {
329     FreeRTOS_Socket_t xSocket;
330     BaseType_t xByteCount = 100, xReturn;
331 
332     memset( &xSocket, 0, sizeof( xSocket ) );
333 
334     uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnBadAddress );
335 
336     xReturn = FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, xByteCount );
337 
338     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
339 }
340 
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectSizeAssert(void)341 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectSizeAssert( void )
342 {
343     FreeRTOS_Socket_t xSocket;
344     BaseType_t xReturn;
345 
346     memset( &xSocket, 0, sizeof( xSocket ) );
347 
348     uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnIncorrectSize );
349 
350     xReturn = FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount );
351 
352     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
353 }
354 
test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBytesReleasedAssert(void)355 void test_FreeRTOS_ReleaseTCPPayloadBuffer_IncorrectBytesReleasedAssert( void )
356 {
357     FreeRTOS_Socket_t xSocket;
358     BaseType_t xReturn;
359 
360     memset( &xSocket, 0, sizeof( xSocket ) );
361 
362     uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnCorrectVals );
363 
364     FreeRTOS_recv_ExpectAndReturn( &xSocket, NULL, ReleaseTCPPayloadBufferxByteCount, FREERTOS_MSG_DONTWAIT, ( ReleaseTCPPayloadBufferxByteCount >> 1 ) );
365 
366     xReturn = FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount );
367 
368     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
369 }
370 
test_FreeRTOS_ReleaseTCPPayloadBuffer_HappyPath(void)371 void test_FreeRTOS_ReleaseTCPPayloadBuffer_HappyPath( void )
372 {
373     FreeRTOS_Socket_t xSocket;
374     BaseType_t xReturn;
375 
376     memset( &xSocket, 0, sizeof( xSocket ) );
377 
378     uxStreamBufferGetPtr_Stub( StubuxStreamBufferGetPtr_ReturnCorrectVals );
379 
380     FreeRTOS_recv_ExpectAndReturn( &xSocket, NULL, ReleaseTCPPayloadBufferxByteCount, FREERTOS_MSG_DONTWAIT, ReleaseTCPPayloadBufferxByteCount );
381 
382     xReturn = FreeRTOS_ReleaseTCPPayloadBuffer( &xSocket, ReleaseTCPPayloadBuffer, ReleaseTCPPayloadBufferxByteCount );
383 
384     TEST_ASSERT_EQUAL( pdPASS, xReturn );
385 }
386 
test_prvAllowIPPacket_BroadcastSourceIP(void)387 void test_prvAllowIPPacket_BroadcastSourceIP( void )
388 {
389     eFrameProcessingResult_t eResult;
390     IPPacket_t * pxIPPacket;
391     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
392     UBaseType_t uxHeaderLength = 0;
393     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
394     IPHeader_t * pxIPHeader;
395 
396     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
397 
398     pxNetworkBuffer = &xNetworkBuffer;
399     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
400     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
401     pxIPHeader = &( pxIPPacket->xIPHeader );
402 
403     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
404 
405     pxIPHeader->ucVersionHeaderLength = 0x45;
406 
407     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
408 
409     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
410 
411     pxIPHeader->ulSourceIPAddress = 0xFFFFFFFF;
412 
413     eResult = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
414 
415     TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
416 }
417 
test_prvAllowIPPacket_IncorrectSizeFields(void)418 void test_prvAllowIPPacket_IncorrectSizeFields( void )
419 {
420     eFrameProcessingResult_t eResult;
421     IPPacket_t * pxIPPacket;
422     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
423     UBaseType_t uxHeaderLength = 0;
424     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
425     IPHeader_t * pxIPHeader;
426 
427     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
428 
429     pxNetworkBuffer = &xNetworkBuffer;
430     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
431     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
432     pxIPHeader = &( pxIPPacket->xIPHeader );
433 
434     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
435 
436     pxIPHeader->ucVersionHeaderLength = 0x45;
437 
438     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
439 
440     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
441 
442     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
443 
444     eResult = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
445 
446     TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
447 }
448 
test_prvAllowIPPacket_UDPCheckSumZero(void)449 void test_prvAllowIPPacket_UDPCheckSumZero( void )
450 {
451     eFrameProcessingResult_t eResult;
452     IPPacket_t * pxIPPacket;
453     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
454     UBaseType_t uxHeaderLength = 0;
455     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
456     IPHeader_t * pxIPHeader;
457 
458     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
459 
460     pxNetworkBuffer = &xNetworkBuffer;
461     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
462     /* Set correct length. */
463     pxNetworkBuffer->xDataLength = sizeof( UDPPacket_t );
464     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
465     pxIPHeader = &( pxIPPacket->xIPHeader );
466 
467     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
468 
469     pxIPHeader->ucVersionHeaderLength = 0x45;
470 
471     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
472     /* Correct protocol. */
473     pxIPHeader->ucProtocol = ipPROTOCOL_UDP;
474     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( UDPHeader_t ) );
475 
476     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
477 
478     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
479 
480     eResult = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
481 
482     TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
483 }
484 
test_prvAllowIPPacket_UDP_HappyPath(void)485 void test_prvAllowIPPacket_UDP_HappyPath( void )
486 {
487     eFrameProcessingResult_t eResult;
488     IPPacket_t * pxIPPacket;
489     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
490     UBaseType_t uxHeaderLength = 0;
491     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
492     IPHeader_t * pxIPHeader;
493     ProtocolPacket_t * pxProtPack;
494 
495     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
496 
497     pxNetworkBuffer = &xNetworkBuffer;
498     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
499     /* Set correct length. */
500     pxNetworkBuffer->xDataLength = sizeof( UDPPacket_t );
501     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
502     pxIPHeader = &( pxIPPacket->xIPHeader );
503 
504     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
505 
506     pxIPHeader->ucVersionHeaderLength = 0x45;
507 
508     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
509     /* Correct protocol. */
510     pxIPHeader->ucProtocol = ipPROTOCOL_UDP;
511     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( UDPHeader_t ) );
512 
513     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
514 
515     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
516 
517     uxHeaderLength = ipSIZE_OF_IPv4_HEADER;
518     pxProtPack = ( ( ProtocolPacket_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ uxHeaderLength - ipSIZE_OF_IPv4_HEADER ] ) );
519 
520     /* Non-zero checksum. */
521     pxProtPack->xUDPPacket.xUDPHeader.usChecksum = 0xFF12;
522 
523     eResult = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
524 
525     TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
526 }
527 
test_prvAllowIPPacket_TCP_HappyPath(void)528 void test_prvAllowIPPacket_TCP_HappyPath( void )
529 {
530     eFrameProcessingResult_t eResult;
531     IPPacket_t * pxIPPacket;
532     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
533     UBaseType_t uxHeaderLength = ipSIZE_OF_IPv4_HEADER;
534     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
535     IPHeader_t * pxIPHeader;
536     ProtocolPacket_t * pxProtPack;
537 
538     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
539 
540     pxNetworkBuffer = &xNetworkBuffer;
541     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
542     /* Set correct length. */
543     pxNetworkBuffer->xDataLength = sizeof( TCPPacket_t );
544     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
545     pxIPHeader = &( pxIPPacket->xIPHeader );
546 
547     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
548 
549     pxIPHeader->ucVersionHeaderLength = 0x45;
550 
551     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
552     /* Correct protocol. */
553     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
554     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( UDPHeader_t ) );
555 
556     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
557 
558     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
559 
560     eResult = prvAllowIPPacket( pxIPPacket, pxNetworkBuffer, uxHeaderLength );
561 
562     TEST_ASSERT_EQUAL( eProcessBuffer, eResult );
563 }
564 
test_prvProcessIPPacket_(void)565 void test_prvProcessIPPacket_( void )
566 {
567     eFrameProcessingResult_t eResult;
568     IPPacket_t * pxIPPacket;
569     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
570     UBaseType_t uxHeaderLength = 0;
571     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
572     IPHeader_t * pxIPHeader;
573 
574     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
575 
576     pxNetworkBuffer = &xNetworkBuffer;
577     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
578     pxNetworkBuffer->xDataLength = ipconfigTCP_MSS;
579 
580     pxIPPacket = ( IPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
581     pxIPHeader = &( pxIPPacket->xIPHeader );
582 
583     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
584 
585     pxIPHeader->ucVersionHeaderLength = 0x46;
586     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
587     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
588     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
589 
590     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
591 
592     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
593 
594     eResult = prvProcessIPPacket( pxIPPacket, pxNetworkBuffer );
595 
596     TEST_ASSERT_EQUAL( eReleaseBuffer, eResult );
597 }
598 
test_xCheckSizeFields_BufferLengthLess(void)599 void test_xCheckSizeFields_BufferLengthLess( void )
600 {
601     BaseType_t xReturn;
602     size_t uxBufferLength = 0;
603     eFrameProcessingResult_t eResult;
604     IPPacket_t * pxIPPacket;
605     UBaseType_t uxHeaderLength = 0;
606     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
607     IPHeader_t * pxIPHeader;
608 
609     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
610 
611     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
612     pxIPHeader = &( pxIPPacket->xIPHeader );
613 
614     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
615 
616     pxIPHeader->ucVersionHeaderLength = 0x46;
617     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
618     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
619     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
620 
621     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
622 
623     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
624 
625     for( uint32_t i = 0; i < sizeof( IPPacket_t ); i++ )
626     {
627         uxBufferLength = i;
628         xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
629 
630         TEST_ASSERT_EQUAL( pdFAIL, xReturn );
631     }
632 }
633 
test_xCheckSizeFields_HeaderLengthLess(void)634 void test_xCheckSizeFields_HeaderLengthLess( void )
635 {
636     BaseType_t xReturn;
637     size_t uxBufferLength = sizeof( IPPacket_t );
638     eFrameProcessingResult_t eResult;
639     IPPacket_t * pxIPPacket;
640     UBaseType_t uxHeaderLength = 0;
641     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
642     IPHeader_t * pxIPHeader;
643 
644     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
645 
646     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
647     pxIPHeader = &( pxIPPacket->xIPHeader );
648 
649     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
650 
651     /* Value less than 0x45. */
652     pxIPHeader->ucVersionHeaderLength = 0x45 - 2;
653     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
654     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
655     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
656 
657     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
658 
659     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
660 
661     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
662 
663     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
664 }
665 
test_xCheckSizeFields_HeaderLengthMore(void)666 void test_xCheckSizeFields_HeaderLengthMore( void )
667 {
668     BaseType_t xReturn;
669     size_t uxBufferLength = sizeof( IPPacket_t );
670     eFrameProcessingResult_t eResult;
671     IPPacket_t * pxIPPacket;
672     UBaseType_t uxHeaderLength = 0;
673     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
674     IPHeader_t * pxIPHeader;
675 
676     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
677 
678     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
679     pxIPHeader = &( pxIPPacket->xIPHeader );
680 
681     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
682 
683     /* Value more than 4F. */
684     pxIPHeader->ucVersionHeaderLength = 0x4F + 2;
685     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
686     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
687     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
688 
689     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
690 
691     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
692 
693     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
694 
695     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
696 }
697 
test_xCheckSizeFields_HeaderLengthMoreThanTotalLength(void)698 void test_xCheckSizeFields_HeaderLengthMoreThanTotalLength( void )
699 {
700     BaseType_t xReturn;
701     size_t uxBufferLength;
702     eFrameProcessingResult_t eResult;
703     IPPacket_t * pxIPPacket;
704     UBaseType_t uxHeaderLength = 0;
705     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
706     IPHeader_t * pxIPHeader;
707 
708     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
709 
710     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
711     pxIPHeader = &( pxIPPacket->xIPHeader );
712 
713     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
714 
715     /* Value more than 4F. */
716     pxIPHeader->ucVersionHeaderLength = 0x4F;
717     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
718     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
719     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
720 
721     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
722 
723     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
724 
725     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 );
726 
727     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
728 
729     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
730 }
731 
test_xCheckSizeFields_IPPacketLengthMoreThanTotalLength(void)732 void test_xCheckSizeFields_IPPacketLengthMoreThanTotalLength( void )
733 {
734     BaseType_t xReturn;
735     size_t uxBufferLength;
736     eFrameProcessingResult_t eResult;
737     IPPacket_t * pxIPPacket;
738     UBaseType_t uxHeaderLength = 0;
739     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
740     IPHeader_t * pxIPHeader;
741 
742     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
743 
744     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
745     pxIPHeader = &( pxIPPacket->xIPHeader );
746 
747     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
748 
749     /* Value more than 4F. */
750     pxIPHeader->ucVersionHeaderLength = 0x4F;
751     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
752     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
753     pxIPHeader->usLength = FreeRTOS_htons( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( TCPHeader_t ) );
754 
755     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
756 
757     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
758 
759     uxBufferLength = FreeRTOS_ntohs( pxIPHeader->usLength ) - 1;
760 
761     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
762 
763     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
764 }
765 
test_xCheckSizeFields_UDP_IncorrectPacketLen(void)766 void test_xCheckSizeFields_UDP_IncorrectPacketLen( void )
767 {
768     BaseType_t xReturn;
769     size_t uxBufferLength;
770     eFrameProcessingResult_t eResult;
771     IPPacket_t * pxIPPacket;
772     UBaseType_t uxHeaderLength = 0;
773     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
774     IPHeader_t * pxIPHeader;
775 
776     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
777 
778     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
779     pxIPHeader = &( pxIPPacket->xIPHeader );
780 
781     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
782 
783     /* Value more than 4F. */
784     pxIPHeader->ucVersionHeaderLength = 0x4F;
785     pxIPHeader->ucProtocol = ipPROTOCOL_UDP;
786     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
787 
788     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER - 1;
789 
790     pxIPHeader->usLength = FreeRTOS_htons( uxBufferLength - ipSIZE_OF_ETH_HEADER );
791 
792     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
793 
794     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
795 
796     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
797 
798     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
799 }
800 
test_xCheckSizeFields_TCP_IncorrectPacketLen(void)801 void test_xCheckSizeFields_TCP_IncorrectPacketLen( void )
802 {
803     BaseType_t xReturn;
804     size_t uxBufferLength;
805     eFrameProcessingResult_t eResult;
806     IPPacket_t * pxIPPacket;
807     UBaseType_t uxHeaderLength = 0;
808     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
809     IPHeader_t * pxIPHeader;
810 
811     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
812 
813     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
814     pxIPHeader = &( pxIPPacket->xIPHeader );
815 
816     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
817 
818     /* Value more than 4F. */
819     pxIPHeader->ucVersionHeaderLength = 0x4F;
820     pxIPHeader->ucProtocol = ipPROTOCOL_TCP;
821     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
822 
823     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_TCP_HEADER - 1;
824 
825     pxIPHeader->usLength = FreeRTOS_htons( uxBufferLength - ipSIZE_OF_ETH_HEADER );
826 
827     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
828 
829     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
830 
831     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
832 
833     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
834 }
835 
test_xCheckSizeFields_ICMP_IncorrectPacketLen(void)836 void test_xCheckSizeFields_ICMP_IncorrectPacketLen( void )
837 {
838     BaseType_t xReturn;
839     size_t uxBufferLength;
840     eFrameProcessingResult_t eResult;
841     IPPacket_t * pxIPPacket;
842     UBaseType_t uxHeaderLength = 0;
843     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
844     IPHeader_t * pxIPHeader;
845 
846     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
847 
848     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
849     pxIPHeader = &( pxIPPacket->xIPHeader );
850 
851     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
852 
853     /* Value more than 4F. */
854     pxIPHeader->ucVersionHeaderLength = 0x4F;
855     pxIPHeader->ucProtocol = ipPROTOCOL_ICMP;
856     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
857 
858     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMP_HEADER - 1;
859 
860     pxIPHeader->usLength = FreeRTOS_htons( uxBufferLength - ipSIZE_OF_ETH_HEADER );
861 
862     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
863 
864     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
865 
866     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
867 
868     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
869 }
870 
test_xCheckSizeFields_IGMP_IncorrectPacketLen(void)871 void test_xCheckSizeFields_IGMP_IncorrectPacketLen( void )
872 {
873     BaseType_t xReturn;
874     size_t uxBufferLength;
875     eFrameProcessingResult_t eResult;
876     IPPacket_t * pxIPPacket;
877     UBaseType_t uxHeaderLength = 0;
878     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
879     IPHeader_t * pxIPHeader;
880 
881     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
882 
883     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
884     pxIPHeader = &( pxIPPacket->xIPHeader );
885 
886     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
887 
888     /* Value more than 4F. */
889     pxIPHeader->ucVersionHeaderLength = 0x4F;
890     pxIPHeader->ucProtocol = ipPROTOCOL_IGMP;
891     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
892 
893     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMP_HEADER - 1;
894 
895     pxIPHeader->usLength = FreeRTOS_htons( uxBufferLength - ipSIZE_OF_ETH_HEADER );
896 
897     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
898 
899     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
900 
901     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
902 
903     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
904 }
905 
test_xCheckSizeFields_NoProt(void)906 void test_xCheckSizeFields_NoProt( void )
907 {
908     BaseType_t xReturn;
909     size_t uxBufferLength;
910     eFrameProcessingResult_t eResult;
911     IPPacket_t * pxIPPacket;
912     UBaseType_t uxHeaderLength = 0;
913     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
914     IPHeader_t * pxIPHeader;
915 
916     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
917 
918     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
919     pxIPHeader = &( pxIPPacket->xIPHeader );
920 
921     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
922 
923     /* Value more than 4F. */
924     pxIPHeader->ucVersionHeaderLength = 0x4F;
925     pxIPHeader->ucProtocol = 0;
926     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
927 
928     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMP_HEADER - 1;
929 
930     pxIPHeader->usLength = FreeRTOS_htons( uxBufferLength - ipSIZE_OF_ETH_HEADER );
931 
932     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
933 
934     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
935 
936     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
937 
938     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
939 }
940 
test_xCheckSizeFields_UDP_LengthLess(void)941 void test_xCheckSizeFields_UDP_LengthLess( void )
942 {
943     BaseType_t xReturn;
944     size_t uxBufferLength;
945     eFrameProcessingResult_t eResult;
946     IPPacket_t * pxIPPacket;
947     UBaseType_t uxHeaderLength = 0;
948     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
949     IPHeader_t * pxIPHeader;
950     ProtocolPacket_t * pxProtPack;
951 
952     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
953 
954     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
955     pxIPHeader = &( pxIPPacket->xIPHeader );
956 
957     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
958 
959     /* Value more than 4F. */
960     pxIPHeader->ucVersionHeaderLength = 0x4F;
961     pxIPHeader->ucProtocol = ipPROTOCOL_UDP;
962     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
963 
964     uxBufferLength = ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER;
965 
966     pxIPHeader->usLength = FreeRTOS_ntohs( ( ( pxIPHeader->ucVersionHeaderLength & 0x0F ) << 2 ) + sizeof( pxProtPack->xUDPPacket.xUDPHeader ) - 1 );
967 
968     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
969 
970     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
971 
972     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
973 
974     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
975 }
976 
test_xCheckSizeFields_UDP_LengthMore(void)977 void test_xCheckSizeFields_UDP_LengthMore( void )
978 {
979     BaseType_t xReturn;
980     size_t uxBufferLength;
981     eFrameProcessingResult_t eResult;
982     IPPacket_t * pxIPPacket;
983     UBaseType_t uxHeaderLength = 0;
984     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
985     IPHeader_t * pxIPHeader;
986     ProtocolPacket_t * pxProtPack;
987 
988     memset( ucEthBuffer, 0, ipconfigTCP_MSS );
989 
990     pxIPPacket = ( IPPacket_t * ) ucEthBuffer;
991     pxIPHeader = &( pxIPPacket->xIPHeader );
992 
993     *ipLOCAL_IP_ADDRESS_POINTER = 0xFFFFFFFF;
994 
995     /* Value more than 4F. */
996     pxIPHeader->ucVersionHeaderLength = 0x4F;
997     pxIPHeader->ucProtocol = ipPROTOCOL_UDP;
998     pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;
999 
1000     uxBufferLength = ipconfigNETWORK_MTU + 20;
1001 
1002     pxIPHeader->usLength = FreeRTOS_ntohs( ipconfigNETWORK_MTU + 1 );
1003 
1004     memcpy( pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes, xBroadcastMACAddress.ucBytes, sizeof( MACAddress_t ) );
1005 
1006     pxIPHeader->ulSourceIPAddress = 0xC0C00101;
1007 
1008     xReturn = xCheckSizeFields( ucEthBuffer, uxBufferLength );
1009 
1010     TEST_ASSERT_EQUAL( pdFAIL, xReturn );
1011 }
1012 
test_vReturnEthernetFrame_DuplicationFailed(void)1013 void test_vReturnEthernetFrame_DuplicationFailed( void )
1014 {
1015     NetworkBufferDescriptor_t xNetworkBuffer;
1016     BaseType_t xReleaseAfterSend = pdFALSE;
1017 
1018     xNetworkBuffer.xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
1019 
1020     pxDuplicateNetworkBufferWithDescriptor_ExpectAndReturn( &xNetworkBuffer, xNetworkBuffer.xDataLength, NULL );
1021     vReturnEthernetFrame( &xNetworkBuffer, xReleaseAfterSend );
1022 }
1023 
test_vReturnEthernetFrame_DuplicationSuccess(void)1024 void test_vReturnEthernetFrame_DuplicationSuccess( void )
1025 {
1026     NetworkBufferDescriptor_t xDuplicateNetworkBuffer;
1027     BaseType_t xReleaseAfterSend = pdFALSE;
1028     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1029     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
1030     EthernetHeader_t * pxEthernetHeader;
1031 
1032     pxNetworkBuffer = &xNetworkBuffer;
1033     memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1034     memset( &xDuplicateNetworkBuffer, 0, sizeof( xDuplicateNetworkBuffer ) );
1035 
1036     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
1037     memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
1038 
1039     xDuplicateNetworkBuffer.pucEthernetBuffer = ucEthBuffer;
1040 
1041     pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1042     memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
1043     memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
1044 
1045     pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
1046 
1047     pxDuplicateNetworkBufferWithDescriptor_ExpectAndReturn( &xNetworkBuffer, xNetworkBuffer.xDataLength, &xDuplicateNetworkBuffer );
1048 
1049     xNetworkInterfaceOutput_ExpectAndReturn( &xDuplicateNetworkBuffer, pdTRUE, pdTRUE );
1050 
1051     vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
1052 
1053     TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
1054     TEST_ASSERT_EQUAL( xNetworkBuffer.xDataLength, xDuplicateNetworkBuffer.xDataLength );
1055     TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
1056     TEST_ASSERT_EQUAL_MEMORY( ipLOCAL_MAC_ADDRESS, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
1057 }
1058 
test_vReturnEthernetFrame(void)1059 void test_vReturnEthernetFrame( void )
1060 {
1061     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1062     BaseType_t xReleaseAfterSend = pdTRUE;
1063     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
1064     EthernetHeader_t * pxEthernetHeader;
1065 
1066     pxNetworkBuffer = &xNetworkBuffer;
1067     memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1068 
1069     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
1070     memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
1071 
1072     pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1073     memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
1074     memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
1075 
1076     pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10;
1077 
1078     xNetworkInterfaceOutput_ExpectAndReturn( pxNetworkBuffer, xReleaseAfterSend, pdTRUE );
1079 
1080     vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
1081 
1082     TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
1083     TEST_ASSERT_EACH_EQUAL_UINT8( 0, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
1084     TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
1085     TEST_ASSERT_EQUAL_MEMORY( ipLOCAL_MAC_ADDRESS, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
1086 }
1087 
test_vReturnEthernetFrame_DataLenMoreThanRequired(void)1088 void test_vReturnEthernetFrame_DataLenMoreThanRequired( void )
1089 {
1090     NetworkBufferDescriptor_t * pxNetworkBuffer, xNetworkBuffer;
1091     BaseType_t xReleaseAfterSend = pdTRUE;
1092     uint8_t ucEthBuffer[ ipconfigTCP_MSS ];
1093     EthernetHeader_t * pxEthernetHeader;
1094 
1095     pxNetworkBuffer = &xNetworkBuffer;
1096     memset( pxNetworkBuffer, 0, sizeof( NetworkBufferDescriptor_t ) );
1097 
1098     pxNetworkBuffer->pucEthernetBuffer = ucEthBuffer;
1099     memset( ucEthBuffer, 0xAA, ipconfigTCP_MSS );
1100 
1101     pxEthernetHeader = ( EthernetHeader_t * ) pxNetworkBuffer->pucEthernetBuffer;
1102     memset( &pxEthernetHeader->xDestinationAddress, 0x11, sizeof( pxEthernetHeader->xDestinationAddress ) );
1103     memset( &pxEthernetHeader->xSourceAddress, 0x22, sizeof( pxEthernetHeader->xSourceAddress ) );
1104 
1105     pxNetworkBuffer->xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES;
1106 
1107     xNetworkInterfaceOutput_ExpectAndReturn( pxNetworkBuffer, xReleaseAfterSend, pdTRUE );
1108 
1109     vReturnEthernetFrame( pxNetworkBuffer, xReleaseAfterSend );
1110 
1111     TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
1112     TEST_ASSERT_EACH_EQUAL_UINT8( 0xAA, &ucEthBuffer[ ipconfigETHERNET_MINIMUM_PACKET_BYTES - 10 ], 10 );
1113     TEST_ASSERT_EACH_EQUAL_UINT8( 0x22, &pxEthernetHeader->xDestinationAddress, sizeof( pxEthernetHeader->xDestinationAddress ) );
1114     TEST_ASSERT_EQUAL_MEMORY( ipLOCAL_MAC_ADDRESS, &pxEthernetHeader->xSourceAddress, sizeof( pxEthernetHeader->xSourceAddress ) );
1115 }
1116 
test_uxGetMinimumIPQueueSpace(void)1117 void test_uxGetMinimumIPQueueSpace( void )
1118 {
1119     UBaseType_t uxReturn;
1120 
1121     uxQueueMinimumSpace = 10;
1122 
1123     uxReturn = uxGetMinimumIPQueueSpace();
1124 
1125     TEST_ASSERT_EQUAL( 10, uxReturn );
1126 }
1127