1 /*
2 * FreeRTOS+TCP <DEVELOPMENT BRANCH>
3 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * http://aws.amazon.com/freertos
25 * http://www.FreeRTOS.org
26 */
27
28
29 /* Include Unity header */
30 #include "unity.h"
31
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36
37 #include "FreeRTOSIPConfig.h"
38
39 #include "mock_task.h"
40 #include "mock_list.h"
41
42 /* This must come after list.h is included (in this case, indirectly
43 * by mock_list.h). */
44 #include "mock_FreeRTOS_UDP_IPv4_list_macros.h"
45 #include "mock_queue.h"
46 #include "mock_event_groups.h"
47 #include "mock_FreeRTOS_ARP.h"
48 #include "mock_FreeRTOS_DHCP.h"
49 #include "mock_FreeRTOS_DNS.h"
50 #include "mock_FreeRTOS_IP_Utils.h"
51 #include "mock_FreeRTOS_Routing.h"
52 #include "mock_NetworkBufferManagement.h"
53
54 #include "FreeRTOS_UDP_IPv4_stubs.c"
55 #include "catch_assert.h"
56
57 /* =========================== EXTERN VARIABLES =========================== */
58
59 const uint32_t ulDefaultIPv4Address = 0x12345678;
60 const uint16_t ulDefaultProtoChecksum = 0xABCD;
61 BaseType_t xIsIfOutCalled = 0;
62
63 /* ============================ Unity Fixtures ============================ */
64
65 /*! called before each test case */
setUp(void)66 void setUp( void )
67 {
68 xIsIfOutCalled = 0;
69 }
70
71 /* ============================== Test Cases ============================== */
72
73 /**
74 * @brief Trigger assertion when input network buffer pointer is NULL.
75 */
test_xProcessReceivedUDPPacket_IPv4_NullInput()76 void test_xProcessReceivedUDPPacket_IPv4_NullInput()
77 {
78 BaseType_t xIsWaitingForARPResolution;
79
80 catch_assert( xProcessReceivedUDPPacket_IPv4( NULL, 0, &xIsWaitingForARPResolution ) );
81 }
82
83 /**
84 * @brief Trigger assertion when input buffer pointer in network buffer is NULL.
85 */
test_xProcessReceivedUDPPacket_IPv4_NullBufferPointer()86 void test_xProcessReceivedUDPPacket_IPv4_NullBufferPointer()
87 {
88 BaseType_t xIsWaitingForARPResolution;
89 NetworkBufferDescriptor_t xNetworkBuffer;
90
91 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
92
93 catch_assert( xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, 0, &xIsWaitingForARPResolution ) );
94 }
95
96 /**
97 * @brief To validate the scenario that receives DNS reply packet and pass.
98 */
test_xProcessReceivedUDPPacket_IPv4_DNSReplyPass()99 void test_xProcessReceivedUDPPacket_IPv4_DNSReplyPass()
100 {
101 BaseType_t xReturn;
102 uint16_t usSrcPort = ipDNS_PORT;
103 uint16_t usDestPort = 1024U;
104 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
105 BaseType_t xIsWaitingForARPResolution;
106 NetworkBufferDescriptor_t xNetworkBuffer;
107 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
108 UDPPacket_t * pxUDPPacket;
109
110 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
111 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
112
113 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
114 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
115
116 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
117 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
118 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
119
120 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
121 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
122 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
123
124 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
125
126 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
127 }
128
129 /**
130 * @brief To validate the scenario that receives DNS reply packet and fail.
131 */
test_xProcessReceivedUDPPacket_IPv4_DNSReplyFail()132 void test_xProcessReceivedUDPPacket_IPv4_DNSReplyFail()
133 {
134 BaseType_t xReturn;
135 uint16_t usSrcPort = ipDNS_PORT;
136 uint16_t usDestPort = 1024U;
137 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
138 BaseType_t xIsWaitingForARPResolution;
139 NetworkBufferDescriptor_t xNetworkBuffer;
140 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
141 UDPPacket_t * pxUDPPacket;
142
143 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
144 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
145
146 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
147 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
148
149 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
150 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
151 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
152
153 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
154 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
155 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
156
157 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
158
159 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
160 }
161
162 /**
163 * @brief To validate the scenario that receives LLMNR request packet and pass.
164 */
test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestPass()165 void test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestPass()
166 {
167 BaseType_t xReturn;
168 uint16_t usSrcPort = 1024U;
169 uint16_t usDestPort = ipLLMNR_PORT;
170 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
171 BaseType_t xIsWaitingForARPResolution;
172 NetworkBufferDescriptor_t xNetworkBuffer;
173 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
174 UDPPacket_t * pxUDPPacket;
175
176 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
177 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
178
179 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
180 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
181
182 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
183 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
184 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
185
186 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
187 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
188 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
189
190 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
191
192 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
193 }
194
195 /**
196 * @brief To validate the scenario that receives LLMNR request packet and fail.
197 */
test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestFail()198 void test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestFail()
199 {
200 BaseType_t xReturn;
201 uint16_t usSrcPort = 1024U;
202 uint16_t usDestPort = ipLLMNR_PORT;
203 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
204 BaseType_t xIsWaitingForARPResolution;
205 NetworkBufferDescriptor_t xNetworkBuffer;
206 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
207 UDPPacket_t * pxUDPPacket;
208
209 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
210 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
211
212 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
213 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
214
215 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
216 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
217 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
218
219 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
220 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
221 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
222
223 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
224
225 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
226 }
227
228 /**
229 * @brief To validate the scenario that receives LLMNR reply packet and pass.
230 */
test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyPass()231 void test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyPass()
232 {
233 BaseType_t xReturn;
234 uint16_t usSrcPort = ipLLMNR_PORT;
235 uint16_t usDestPort = 1024U;
236 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
237 BaseType_t xIsWaitingForARPResolution;
238 NetworkBufferDescriptor_t xNetworkBuffer;
239 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
240 UDPPacket_t * pxUDPPacket;
241
242 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
243 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
244
245 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
246 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
247
248 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
249 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
250 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
251
252 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
253 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
254 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
255
256 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
257
258 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
259 }
260
261 /**
262 * @brief To validate the scenario that receives LLMNR reply packet and fail.
263 */
test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyFail()264 void test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyFail()
265 {
266 BaseType_t xReturn;
267 uint16_t usSrcPort = ipLLMNR_PORT;
268 uint16_t usDestPort = 1024U;
269 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
270 BaseType_t xIsWaitingForARPResolution;
271 NetworkBufferDescriptor_t xNetworkBuffer;
272 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
273 UDPPacket_t * pxUDPPacket;
274
275 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
276 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
277
278 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
279 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
280
281 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
282 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
283 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
284
285 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
286 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
287 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
288
289 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
290
291 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
292 }
293
294 /**
295 * @brief To validate the scenario that receives MDNS request packet and pass.
296 */
test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPass()297 void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPass()
298 {
299 BaseType_t xReturn;
300 uint16_t usSrcPort = 1024U;
301 uint16_t usDestPort = ipMDNS_PORT;
302 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
303 BaseType_t xIsWaitingForARPResolution;
304 NetworkBufferDescriptor_t xNetworkBuffer;
305 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
306 UDPPacket_t * pxUDPPacket;
307
308 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
309 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
310
311 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
312 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
313
314 pxUDPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
315
316 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
317 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
318 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
319
320 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
321 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
322 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
323
324 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
325
326 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
327 }
328
329 /**
330 * @brief To validate the scenario that receives MDNS request packet and fail.
331 */
test_xProcessReceivedUDPPacket_IPv4_MDNSRequestFail()332 void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestFail()
333 {
334 BaseType_t xReturn;
335 uint16_t usSrcPort = 1024U;
336 uint16_t usDestPort = ipMDNS_PORT;
337 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
338 BaseType_t xIsWaitingForARPResolution;
339 NetworkBufferDescriptor_t xNetworkBuffer;
340 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
341 UDPPacket_t * pxUDPPacket;
342
343 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
344 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
345
346 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
347 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
348
349 pxUDPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
350
351 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
352 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
353 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
354
355 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
356 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
357 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
358
359 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
360
361 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
362 }
363
364 /**
365 * @brief To validate the scenario that receives MDNS Reply packet and pass.
366 */
test_xProcessReceivedUDPPacket_IPv4_MDNSReplyPass()367 void test_xProcessReceivedUDPPacket_IPv4_MDNSReplyPass()
368 {
369 BaseType_t xReturn;
370 uint16_t usSrcPort = ipMDNS_PORT;
371 uint16_t usDestPort = 1024U;
372 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
373 BaseType_t xIsWaitingForARPResolution;
374 NetworkBufferDescriptor_t xNetworkBuffer;
375 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
376 UDPPacket_t * pxUDPPacket;
377
378 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
379 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
380
381 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
382 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
383
384 pxUDPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
385
386 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
387 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
388 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
389
390 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
391 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
392 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
393
394 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
395
396 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
397 }
398
399 /**
400 * @brief To validate the scenario that receives MDNS Reply packet and fail.
401 */
test_xProcessReceivedUDPPacket_IPv4_MDNSReplyFail()402 void test_xProcessReceivedUDPPacket_IPv4_MDNSReplyFail()
403 {
404 BaseType_t xReturn;
405 uint16_t usSrcPort = ipMDNS_PORT;
406 uint16_t usDestPort = 1024U;
407 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
408 BaseType_t xIsWaitingForARPResolution;
409 NetworkBufferDescriptor_t xNetworkBuffer;
410 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
411 UDPPacket_t * pxUDPPacket;
412
413 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
414 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
415
416 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
417 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
418
419 pxUDPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
420
421 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
422 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
423 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
424
425 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
426 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
427 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
428
429 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
430
431 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
432 }
433
434 /**
435 * @brief To validate the scenario that receives MDNS request packet and pass
436 * with IPv6 frame type in ethernet header.
437 */
test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPassWithIPv6FrameType()438 void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPassWithIPv6FrameType()
439 {
440 BaseType_t xReturn;
441 uint16_t usSrcPort = 1024U;
442 uint16_t usDestPort = ipMDNS_PORT;
443 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
444 BaseType_t xIsWaitingForARPResolution;
445 NetworkBufferDescriptor_t xNetworkBuffer;
446 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
447 UDPPacket_t * pxUDPPacket;
448
449 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
450 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
451
452 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
453 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
454
455 pxUDPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
456
457 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
458 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
459 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
460
461 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
462 ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
463
464 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
465
466 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
467 }
468
469 /**
470 * @brief To validate the scenario that receives NBNS request packet and pass.
471 */
test_xProcessReceivedUDPPacket_IPv4_NBNSRequestPass()472 void test_xProcessReceivedUDPPacket_IPv4_NBNSRequestPass()
473 {
474 BaseType_t xReturn;
475 uint16_t usSrcPort = 1024U;
476 uint16_t usDestPort = ipNBNS_PORT;
477 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
478 BaseType_t xIsWaitingForARPResolution;
479 NetworkBufferDescriptor_t xNetworkBuffer;
480 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
481 UDPPacket_t * pxUDPPacket;
482
483 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
484 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
485
486 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
487 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
488
489 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
490 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
491 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
492
493 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
494 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
495 ulNBNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
496
497 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
498
499 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
500 }
501
502 /**
503 * @brief To validate the scenario that receives NBNS request packet and fail.
504 */
test_xProcessReceivedUDPPacket_IPv4_NBNSRequestFail()505 void test_xProcessReceivedUDPPacket_IPv4_NBNSRequestFail()
506 {
507 BaseType_t xReturn;
508 uint16_t usSrcPort = 1024U;
509 uint16_t usDestPort = ipNBNS_PORT;
510 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
511 BaseType_t xIsWaitingForARPResolution;
512 NetworkBufferDescriptor_t xNetworkBuffer;
513 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
514 UDPPacket_t * pxUDPPacket;
515
516 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
517 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
518
519 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
520 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
521
522 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
523 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
524 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
525
526 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
527 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
528 ulNBNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
529
530 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
531
532 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
533 }
534
535 /**
536 * @brief To validate the scenario that receives NBNS Reply packet and pass.
537 */
test_xProcessReceivedUDPPacket_IPv4_NBNSReplyPass()538 void test_xProcessReceivedUDPPacket_IPv4_NBNSReplyPass()
539 {
540 BaseType_t xReturn;
541 uint16_t usSrcPort = ipNBNS_PORT;
542 uint16_t usDestPort = 1024U;
543 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
544 BaseType_t xIsWaitingForARPResolution;
545 NetworkBufferDescriptor_t xNetworkBuffer;
546 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
547 UDPPacket_t * pxUDPPacket;
548
549 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
550 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
551
552 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
553 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
554
555 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
556 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
557 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
558
559 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
560 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
561 ulNBNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
562
563 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
564
565 TEST_ASSERT_EQUAL( pdTRUE, xReturn );
566 }
567
568 /**
569 * @brief To validate the scenario that receives NBNS Reply packet and fail.
570 */
test_xProcessReceivedUDPPacket_IPv4_NBNSReplyFail()571 void test_xProcessReceivedUDPPacket_IPv4_NBNSReplyFail()
572 {
573 BaseType_t xReturn;
574 uint16_t usSrcPort = ipNBNS_PORT;
575 uint16_t usDestPort = 1024U;
576 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
577 BaseType_t xIsWaitingForARPResolution;
578 NetworkBufferDescriptor_t xNetworkBuffer;
579 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
580 UDPPacket_t * pxUDPPacket;
581
582 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
583 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
584
585 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
586 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
587
588 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
589 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
590 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
591
592 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
593 vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
594 ulNBNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
595
596 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
597
598 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
599 }
600
601 /**
602 * @brief To validate the scenario that no one is waiting for the packet.
603 */
test_xProcessReceivedUDPPacket_IPv4_NoSocket()604 void test_xProcessReceivedUDPPacket_IPv4_NoSocket()
605 {
606 BaseType_t xReturn;
607 uint16_t usSrcPort = 2048U;
608 uint16_t usDestPort = 1024U;
609 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
610 BaseType_t xIsWaitingForARPResolution;
611 NetworkBufferDescriptor_t xNetworkBuffer;
612 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
613 UDPPacket_t * pxUDPPacket;
614
615 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
616 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
617
618 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
619 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
620
621 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
622 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
623 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
624
625 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
626
627 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
628
629 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
630 }
631
632 /**
633 * @brief To validate the flow that socket has NULL endpoint.
634 */
test_xProcessReceivedUDPPacket_IPv4_SocketNullEndpoint()635 void test_xProcessReceivedUDPPacket_IPv4_SocketNullEndpoint()
636 {
637 BaseType_t xReturn;
638 uint16_t usSrcPort = 2048U;
639 uint16_t usDestPort = 1024U;
640 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
641 BaseType_t xIsWaitingForARPResolution;
642 NetworkBufferDescriptor_t xNetworkBuffer;
643 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
644 UDPPacket_t * pxUDPPacket;
645 FreeRTOS_Socket_t xSocket;
646
647 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
648 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
649 memset( &xSocket, 0, sizeof( xSocket ) );
650
651 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
652 xNetworkBuffer.pxEndPoint = NULL;
653
654 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
655 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
656 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
657 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
658
659 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
660
661 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
662
663 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
664 }
665
666 /**
667 * @brief To validate the flow that endpoint in socket handler has zero IP address.
668 */
test_xProcessReceivedUDPPacket_IPv4_SocketEndPointZeroIP()669 void test_xProcessReceivedUDPPacket_IPv4_SocketEndPointZeroIP()
670 {
671 BaseType_t xReturn;
672 uint16_t usSrcPort = 2048U;
673 uint16_t usDestPort = 1024U;
674 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
675 BaseType_t xIsWaitingForARPResolution;
676 NetworkBufferDescriptor_t xNetworkBuffer;
677 NetworkEndPoint_t xEndPoint;
678 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
679 UDPPacket_t * pxUDPPacket;
680 FreeRTOS_Socket_t xSocket;
681
682 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
683 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
684 memset( &xSocket, 0, sizeof( xSocket ) );
685 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
686
687 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
688 xNetworkBuffer.pxEndPoint = &xEndPoint;
689
690 xEndPoint.ipv4_settings.ulIPAddress = 0U;
691
692 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
693 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
694 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
695 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
696
697 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
698
699 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
700
701 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
702 }
703
704 /**
705 * @brief To validate the flow that socket needs ARP discovery.
706 */
test_xProcessReceivedUDPPacket_IPv4_SocketNeedARP()707 void test_xProcessReceivedUDPPacket_IPv4_SocketNeedARP()
708 {
709 BaseType_t xReturn;
710 uint16_t usSrcPort = 2048U;
711 uint16_t usDestPort = 1024U;
712 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
713 BaseType_t xIsWaitingForARPResolution;
714 NetworkBufferDescriptor_t xNetworkBuffer;
715 NetworkEndPoint_t xEndPoint;
716 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
717 UDPPacket_t * pxUDPPacket;
718 FreeRTOS_Socket_t xSocket;
719
720 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
721 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
722 memset( &xSocket, 0, sizeof( xSocket ) );
723 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
724
725 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
726 xNetworkBuffer.pxEndPoint = &xEndPoint;
727
728 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
729
730 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
731 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
732 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
733 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
734
735 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
736 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
737
738 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
739
740 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
741 TEST_ASSERT_EQUAL( pdTRUE, xIsWaitingForARPResolution );
742 }
743
744 /**
745 * @brief To validate the flow that socket receive handler returns fail.
746 */
test_xProcessReceivedUDPPacket_IPv4_SocketRecvHandlerFail()747 void test_xProcessReceivedUDPPacket_IPv4_SocketRecvHandlerFail()
748 {
749 BaseType_t xReturn;
750 uint16_t usSrcPort = 2048U;
751 uint16_t usDestPort = 1024U;
752 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
753 BaseType_t xIsWaitingForARPResolution;
754 NetworkBufferDescriptor_t xNetworkBuffer;
755 NetworkEndPoint_t xEndPoint;
756 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
757 UDPPacket_t * pxUDPPacket;
758 FreeRTOS_Socket_t xSocket;
759
760 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
761 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
762 memset( &xSocket, 0, sizeof( xSocket ) );
763 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
764
765 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
766 xNetworkBuffer.pxEndPoint = &xEndPoint;
767 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
768 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
769
770 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
771
772 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
773 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
774
775 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
776 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
777 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
778
779 xSocket.u.xUDP.pxHandleReceive = xStubUDPReceiveHandler_Fail;
780
781 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
782 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
783 vARPRefreshCacheEntryAge_Ignore();
784
785 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
786
787 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
788 }
789
790 /**
791 * @brief To validate the flow that list of the socket is full and return fail.
792 */
test_xProcessReceivedUDPPacket_IPv4_UDPListBufferFull()793 void test_xProcessReceivedUDPPacket_IPv4_UDPListBufferFull()
794 {
795 BaseType_t xReturn;
796 uint16_t usSrcPort = 2048U;
797 uint16_t usDestPort = 1024U;
798 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
799 BaseType_t xIsWaitingForARPResolution;
800 NetworkBufferDescriptor_t xNetworkBuffer;
801 NetworkEndPoint_t xEndPoint;
802 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
803 UDPPacket_t * pxUDPPacket;
804 FreeRTOS_Socket_t xSocket;
805
806 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
807 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
808 memset( &xSocket, 0, sizeof( xSocket ) );
809 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
810
811 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
812 xNetworkBuffer.pxEndPoint = &xEndPoint;
813 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
814 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
815
816 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
817
818 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
819 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
820
821 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
822 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
823 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
824
825 xSocket.u.xUDP.pxHandleReceive = xStubUDPReceiveHandler_Pass;
826
827 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
828 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
829 vARPRefreshCacheEntryAge_Ignore();
830
831 /* Set for listCURRENT_LIST_LENGTH */
832 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = xSocket.u.xUDP.uxMaxPackets;
833
834 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
835
836 TEST_ASSERT_EQUAL( pdFAIL, xReturn );
837 }
838
839 /**
840 * @brief To validate the flow that all flows (list/event group/select/queue/DHCP) are all pass.
841 */
test_xProcessReceivedUDPPacket_IPv4_Pass()842 void test_xProcessReceivedUDPPacket_IPv4_Pass()
843 {
844 BaseType_t xReturn;
845 uint16_t usSrcPort = 2048U;
846 uint16_t usDestPort = 1024U;
847 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
848 BaseType_t xIsWaitingForARPResolution;
849 NetworkBufferDescriptor_t xNetworkBuffer;
850 NetworkEndPoint_t xEndPoint;
851 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
852 UDPPacket_t * pxUDPPacket;
853 FreeRTOS_Socket_t xSocket;
854 EventGroupHandle_t xEventGroup;
855 struct xSOCKET_SET xSocketSet;
856 SemaphoreHandle_t xSocketSem;
857
858 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
859 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
860 memset( &xSocket, 0, sizeof( xSocket ) );
861 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
862
863 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
864 xNetworkBuffer.pxEndPoint = &xEndPoint;
865 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
866 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
867
868 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
869
870 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
871 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
872
873 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
874 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
875 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
876
877 xSocket.u.xUDP.pxHandleReceive = NULL;
878
879 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
880 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
881 vARPRefreshCacheEntryAge_Ignore();
882
883 /* Set for listCURRENT_LIST_LENGTH */
884 xSocket.u.xUDP.uxMaxPackets = 255U;
885 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
886
887 vTaskSuspendAll_Ignore();
888 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
889 xTaskResumeAll_ExpectAndReturn( pdPASS );
890
891 xSocket.xEventGroup = xEventGroup;
892 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE, pdPASS );
893
894 xSocket.pxSocketSet = &xSocketSet;
895 xSocket.xSelectBits |= eSELECT_READ;
896 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
897
898 /* xSemaphoreGive is defined as xQueueGenericSend */
899 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) &xSocketSem;
900 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
901
902 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdTRUE );
903 xSendDHCPEvent_ExpectAndReturn( xNetworkBuffer.pxEndPoint, pdPASS );
904
905 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
906
907 TEST_ASSERT_EQUAL( pdPASS, xReturn );
908 }
909
910 /**
911 * @brief To validate the flow that all flows except for event group (list/select/queue/DHCP) are all pass.
912 */
test_xProcessReceivedUDPPacket_IPv4_PassNoEventGroup()913 void test_xProcessReceivedUDPPacket_IPv4_PassNoEventGroup()
914 {
915 BaseType_t xReturn;
916 uint16_t usSrcPort = 2048U;
917 uint16_t usDestPort = 1024U;
918 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
919 BaseType_t xIsWaitingForARPResolution;
920 NetworkBufferDescriptor_t xNetworkBuffer;
921 NetworkEndPoint_t xEndPoint;
922 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
923 UDPPacket_t * pxUDPPacket;
924 FreeRTOS_Socket_t xSocket;
925 struct xSOCKET_SET xSocketSet;
926 SemaphoreHandle_t xSocketSem;
927
928 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
929 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
930 memset( &xSocket, 0, sizeof( xSocket ) );
931 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
932
933 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
934 xNetworkBuffer.pxEndPoint = &xEndPoint;
935 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
936 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
937
938 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
939
940 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
941 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
942
943 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
944 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
945 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
946
947 xSocket.u.xUDP.pxHandleReceive = NULL;
948 xSocket.xEventGroup = NULL;
949
950 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
951 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
952 vARPRefreshCacheEntryAge_Ignore();
953
954 /* Set for listCURRENT_LIST_LENGTH */
955 xSocket.u.xUDP.uxMaxPackets = 255U;
956 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
957
958 vTaskSuspendAll_Ignore();
959 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
960 xTaskResumeAll_ExpectAndReturn( pdPASS );
961
962 xSocket.pxSocketSet = &xSocketSet;
963 xSocket.xSelectBits |= eSELECT_READ;
964 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
965
966 /* xSemaphoreGive is defined as xQueueGenericSend */
967 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) &xSocketSem;
968 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
969
970 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdTRUE );
971 xSendDHCPEvent_ExpectAndReturn( xNetworkBuffer.pxEndPoint, pdPASS );
972
973 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
974
975 TEST_ASSERT_EQUAL( pdPASS, xReturn );
976 }
977
978 /**
979 * @brief To validate the flow that all flows except for select bit (list/event group/queue/DHCP) are all pass.
980 */
test_xProcessReceivedUDPPacket_IPv4_PassNoSelectBit()981 void test_xProcessReceivedUDPPacket_IPv4_PassNoSelectBit()
982 {
983 BaseType_t xReturn;
984 uint16_t usSrcPort = 2048U;
985 uint16_t usDestPort = 1024U;
986 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
987 BaseType_t xIsWaitingForARPResolution;
988 NetworkBufferDescriptor_t xNetworkBuffer;
989 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
990 NetworkEndPoint_t xEndPoint;
991 UDPPacket_t * pxUDPPacket;
992 FreeRTOS_Socket_t xSocket;
993 EventGroupHandle_t xEventGroup;
994 struct xSOCKET_SET xSocketSet;
995 SemaphoreHandle_t xSocketSem;
996
997 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
998 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
999 memset( &xSocket, 0, sizeof( xSocket ) );
1000
1001 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
1002 xNetworkBuffer.pxEndPoint = &xEndPoint;
1003 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
1004 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
1005
1006 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
1007
1008 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
1009 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
1010
1011 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
1012 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
1013 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
1014
1015 xSocket.u.xUDP.pxHandleReceive = NULL;
1016 xSocket.xEventGroup = xEventGroup;
1017
1018 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
1019 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
1020 vARPRefreshCacheEntryAge_Ignore();
1021
1022 /* Set for listCURRENT_LIST_LENGTH */
1023 xSocket.u.xUDP.uxMaxPackets = 255U;
1024 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
1025
1026 vTaskSuspendAll_Ignore();
1027 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
1028 xTaskResumeAll_ExpectAndReturn( pdPASS );
1029
1030 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE, pdPASS );
1031
1032 xSocket.pxSocketSet = &xSocketSet;
1033
1034 /* xSemaphoreGive is defined as xQueueGenericSend */
1035 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) &xSocketSem;
1036 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
1037
1038 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdTRUE );
1039 xSendDHCPEvent_ExpectAndReturn( xNetworkBuffer.pxEndPoint, pdPASS );
1040
1041 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
1042
1043 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1044 }
1045
1046 /**
1047 * @brief To validate the flow that all flows except for select set (list/event group/queue/DHCP) are all pass.
1048 */
test_xProcessReceivedUDPPacket_IPv4_PassNoSelectSet()1049 void test_xProcessReceivedUDPPacket_IPv4_PassNoSelectSet()
1050 {
1051 BaseType_t xReturn;
1052 uint16_t usSrcPort = 2048U;
1053 uint16_t usDestPort = 1024U;
1054 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
1055 BaseType_t xIsWaitingForARPResolution;
1056 NetworkBufferDescriptor_t xNetworkBuffer;
1057 NetworkEndPoint_t xEndPoint;
1058 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1059 UDPPacket_t * pxUDPPacket;
1060 FreeRTOS_Socket_t xSocket;
1061 EventGroupHandle_t xEventGroup;
1062 SemaphoreHandle_t xSocketSem;
1063
1064 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
1065 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
1066 memset( &xSocket, 0, sizeof( xSocket ) );
1067 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
1068
1069 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
1070 xNetworkBuffer.pxEndPoint = &xEndPoint;
1071 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
1072 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
1073
1074 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
1075
1076 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
1077 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
1078
1079 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
1080 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
1081 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
1082
1083 xSocket.u.xUDP.pxHandleReceive = NULL;
1084 xSocket.xEventGroup = xEventGroup;
1085
1086 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
1087 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
1088 vARPRefreshCacheEntryAge_Ignore();
1089
1090 /* Set for listCURRENT_LIST_LENGTH */
1091 xSocket.u.xUDP.uxMaxPackets = 255U;
1092 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
1093
1094 vTaskSuspendAll_Ignore();
1095 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
1096 xTaskResumeAll_ExpectAndReturn( pdPASS );
1097
1098 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE, pdPASS );
1099
1100 /* xSemaphoreGive is defined as xQueueGenericSend */
1101 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) &xSocketSem;
1102 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
1103
1104 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdTRUE );
1105 xSendDHCPEvent_ExpectAndReturn( xNetworkBuffer.pxEndPoint, pdPASS );
1106
1107 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
1108
1109 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1110 }
1111
1112 /**
1113 * @brief To validate the flow that all flows except for semaphore (list/event group/select/DHCP) are all pass.
1114 */
test_xProcessReceivedUDPPacket_IPv4_PassNoSem()1115 void test_xProcessReceivedUDPPacket_IPv4_PassNoSem()
1116 {
1117 BaseType_t xReturn;
1118 uint16_t usSrcPort = 2048U;
1119 uint16_t usDestPort = 1024U;
1120 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
1121 BaseType_t xIsWaitingForARPResolution;
1122 NetworkBufferDescriptor_t xNetworkBuffer;
1123 NetworkEndPoint_t xEndPoint;
1124 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1125 UDPPacket_t * pxUDPPacket;
1126 FreeRTOS_Socket_t xSocket;
1127 EventGroupHandle_t xEventGroup;
1128 struct xSOCKET_SET xSocketSet;
1129
1130 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
1131 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
1132 memset( &xSocket, 0, sizeof( xSocket ) );
1133 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
1134
1135 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
1136 xNetworkBuffer.pxEndPoint = &xEndPoint;
1137 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
1138 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
1139
1140 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
1141
1142 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
1143 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
1144
1145 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
1146 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
1147 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
1148
1149 xSocket.u.xUDP.pxHandleReceive = NULL;
1150 xSocket.xEventGroup = xEventGroup;
1151
1152 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
1153 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
1154 vARPRefreshCacheEntryAge_Ignore();
1155
1156 /* Set for listCURRENT_LIST_LENGTH */
1157 xSocket.u.xUDP.uxMaxPackets = 255U;
1158 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
1159
1160 vTaskSuspendAll_Ignore();
1161 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
1162 xTaskResumeAll_ExpectAndReturn( pdPASS );
1163
1164 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE, pdPASS );
1165
1166 xSocket.pxSocketSet = &xSocketSet;
1167 xSocket.xSelectBits |= eSELECT_READ;
1168 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
1169
1170 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdTRUE );
1171 xSendDHCPEvent_ExpectAndReturn( xNetworkBuffer.pxEndPoint, pdPASS );
1172
1173 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
1174
1175 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1176 }
1177
1178 /**
1179 * @brief To validate the flow that all flows except for DHCP (list/event group/select/queue) are all pass.
1180 */
test_xProcessReceivedUDPPacket_IPv4_PassNoDHCP()1181 void test_xProcessReceivedUDPPacket_IPv4_PassNoDHCP()
1182 {
1183 BaseType_t xReturn;
1184 uint16_t usSrcPort = 2048U;
1185 uint16_t usDestPort = 1024U;
1186 uint16_t usDestPortNetworkEndian = FreeRTOS_htons( usDestPort );
1187 BaseType_t xIsWaitingForARPResolution;
1188 NetworkBufferDescriptor_t xNetworkBuffer;
1189 NetworkEndPoint_t xEndPoint;
1190 uint8_t pucEthernetBuffer[ ipconfigTCP_MSS ];
1191 UDPPacket_t * pxUDPPacket;
1192 FreeRTOS_Socket_t xSocket;
1193 EventGroupHandle_t xEventGroup;
1194 struct xSOCKET_SET xSocketSet;
1195 SemaphoreHandle_t xSocketSem;
1196
1197 memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
1198 memset( pucEthernetBuffer, 0, sizeof( pucEthernetBuffer ) );
1199 memset( &xSocket, 0, sizeof( xSocket ) );
1200 memset( &xEndPoint, 0, sizeof( xEndPoint ) );
1201
1202 xNetworkBuffer.pucEthernetBuffer = pucEthernetBuffer;
1203 xNetworkBuffer.pxEndPoint = &xEndPoint;
1204 xNetworkBuffer.usPort = FreeRTOS_htons( usSrcPort );
1205 xNetworkBuffer.xDataLength = ipconfigTCP_MSS;
1206
1207 xEndPoint.ipv4_settings.ulIPAddress = ulDefaultIPv4Address;
1208
1209 pxUDPPacket = ( UDPPacket_t * ) pucEthernetBuffer;
1210 pxUDPPacket->xIPHeader.usLength = xNetworkBuffer.xDataLength - ipSIZE_OF_ETH_HEADER;
1211
1212 pxUDPPacket->xUDPHeader.usChecksum = 0x1234U;
1213 pxUDPPacket->xUDPHeader.usSourcePort = FreeRTOS_htons( usSrcPort );
1214 pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
1215
1216 xSocket.u.xUDP.pxHandleReceive = NULL;
1217 xSocket.xEventGroup = xEventGroup;
1218
1219 pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, &xSocket );
1220 xCheckRequiresARPResolution_ExpectAndReturn( &xNetworkBuffer, pdFALSE );
1221 vARPRefreshCacheEntryAge_Ignore();
1222
1223 /* Set for listCURRENT_LIST_LENGTH */
1224 xSocket.u.xUDP.uxMaxPackets = 255U;
1225 xSocket.u.xUDP.xWaitingPacketsList.uxNumberOfItems = 0U;
1226
1227 vTaskSuspendAll_Ignore();
1228 vListInsertEnd_Expect( &( xSocket.u.xUDP.xWaitingPacketsList ), &( xNetworkBuffer.xBufferListItem ) );
1229 xTaskResumeAll_ExpectAndReturn( pdPASS );
1230
1231 xEventGroupSetBits_ExpectAndReturn( xSocket.xEventGroup, eSOCKET_RECEIVE, pdPASS );
1232
1233 xSocket.pxSocketSet = &xSocketSet;
1234 xSocket.xSelectBits |= eSELECT_READ;
1235 xEventGroupSetBits_ExpectAndReturn( xSocket.pxSocketSet->xSelectGroup, eSELECT_READ, pdPASS );
1236
1237 /* xSemaphoreGive is defined as xQueueGenericSend */
1238 xSocket.pxUserSemaphore = ( SemaphoreHandle_t ) &xSocketSem;
1239 xQueueGenericSend_ExpectAndReturn( xSocket.pxUserSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK, pdPASS );
1240
1241 xIsDHCPSocket_ExpectAndReturn( &xSocket, pdFALSE );
1242
1243 xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
1244
1245 TEST_ASSERT_EQUAL( pdPASS, xReturn );
1246 }
1247
1248 /**
1249 * @brief To validate the flow to send ping message but get failure on ARP get entry.
1250 */
test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCantSend()1251 void test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCantSend()
1252 {
1253 BaseType_t xReturn;
1254 NetworkBufferDescriptor_t * pxNetworkBuffer;
1255 NetworkEndPoint_t * pxEndPoint;
1256 ICMPPacket_t * pxICMPPacket;
1257
1258 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_ICMP );
1259 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1260
1261 pxNetworkBuffer->usPort = ipPACKET_CONTAINS_ICMP_DATA;
1262
1263 pxICMPPacket = ( ICMPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1264
1265 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxICMPPacket->xEthernetHeader.xDestinationAddress ), NULL, eCantSendPacket );
1266 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1267 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1268 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1269 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1270
1271 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1272 }
1273
1274 /**
1275 * @brief To validate the flow to send ping message but get an unknown ND return.
1276 */
test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCacheUnknown()1277 void test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCacheUnknown()
1278 {
1279 BaseType_t xReturn;
1280 NetworkBufferDescriptor_t * pxNetworkBuffer;
1281 NetworkEndPoint_t * pxEndPoint;
1282 ICMPPacket_t * pxICMPPacket;
1283
1284 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_ICMP );
1285 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1286
1287 pxNetworkBuffer->usPort = ipPACKET_CONTAINS_ICMP_DATA;
1288
1289 pxICMPPacket = ( ICMPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1290
1291 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxICMPPacket->xEthernetHeader.xDestinationAddress ), NULL, 0xFF );
1292 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1293 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1294 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1295 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1296
1297 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1298 }
1299
1300 /**
1301 * @brief To validate the flow to send ping message and get a cache hit.
1302 */
test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCacheHit()1303 void test_vProcessGeneratedUDPPacket_IPv4_ICMPPingCacheHit()
1304 {
1305 BaseType_t xReturn;
1306 NetworkBufferDescriptor_t * pxNetworkBuffer;
1307 NetworkEndPoint_t * pxEndPoint;
1308 ICMPPacket_t * pxICMPPacket;
1309
1310 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_ICMP );
1311 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1312
1313 /* To trigger checksum generation. */
1314 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1315
1316 pxNetworkBuffer->usPort = ipPACKET_CONTAINS_ICMP_DATA;
1317
1318 pxICMPPacket = ( ICMPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1319
1320 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxICMPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1321 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1322 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1323 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1324 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1325 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1326 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1327
1328 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1329
1330 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1331 TEST_ASSERT_EQUAL( ipPROTOCOL_ICMP, pxICMPPacket->xIPHeader.ucProtocol );
1332 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1333 }
1334
1335 /**
1336 * @brief To validate the flow to send UDP and get a cache hit.
1337 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHit()1338 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHit()
1339 {
1340 BaseType_t xReturn;
1341 NetworkBufferDescriptor_t * pxNetworkBuffer;
1342 NetworkEndPoint_t * pxEndPoint;
1343 UDPPacket_t * pxUDPPacket;
1344
1345 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1346 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1347
1348 /* To trigger checksum generation. */
1349 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1350
1351 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1352
1353 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1354 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1355 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1356 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1357 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1358 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1359 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1360
1361 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1362
1363 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1364 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1365 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1366 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1367 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1368 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1369 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1370 }
1371
1372 /**
1373 * @brief To validate the flow to send UDP and get a cache hit. But the buffer length is
1374 * less than minimum requirement.
1375 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitLessBufferLength()1376 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitLessBufferLength()
1377 {
1378 BaseType_t xReturn;
1379 NetworkBufferDescriptor_t * pxNetworkBuffer;
1380 NetworkEndPoint_t * pxEndPoint;
1381 UDPPacket_t * pxUDPPacket;
1382 size_t xBufferLength = ipconfigETHERNET_MINIMUM_PACKET_BYTES - 1;
1383
1384 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1385 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1386
1387 /* To trigger checksum generation. */
1388 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1389 pxNetworkBuffer->xDataLength = xBufferLength;
1390
1391 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1392
1393 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1394 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1395 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1396 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1397 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1398 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1399 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1400
1401 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1402
1403 TEST_ASSERT_EQUAL( ipconfigETHERNET_MINIMUM_PACKET_BYTES, pxNetworkBuffer->xDataLength );
1404 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1405 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1406 TEST_ASSERT_EQUAL( xBufferLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1407 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1408 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1409 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1410 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1411 }
1412
1413 /**
1414 * @brief To validate the flow to send UDP and get a cache hit with different endpoint.
1415 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitDiffEndPoint()1416 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitDiffEndPoint()
1417 {
1418 BaseType_t xReturn;
1419 NetworkBufferDescriptor_t * pxNetworkBuffer;
1420 NetworkEndPoint_t * pxEndPoint, xDifferentEndPoint, * pxDifferentEndPoint = &xDifferentEndPoint;
1421 UDPPacket_t * pxUDPPacket;
1422
1423 memset( &xDifferentEndPoint, 0, sizeof( xDifferentEndPoint ) );
1424
1425 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1426 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1427
1428 pxNetworkBuffer->pxEndPoint = pxEndPoint;
1429
1430 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1431
1432 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1433 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1434 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxDifferentEndPoint );
1435 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1436 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1437 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1438
1439 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1440
1441 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1442 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1443 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1444 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1445 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1446 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1447 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1448 }
1449
1450 /**
1451 * @brief To validate the flow to send LLMNR UDP and get a cache hit.
1452 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitLLMNR()1453 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitLLMNR()
1454 {
1455 BaseType_t xReturn;
1456 NetworkBufferDescriptor_t * pxNetworkBuffer;
1457 NetworkEndPoint_t * pxEndPoint;
1458 UDPPacket_t * pxUDPPacket;
1459
1460 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1461 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1462
1463 /* To trigger checksum generation. */
1464 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1465 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = ipLLMNR_IP_ADDR;
1466
1467 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1468
1469 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1470 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1471 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1472 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1473 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1474 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1475 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1476
1477 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1478
1479 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1480 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1481 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1482 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1483 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1484 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1485 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1486 TEST_ASSERT_EQUAL( 0x01, pxUDPPacket->xIPHeader.ucTimeToLive );
1487 }
1488
1489 /**
1490 * @brief To validate the flow to send MDNS UDP and get a cache hit.
1491 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitMDNS()1492 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitMDNS()
1493 {
1494 BaseType_t xReturn;
1495 NetworkBufferDescriptor_t * pxNetworkBuffer;
1496 NetworkEndPoint_t * pxEndPoint;
1497 UDPPacket_t * pxUDPPacket;
1498
1499 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1500 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1501
1502 /* To trigger checksum generation. */
1503 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1504 pxNetworkBuffer->xIPAddress.ulIP_IPv4 = ipMDNS_IP_ADDRESS;
1505
1506 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1507
1508 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1509 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1510 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1511 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1512 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1513 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1514 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1515
1516 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1517
1518 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1519 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1520 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1521 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1522 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1523 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1524 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1525 TEST_ASSERT_EQUAL( 0xFF, pxUDPPacket->xIPHeader.ucTimeToLive );
1526 }
1527
1528 /**
1529 * @brief To validate the flow to send UDP and get a cache hit
1530 * but there is no network interface in endpoint.
1531 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitNoInterface()1532 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitNoInterface()
1533 {
1534 BaseType_t xReturn;
1535 NetworkBufferDescriptor_t * pxNetworkBuffer;
1536 NetworkEndPoint_t * pxEndPoint;
1537 UDPPacket_t * pxUDPPacket;
1538
1539 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1540 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1541 pxEndPoint->pxNetworkInterface = NULL;
1542
1543 /* To trigger checksum generation. */
1544 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1545
1546 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1547
1548 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1549 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1550 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1551 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1552 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1553 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1554 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1555
1556 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1557
1558 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1559 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1560 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1561 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1562 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1563 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1564 TEST_ASSERT_EQUAL( 0, xIsIfOutCalled );
1565 }
1566
1567 /**
1568 * @brief To validate the flow to send UDP and get a cache hit
1569 * but there is no output function in network interface.
1570 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitInterfaceNoOutput()1571 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitInterfaceNoOutput()
1572 {
1573 BaseType_t xReturn;
1574 NetworkBufferDescriptor_t * pxNetworkBuffer;
1575 NetworkEndPoint_t * pxEndPoint;
1576 UDPPacket_t * pxUDPPacket;
1577
1578 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1579 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1580 pxEndPoint->pxNetworkInterface->pfOutput = NULL;
1581
1582 /* To trigger checksum generation. */
1583 pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ] |= FREERTOS_SO_UDPCKSUM_OUT;
1584
1585 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1586
1587 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1588 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1589 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1590 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1591 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1592 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1593 usGenerateProtocolChecksum_ExpectAndReturn( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, pdTRUE, ipCORRECT_CRC );
1594
1595 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1596
1597 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1598 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1599 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1600 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1601 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1602 TEST_ASSERT_EQUAL( ulDefaultIPv4Address, pxUDPPacket->xIPHeader.ulSourceIPAddress );
1603 TEST_ASSERT_EQUAL( 0, xIsIfOutCalled );
1604 }
1605
1606 /**
1607 * @brief To validate the flow to send UDP and get a cache hit but no matching endpoint.
1608 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitNoEndPoint()1609 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheHitNoEndPoint()
1610 {
1611 BaseType_t xReturn;
1612 NetworkBufferDescriptor_t * pxNetworkBuffer;
1613 NetworkEndPoint_t * pxEndPoint;
1614 UDPPacket_t * pxUDPPacket;
1615
1616 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1617 pxEndPoint = NULL;
1618
1619 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1620
1621 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheHit );
1622 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1623 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPoint );
1624 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1625 uxIPHeaderSizePacket_ExpectAndReturn( pxNetworkBuffer, ipSIZE_OF_IPv4_HEADER );
1626 usGenerateChecksum_ExpectAnyArgsAndReturn( ulDefaultProtoChecksum );
1627 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1628
1629 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1630
1631 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1632 TEST_ASSERT_EQUAL( ipPROTOCOL_UDP, pxUDPPacket->xIPHeader.ucProtocol );
1633 TEST_ASSERT_EQUAL( pxNetworkBuffer->xDataLength - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ), FreeRTOS_ntohs( pxUDPPacket->xUDPHeader.usLength ) );
1634 TEST_ASSERT_EQUAL( pxNetworkBuffer->usBoundPort, pxUDPPacket->xUDPHeader.usSourcePort );
1635 TEST_ASSERT_EQUAL( pxNetworkBuffer->usPort, pxUDPPacket->xUDPHeader.usDestinationPort );
1636 TEST_ASSERT_EQUAL( 0, xIsIfOutCalled );
1637 }
1638
1639 /**
1640 * @brief To validate the flow to send UDP and get a cache miss but
1641 * matching endpoint is found.
1642 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheMissEndPointFound()1643 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheMissEndPointFound()
1644 {
1645 BaseType_t xReturn;
1646 NetworkBufferDescriptor_t * pxNetworkBuffer;
1647 NetworkEndPoint_t * pxEndPoint, * pxEndPointNull = NULL;
1648 UDPPacket_t * pxUDPPacket;
1649
1650 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1651 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1652
1653 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1654
1655 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheMiss );
1656 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1657 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPointNull );
1658 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1659
1660 vARPRefreshCacheEntry_Expect( NULL, pxNetworkBuffer->xIPAddress.ulIP_IPv4, NULL );
1661 FreeRTOS_FindEndPointOnNetMask_ExpectAndReturn( pxNetworkBuffer->xIPAddress.ulIP_IPv4, 0, pxEndPoint );
1662 FreeRTOS_FindEndPointOnNetMask_IgnoreArg_ulWhere();
1663
1664 vARPGenerateRequestPacket_Expect( pxNetworkBuffer );
1665
1666 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1667
1668 TEST_ASSERT_EQUAL( pxEndPoint, pxNetworkBuffer->pxEndPoint );
1669 TEST_ASSERT_EQUAL( 1, xIsIfOutCalled );
1670 }
1671
1672 /**
1673 * @brief To validate the flow to send UDP and get a cache miss and
1674 * matching endpoint is not found.
1675 */
test_vProcessGeneratedUDPPacket_IPv4_UDPCacheMissEndPointNotFound()1676 void test_vProcessGeneratedUDPPacket_IPv4_UDPCacheMissEndPointNotFound()
1677 {
1678 BaseType_t xReturn;
1679 NetworkBufferDescriptor_t * pxNetworkBuffer;
1680 NetworkEndPoint_t * pxEndPoint, * pxEndPointNull = NULL;
1681 UDPPacket_t * pxUDPPacket;
1682
1683 pxNetworkBuffer = prvPrepareDefaultNetworkbuffer( ipPROTOCOL_UDP );
1684 pxEndPoint = prvPrepareDefaultIPv4EndPoint();
1685
1686 pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
1687
1688 eARPGetCacheEntry_ExpectAndReturn( &( pxNetworkBuffer->xIPAddress.ulIP_IPv4 ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ), NULL, eARPCacheMiss );
1689 eARPGetCacheEntry_IgnoreArg_ppxEndPoint();
1690 eARPGetCacheEntry_ReturnThruPtr_ppxEndPoint( &pxEndPointNull );
1691 eARPGetCacheEntry_IgnoreArg_pulIPAddress();
1692
1693 vARPRefreshCacheEntry_Expect( NULL, pxNetworkBuffer->xIPAddress.ulIP_IPv4, NULL );
1694 FreeRTOS_FindEndPointOnNetMask_ExpectAndReturn( pxNetworkBuffer->xIPAddress.ulIP_IPv4, 0, NULL );
1695 FreeRTOS_FindEndPointOnNetMask_IgnoreArg_ulWhere();
1696 vReleaseNetworkBufferAndDescriptor_Expect( pxNetworkBuffer );
1697
1698 vProcessGeneratedUDPPacket_IPv4( pxNetworkBuffer );
1699
1700 TEST_ASSERT_EQUAL( NULL, pxNetworkBuffer->pxEndPoint );
1701 TEST_ASSERT_EQUAL( 0, xIsIfOutCalled );
1702 }
1703
