1 /*
2  * FreeRTOS+TCP <DEVELOPMENT BRANCH>
3  * Copyright (C) 2022 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
4  *
5  * SPDX-License-Identifier: MIT
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy of
8  * this software and associated documentation files (the "Software"), to deal in
9  * the Software without restriction, including without limitation the rights to
10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11  * the Software, and to permit persons to whom the Software is furnished to do so,
12  * subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23  *
24  * http://aws.amazon.com/freertos
25  * http://www.FreeRTOS.org
26  */
27 
28 
29 /* Include Unity header */
30 #include "unity.h"
31 
32 /* Include standard libraries */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdint.h>
36 
37 #include "mock_task.h"
38 
39 #include "mock_FreeRTOS_IP_Private.h"
40 #include "mock_FreeRTOS_Sockets.h"
41 #include "mock_FreeRTOS_Stream_Buffer.h"
42 #include "mock_FreeRTOS_TCP_WIN.h"
43 #include "mock_FreeRTOS_TCP_Transmission.h"
44 #include "mock_FreeRTOS_TCP_Reception.h"
45 #include "mock_TCP_State_Handling_list_macros.h"
46 
47 #include "catch_assert.h"
48 
49 #include "FreeRTOSIPConfig.h"
50 
51 #include "FreeRTOS_TCP_State_Handling.h"
52 #include "FreeRTOS_TCP_State_Handling_stubs.c"
53 
54 /* ===========================  EXTERN VARIABLES  =========================== */
55 
56 BaseType_t prvTCPHandleFin( FreeRTOS_Socket_t * pxSocket,
57                             const NetworkBufferDescriptor_t * pxNetworkBuffer );
58 
59 BaseType_t prvHandleSynReceived( FreeRTOS_Socket_t * pxSocket,
60                                  const NetworkBufferDescriptor_t * pxNetworkBuffer,
61                                  uint32_t ulReceiveLength,
62                                  UBaseType_t uxOptionsLength );
63 
64 BaseType_t prvHandleEstablished( FreeRTOS_Socket_t * pxSocket,
65                                  NetworkBufferDescriptor_t ** ppxNetworkBuffer,
66                                  uint32_t ulReceiveLength,
67                                  UBaseType_t uxOptionsLength );
68 
69 FreeRTOS_Socket_t xSocket, * pxSocket;
70 NetworkBufferDescriptor_t xNetworkBuffer, * pxNetworkBuffer;
71 
72 uint8_t ucEthernetBuffer[ ipconfigNETWORK_MTU ];
73 
74 /* ============================  Unity Fixtures  ============================ */
75 
76 /*! called before each test case */
setUp(void)77 void setUp( void )
78 {
79     memset( &xSocket, 0, sizeof( xSocket ) );
80     memset( &xNetworkBuffer, 0, sizeof( xNetworkBuffer ) );
81     memset( &ucEthernetBuffer, 0, sizeof( ucEthernetBuffer ) );
82 
83     pxSocket = NULL;
84     pxNetworkBuffer = NULL;
85 }
86 
87 /* ==============================  Test Cases  ============================== */
88 
89 /**
90  * @brief Check if socket is active in different states.
91  */
test_prvTCPSocketIsActive(void)92 void test_prvTCPSocketIsActive( void )
93 {
94     BaseType_t xResult;
95 
96     /* Setup TCP option for tests */
97     eIPTCPState_t Status;
98 
99     Status = eCLOSED;
100     xResult = prvTCPSocketIsActive( Status );
101     TEST_ASSERT_EQUAL( pdFALSE, xResult );
102 
103     Status = eCLOSE_WAIT;
104     xResult = prvTCPSocketIsActive( Status );
105     TEST_ASSERT_EQUAL( pdFALSE, xResult );
106 
107     Status = eFIN_WAIT_2;
108     xResult = prvTCPSocketIsActive( Status );
109     TEST_ASSERT_EQUAL( pdFALSE, xResult );
110 
111     Status = eCLOSING;
112     xResult = prvTCPSocketIsActive( Status );
113     TEST_ASSERT_EQUAL( pdFALSE, xResult );
114 
115     Status = eTIME_WAIT;
116     xResult = prvTCPSocketIsActive( Status );
117     TEST_ASSERT_EQUAL( pdFALSE, xResult );
118 
119     Status = eTCP_LISTEN;
120     xResult = prvTCPSocketIsActive( Status );
121     TEST_ASSERT_EQUAL( pdTRUE, xResult );
122 
123     Status = eCONNECT_SYN;
124     xResult = prvTCPSocketIsActive( Status );
125     TEST_ASSERT_EQUAL( pdTRUE, xResult );
126 
127     Status = eSYN_FIRST;
128     xResult = prvTCPSocketIsActive( Status );
129     TEST_ASSERT_EQUAL( pdTRUE, xResult );
130 
131     Status = eSYN_RECEIVED;
132     xResult = prvTCPSocketIsActive( Status );
133     TEST_ASSERT_EQUAL( pdTRUE, xResult );
134 
135     Status = eESTABLISHED;
136     xResult = prvTCPSocketIsActive( Status );
137     TEST_ASSERT_EQUAL( pdTRUE, xResult );
138 
139     Status = eFIN_WAIT_1;
140     xResult = prvTCPSocketIsActive( Status );
141     TEST_ASSERT_EQUAL( pdTRUE, xResult );
142 
143     Status = eLAST_ACK;
144     xResult = prvTCPSocketIsActive( Status );
145     TEST_ASSERT_EQUAL( pdTRUE, xResult );
146 }
147 
148 #if ( ipconfigTCP_HANG_PROTECTION == 1 )
149 
150 /**
151  * @brief No need to check timeout in some states.
152  */
test_prvTCPStatusAgeCheck_NoChecksNeeded(void)153     void test_prvTCPStatusAgeCheck_NoChecksNeeded( void )
154     {
155         BaseType_t xResult = pdTRUE;
156 
157         pxSocket = &xSocket;
158 
159         pxSocket->u.xTCP.eTCPState = eESTABLISHED;
160         xResult = prvTCPStatusAgeCheck( pxSocket );
161         TEST_ASSERT_EQUAL( pdFALSE, xResult );
162 
163         pxSocket->u.xTCP.eTCPState = eCLOSED;
164         xResult = prvTCPStatusAgeCheck( pxSocket );
165         TEST_ASSERT_EQUAL( pdFALSE, xResult );
166 
167         pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
168         xResult = prvTCPStatusAgeCheck( pxSocket );
169         TEST_ASSERT_EQUAL( pdFALSE, xResult );
170 
171         pxSocket->u.xTCP.eTCPState = eCLOSE_WAIT;
172         xResult = prvTCPStatusAgeCheck( pxSocket );
173         TEST_ASSERT_EQUAL( pdFALSE, xResult );
174     }
175 
176 /**
177  * @brief Keep waiting when timeout is not triggered.
178  */
test_prvTCPStatusAgeCheck_ChecksDoneAgeLEProtectiontime(void)179     void test_prvTCPStatusAgeCheck_ChecksDoneAgeLEProtectiontime( void )
180     {
181         BaseType_t xResult = pdTRUE;
182 
183         pxSocket = &xSocket;
184 
185         pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
186         pxSocket->u.xTCP.xLastAliveTime = 1000;
187 
188         xTaskGetTickCount_ExpectAndReturn( 2000 );
189         xResult = prvTCPStatusAgeCheck( pxSocket );
190         TEST_ASSERT_EQUAL( pdTRUE, xResult );
191     }
192 
193 /**
194  * @brief Start close procedure when waiting SYN/ACK timeout.
195  */
test_prvTCPStatusAgeCheck_ChecksDoneAgeGTProtectiontime(void)196     void test_prvTCPStatusAgeCheck_ChecksDoneAgeGTProtectiontime( void )
197     {
198         BaseType_t xResult = pdTRUE;
199 
200         pxSocket = &xSocket;
201 
202         pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
203         pxSocket->u.xTCP.xLastAliveTime = 1000;
204 
205         xTaskGetTickCount_ExpectAndReturn( 32000 );
206         vTCPStateChange_ExpectAnyArgs();
207         xResult = prvTCPStatusAgeCheck( pxSocket );
208         TEST_ASSERT_EQUAL( pdTRUE, xResult );
209     }
210 
211 /**
212  * @brief Start close procedure when waiting SYN/ACK timeout.
213  * And the pass queue is true.
214  */
test_prvTCPStatusAgeCheck_ChecksDonePassQueueBitTrue(void)215     void test_prvTCPStatusAgeCheck_ChecksDonePassQueueBitTrue( void )
216     {
217         BaseType_t xResult = pdTRUE;
218 
219         pxSocket = &xSocket;
220 
221         pxSocket->u.xTCP.eTCPState = eSYN_FIRST;
222         pxSocket->u.xTCP.xLastAliveTime = 1000;
223         pxSocket->u.xTCP.bits.bPassQueued = pdTRUE;
224 
225         xTaskGetTickCount_ExpectAndReturn( 32000 );
226         vTCPStateChange_ExpectAnyArgs();
227         xResult = prvTCPStatusAgeCheck( pxSocket );
228         TEST_ASSERT_EQUAL( -1, xResult );
229     }
230 
231 #endif /* if ( ipconfigTCP_HANG_PROTECTION == 1 ) */
232 
233 /**
234  * @brief Receive FIN packet when FIN sent/ack/recv/last are all not true.
235  */
test_prvTCPHandleFin_FIN_BitsAllFalse(void)236 void test_prvTCPHandleFin_FIN_BitsAllFalse( void )
237 {
238     BaseType_t xSendLength = 0;
239 
240     pxSocket = &xSocket;
241     pxNetworkBuffer = &xNetworkBuffer;
242     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
243 
244     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
245     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
246                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
247     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
248     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
249     uint32_t ulAckNr = FreeRTOS_ntohl( pxTCPHeader->ulAckNr );
250 
251     pxTCPHeader->ucTCPFlags = 0;
252     pxTCPWindow->rx.ulCurrentSequenceNumber = 1000;
253     pxTCPWindow->tx.ulCurrentSequenceNumber = 2000;
254     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
255     pxSocket->u.xTCP.bits.bFinAcked = pdFALSE;
256     pxSocket->u.xTCP.bits.bFinRecv = pdFALSE;
257     pxSocket->u.xTCP.bits.bFinLast = pdFALSE;
258     pxTCPHeader->ulAckNr = 2000;
259 
260     uxIPHeaderSizePacket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
261     vTCPStateChange_ExpectAnyArgs();
262     uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
263 
264     xSendLength = prvTCPHandleFin( pxSocket, ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer );
265     TEST_ASSERT_EQUAL( 40, xSendLength );
266     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->tx.ulFINSequenceNumber );
267 }
268 
269 /**
270  * @brief Receive FIN packet when FIN recv is not true.
271  */
test_prvTCPHandleFin_FIN_FINSentFINACKNoFINRecv(void)272 void test_prvTCPHandleFin_FIN_FINSentFINACKNoFINRecv( void )
273 {
274     BaseType_t xSendLength = 0;
275 
276     pxSocket = &xSocket;
277     pxNetworkBuffer = &xNetworkBuffer;
278     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
279 
280     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
281     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
282                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
283     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
284     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
285     uint32_t ulAckNr = FreeRTOS_ntohl( pxTCPHeader->ulAckNr );
286 
287     pxTCPHeader->ucTCPFlags |= tcpTCP_FLAG_FIN;
288     pxTCPHeader->ulAckNr = FreeRTOS_htonl( 2001 );
289     pxTCPWindow->rx.ulCurrentSequenceNumber = 1000;
290     pxTCPWindow->tx.ulCurrentSequenceNumber = 2000;
291     pxTCPWindow->tx.ulFINSequenceNumber = 2000;
292     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
293     pxSocket->u.xTCP.bits.bFinAcked = pdTRUE;
294     pxSocket->u.xTCP.bits.bFinRecv = pdFALSE;
295     pxSocket->u.xTCP.bits.bFinLast = pdFALSE;
296 
297     uxIPHeaderSizePacket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
298 
299     xSendLength = prvTCPHandleFin( pxSocket, ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer );
300     TEST_ASSERT_EQUAL( 0, xSendLength );
301     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->tx.ulFINSequenceNumber );
302 }
303 
304 /**
305  * @brief Receive FIN packet when FIN last is not true.
306  */
test_prvTCPHandleFin_FIN_FINRecvFINSentFINACKFINNotLast(void)307 void test_prvTCPHandleFin_FIN_FINRecvFINSentFINACKFINNotLast( void )
308 {
309     BaseType_t xSendLength = 0;
310 
311     pxSocket = &xSocket;
312     pxNetworkBuffer = &xNetworkBuffer;
313     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
314 
315     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
316     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
317                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
318     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
319     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
320     uint32_t ulAckNr = FreeRTOS_ntohl( pxTCPHeader->ulAckNr );
321 
322     pxTCPHeader->ucTCPFlags |= tcpTCP_FLAG_FIN;
323     pxTCPHeader->ulAckNr = FreeRTOS_htonl( 2001 );
324     pxTCPWindow->rx.ulCurrentSequenceNumber = 1000;
325     pxTCPWindow->tx.ulCurrentSequenceNumber = 2000;
326     pxTCPWindow->tx.ulFINSequenceNumber = 2000;
327     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
328     pxSocket->u.xTCP.bits.bFinAcked = pdTRUE;
329     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
330     pxSocket->u.xTCP.bits.bFinLast = pdFALSE;
331 
332     uxIPHeaderSizePacket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
333     vTCPStateChange_ExpectAnyArgs();
334     uxIPHeaderSizeSocket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
335 
336     xSendLength = prvTCPHandleFin( pxSocket, ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer );
337     TEST_ASSERT_EQUAL( 40, xSendLength );
338     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->tx.ulFINSequenceNumber );
339 }
340 
341 /**
342  * @brief Receive FIN packet when FIN sent/ack/recv/last are all true.
343  */
test_prvTCPHandleFin_FIN_FINRecvFINSentFINACKFINLast(void)344 void test_prvTCPHandleFin_FIN_FINRecvFINSentFINACKFINLast( void )
345 {
346     BaseType_t xSendLength = 0;
347 
348     pxSocket = &xSocket;
349     pxNetworkBuffer = &xNetworkBuffer;
350     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
351 
352     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
353     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
354                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
355     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
356     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
357     uint32_t ulAckNr = FreeRTOS_ntohl( pxTCPHeader->ulAckNr );
358 
359     pxTCPHeader->ucTCPFlags |= tcpTCP_FLAG_FIN;
360     pxTCPHeader->ulAckNr = 2001;
361     pxTCPWindow->rx.ulCurrentSequenceNumber = 1000;
362     pxTCPWindow->tx.ulCurrentSequenceNumber = 2000;
363     pxTCPWindow->tx.ulFINSequenceNumber = 2000;
364     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
365     pxSocket->u.xTCP.bits.bFinAcked = pdTRUE;
366     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
367     pxSocket->u.xTCP.bits.bFinLast = pdTRUE;
368 
369     uxIPHeaderSizePacket_ExpectAnyArgsAndReturn( ipSIZE_OF_IPv4_HEADER );
370     vTCPStateChange_ExpectAnyArgs();
371 
372     xSendLength = prvTCPHandleFin( pxSocket, ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer );
373     TEST_ASSERT_EQUAL( 0, xSendLength );
374     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->tx.ulFINSequenceNumber );
375 }
376 
377 /**
378  * @brief Receive SYN packet when waiting for it.
379  */
test_prvHandleSynReceived_ExpSYNStateConnectSyn(void)380 void test_prvHandleSynReceived_ExpSYNStateConnectSyn( void )
381 {
382     BaseType_t xSendLength = 0;
383 
384     pxSocket = &xSocket;
385     pxNetworkBuffer = &xNetworkBuffer;
386     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
387 
388     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
389     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
390                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
391     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
392     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
393 
394     pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
395     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_SYN | tcpTCP_FLAG_ACK;
396     pxTCPHeader->ulSequenceNumber = 0;
397 
398     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
399     vTCPWindowInit_ExpectAnyArgs();
400     FreeRTOS_inet_ntop_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
401     vTCPStateChange_ExpectAnyArgs();
402 
403     xSendLength = prvHandleSynReceived( pxSocket,
404                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
405                                         0,
406                                         0 );
407     TEST_ASSERT_EQUAL( 40, xSendLength );
408 }
409 
410 /**
411  * @brief Receive SYN IPv6 packet when waiting for it.
412  */
test_prvHandleSynReceived_ExpSYNStateConnectSynIPv6(void)413 void test_prvHandleSynReceived_ExpSYNStateConnectSynIPv6( void )
414 {
415     BaseType_t xSendLength = 0;
416 
417     pxSocket = &xSocket;
418     pxNetworkBuffer = &xNetworkBuffer;
419     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
420 
421     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
422     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
423                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
424     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
425     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
426 
427     pxSocket->bits.bIsIPv6 = pdTRUE_UNSIGNED;
428     pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
429     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_SYN | tcpTCP_FLAG_ACK;
430     pxTCPHeader->ulSequenceNumber = 0;
431 
432     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
433     vTCPWindowInit_ExpectAnyArgs();
434     FreeRTOS_inet_ntop_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
435     vTCPStateChange_ExpectAnyArgs();
436 
437     xSendLength = prvHandleSynReceived( pxSocket,
438                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
439                                         0,
440                                         0 );
441     TEST_ASSERT_EQUAL( 40, xSendLength );
442 }
443 
444 /**
445  * @brief Trigger close procedure when expect SYN packet but receive packet without SYN.
446  */
test_prvHandleSynReceived_NotSYNStateConnectSyn(void)447 void test_prvHandleSynReceived_NotSYNStateConnectSyn( void )
448 {
449     BaseType_t xSendLength = 0;
450 
451     pxSocket = &xSocket;
452     pxNetworkBuffer = &xNetworkBuffer;
453     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
454 
455     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
456     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
457                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
458     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
459     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
460 
461     pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
462     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
463     pxTCPHeader->ulAckNr = 1;
464     pxTCPHeader->ulSequenceNumber = 0;
465 
466     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
467     vTCPStateChange_ExpectAnyArgs();
468 
469     xSendLength = prvHandleSynReceived( pxSocket,
470                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
471                                         0,
472                                         0 );
473     TEST_ASSERT_EQUAL( 40, xSendLength );
474 }
475 
476 /**
477  * @brief Trigger close procedure when not expect SYN packet but receive one.
478  */
test_prvHandleSynReceived_NotExpSYNStateSynreceived(void)479 void test_prvHandleSynReceived_NotExpSYNStateSynreceived( void )
480 {
481     BaseType_t xSendLength = 0;
482 
483     pxSocket = &xSocket;
484     pxNetworkBuffer = &xNetworkBuffer;
485     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
486 
487     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
488     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
489                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
490     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
491     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
492 
493     pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
494     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_SYN;
495     pxTCPHeader->ulAckNr = 1;
496     pxTCPHeader->ulSequenceNumber = 0;
497 
498     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
499     vTCPStateChange_ExpectAnyArgs();
500 
501     xSendLength = prvHandleSynReceived( pxSocket,
502                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
503                                         0,
504                                         0 );
505     TEST_ASSERT_EQUAL( 40, xSendLength );
506 }
507 
508 /**
509  * @brief Handle an ACK packet.
510  */
test_prvHandleSynReceived_ExpACKStateSynreceivedZeroData(void)511 void test_prvHandleSynReceived_ExpACKStateSynreceivedZeroData( void )
512 {
513     BaseType_t xSendLength = 0;
514 
515     pxSocket = &xSocket;
516     pxNetworkBuffer = &xNetworkBuffer;
517     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
518 
519     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
520     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
521                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
522     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
523     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
524 
525     pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
526     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
527     pxTCPHeader->ulSequenceNumber = 0;
528 
529     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
530     FreeRTOS_inet_ntop_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
531     vTCPStateChange_ExpectAnyArgs();
532 
533     xSendLength = prvHandleSynReceived( pxSocket,
534                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
535                                         0,
536                                         0 );
537     TEST_ASSERT_EQUAL( 0, xSendLength );
538 }
539 
540 /**
541  * @brief Handle an ACK packet with window scaling enabled.
542  */
test_prvHandleSynReceived_ExpACKStateSynreceivedNonZeroDataWinScaling(void)543 void test_prvHandleSynReceived_ExpACKStateSynreceivedNonZeroDataWinScaling( void )
544 {
545     BaseType_t xSendLength = 0;
546 
547     pxSocket = &xSocket;
548     pxNetworkBuffer = &xNetworkBuffer;
549     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
550 
551     /* Map the ethernet buffer onto the ProtocolHeader_t struct for easy access to the fields. */
552     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
553                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
554     TCPHeader_t * pxTCPHeader = &( pxProtocolHeaders->xTCPHeader );
555     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
556 
557     pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
558     pxSocket->u.xTCP.bits.bWinScaling = pdTRUE;
559     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
560     pxTCPHeader->ulSequenceNumber = 0;
561 
562     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
563     FreeRTOS_inet_ntop_ExpectAnyArgsAndReturn( ( void * ) 0x1234 );
564     vTCPStateChange_ExpectAnyArgs();
565 
566     xSendLength = prvHandleSynReceived( pxSocket,
567                                         ( const NetworkBufferDescriptor_t * ) pxNetworkBuffer,
568                                         20,
569                                         0 );
570     TEST_ASSERT_EQUAL( 40, xSendLength );
571 }
572 
573 /**
574  * @brief Handle a packet without ACK flag.
575  */
test_prvHandleEstablished_NoACK(void)576 void test_prvHandleEstablished_NoACK( void )
577 {
578     BaseType_t xSendLength = 0;
579 
580     pxSocket = &xSocket;
581     pxNetworkBuffer = &xNetworkBuffer;
582     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
583 
584     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
585     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
586                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
587     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
588 
589     pxTCPHeader->ucTCPFlags = 0;
590 
591     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
592 
593     xSendLength = prvHandleEstablished( pxSocket,
594                                         &pxNetworkBuffer,
595                                         1000,
596                                         0 );
597     TEST_ASSERT_EQUAL( 0, xSendLength );
598 }
599 
600 /**
601  * @brief Happy path to handle ACK packet.
602  */
test_prvHandleEstablished_ACKHappy(void)603 void test_prvHandleEstablished_ACKHappy( void )
604 {
605     BaseType_t xSendLength = 0;
606 
607     pxSocket = &xSocket;
608     pxNetworkBuffer = &xNetworkBuffer;
609     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
610 
611     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
612     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
613                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
614     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
615     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
616 
617     ulCalled = 0;
618     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
619     pxTCPHeader->usWindow = 1000;
620     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
621     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
622 
623     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
624     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1000 );
625     uxStreamBufferGet_ExpectAnyArgsAndReturn( 1000 );
626     prvTCPAddTxData_ExpectAnyArgs();
627     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 1040 );
628 
629     xSendLength = prvHandleEstablished( pxSocket,
630                                         &pxNetworkBuffer,
631                                         1000,
632                                         0 );
633     TEST_ASSERT_EQUAL( 1040, xSendLength );
634     TEST_ASSERT_EQUAL( 1, ulCalled );
635 }
636 
637 /**
638  * @brief Receive packet with NULL TX stream.
639  */
test_prvHandleEstablished_ACKNullTXRecvZero(void)640 void test_prvHandleEstablished_ACKNullTXRecvZero( void )
641 {
642     BaseType_t xSendLength = 0;
643 
644     pxSocket = &xSocket;
645     pxNetworkBuffer = &xNetworkBuffer;
646     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
647 
648     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
649     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
650                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
651     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
652     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
653 
654     ulCalled = 0;
655     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
656     pxTCPHeader->usWindow = 1000;
657     pxSocket->u.xTCP.txStream = NULL;
658     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
659 
660     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
661     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1000 );
662     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 40 );
663 
664     xSendLength = prvHandleEstablished( pxSocket,
665                                         &pxNetworkBuffer,
666                                         0,
667                                         0 );
668     TEST_ASSERT_EQUAL( 40, xSendLength );
669     TEST_ASSERT_EQUAL( 0, ulCalled );
670 }
671 
672 /**
673  * @brief Return basic header size and option length to send ACK back when option length is not zero.
674  */
test_prvHandleEstablished_ACKWinZeroRecvZero_HasOption(void)675 void test_prvHandleEstablished_ACKWinZeroRecvZero_HasOption( void )
676 {
677     BaseType_t xSendLength = 0;
678 
679     pxSocket = &xSocket;
680     pxNetworkBuffer = &xNetworkBuffer;
681     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
682 
683     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
684     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
685                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
686     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
687     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
688 
689     ulCalled = 0;
690     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
691     pxTCPHeader->usWindow = 1000;
692     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
693     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
694 
695     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
696     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
697     prvTCPAddTxData_ExpectAnyArgs();
698 
699     xSendLength = prvHandleEstablished( pxSocket,
700                                         &pxNetworkBuffer,
701                                         1000,
702                                         12 );
703     TEST_ASSERT_EQUAL( 52, xSendLength );
704     TEST_ASSERT_EQUAL( 0, ulCalled );
705 }
706 
707 /**
708  * @brief No buffer available to send, return basic header size to send ACK back.
709  */
test_prvHandleEstablished_ACKBufferZeroPrepFalse(void)710 void test_prvHandleEstablished_ACKBufferZeroPrepFalse( void )
711 {
712     BaseType_t xSendLength = 0;
713 
714     pxSocket = &xSocket;
715     pxNetworkBuffer = &xNetworkBuffer;
716     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
717 
718     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
719     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
720                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
721     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
722     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
723 
724     ulCalled = 0;
725     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
726     pxTCPHeader->usWindow = 1000;
727     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
728     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
729 
730     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
731     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1000 );
732     uxStreamBufferGet_ExpectAnyArgsAndReturn( 0 );
733     prvTCPAddTxData_ExpectAnyArgs();
734     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 0 );
735 
736     xSendLength = prvHandleEstablished( pxSocket,
737                                         &pxNetworkBuffer,
738                                         1000,
739                                         0 );
740     TEST_ASSERT_EQUAL( 40, xSendLength );
741     TEST_ASSERT_EQUAL( 0, ulCalled );
742 }
743 
744 /**
745  * @brief Happy path to send packet back with select bit when receiving TCP packet with ACK.
746  * But no callback registered.
747  */
test_prvHandleEstablished_ACKHappySelectNoHandler(void)748 void test_prvHandleEstablished_ACKHappySelectNoHandler( void )
749 {
750     BaseType_t xSendLength = 0;
751 
752     pxSocket = &xSocket;
753     pxNetworkBuffer = &xNetworkBuffer;
754     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
755 
756     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
757     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
758                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
759     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
760     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
761 
762     ulCalled = 0;
763     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
764     pxTCPHeader->usWindow = 1000;
765     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
766     pxSocket->u.xTCP.pxHandleSent = NULL;
767     pxSocket->xSelectBits = eSELECT_WRITE;
768 
769     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
770     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1000 );
771     uxStreamBufferGet_ExpectAnyArgsAndReturn( 1000 );
772     prvTCPAddTxData_ExpectAnyArgs();
773     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 1040 );
774 
775     xSendLength = prvHandleEstablished( pxSocket,
776                                         &pxNetworkBuffer,
777                                         1000,
778                                         0 );
779     TEST_ASSERT_EQUAL( 1040, xSendLength );
780 }
781 
782 /**
783  * @brief Trigger closing flow when first receiving TCP packet with FIN/ACK.
784  */
test_prvHandleEstablished_FINNotSentRXComplete(void)785 void test_prvHandleEstablished_FINNotSentRXComplete( void )
786 {
787     BaseType_t xSendLength = 0;
788 
789     pxSocket = &xSocket;
790 
791     pxNetworkBuffer = &xNetworkBuffer;
792     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
793 
794     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
795     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
796                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
797     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
798     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
799 
800     ulCalled = 0;
801     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_FIN | tcpTCP_FLAG_ACK;
802     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
803     pxTCPHeader->usWindow = 1000;
804     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
805     pxSocket->u.xTCP.pxHandleSent = NULL;
806     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
807     pxTCPWindow->rx.ulCurrentSequenceNumber = 2501;
808 
809     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
810     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
811     prvTCPAddTxData_ExpectAnyArgs();
812     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdTRUE );
813     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdTRUE );
814     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
815     vTCPStateChange_ExpectAnyArgs();
816 
817     xSendLength = prvHandleEstablished( pxSocket,
818                                         &pxNetworkBuffer,
819                                         0,
820                                         0 );
821     TEST_ASSERT_EQUAL( 40, xSendLength );
822 }
823 
824 /**
825  * @brief Data left for receiving when receiving TCP packet with FIN/ACK.
826  */
test_prvHandleEstablished_FINNotSentRXNotComplete(void)827 void test_prvHandleEstablished_FINNotSentRXNotComplete( void )
828 {
829     BaseType_t xSendLength = 0;
830 
831     pxSocket = &xSocket;
832 
833     pxNetworkBuffer = &xNetworkBuffer;
834     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
835 
836     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
837     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
838                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
839     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
840     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
841 
842     ulCalled = 0;
843     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_FIN | tcpTCP_FLAG_ACK;
844     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
845     pxTCPHeader->usWindow = 1000;
846     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
847     pxSocket->u.xTCP.pxHandleSent = NULL;
848     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
849     pxTCPWindow->rx.ulCurrentSequenceNumber = 2501;
850 
851     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
852     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
853     prvTCPAddTxData_ExpectAnyArgs();
854     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdFALSE );
855     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdTRUE );
856     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 0 );
857 
858     xSendLength = prvHandleEstablished( pxSocket,
859                                         &pxNetworkBuffer,
860                                         0,
861                                         0 );
862     TEST_ASSERT_EQUAL( 0, xSendLength );
863 }
864 
865 /**
866  * @brief Data left for sending when receiving TCP packet with FIN/ACK.
867  */
test_prvHandleEstablished_FINNotSentTXWinNotComplete(void)868 void test_prvHandleEstablished_FINNotSentTXWinNotComplete( void )
869 {
870     BaseType_t xSendLength = 0;
871 
872     pxSocket = &xSocket;
873 
874     pxNetworkBuffer = &xNetworkBuffer;
875     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
876 
877     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
878     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
879                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
880     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
881     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
882 
883     ulCalled = 0;
884     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_FIN | tcpTCP_FLAG_ACK;
885     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
886     pxTCPHeader->usWindow = 1000;
887     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
888     pxSocket->u.xTCP.pxHandleSent = NULL;
889     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
890     pxTCPWindow->rx.ulCurrentSequenceNumber = 2501;
891 
892     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
893     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
894     prvTCPAddTxData_ExpectAnyArgs();
895     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdTRUE );
896     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdFALSE );
897     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 0 );
898 
899     xSendLength = prvHandleEstablished( pxSocket,
900                                         &pxNetworkBuffer,
901                                         0,
902                                         0 );
903     TEST_ASSERT_EQUAL( 0, xSendLength );
904 }
905 
906 /**
907  * @brief RX sequence doesn't match when receiving TCP packet with FIN/ACK.
908  */
test_prvHandleEstablished_FINNotSentDataLeft(void)909 void test_prvHandleEstablished_FINNotSentDataLeft( void )
910 {
911     BaseType_t xSendLength = 0;
912 
913     pxSocket = &xSocket;
914 
915     pxNetworkBuffer = &xNetworkBuffer;
916     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
917 
918     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
919     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
920                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
921     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
922     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
923 
924     ulCalled = 0;
925     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_FIN | tcpTCP_FLAG_ACK;
926     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
927     pxTCPHeader->usWindow = 1000;
928     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
929     pxSocket->u.xTCP.pxHandleSent = NULL;
930     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
931     pxTCPWindow->rx.ulCurrentSequenceNumber = 2200;
932 
933     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
934     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
935     prvTCPAddTxData_ExpectAnyArgs();
936     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdTRUE );
937     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdTRUE );
938     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 40 );
939 
940     xSendLength = prvHandleEstablished( pxSocket,
941                                         &pxNetworkBuffer,
942                                         1000,
943                                         0 );
944     TEST_ASSERT_EQUAL( 40, xSendLength );
945 }
946 
947 /**
948  * @brief Fin sent bit was set before receiving an ACK packet.
949  */
test_prvHandleEstablished_FINSentACKPacket(void)950 void test_prvHandleEstablished_FINSentACKPacket( void )
951 {
952     BaseType_t xSendLength = 0;
953 
954     pxSocket = &xSocket;
955 
956     pxNetworkBuffer = &xNetworkBuffer;
957     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
958 
959     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
960     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
961                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
962     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
963     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
964 
965     ulCalled = 0;
966     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
967     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
968     pxTCPHeader->usWindow = 1000;
969     pxSocket->u.xTCP.txStream = NULL;
970     pxSocket->u.xTCP.pxHandleSent = NULL;
971     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
972     pxTCPWindow->rx.ulCurrentSequenceNumber = 2200;
973     pxTCPWindow->tx.ulCurrentSequenceNumber = 1999;
974     pxTCPWindow->tx.ulFINSequenceNumber = 2000;
975 
976     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
977     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
978     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 40 );
979 
980     xSendLength = prvHandleEstablished( pxSocket,
981                                         &pxNetworkBuffer,
982                                         1000,
983                                         0 );
984     TEST_ASSERT_EQUAL( 40, xSendLength );
985     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->tx.ulCurrentSequenceNumber );
986 }
987 
988 /**
989  * @brief Need to release resources when receiving TCP packet with FIN/ACK.
990  */
test_prvHandleEstablished_FINSent(void)991 void test_prvHandleEstablished_FINSent( void )
992 {
993     BaseType_t xSendLength = 0;
994 
995     pxSocket = &xSocket;
996 
997     pxNetworkBuffer = &xNetworkBuffer;
998     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
999 
1000     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1001     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1002                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1003     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1004     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1005 
1006     ulCalled = 0;
1007     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_FIN | tcpTCP_FLAG_ACK;
1008     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
1009     pxTCPHeader->usWindow = 1000;
1010     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1011     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1012     pxSocket->u.xTCP.pxHandleSent = NULL;
1013     pxTCPWindow->rx.ulCurrentSequenceNumber = 2501;
1014 
1015     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1016     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1017     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
1018     prvTCPAddTxData_ExpectAnyArgs();
1019     vTCPStateChange_ExpectAnyArgs();
1020 
1021     xSendLength = prvHandleEstablished( pxSocket,
1022                                         &pxNetworkBuffer,
1023                                         0,
1024                                         0 );
1025     TEST_ASSERT_EQUAL( 40, xSendLength );
1026 }
1027 
1028 /**
1029  * @brief FIN was accepted before receiving an ACK packet.
1030  */
test_prvHandleEstablished_FINAccept(void)1031 void test_prvHandleEstablished_FINAccept( void )
1032 {
1033     BaseType_t xSendLength = 0;
1034 
1035     pxSocket = &xSocket;
1036 
1037     pxNetworkBuffer = &xNetworkBuffer;
1038     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1039 
1040     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1041     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1042                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1043     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1044     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1045 
1046     ulCalled = 0;
1047     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1048     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1500 );
1049     pxTCPHeader->usWindow = 1000;
1050     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1051     pxSocket->u.xTCP.bits.bFinAccepted = pdTRUE;
1052     pxSocket->u.xTCP.txStream = NULL;
1053     pxSocket->u.xTCP.pxHandleSent = NULL;
1054     pxTCPWindow->rx.ulCurrentSequenceNumber = 2501;
1055 
1056     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1057     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1058     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 0 );
1059     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdFALSE );
1060     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdFALSE );
1061     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 40 );
1062 
1063     xSendLength = prvHandleEstablished( pxSocket,
1064                                         &pxNetworkBuffer,
1065                                         1000,
1066                                         0 );
1067     TEST_ASSERT_EQUAL( 40, xSendLength );
1068 }
1069 
1070 /**
1071  * @brief Get TCP packet with ACK when the state of socket is eCLOSED.
1072  * To simulate malloc fail case.
1073  */
test_prvTCPHandleState_ClosedMallocFailure(void)1074 void test_prvTCPHandleState_ClosedMallocFailure( void )
1075 {
1076     BaseType_t xSendLength = 0;
1077 
1078     pxSocket = &xSocket;
1079 
1080     pxNetworkBuffer = &xNetworkBuffer;
1081     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1082 
1083     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1084     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1085                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1086     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1087     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1088 
1089     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1090     pxSocket->u.xTCP.eTCPState = eCLOSED;
1091     pxSocket->u.xTCP.txStream = NULL;
1092     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1093     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1094     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1095     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1096     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1097 
1098     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1099     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1100     prvStoreRxData_ExpectAnyArgsAndReturn( -1 );
1101 
1102     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1103 
1104     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1105     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1106     TEST_ASSERT_EQUAL( -1, xSendLength );
1107 }
1108 
1109 /**
1110  * @brief Get TCP packet with ACK when the state of socket is eCLOSED.
1111  */
test_prvTCPHandleState_Closed(void)1112 void test_prvTCPHandleState_Closed( void )
1113 {
1114     BaseType_t xSendLength = 0;
1115 
1116     pxSocket = &xSocket;
1117 
1118     pxNetworkBuffer = &xNetworkBuffer;
1119     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1120 
1121     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1122     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1123                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1124     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1125     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1126 
1127     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1128     pxSocket->u.xTCP.eTCPState = eCLOSED;
1129     pxSocket->u.xTCP.txStream = NULL;
1130     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1131     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1132     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1133     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1134     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1135     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1136 
1137     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1138     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1139     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1140     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1141 
1142     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1143 
1144     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1145     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1146     TEST_ASSERT_EQUAL( 0, xSendLength );
1147 }
1148 
1149 /**
1150  * @brief Get TCP packet with ACK when the state of socket is eTCP_LISTEN.
1151  */
test_prvTCPHandleState_TCPListen(void)1152 void test_prvTCPHandleState_TCPListen( void )
1153 {
1154     BaseType_t xSendLength = 0;
1155 
1156     pxSocket = &xSocket;
1157 
1158     pxNetworkBuffer = &xNetworkBuffer;
1159     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1160 
1161     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1162     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1163                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1164     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1165     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1166 
1167     pxSocket->u.xTCP.eTCPState = eTCP_LISTEN;
1168     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1169     pxSocket->u.xTCP.txStream = NULL;
1170     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1171     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1172     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1173     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1174     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1175     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1176 
1177     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1178     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1179     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1180     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1181 
1182     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1183 
1184     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1185     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1186     TEST_ASSERT_EQUAL( 0, xSendLength );
1187 }
1188 
1189 /**
1190  * @brief Get TCP packet with no flag when the state of socket is eSYN_FIRST.
1191  */
test_prvTCPHandleState_SYNFirst(void)1192 void test_prvTCPHandleState_SYNFirst( void )
1193 {
1194     BaseType_t xSendLength = 0;
1195 
1196     pxSocket = &xSocket;
1197 
1198     pxNetworkBuffer = &xNetworkBuffer;
1199     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1200 
1201     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1202     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1203                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1204     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1205     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1206 
1207     pxSocket->u.xTCP.eTCPState = eSYN_FIRST;
1208     pxTCPHeader->ucTCPFlags = 0;
1209     pxSocket->u.xTCP.txStream = NULL;
1210     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1211     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1212     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1213     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1214     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1215     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1216 
1217     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1218     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1219     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1220     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1221     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1222     prvSetSynAckOptions_ExpectAnyArgsAndReturn( 0 );
1223     vTCPStateChange_ExpectAnyArgs();
1224     prvSendData_ExpectAnyArgsAndReturn( 1040 );
1225 
1226 
1227     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1228 
1229     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1230     TEST_ASSERT_EQUAL( 1001, pxTCPWindow->rx.ulHighestSequenceNumber );
1231     TEST_ASSERT_EQUAL( ( uint8_t ) tcpTCP_FLAG_SYN | ( uint8_t ) tcpTCP_FLAG_ACK, pxTCPHeader->ucTCPFlags );
1232     TEST_ASSERT_EQUAL( 1040, xSendLength );
1233 }
1234 
1235 /**
1236  * @brief Get TCP packet with ACK when the state of socket is eCONNECT_SYN.
1237  */
test_prvTCPHandleState_ConnectSyn(void)1238 void test_prvTCPHandleState_ConnectSyn( void )
1239 {
1240     BaseType_t xSendLength = 0;
1241 
1242     pxSocket = &xSocket;
1243 
1244     pxNetworkBuffer = &xNetworkBuffer;
1245     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1246 
1247     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1248     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1249                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1250     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1251     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1252 
1253     pxSocket->u.xTCP.eTCPState = eCONNECT_SYN;
1254     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1255     pxSocket->u.xTCP.txStream = NULL;
1256     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1257     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1258     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1259     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1260     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1261     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1262 
1263     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1264     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1265     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1266     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1267     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1268     vTCPStateChange_ExpectAnyArgs();
1269     prvSendData_ExpectAnyArgsAndReturn( 60 );
1270 
1271     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1272 
1273     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1274     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1275     TEST_ASSERT_EQUAL( 60, xSendLength );
1276 }
1277 
1278 /**
1279  * @brief Get TCP packet with SYN when the state of socket is eSYN_RECEIVED.
1280  */
test_prvTCPHandleState_SynReceived(void)1281 void test_prvTCPHandleState_SynReceived( void )
1282 {
1283     BaseType_t xSendLength = 0;
1284 
1285     pxSocket = &xSocket;
1286 
1287     pxNetworkBuffer = &xNetworkBuffer;
1288     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1289 
1290     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1291     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1292                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1293     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1294     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1295 
1296     pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
1297     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_SYN;
1298     pxSocket->u.xTCP.txStream = NULL;
1299     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1300     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1301     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1302     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1303     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1304     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1305 
1306     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1307     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1308     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1309     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1310     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1311     vTCPStateChange_ExpectAnyArgs();
1312     vTCPStateChange_ExpectAnyArgs();
1313     prvSendData_ExpectAnyArgsAndReturn( 60 );
1314 
1315     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1316 
1317     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1318     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1319     TEST_ASSERT_EQUAL( 60, xSendLength );
1320 }
1321 
1322 /**
1323  * @brief Get TCP packet with ACK when the state of socket is eSYN_RECEIVED.
1324  */
test_prvTCPHandleState_SynReceivedFlagNotSyn(void)1325 void test_prvTCPHandleState_SynReceivedFlagNotSyn( void )
1326 {
1327     BaseType_t xSendLength = 0;
1328 
1329     pxSocket = &xSocket;
1330 
1331     pxNetworkBuffer = &xNetworkBuffer;
1332     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1333 
1334     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1335     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1336                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1337     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1338     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1339 
1340     pxSocket->u.xTCP.eTCPState = eSYN_RECEIVED;
1341     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1342     pxSocket->u.xTCP.txStream = NULL;
1343     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1344     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1345     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1346     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1347     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1348     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1349 
1350     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1351     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1352     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1353     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1354     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1355     FreeRTOS_inet_ntop_ExpectAnyArgsAndReturn( "" );
1356     vTCPStateChange_ExpectAnyArgs();
1357     prvSendData_ExpectAnyArgsAndReturn( 60 );
1358 
1359     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1360 
1361     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1362     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1363     TEST_ASSERT_EQUAL( 60, xSendLength );
1364 }
1365 
1366 /**
1367  * @brief Get TCP packet with ACK when the state of socket is eESTABLISHED.
1368  */
test_prvTCPHandleState_Established_DataAck(void)1369 void test_prvTCPHandleState_Established_DataAck( void )
1370 {
1371     BaseType_t xSendLength = 0;
1372 
1373     pxSocket = &xSocket;
1374 
1375     pxNetworkBuffer = &xNetworkBuffer;
1376     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1377 
1378     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1379     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1380                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1381     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1382     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1383 
1384     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1385     pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1386     pxSocket->u.xTCP.txStream = NULL;
1387     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1388     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1389     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1390     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1391     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1392     pxTCPWindow->rx.ulHighestSequenceNumber = 1500;
1393 
1394     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1395     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1396     prvCheckRxData_ExpectAnyArgsAndReturn( 1000 );
1397     prvStoreRxData_ExpectAnyArgsAndReturn( 1000 );
1398     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1399     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1500 );
1400     prvTCPPrepareSend_ExpectAnyArgsAndReturn( 1000 );
1401     prvSendData_ExpectAnyArgsAndReturn( 1000 );
1402 
1403     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1404 
1405     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1406     TEST_ASSERT_EQUAL( 2000, pxTCPWindow->rx.ulHighestSequenceNumber );
1407     TEST_ASSERT_EQUAL( 1000, xSendLength );
1408 }
1409 
1410 /**
1411  * @brief Get TCP packet with FIN when the state of socket is eESTABLISHED.
1412  */
test_prvTCPHandleState_Established_FirstFinFromPeer(void)1413 void test_prvTCPHandleState_Established_FirstFinFromPeer( void )
1414 {
1415     BaseType_t xSendLength = 0;
1416 
1417     pxSocket = &xSocket;
1418 
1419     pxNetworkBuffer = &xNetworkBuffer;
1420     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1421 
1422     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1423     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1424                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1425     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1426     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1427 
1428     ulCalled = 0;
1429     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1430     pxSocket->u.xTCP.eTCPState = eESTABLISHED;
1431     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1432     pxSocket->u.xTCP.bits.bFinSent = pdFALSE;
1433     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1434     pxSocket->u.xTCP.bits.bFinRecv = pdFALSE;
1435     pxSocket->u.xTCP.bits.bFinAcked = pdFALSE;
1436     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
1437     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1438     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1439     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1440     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1441 
1442     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1443     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1444     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1445     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1446     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1447     ulTCPWindowTxAck_ExpectAnyArgsAndReturn( 1500 );
1448     uxStreamBufferGet_ExpectAnyArgsAndReturn( 1000 );
1449     prvTCPAddTxData_ExpectAnyArgs();
1450     xTCPWindowRxEmpty_ExpectAnyArgsAndReturn( pdTRUE );
1451     xTCPWindowTxDone_ExpectAnyArgsAndReturn( pdTRUE );
1452     vTCPStateChange_ExpectAnyArgs();
1453     prvSendData_ExpectAnyArgsAndReturn( 40 );
1454 
1455     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1456 
1457     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1458     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1459     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulFINSequenceNumber );
1460     TEST_ASSERT_EQUAL( 1, ulCalled );
1461     TEST_ASSERT_EQUAL( 40, xSendLength );
1462 }
1463 
1464 /**
1465  * @brief Get TCP packet when the state of socket is eLAST_ACK.
1466  */
test_prvTCPHandleState_LastAck(void)1467 void test_prvTCPHandleState_LastAck( void )
1468 {
1469     BaseType_t xSendLength = 0;
1470 
1471     pxSocket = &xSocket;
1472 
1473     pxNetworkBuffer = &xNetworkBuffer;
1474     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1475 
1476     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1477     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1478                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1479     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1480     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1481 
1482     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK;
1483     pxSocket->u.xTCP.eTCPState = eLAST_ACK;
1484     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1485     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1486     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1487     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
1488     pxSocket->u.xTCP.bits.bFinAcked = pdTRUE;
1489     pxSocket->u.xTCP.bits.bFinLast = pdTRUE;
1490     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1491     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1492     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1493     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1494 
1495     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1496     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1497     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1498     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1499     vTCPStateChange_ExpectAnyArgs();
1500 
1501     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1502 
1503     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1504     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1505     TEST_ASSERT_EQUAL( 0, xSendLength );
1506 }
1507 
1508 /**
1509  * @brief Get TCP packet with FIN flag when the state of socket is eFIN_WAIT_1.
1510  */
test_prvTCPHandleState_FinWait1_FinFromPeer(void)1511 void test_prvTCPHandleState_FinWait1_FinFromPeer( void )
1512 {
1513     BaseType_t xSendLength = 0;
1514 
1515     pxSocket = &xSocket;
1516 
1517     pxNetworkBuffer = &xNetworkBuffer;
1518     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1519 
1520     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1521     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1522                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1523     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1524     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1525 
1526     ulCalled = 0;
1527     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1528     pxSocket->u.xTCP.eTCPState = eFIN_WAIT_1;
1529     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1530     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1531     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1532     pxSocket->u.xTCP.bits.bFinRecv = pdFALSE;
1533     pxSocket->u.xTCP.bits.bFinAcked = pdFALSE;
1534     pxSocket->u.xTCP.pxHandleSent = xLocalFunctionPointer;
1535     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1536     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1537     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1538     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1539 
1540     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1541     uxIPHeaderSizeSocket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1542     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1543     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1544     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1545     vTCPStateChange_ExpectAnyArgs();
1546     prvSendData_ExpectAnyArgsAndReturn( 40 );
1547 
1548     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1549 
1550     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1551     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1552     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulFINSequenceNumber );
1553     TEST_ASSERT_EQUAL( 0, ulCalled );
1554     TEST_ASSERT_EQUAL( 40, xSendLength );
1555 }
1556 
1557 /**
1558  * @brief Get TCP packet when the state of socket is eCLOSE_WAIT.
1559  */
test_prvTCPHandleState_CloseWait(void)1560 void test_prvTCPHandleState_CloseWait( void )
1561 {
1562     BaseType_t xSendLength = 0;
1563 
1564     pxSocket = &xSocket;
1565 
1566     pxNetworkBuffer = &xNetworkBuffer;
1567     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1568 
1569     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1570     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1571                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1572     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1573     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1574 
1575     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1576     pxSocket->u.xTCP.eTCPState = eCLOSE_WAIT;
1577     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1578     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1579     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1580     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
1581     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1582     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1583     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1584     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1585 
1586     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1587     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1588     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1589     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1590 
1591     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1592 
1593     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1594     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1595     TEST_ASSERT_EQUAL( 0, pxTCPWindow->rx.ulFINSequenceNumber );
1596     TEST_ASSERT_EQUAL( 0, xSendLength );
1597 }
1598 
1599 /**
1600  * @brief Get TCP packet when the state of socket is eCLOSING.
1601  */
test_prvTCPHandleState_ClosingKeepAlive(void)1602 void test_prvTCPHandleState_ClosingKeepAlive( void )
1603 {
1604     BaseType_t xSendLength = 0;
1605 
1606     pxSocket = &xSocket;
1607 
1608     pxNetworkBuffer = &xNetworkBuffer;
1609     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1610 
1611     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1612     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1613                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1614     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1615     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1616 
1617     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1618     pxSocket->u.xTCP.eTCPState = eCLOSING;
1619     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1620     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1621     pxSocket->u.xTCP.bits.bFinAccepted = pdFALSE;
1622     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
1623     pxSocket->u.xTCP.bits.bWinChange = pdFALSE;
1624     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1625     pxTCPWindow->rx.ulCurrentSequenceNumber = 1000;
1626     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1627 
1628     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1629     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1630     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1631     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1632 
1633     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1634 
1635     TEST_ASSERT_EQUAL( pdFALSE, pxSocket->u.xTCP.bits.bWinChange );
1636     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1637     TEST_ASSERT_EQUAL( 0, pxTCPWindow->rx.ulFINSequenceNumber );
1638     TEST_ASSERT_EQUAL( 0, xSendLength );
1639 }
1640 
1641 /**
1642  * @brief Get TCP packet when the state of socket is eTIME_WAIT.
1643  */
test_prvTCPHandleState_TimeWait(void)1644 void test_prvTCPHandleState_TimeWait( void )
1645 {
1646     BaseType_t xSendLength = 0;
1647 
1648     pxSocket = &xSocket;
1649 
1650     pxNetworkBuffer = &xNetworkBuffer;
1651     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1652 
1653     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1654     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1655                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1656     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1657     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1658 
1659     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1660     pxSocket->u.xTCP.eTCPState = eTIME_WAIT;
1661     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1662     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1663     pxSocket->u.xTCP.bits.bFinAccepted = pdTRUE;
1664     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
1665     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1666     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1667     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1668 
1669     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1670     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1671     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1672     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1673 
1674     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1675 
1676     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1677     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1678     TEST_ASSERT_EQUAL( 0, pxTCPWindow->rx.ulFINSequenceNumber );
1679     TEST_ASSERT_EQUAL( 0, xSendLength );
1680 }
1681 
1682 /**
1683  * @brief Get TCP packet when the state of socket is unknown.
1684  */
test_prvTCPHandleState_StateUnknown(void)1685 void test_prvTCPHandleState_StateUnknown( void )
1686 {
1687     BaseType_t xSendLength = 0;
1688 
1689     pxSocket = &xSocket;
1690 
1691     pxNetworkBuffer = &xNetworkBuffer;
1692     pxNetworkBuffer->pucEthernetBuffer = ucEthernetBuffer;
1693 
1694     /* Map the buffer onto the ProtocolHeader_t struct for easy access to the fields. */
1695     ProtocolHeaders_t * pxProtocolHeaders = ( ( ProtocolHeaders_t * )
1696                                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER ] ) );
1697     TCPHeader_t * pxTCPHeader = &pxProtocolHeaders->xTCPHeader;
1698     TCPWindow_t * pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;
1699 
1700     pxTCPHeader->ucTCPFlags = tcpTCP_FLAG_ACK | tcpTCP_FLAG_FIN;
1701     pxSocket->u.xTCP.eTCPState = 12;
1702     pxSocket->u.xTCP.txStream = ( StreamBuffer_t * ) 0x12345678;
1703     pxSocket->u.xTCP.bits.bFinSent = pdTRUE;
1704     pxSocket->u.xTCP.bits.bFinAccepted = pdTRUE;
1705     pxSocket->u.xTCP.bits.bFinRecv = pdTRUE;
1706     pxTCPHeader->ulSequenceNumber = FreeRTOS_htonl( 1000 );
1707     pxTCPWindow->rx.ulCurrentSequenceNumber = 1001;
1708     pxTCPWindow->rx.ulHighestSequenceNumber = 1000;
1709 
1710     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1711     prvCheckRxData_ExpectAnyArgsAndReturn( 0 );
1712     prvStoreRxData_ExpectAnyArgsAndReturn( 0 );
1713     prvSetOptions_ExpectAnyArgsAndReturn( 0 );
1714 
1715     xSendLength = prvTCPHandleState( pxSocket, &pxNetworkBuffer );
1716 
1717     TEST_ASSERT_EQUAL( pdTRUE, pxSocket->u.xTCP.bits.bWinChange );
1718     TEST_ASSERT_EQUAL( 1000, pxTCPWindow->rx.ulHighestSequenceNumber );
1719     TEST_ASSERT_EQUAL( 0, pxTCPWindow->rx.ulFINSequenceNumber );
1720     TEST_ASSERT_EQUAL( 0, xSendLength );
1721 }
1722 
1723 /**
1724  * @brief Call prvHandleListen with IPv4 packet.
1725  */
test_prvHandleListen_IPv4Packet(void)1726 void test_prvHandleListen_IPv4Packet( void )
1727 {
1728     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
1729     prvHandleListen_IPV4_ExpectAndReturn( pxSocket, pxNetworkBuffer, NULL );
1730 
1731     pxSocket = prvHandleListen( pxSocket, pxNetworkBuffer );
1732 
1733     TEST_ASSERT_EQUAL( NULL, pxSocket );
1734 }
1735 
1736 /**
1737  * @brief Call prvHandleListen with IPv6 packet.
1738  */
test_prvHandleListen_IPv6Packet(void)1739 void test_prvHandleListen_IPv6Packet( void )
1740 {
1741     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv6_HEADER );
1742     prvHandleListen_IPV6_ExpectAndReturn( pxSocket, pxNetworkBuffer, NULL );
1743 
1744     pxSocket = prvHandleListen( pxSocket, pxNetworkBuffer );
1745 
1746     TEST_ASSERT_EQUAL( NULL, pxSocket );
1747 }
1748 
1749 /**
1750  * @brief Call prvHandleListen with unknown IP type packet.
1751  */
test_prvHandleListen_UnknownIPType(void)1752 void test_prvHandleListen_UnknownIPType( void )
1753 {
1754     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER + 1 );
1755 
1756     pxSocket = prvHandleListen( pxSocket, pxNetworkBuffer );
1757 
1758     TEST_ASSERT_EQUAL( NULL, pxSocket );
1759 }
1760 
1761 /**
1762  * @brief Socket handler has NULL socket set pointer.
1763  */
test_prvTCPSocketCopy_NullSocketSet(void)1764 void test_prvTCPSocketCopy_NullSocketSet( void )
1765 {
1766     BaseType_t Result = pdFALSE;
1767 
1768     FreeRTOS_Socket_t MockReturnSocket;
1769 
1770     pxSocket = &xSocket;
1771 
1772     pxSocket->usLocalPort = 22;
1773     pxSocket->u.xTCP.uxTxWinSize = 0x123456;
1774     pxSocket->pxSocketSet = NULL;
1775     pxSocket->xSelectBits = eSELECT_READ;
1776 
1777     vSocketBind_ExpectAnyArgsAndReturn( 0 );
1778 
1779     Result = prvTCPSocketCopy( &MockReturnSocket, pxSocket );
1780     TEST_ASSERT_EQUAL( pdTRUE, Result );
1781     TEST_ASSERT_NOT_EQUAL( pxSocket->usLocalPort, MockReturnSocket.usLocalPort );
1782     TEST_ASSERT_EQUAL( pxSocket->u.xTCP.uxTxWinSize, MockReturnSocket.u.xTCP.uxTxWinSize );
1783     TEST_ASSERT_NOT_EQUAL( ( pxSocket->xSelectBits | eSELECT_READ | eSELECT_EXCEPT ), MockReturnSocket.xSelectBits );
1784 }
1785 
1786 /**
1787  * @brief Get fail return in bind function.
1788  */
test_prvTCPSocketCopy_BindError(void)1789 void test_prvTCPSocketCopy_BindError( void )
1790 {
1791     BaseType_t Result = pdFALSE;
1792 
1793     FreeRTOS_Socket_t MockReturnSocket;
1794 
1795     pxSocket = &xSocket;
1796 
1797     pxSocket->usLocalPort = 22;
1798     pxSocket->u.xTCP.uxTxWinSize = 0x123456;
1799     pxSocket->pxSocketSet = ( struct xSOCKET_SET * ) 0x1111111;
1800     pxSocket->xSelectBits = eSELECT_READ;
1801 
1802     vSocketBind_ExpectAnyArgsAndReturn( 1 );
1803     vSocketClose_ExpectAnyArgsAndReturn( NULL );
1804 
1805     Result = prvTCPSocketCopy( &MockReturnSocket, pxSocket );
1806     TEST_ASSERT_EQUAL( pdFALSE, Result );
1807     TEST_ASSERT_NOT_EQUAL( pxSocket->usLocalPort, MockReturnSocket.usLocalPort );
1808     TEST_ASSERT_EQUAL( pxSocket->u.xTCP.uxTxWinSize, MockReturnSocket.u.xTCP.uxTxWinSize );
1809     TEST_ASSERT_EQUAL( ( pxSocket->xSelectBits | eSELECT_READ | eSELECT_EXCEPT ), MockReturnSocket.xSelectBits );
1810 }
1811 
1812 /**
1813  * @brief Test for FreeRTOS_GetTCPStateName function.
1814  */
test_FreeRTOS_GetTCPStateName(void)1815 void test_FreeRTOS_GetTCPStateName( void )
1816 {
1817     const char * ReturnStateName;
1818 
1819     ReturnStateName = FreeRTOS_GetTCPStateName( 0 );
1820 
1821     TEST_ASSERT_EQUAL_STRING( "eCLOSED", ReturnStateName );
1822 }
1823 
1824 /**
1825  * @brief Negative index as input.
1826  */
test_FreeRTOS_GetTCPStateName_NegativeIndex(void)1827 void test_FreeRTOS_GetTCPStateName_NegativeIndex( void )
1828 {
1829     const char * ReturnStateName;
1830 
1831     ReturnStateName = FreeRTOS_GetTCPStateName( -1 );
1832 
1833     TEST_ASSERT_EQUAL_STRING( "eUNKNOWN", ReturnStateName );
1834 }
1835 
1836 /**
1837  * @brief Input with index greater than maximum.
1838  */
test_FreeRTOS_GetTCPStateName_GreaterIndex(void)1839 void test_FreeRTOS_GetTCPStateName_GreaterIndex( void )
1840 {
1841     const char * ReturnStateName;
1842 
1843     ReturnStateName = FreeRTOS_GetTCPStateName( 30 );
1844 
1845     TEST_ASSERT_EQUAL_STRING( "eUNKNOWN", ReturnStateName );
1846 }
1847