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_list_macros.h"
43 #include "mock_queue.h"
44 #include "mock_event_groups.h"
45 
46 #include "mock_FreeRTOS_IP.h"
47 #include "mock_FreeRTOS_IP_Utils.h"
48 #include "mock_FreeRTOS_Sockets.h"
49 #include "mock_FreeRTOS_IP_Private.h"
50 #include "mock_FreeRTOS_ARP.h"
51 #include "mock_NetworkBufferManagement.h"
52 #include "mock_NetworkInterface.h"
53 #include "mock_FreeRTOS_DHCP.h"
54 #include "mock_FreeRTOS_DNS.h"
55 
56 #include "FreeRTOS_UDP_IP.h"
57 
58 #include "FreeRTOS_UDP_IP_stubs.c"
59 #include "catch_assert.h"
60 
61 #include "FreeRTOSIPConfig.h"
62 
63 static uint32_t ulFunctionCalled = 0;
64 static BaseType_t xFunctionReturn;
xLocalHandler(Socket_t pxSocket,void * pvData,size_t xLength,const struct freertos_sockaddr * pxFrom,const struct freertos_sockaddr * pxTo)65 static BaseType_t xLocalHandler( Socket_t pxSocket,
66                                  void * pvData,
67                                  size_t xLength,
68                                  const struct freertos_sockaddr * pxFrom,
69                                  const struct freertos_sockaddr * pxTo )
70 {
71     TEST_ASSERT( pxSocket != NULL );
72     TEST_ASSERT( pvData != NULL );
73     TEST_ASSERT( pxFrom != NULL );
74     TEST_ASSERT( pxTo != NULL );
75 
76     ulFunctionCalled++;
77 
78     return xFunctionReturn;
79 }
80 
81 /*
82  * @brief Test what happens if the packet cannot be sent due to
83  *        the address not being resolved.
84  */
test_vProcessGeneratedUDPPacket_CantSendPacket(void)85 void test_vProcessGeneratedUDPPacket_CantSendPacket( void )
86 {
87     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
88     NetworkBufferDescriptor_t xLocalNetworkBuffer;
89 
90     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
91 
92     /* Cleanup the ethernet buffer. */
93     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
94 
95     /* Address not resolved. */
96     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eCantSendPacket );
97 
98     /* Expect the buffer to be released in this case. */
99     vReleaseNetworkBufferAndDescriptor_Expect( &xLocalNetworkBuffer );
100 
101     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
102 
103     /* Nothing to assert on since there was no modification. */
104 }
105 
106 /*
107  * @brief Test what if there is a cache miss and the packet is smaller
108  *        than the minimum number of bytes required in the packet.
109  */
test_vProcessGeneratedUDPPacket_CacheMiss_PacketSmaller(void)110 void test_vProcessGeneratedUDPPacket_CacheMiss_PacketSmaller( void )
111 {
112     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
113     NetworkBufferDescriptor_t xLocalNetworkBuffer;
114     UDPPacket_t * pxUDPPacket;
115     uint32_t ulIPAddr = 0x1234ABCD, ulLocalIPAddress = 0xAABBCCDD;
116 
117     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
118     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
119 
120     xLocalNetworkBuffer.ulIPAddress = ulIPAddr;
121 
122     /* Cleanup the ethernet buffer. */
123     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
124 
125     /* Map the UDP packet onto the start of the frame. */
126     pxUDPPacket = ( UDPPacket_t * ) pucLocalEthernetBuffer;
127 
128     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
129     eARPGetCacheEntry_ReturnMemThruPtr_pulIPAddress( &ulLocalIPAddress, sizeof( ulLocalIPAddress ) );
130 
131     vARPRefreshCacheEntry_Expect( NULL, ulLocalIPAddress );
132     vARPGenerateRequestPacket_Expect( &xLocalNetworkBuffer );
133 
134     xNetworkInterfaceOutput_ExpectAndReturn( &xLocalNetworkBuffer, pdTRUE, pdTRUE );
135 
136     /* Make sure that the packet is smaller than minimum packet length. */
137     xLocalNetworkBuffer.xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES - 2;
138 
139     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
140 
141     TEST_ASSERT_EQUAL( ulLocalIPAddress, xLocalNetworkBuffer.ulIPAddress );
142 }
143 
144 /*
145  * @brief Test when there is a cache miss, but the packet is of
146  *        appropriate size.
147  */
test_vProcessGeneratedUDPPacket_CacheMiss_PacketNotSmaller(void)148 void test_vProcessGeneratedUDPPacket_CacheMiss_PacketNotSmaller( void )
149 {
150     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
151     NetworkBufferDescriptor_t xLocalNetworkBuffer;
152     UDPPacket_t * pxUDPPacket;
153     uint32_t ulIPAddr = 0x1234ABCD, ulLocalIPAddress = 0xAABBCCDD;
154 
155     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
156     xLocalNetworkBuffer.xDataLength = sizeof( UDPPacket_t );
157 
158     xLocalNetworkBuffer.ulIPAddress = ulIPAddr;
159 
160     /* Cleanup the ethernet buffer. */
161     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
162 
163     /* Map the UDP packet onto the start of the frame. */
164     pxUDPPacket = ( UDPPacket_t * ) pucLocalEthernetBuffer;
165 
166     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheMiss );
167     eARPGetCacheEntry_ReturnMemThruPtr_pulIPAddress( &ulLocalIPAddress, sizeof( ulLocalIPAddress ) );
168 
169     vARPRefreshCacheEntry_Expect( NULL, ulLocalIPAddress );
170     vARPGenerateRequestPacket_Expect( &xLocalNetworkBuffer );
171 
172     xNetworkInterfaceOutput_ExpectAndReturn( &xLocalNetworkBuffer, pdTRUE, pdTRUE );
173 
174     xLocalNetworkBuffer.xDataLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES + 2;
175 
176     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
177 
178     TEST_ASSERT_EQUAL( ulLocalIPAddress, xLocalNetworkBuffer.ulIPAddress );
179 }
180 
181 /*
182  * @brief Test when ARP cache returned an unknown value.
183  */
test_vProcessGeneratedUDPPacket_UnknownARPReturn(void)184 void test_vProcessGeneratedUDPPacket_UnknownARPReturn( void )
185 {
186     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
187     NetworkBufferDescriptor_t xLocalNetworkBuffer;
188     UDPPacket_t * pxUDPPacket;
189     uint32_t ulIPAddr = 0x1234ABCD;
190 
191     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
192     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
193 
194     xLocalNetworkBuffer.ulIPAddress = ulIPAddr;
195     xLocalNetworkBuffer.usPort = ipPACKET_CONTAINS_ICMP_DATA;
196 
197     /* Cleanup the ethernet buffer. */
198     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
199 
200     /* Map the UDP packet onto the start of the frame. */
201     pxUDPPacket = ( UDPPacket_t * ) pucLocalEthernetBuffer;
202 
203     /* Return an unknown value. */
204     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eCantSendPacket + 1 );
205 
206     vReleaseNetworkBufferAndDescriptor_Expect( &xLocalNetworkBuffer );
207 
208     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
209 
210     /* Nothing to assert on since there was no modification. */
211 }
212 
213 /*
214  * @brief Test when there is a cache hit but the packet does not have
215  *        ICMP data.
216  */
test_vProcessGeneratedUDPPacket_CacheHit_NoICMP(void)217 void test_vProcessGeneratedUDPPacket_CacheHit_NoICMP( void )
218 {
219     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
220     NetworkBufferDescriptor_t xLocalNetworkBuffer;
221     UDPPacket_t * pxUDPPacket;
222     uint32_t ulIPAddr = 0x1234ABCD;
223 
224     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
225 
226     xLocalNetworkBuffer.ulIPAddress = ulIPAddr;
227     /* Not ICMP data. */
228     xLocalNetworkBuffer.usPort = ipPACKET_CONTAINS_ICMP_DATA + 1;
229     xLocalNetworkBuffer.usBoundPort = 0x1023;
230     xLocalNetworkBuffer.xDataLength = sizeof( UDPPacket_t );
231 
232     /* Cleanup the ethernet buffer. */
233     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
234 
235     /* Map the UDP packet onto the start of the frame. */
236     pxUDPPacket = ( UDPPacket_t * ) pucLocalEthernetBuffer;
237 
238     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
239 
240     usGenerateChecksum_ExpectAndReturn( 0U, NULL, ipSIZE_OF_IPv4_HEADER, 0 );
241     usGenerateChecksum_IgnoreArg_pucNextData();
242 
243     xNetworkInterfaceOutput_ExpectAndReturn( &xLocalNetworkBuffer, pdTRUE, pdTRUE );
244 
245     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
246 
247     TEST_ASSERT_EQUAL( xLocalNetworkBuffer.usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
248     TEST_ASSERT_EQUAL( xLocalNetworkBuffer.usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
249     TEST_ASSERT_EQUAL( 0, pxUDPPacket->xUDPHeader.usChecksum );
250 }
251 
252 /*
253  * @brief Test cache hit when the packet is ICMP packet and has an LLMNR
254  *        IP address with a UDP socket option.
255  */
test_vProcessGeneratedUDPPacket_CacheHit_ICMPPacket_LLMNR_UDPChkSumOption(void)256 void test_vProcessGeneratedUDPPacket_CacheHit_ICMPPacket_LLMNR_UDPChkSumOption( void )
257 {
258     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
259     NetworkBufferDescriptor_t xLocalNetworkBuffer;
260     UDPPacket_t * pxUDPPacket;
261     uint32_t ulIPAddr = ipLLMNR_IP_ADDR;
262     uint8_t ucSocketOptions = FREERTOS_SO_UDPCKSUM_OUT;
263 
264     /* Cleanup the ethernet buffer. */
265     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
266 
267     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
268     xLocalNetworkBuffer.pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] = ucSocketOptions;
269 
270     xLocalNetworkBuffer.ulIPAddress = ulIPAddr;
271     xLocalNetworkBuffer.usPort = ipPACKET_CONTAINS_ICMP_DATA;
272     xLocalNetworkBuffer.usBoundPort = 0x1023;
273     xLocalNetworkBuffer.xDataLength = sizeof( UDPPacket_t );
274 
275     /* Map the UDP packet onto the start of the frame. */
276     pxUDPPacket = ( UDPPacket_t * ) pucLocalEthernetBuffer;
277 
278     eARPGetCacheEntry_ExpectAnyArgsAndReturn( eARPCacheHit );
279 
280     usGenerateChecksum_ExpectAndReturn( 0U, NULL, ipSIZE_OF_IPv4_HEADER, 0 );
281     usGenerateChecksum_IgnoreArg_pucNextData();
282 
283     usGenerateProtocolChecksum_ExpectAndReturn( pucLocalEthernetBuffer, xLocalNetworkBuffer.xDataLength, pdTRUE, 0 );
284 
285     xNetworkInterfaceOutput_ExpectAndReturn( &xLocalNetworkBuffer, pdTRUE, pdTRUE );
286 
287     vProcessGeneratedUDPPacket( &xLocalNetworkBuffer );
288 
289     TEST_ASSERT_EQUAL( xLocalNetworkBuffer.usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
290     TEST_ASSERT_EQUAL( ipPROTOCOL_ICMP, pxUDPPacket->xIPHeader.ucProtocol );
291     TEST_ASSERT_EQUAL( 0, pxUDPPacket->xUDPHeader.usChecksum );
292 }
293 
294 /*
295  * @brief Test the asserts in the function.
296  */
test_xProcessReceivedUDPPacket_catchAsserts(void)297 void test_xProcessReceivedUDPPacket_catchAsserts( void )
298 {
299     NetworkBufferDescriptor_t xLocalNetworkBuffer;
300     BaseType_t xIsWaitingARPResolution = pdFALSE;
301 
302     catch_assert( xProcessReceivedUDPPacket( NULL, 0, &xIsWaitingARPResolution ) );
303 
304     xLocalNetworkBuffer.pucEthernetBuffer = NULL;
305     catch_assert( xProcessReceivedUDPPacket( &xLocalNetworkBuffer, 0, &xIsWaitingARPResolution ) );
306 }
307 
308 /*
309  * @brief Test when there is no listening socket and the packet is not
310  *        for this node.
311  */
test_xProcessReceivedUDPPacket_NoListeningSocket_NotForThisNode(void)312 void test_xProcessReceivedUDPPacket_NoListeningSocket_NotForThisNode( void )
313 {
314     NetworkBufferDescriptor_t xLocalNetworkBuffer;
315     uint16_t usPort = 0;
316     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
317     BaseType_t xResult;
318     BaseType_t xIsWaitingARPResolution = pdFALSE;
319 
320     /* Cleanup the ethernet buffer. */
321     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
322 
323     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
324 
325     /* No socket found. */
326     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
327 
328     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
329     TEST_ASSERT_EQUAL( pdFAIL, xResult );
330     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
331 }
332 
333 /*
334  * @brief Test when there is no listening socket but the packet seems like
335  *        a late DNS response.
336  */
test_xProcessReceivedUDPPacket_NoListeningSocket_DelayedDNSResponse(void)337 void test_xProcessReceivedUDPPacket_NoListeningSocket_DelayedDNSResponse( void )
338 {
339     NetworkBufferDescriptor_t xLocalNetworkBuffer;
340     uint16_t usPort = 0;
341     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
342     BaseType_t xResult;
343     BaseType_t xIsWaitingARPResolution = pdFALSE;
344     UDPPacket_t * pxUDPPacket;
345 
346     /* Cleanup the ethernet buffer. */
347     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
348 
349     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
350 
351     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
352     /* Packet coming from a DNS port. */
353     pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( ipDNS_PORT );
354 
355     /* No socket found. */
356     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
357 
358     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
359     ulDNSHandlePacket_ExpectAndReturn( &xLocalNetworkBuffer, pdPASS );
360 
361     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
362     TEST_ASSERT_EQUAL( pdPASS, xResult );
363     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
364 }
365 
366 /*
367  * @brief Test when there is no listening socket but the packet seems like an
368  *        LLMNR response.
369  */
test_xProcessReceivedUDPPacket_NoListeningSocket_LLMNRResponse(void)370 void test_xProcessReceivedUDPPacket_NoListeningSocket_LLMNRResponse( void )
371 {
372     NetworkBufferDescriptor_t xLocalNetworkBuffer;
373     uint16_t usPort = FreeRTOS_ntohs( ipLLMNR_PORT );
374     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
375     BaseType_t xResult;
376     BaseType_t xIsWaitingARPResolution = pdFALSE;
377     UDPPacket_t * pxUDPPacket;
378 
379     /* Cleanup the ethernet buffer. */
380     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
381 
382     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
383 
384     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
385     /* LLMNR port. */
386     pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_ntohs( ipLLMNR_PORT );
387 
388     /* No socket found. */
389     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
390 
391     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
392     ulDNSHandlePacket_ExpectAndReturn( &xLocalNetworkBuffer, pdPASS );
393 
394     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
395     TEST_ASSERT_EQUAL( pdPASS, xResult );
396     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
397 }
398 
399 /*
400  * @brief Test when there is no listening socket but the packet is for LLMNR and the
401  *        source and destination sockets are mismatching.
402  */
test_xProcessReceivedUDPPacket_NoListeningSocket_LLMNRResponse_MismatchingPorts(void)403 void test_xProcessReceivedUDPPacket_NoListeningSocket_LLMNRResponse_MismatchingPorts( void )
404 {
405     NetworkBufferDescriptor_t xLocalNetworkBuffer;
406     uint16_t usPort = FreeRTOS_ntohs( ipLLMNR_PORT + 1 );
407     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
408     BaseType_t xResult;
409     BaseType_t xIsWaitingARPResolution = pdFALSE;
410     UDPPacket_t * pxUDPPacket;
411 
412     /* Cleanup the ethernet buffer. */
413     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
414 
415     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
416 
417     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
418     pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_ntohs( ipLLMNR_PORT );
419 
420     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
421 
422     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
423     ulDNSHandlePacket_ExpectAndReturn( &xLocalNetworkBuffer, pdPASS );
424 
425     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
426     TEST_ASSERT_EQUAL( pdPASS, xResult );
427     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
428 }
429 
430 /*
431  * @brief Test when there is no listening socket and this is an NBNS response.
432  */
test_xProcessReceivedUDPPacket_NoListeningSocket_NBNSResponse(void)433 void test_xProcessReceivedUDPPacket_NoListeningSocket_NBNSResponse( void )
434 {
435     NetworkBufferDescriptor_t xLocalNetworkBuffer;
436     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
437     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
438     BaseType_t xResult;
439     BaseType_t xIsWaitingARPResolution = pdFALSE;
440     UDPPacket_t * pxUDPPacket;
441 
442     /* Cleanup the ethernet buffer. */
443     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
444 
445     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
446 
447     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
448     pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_ntohs( ipNBNS_PORT );
449 
450     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
451 
452     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
453     ulNBNSHandlePacket_ExpectAndReturn( &xLocalNetworkBuffer, pdPASS );
454 
455     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
456     TEST_ASSERT_EQUAL( pdPASS, xResult );
457     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
458 }
459 
460 /*
461  * @brief Test when there is no listening socket and this is an NBNS packet but the source
462  *        and destination ports mismatch.
463  */
test_xProcessReceivedUDPPacket_NoListeningSocket_NBNSResponse_MismatchingPorts(void)464 void test_xProcessReceivedUDPPacket_NoListeningSocket_NBNSResponse_MismatchingPorts( void )
465 {
466     NetworkBufferDescriptor_t xLocalNetworkBuffer;
467     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT + 1 );
468     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
469     BaseType_t xResult;
470     BaseType_t xIsWaitingARPResolution = pdFALSE;
471     UDPPacket_t * pxUDPPacket;
472 
473     /* Cleanup the ethernet buffer. */
474     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
475 
476     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
477 
478     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
479     pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_ntohs( ipNBNS_PORT );
480 
481     pxUDPSocketLookup_ExpectAndReturn( usPort, NULL );
482 
483     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
484     ulNBNSHandlePacket_ExpectAndReturn( &xLocalNetworkBuffer, pdPASS );
485 
486     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
487     TEST_ASSERT_EQUAL( pdPASS, xResult );
488     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
489 }
490 
491 /*
492  * @brief Test when a matching socket is found but there is no handler listed.
493  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_BufferFull(void)494 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_BufferFull( void )
495 {
496     NetworkBufferDescriptor_t xLocalNetworkBuffer;
497     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
498     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
499     BaseType_t xResult;
500     BaseType_t xIsWaitingARPResolution = pdFALSE;
501     FreeRTOS_Socket_t xLocalSocket;
502     UDPPacket_t * pxUDPPacket;
503 
504     /* Cleanup. */
505     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
506     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
507 
508     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
509 
510     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
511     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
512     xLocalNetworkBuffer.xDataLength = sizeof( UDPPacket_t );
513 
514     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
515 
516     /* No socket handler listed for UDP packets. */
517     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
518 
519     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
520 
521     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
522     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
523     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 1 );
524 
525     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
526     TEST_ASSERT_EQUAL( pdFAIL, xResult );
527     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
528 }
529 
530 /*
531  * @brief Test when a matching socket is found but there is no handler listed.
532  *        Also the packet comes in when DHCP process is going on.
533  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_BufferFull1(void)534 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_BufferFull1( void )
535 {
536     NetworkBufferDescriptor_t xLocalNetworkBuffer;
537     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
538     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
539     BaseType_t xResult;
540     BaseType_t xIsWaitingARPResolution = pdFALSE;
541     FreeRTOS_Socket_t xLocalSocket;
542     UDPPacket_t * pxUDPPacket;
543 
544     /* Cleanup. */
545     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
546     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
547 
548     /* DHCP process is going on. IP address is zero. */
549     *ipLOCAL_IP_ADDRESS_POINTER = 0;
550 
551     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
552     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
553     xLocalNetworkBuffer.xDataLength = sizeof( UDPPacket_t );
554 
555     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
556 
557     /* No socket handler listed for UDP packets. */
558     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
559 
560     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
561 
562     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 1 );
563 
564     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
565     TEST_ASSERT_EQUAL( pdFAIL, xResult );
566     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
567 }
568 
569 /*
570  * @brief Test when a matching socket is found but there is no handler, event groups,
571  *        socket set and user semaphore added to the socket.
572  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_NoEventGroupSocketSetUSemaphore(void)573 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_NoEventGroupSocketSetUSemaphore( void )
574 {
575     NetworkBufferDescriptor_t xLocalNetworkBuffer;
576     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
577     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
578     BaseType_t xResult;
579     BaseType_t xIsWaitingARPResolution = pdFALSE;
580     FreeRTOS_Socket_t xLocalSocket;
581     UDPPacket_t * pxUDPPacket;
582 
583     /* Cleanup. */
584     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
585     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
586 
587     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
588 
589     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
590     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
591 
592     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
593 
594     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
595     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
596     xLocalSocket.u.xUDP.uxMaxPackets = 1;
597     xLocalSocket.xEventGroup = NULL;
598     xLocalSocket.pxSocketSet = NULL;
599     xLocalSocket.pxUserSemaphore = NULL;
600 
601     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
602 
603     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
604     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
605     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 0 );
606 
607     vTaskSuspendAll_Expect();
608     vListInsertEnd_Expect( &( xLocalSocket.u.xUDP.xWaitingPacketsList ), &( xLocalNetworkBuffer.xBufferListItem ) );
609     xTaskResumeAll_ExpectAndReturn( pdPASS );
610 
611     xIsDHCPSocket_ExpectAndReturn( &xLocalSocket, 0 );
612 
613     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
614     TEST_ASSERT_EQUAL( pdPASS, xResult );
615     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
616 }
617 
618 /*
619  * @brief Test when a matching socket is found but there is no handler listed but there
620  *        is a user semaphore, event group.
621  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphore(void)622 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphore( void )
623 {
624     NetworkBufferDescriptor_t xLocalNetworkBuffer;
625     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
626     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
627     BaseType_t xResult;
628     BaseType_t xIsWaitingARPResolution = pdFALSE;
629     FreeRTOS_Socket_t xLocalSocket;
630     UDPPacket_t * pxUDPPacket;
631 
632     /* Cleanup. */
633     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
634     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
635 
636     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
637 
638     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
639     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
640 
641     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
642 
643     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
644     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
645     xLocalSocket.u.xUDP.uxMaxPackets = 1;
646     xLocalSocket.xEventGroup = ( void * ) 1;
647     xLocalSocket.pxSocketSet = NULL;
648     xLocalSocket.pxUserSemaphore = ( void * ) 1;
649 
650     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
651 
652     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
653     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
654     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 0 );
655 
656     vTaskSuspendAll_Expect();
657     vListInsertEnd_Expect( &( xLocalSocket.u.xUDP.xWaitingPacketsList ), &( xLocalNetworkBuffer.xBufferListItem ) );
658     xTaskResumeAll_ExpectAndReturn( pdPASS );
659 
660     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.xEventGroup, ( EventBits_t ) eSOCKET_RECEIVE, pdPASS );
661     xQueueGenericSend_ExpectAndReturn( xLocalSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
662 
663     xIsDHCPSocket_ExpectAndReturn( &xLocalSocket, 1 );
664     xSendDHCPEvent_ExpectAndReturn( pdPASS );
665 
666     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
667     TEST_ASSERT_EQUAL( pdPASS, xResult );
668     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
669 }
670 
671 /*
672  * @brief Test when a matching socket is found but there is no handler listed but there
673  *        is a user semaphore and event group but the select bits are invalid.
674  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphoreSocketSet_InvalidSelectBits(void)675 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphoreSocketSet_InvalidSelectBits( void )
676 {
677     NetworkBufferDescriptor_t xLocalNetworkBuffer;
678     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
679     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
680     BaseType_t xResult;
681     BaseType_t xIsWaitingARPResolution = pdFALSE;
682     FreeRTOS_Socket_t xLocalSocket;
683     UDPPacket_t * pxUDPPacket;
684 
685     /* Cleanup. */
686     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
687     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
688 
689     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
690 
691     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
692     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
693 
694     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
695 
696     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
697     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
698     xLocalSocket.u.xUDP.uxMaxPackets = 1;
699     xLocalSocket.xEventGroup = ( void * ) 1;
700     xLocalSocket.pxSocketSet = ( void * ) 1;
701     xLocalSocket.pxUserSemaphore = ( void * ) 1;
702 
703     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
704 
705     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
706     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
707     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 0 );
708 
709     vTaskSuspendAll_Expect();
710     vListInsertEnd_Expect( &( xLocalSocket.u.xUDP.xWaitingPacketsList ), &( xLocalNetworkBuffer.xBufferListItem ) );
711     xTaskResumeAll_ExpectAndReturn( pdPASS );
712 
713     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.xEventGroup, ( EventBits_t ) eSOCKET_RECEIVE, pdPASS );
714     xQueueGenericSend_ExpectAndReturn( xLocalSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
715 
716     xIsDHCPSocket_ExpectAndReturn( &xLocalSocket, 1 );
717     xSendDHCPEvent_ExpectAndReturn( pdPASS );
718 
719     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
720     TEST_ASSERT_EQUAL( pdPASS, xResult );
721     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
722 }
723 
724 /*
725  * @brief Test when a matching socket is found but there is no handler listed but there
726  *        is a user semaphore and event group and the select bits are valid.
727  */
test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphoreSocketSet_ValidSelectBits(void)728 void test_xProcessReceivedUDPPacket_SocketFound_NoHandler_ValidEventGroupUSemaphoreSocketSet_ValidSelectBits( void )
729 {
730     NetworkBufferDescriptor_t xLocalNetworkBuffer;
731     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
732     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
733     BaseType_t xResult;
734     FreeRTOS_Socket_t xLocalSocket;
735     UDPPacket_t * pxUDPPacket;
736     BaseType_t xIsWaitingARPResolution = pdFALSE;
737     SocketSelect_t xLocalSocketSet;
738 
739     /* Cleanup. */
740     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
741     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
742 
743     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
744 
745     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
746     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
747 
748     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
749 
750     xLocalSocket.u.xUDP.pxHandleReceive = NULL;
751     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
752     xLocalSocket.u.xUDP.uxMaxPackets = 1;
753     xLocalSocket.xEventGroup = ( void * ) 1;
754     xLocalSocket.pxSocketSet = &xLocalSocketSet;
755     xLocalSocket.pxUserSemaphore = ( void * ) 1;
756 
757     /* Put in valid bits. */
758     xLocalSocket.xSelectBits = eSELECT_READ;
759 
760     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
761 
762     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
763     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
764     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 0 );
765 
766     vTaskSuspendAll_Expect();
767     vListInsertEnd_Expect( &( xLocalSocket.u.xUDP.xWaitingPacketsList ), &( xLocalNetworkBuffer.xBufferListItem ) );
768     xTaskResumeAll_ExpectAndReturn( pdPASS );
769 
770     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.xEventGroup, ( EventBits_t ) eSOCKET_RECEIVE, pdPASS );
771     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
772     xQueueGenericSend_ExpectAndReturn( xLocalSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
773 
774     xIsDHCPSocket_ExpectAndReturn( &xLocalSocket, 1 );
775     xSendDHCPEvent_ExpectAndReturn( pdPASS );
776 
777     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
778     TEST_ASSERT_EQUAL( pdPASS, xResult );
779     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
780 }
781 
782 /*
783  * @brief Test when a matching socket is found and there is a handler listed but it returns a 0.
784  *        Also, there is a user semaphore, socket set and event group and the select bits are valid.
785  */
test_xProcessReceivedUDPPacket_SocketFound_HandlerFoundReturnZero_ValidEventGroupUSemaphoreSocketSet_ValidSelectBits(void)786 void test_xProcessReceivedUDPPacket_SocketFound_HandlerFoundReturnZero_ValidEventGroupUSemaphoreSocketSet_ValidSelectBits( void )
787 {
788     NetworkBufferDescriptor_t xLocalNetworkBuffer;
789     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
790     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
791     BaseType_t xResult;
792     BaseType_t xIsWaitingARPResolution = pdFALSE;
793     FreeRTOS_Socket_t xLocalSocket;
794     UDPPacket_t * pxUDPPacket;
795     SocketSelect_t xLocalSocketSet;
796 
797     /* Cleanup. */
798     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
799     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
800     ulFunctionCalled = 0;
801 
802     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
803 
804     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
805     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
806 
807     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
808 
809     xLocalSocket.u.xUDP.pxHandleReceive = xLocalHandler;
810     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
811     xLocalSocket.u.xUDP.uxMaxPackets = 1;
812     xLocalSocket.xEventGroup = ( void * ) 1;
813     xLocalSocket.pxSocketSet = &xLocalSocketSet;
814     xLocalSocket.pxUserSemaphore = ( void * ) 1;
815     xLocalSocket.xSelectBits = eSELECT_READ;
816 
817     xFunctionReturn = 0;
818 
819     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
820 
821     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
822     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
823     listCURRENT_LIST_LENGTH_ExpectAnyArgsAndReturn( 0 );
824 
825     vTaskSuspendAll_Expect();
826     vListInsertEnd_Expect( &( xLocalSocket.u.xUDP.xWaitingPacketsList ), &( xLocalNetworkBuffer.xBufferListItem ) );
827     xTaskResumeAll_ExpectAndReturn( pdPASS );
828 
829     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.xEventGroup, ( EventBits_t ) eSOCKET_RECEIVE, pdPASS );
830     xEventGroupSetBits_ExpectAndReturn( xLocalSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
831     xQueueGenericSend_ExpectAndReturn( xLocalSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
832 
833     xIsDHCPSocket_ExpectAndReturn( &xLocalSocket, 1 );
834     xSendDHCPEvent_ExpectAndReturn( pdPASS );
835 
836     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
837     TEST_ASSERT_EQUAL( pdPASS, xResult );
838     TEST_ASSERT_EQUAL( 1, ulFunctionCalled );
839     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
840 }
841 
842 /*
843  * @brief Test when a matching socket is found but the IP-address requires ARP
844  * resolution.
845  */
test_xProcessReceivedUDPPacket_SocketFound_ARPResolutionRequired(void)846 void test_xProcessReceivedUDPPacket_SocketFound_ARPResolutionRequired( void )
847 {
848     NetworkBufferDescriptor_t xLocalNetworkBuffer;
849     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
850     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
851     BaseType_t xResult;
852     BaseType_t xIsWaitingARPResolution = pdFALSE;
853     FreeRTOS_Socket_t xLocalSocket;
854     UDPPacket_t * pxUDPPacket;
855     SocketSelect_t xLocalSocketSet;
856 
857     /* Cleanup. */
858     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
859     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
860     ulFunctionCalled = 0;
861 
862     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
863 
864     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
865     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
866 
867     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
868 
869     xLocalSocket.u.xUDP.pxHandleReceive = xLocalHandler;
870     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
871     xLocalSocket.u.xUDP.uxMaxPackets = 1;
872     xLocalSocket.xEventGroup = ( void * ) 1;
873     xLocalSocket.pxSocketSet = &xLocalSocketSet;
874     xLocalSocket.pxUserSemaphore = ( void * ) 1;
875     xLocalSocket.xSelectBits = eSELECT_READ;
876 
877     xFunctionReturn = 0;
878 
879     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
880 
881     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdTRUE );
882 
883     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
884     TEST_ASSERT_EQUAL( pdFAIL, xResult );
885     TEST_ASSERT_EQUAL( 0, ulFunctionCalled );
886     TEST_ASSERT_EQUAL( pdTRUE, xIsWaitingARPResolution );
887 }
888 
889 /*
890  * @brief Test when a matching socket is found and there is a handler listed
891  *        which returns a non zero value.
892  */
test_xProcessReceivedUDPPacket_SocketFound_HandlerFoundReturnNonZero(void)893 void test_xProcessReceivedUDPPacket_SocketFound_HandlerFoundReturnNonZero( void )
894 {
895     NetworkBufferDescriptor_t xLocalNetworkBuffer;
896     uint16_t usPort = FreeRTOS_ntohs( ipNBNS_PORT );
897     uint8_t pucLocalEthernetBuffer[ ipconfigTCP_MSS ];
898     BaseType_t xResult;
899     BaseType_t xIsWaitingARPResolution = pdFALSE;
900     FreeRTOS_Socket_t xLocalSocket;
901     UDPPacket_t * pxUDPPacket;
902     SocketSelect_t xLocalSocketSet;
903 
904     /* Cleanup. */
905     memset( pucLocalEthernetBuffer, 0, ipconfigTCP_MSS );
906     memset( &xLocalSocket, 0, sizeof( xLocalSocket ) );
907     ulFunctionCalled = 0;
908 
909     *ipLOCAL_IP_ADDRESS_POINTER = 0xC01234BD;
910 
911     xLocalNetworkBuffer.pucEthernetBuffer = pucLocalEthernetBuffer;
912     xLocalNetworkBuffer.xDataLength = ipconfigTCP_MSS;
913 
914     pxUDPPacket = ( UDPPacket_t * ) xLocalNetworkBuffer.pucEthernetBuffer;
915 
916     xLocalSocket.u.xUDP.pxHandleReceive = xLocalHandler;
917     /* Since we have memset this to 0, anything bigger than 0 should suffice. */
918     xLocalSocket.u.xUDP.uxMaxPackets = 1;
919     xLocalSocket.xEventGroup = ( void * ) 1;
920     xLocalSocket.pxSocketSet = &xLocalSocketSet;
921     xLocalSocket.pxUserSemaphore = ( void * ) 1;
922     xLocalSocket.xSelectBits = eSELECT_READ;
923 
924     /* Return a non-zero value. */
925     xFunctionReturn = 1;
926 
927     pxUDPSocketLookup_ExpectAndReturn( usPort, &xLocalSocket );
928 
929     xCheckRequiresARPResolution_ExpectAnyArgsAndReturn( pdFALSE );
930     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress );
931 
932     xResult = xProcessReceivedUDPPacket( &xLocalNetworkBuffer, usPort, &xIsWaitingARPResolution );
933     TEST_ASSERT_EQUAL( pdFAIL, xResult );
934     TEST_ASSERT_EQUAL( 1, ulFunctionCalled );
935     TEST_ASSERT_EQUAL( pdFALSE, xIsWaitingARPResolution );
936 }
937