[BUG] Freed memory is being used

[ATDOR-RIH]

Describe the bug
This bug releates to #570 which was solved in #707.

The bug was fixed by clearing pPassQueued and pPassAccept.
By calling

FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

Line 461 in ef14a08

vSocketCloseNextTime( pxSocket );

and

FreeRTOS-Plus-TCP/source/FreeRTOS_IP_Timers.c

Line 309 in ef14a08

vSocketCloseNextTime( NULL );

the socket gets freed, however the parent socket might still have a reference to the socket.
When the user task calls FreeRTOS_accept it will check if the pPassAccept bit is set. If not FreeRTOS_accept will return NULL and everything is fine.
But the memory is freed already, so there is no guarantee that pPassAccept is still cleared.

Target

• Development board: [e.g. HiFive11 RevB]
• Instruction Set Architecture: ARM CortexA7
• IDE and version: Eclipse + CMake
• Toolchain and version: arm-none-eabi-gcc 10.3.1

Host

• Host OS: Ubuntu
• Version: 18.04

To Reproduce
The device acts as web server and the error happened by continuously refreshing the web site using https.
It did not happen when using http.

Expected behavior
Do not leave references to freed memory.

Screenshots
None

Wireshark logs
None

Additional context
Added log lines:

• logll_debug( BASE_FILE_NAME, "FreeRTOS_socket 0x%x", xReturn ); after

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 761 in ef14a08

  xReturn = pxSocket;

• logll_debug( BASE_FILE_NAME, "FreeRTOS_bind 0x%x %li", xSocket, xReturn ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 1773 in ef14a08

  return xReturn;

• logll_debug( BASE_FILE_NAME, "FreeRTOS_closesocket - 0x%x", xSocket ); after

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 2019 in ef14a08

  xCloseEvent.pvData = xSocket;

• logll_debug( BASE_FILE_NAME, "vSocketClose 0x%x", pxSocket ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 2175 in ef14a08

  vPortFreeSocket( pxSocket );

• if( pxParentSocket->u.xTCP.pxPeerSocket != NULL ) { logll_debug( BASE_FILE_NAME, "pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x%x 0x%x 0x%x", pxClientSocket, pxParentSocket, pxParentSocket->u.xTCP.pxPeerSocket ); } before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 3892 in ef14a08

  pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket;

• if( pxParentSocket != NULL ) { logll_debug( BASE_FILE_NAME, "pxClientSocket = pxParentSocket; 0x%x 0x%x", pxClientSocket, pxParentSocket ); } before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 3896 in ef14a08

  pxClientSocket = pxParentSocket;

• logll_debug( BASE_FILE_NAME, "pxClientSocket = NULL;" ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 3910 in ef14a08

  pxClientSocket = NULL;

• if( pxClientSocket != NULL && pxClientSocket != FREERTOS_INVALID_SOCKET ) { logll_debug( BASE_FILE_NAME, "FreeRTOS_accept 0x%x 0x%x", pxSocket, pxClientSocket ); } before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 4059 in ef14a08

  return pxClientSocket;

• logll_debug( BASE_FILE_NAME, "FreeRTOS_listen 0x%x %li", xSocket, xResult ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

  Line 4756 in ef14a08

  return xResult;

• logll_debug( BASE_FILE_NAME, "vSocketCloseNextTime 0x%x 0x%x", xSocketToClose, pxSocket ); after

  FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

  Line 111 in ef14a08

  ( void ) vSocketClose( xSocketToClose );

• else if( pxSocket != NULL ) { logll_debug( BASE_FILE_NAME, "vSocketCloseNextTime set xSocketToClose 0x%x 0x%x", xSocketToClose, pxSocket ); } after

  FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

  Line 112 in ef14a08

  }

• logll_debug( BASE_FILE_NAME, "xParent = pxSocket->u.xTCP.pxPeerSocket; 0x%x 0x%x 0x%x", xParent, pxSocket, pxSocket->u.xTCP.pxPeerSocket ); after

  FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

  Line 325 in ef14a08

  xParent = pxSocket->u.xTCP.pxPeerSocket;

• logll_debug( BASE_FILE_NAME, "xParent->u.xTCP.pxPeerSocket = pxSocket; 0x%x 0x%x", xParent, pxSocket ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

  Line 345 in ef14a08

  xParent->u.xTCP.pxPeerSocket = pxSocket;

• logll_debug( BASE_FILE_NAME, "pxSocket->u.xTCP.pxPeerSocket = pxFound; 0x%x 0x%x", pxSocket, pxFound ); before

  FreeRTOS-Plus-TCP/source/FreeRTOS_TCP_IP.c

  Line 718 in ef14a08

  pxSocket->u.xTCP.pxPeerSocket = pxFound;

logll_debug is a function which writes the given text to a serial interface which is connected to the computer used for debugging.
Format of the log line: (file name provided by macro BASE_FILE_NAME);(log level 1 in case of debug);(monotonic time in ms);(log message)

Log lines where the described bug happens:
Creation of socket.
D:FreeRTOS_Sockets.c;1;38081;FreeRTOS_socket 0x7035c548
D:FreeRTOS_TCP_IP.c;1;38113;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70284130 0x7035c548 0x70284130
D:FreeRTOS_TCP_IP.c;1;38113;xParent->u.xTCP.pxPeerSocket = pxSocket; 0x70284130 0x7035c548

IP-Task is closing the socket.
D:FreeRTOS_TCP_IP.c;1;38130;vSocketCloseNextTime set xSocketToClose 0x0 0x7035c548
D:FreeRTOS_Sockets.c;1;38130;vSocketClose 0x7035c548
D:FreeRTOS_TCP_IP.c;1;38130;vSocketCloseNextTime 0x7035c548 0x0

Call FreeRTOS_accept from user task. The memory was not overwritten yet, so prvAcceptWaitClient returns NULL.
D:FreeRTOS_Sockets.c;1;38706;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70284130 0x7035c548

Full logs
logs.txt

Config
ipconfig.txt

[kstribrnAmzn]

Thanks for raising this bug. Tagging @shubnil and @tony-josi-aws for review

[tony-josi-aws]

@ATDOR-RIH
Thanks for the detailed bug report.
Wondering if you would be able to help with testing if we provided you with a patch for this issue.

[ATDOR-RIH]

@tony-josi-aws
Yes, I can help with testing.

[tony-josi-aws]

@ATDOR-RIH Thanks

In your project, is the macro ipconfigTCP_HANG_PROTECTION kept at its default definition?

If so, could you please define it as 0?:
#define ipconfigTCP_HANG_PROTECTION ( 0 )
in your FreeRTOSIPConfig.h and try to reproduce the issue?

[ATDOR-RIH]

I tried it with #define ipconfigTCP_HANG_PROTECTION ( 0 ).
It is different but there is still an access to freed memory.

D:FreeRTOS_Sockets.c;1;173709;FreeRTOS_socket 0x702b5a60
D:FreeRTOS_TCP_IP.c;1;173722;vSocketCloseNextTime set xSocketToClose 0x0 0x702b5a60
D:FreeRTOS_Sockets.c;1;173722;vSocketClose 0x702b5a60
D:FreeRTOS_TCP_IP.c;1;173722;vSocketCloseNextTime 0x702b5a60 0x0
...
D:FreeRTOS_Sockets.c;1;173963;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70283b30 0x702b5a60

[tony-josi-aws]

@ATDOR-RIH,

Just wondering how its verified that 0x702b5a60 is a freed pointer that is being used.
Its normal to have the malloc return the same pointer that was previously released while a new socket is being created.

I would try associating each socket creation with a random ID when created and then comparing the IDs when the socket pointers happen to match.

[ATDOR-RIH]

@tony-josi-aws
I did what you suggested but instead of a random ID I used the system time of when the socket was created. Therefore I added ulCreationTime to xSOCKET.
`struct xSOCKET
{
EventBits_t xEventBits; /< The eventbits to keep track of events. */
EventGroupHandle_t xEventGroup; /< The event group for this socket. */

/* Most compilers do like bit-flags */
struct
{
    uint32_t bIsIPv6 : 1; /**< Non-zero in case the connection is using IPv6. */
    uint32_t bSomeFlag : 1;
}
bits;

ListItem_t xBoundSocketListItem;       /**< Used to reference the socket from a bound sockets list. */
TickType_t xReceiveBlockTime;          /**< if recv[to] is called while no data is available, wait this amount of time. Unit in clock-ticks */
TickType_t xSendBlockTime;             /**< if send[to] is called while there is not enough space to send, wait this amount of time. Unit in clock-ticks */

IP_Address_t xLocalAddress;            /**< Local IP address */
uint16_t usLocalPort;                  /**< Local port on this machine */
uint8_t ucSocketOptions;               /**< Socket options */
uint8_t ucProtocol;                    /**< choice of FREERTOS_IPPROTO_UDP/TCP */
uint64_t ulCreationTime;
#if ( ipconfigSOCKET_HAS_USER_SEMAPHORE == 1 )
    SemaphoreHandle_t pxUserSemaphore; /**< The user semaphore */
#endif /* ipconfigSOCKET_HAS_USER_SEMAPHORE */
#if ( ipconfigSOCKET_HAS_USER_WAKE_CALLBACK == 1 )
    SocketWakeupCallback_t pxUserWakeCallback; /**< Pointer to the callback function. */
#endif /* ipconfigSOCKET_HAS_USER_WAKE_CALLBACK */

#if ( ipconfigSUPPORT_SELECT_FUNCTION == 1 )
    struct xSOCKET_SET * pxSocketSet; /**< Pointer to the socket set structure */
    EventBits_t xSelectBits;          /**< User may indicate which bits are interesting for this socket. */

    EventBits_t xSocketBits;          /**< These bits indicate the events which have actually occurred.
                                       * They are maintained by the IP-task */
#endif /* ipconfigSUPPORT_SELECT_FUNCTION */
struct xNetworkEndPoint * pxEndPoint; /**< The end-point to which the socket is bound. */

/* This field is only only by the user, and can be accessed with
 * vSocketSetSocketID() / vSocketGetSocketID().
 * All fields of a socket will be cleared by memset() in FreeRTOS_socket().
 */
void * pvSocketID;

/* TCP/UDP specific fields: */
/* Before accessing any member of this structure, it should be confirmed */
/* that the protocol corresponds with the type of structure */

union
{
    IPUDPSocket_t xUDP;     /**< Union member: UDP socket*/
    #if ( ipconfigUSE_TCP == 1 )
        IPTCPSocket_t xTCP; /**< Union member: TCP socket */
    #endif /* ipconfigUSE_TCP */
}
u; /**< Union of TCP/UDP socket */

};`

ulCreationTime is set in the function FreeRTOS_socket.
pxSocket->ulCreationTime = monotonicClock_get();

FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

Line 759 in ee730aa

pxSocket->ucProtocol = ( uint8_t ) xProtocolCpy; /* protocol: UDP or TCP */

I then added ulCreationTime to the logs I mentioned in the description above.
logll_debug( BASE_FILE_NAME, "FreeRTOS_socket 0x%x %llu", xReturn, xReturn->ulCreationTime );
logll_debug( BASE_FILE_NAME, "vSocketClose 0x%x %llu", pxSocket, pxSocket->ulCreationTime );
logll_debug( BASE_FILE_NAME, "pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x%x 0x%x %llu 0x%x %llu", pxClientSocket, pxParentSocket, pxParentSocket->ulCreationTime, pxParentSocket->u.xTCP.pxPeerSocket, pxParentSocket->u.xTCP.pxPeerSocket->ulCreationTime );

First I tried it with ipconfigTCP_HANG_PROTECTION set to 1. (log_ipconfigTCP_HANG_PROTECTION_1.txt)

D:FreeRTOS_Sockets.c;1;47391;FreeRTOS_socket 0x7030cdc8 47391
D:FreeRTOS_TCP_IP.c;1;47407;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349180 0x7030cdc8 47391 0x70349180 2361
D:FreeRTOS_TCP_IP.c;1;47407;xParent->u.xTCP.pxPeerSocket = pxSocket; 0x70349180 2361 0x7030cdc8 47391
D:FreeRTOS_TCP_IP.c;1;47424;vSocketCloseNextTime set xSocketToClose 0x0 0x7030cdc8
D:FreeRTOS_Sockets.c;1;47426;vSocketClose 0x7030cdc8 47391
D:FreeRTOS_TCP_IP.c;1;47426;vSocketCloseNextTime 0x7030cdc8 0x0
...
D:FreeRTOS_Sockets.c;1;48123;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70349180 2361 0x7030cdc8 0

You can see that in the log line pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70349180 2361 0x7030cdc8 0 ulCreationTime is 0. I assume that the memory was already taken by something else.

I removed vPortFreeSocket( pxSocket ); from the function vSocketClose and tried again. (log_ipconfigTCP_HANG_PROTECTION_1_do_not_free_memory.txt)

FreeRTOS-Plus-TCP/source/FreeRTOS_Sockets.c

Line 2175 in ee730aa

vPortFreeSocket( pxSocket );

D:FreeRTOS_Sockets.c;1;31698;FreeRTOS_socket 0x7033dab8 31698
D:FreeRTOS_TCP_IP.c;1;31704;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x7033dab8 31698 0x70349c20 2360
D:FreeRTOS_TCP_IP.c;1;31704;xParent->u.xTCP.pxPeerSocket = pxSocket; 0x70349c20 2360 0x7033dab8 31698
D:FreeRTOS_TCP_IP.c;1;31720;vSocketCloseNextTime set xSocketToClose 0x0 0x7033dab8
D:FreeRTOS_Sockets.c;1;31720;vSocketClose 0x7033dab8 31698
...
D:FreeRTOS_Sockets.c;1;33358;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70349c20 2360 0x7033dab8 31698

Then I tried it with ipconfigTCP_HANG_PROTECTION set to 0. (log_ipconfigTCP_HANG_PROTECTION_0_do_not_free_memory.txt)

D:FreeRTOS_Sockets.c;1;210483;FreeRTOS_socket 0x7034eca8 210483
D:FreeRTOS_TCP_IP.c;1;210498;vSocketCloseNextTime set xSocketToClose 0x0 0x7034eca8
D:FreeRTOS_Sockets.c;1;210498;vSocketClose 0x7034eca8 210483
D:FreeRTOS_TCP_IP.c;1;210498;vSocketCloseNextTime 0x7034eca8 0x0
...
D:FreeRTOS_Sockets.c;1;215348;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x7027d298 2371 0x7034eca8 210483

Summary
The socket is being used after it was closed, even if the memory of the socket was not freed. So it cannot be a new socket.

log_ipconfigTCP_HANG_PROTECTION_1.txt
log_ipconfigTCP_HANG_PROTECTION_1_do_not_free_memory.txt
log_ipconfigTCP_HANG_PROTECTION_0_do_not_free_memory.txt

[shubnil]

Hi @ATDOR-RIH,
We were analyzing the logs and have some observations:

Data:

Cycle 1:
FreeRTOS_Sockets.c;1;31698;FreeRTOS_socket 0x7033dab8 31698
FreeRTOS_TCP_IP.c;1;31704;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x7033dab8 31698 0x70349c20 2360
FreeRTOS_TCP_IP.c;1;31704;xParent->u.xTCP.pxPeerSocket = pxSocket; 0x70349c20 2360 0x7033dab8 31698
FreeRTOS_TCP_IP.c;1;31720;vSocketCloseNextTime set xSocketToClose 0x0 0x7033dab8
FreeRTOS_Sockets.c;1;31720;vSocketClose 0x7033dab8 31698
FreeRTOS_TCP_IP.c;1;31720;vSocketCloseNextTime 0x7033dab8 0x0

Cycle 2:
FreeRTOS_Sockets.c;1;31853;FreeRTOS_socket 0x702f3cb8 31853
FreeRTOS_TCP_IP.c;1;31859;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x702f3cb8 31853 0x70349c20 2360
FreeRTOS_TCP_IP.c;1;31869;vSocketCloseNextTime set xSocketToClose 0x0 0x702f3cb8
FreeRTOS_Sockets.c;1;31869;vSocketClose 0x702f3cb8 31853
FreeRTOS_TCP_IP.c;1;31869;vSocketCloseNextTime 0x702f3cb8 0x0

Cycle 3:
FreeRTOS_Sockets.c;1;32004;FreeRTOS_socket 0x7025edf0 32004
FreeRTOS_TCP_IP.c;1;32010;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x7025edf0 32004 0x70349c20 2360
FreeRTOS_TCP_IP.c;1;32020;vSocketCloseNextTime set xSocketToClose 0x0 0x7025edf0
FreeRTOS_Sockets.c;1;32020;vSocketClose 0x7025edf0 32004
FreeRTOS_TCP_IP.c;1;32020;vSocketCloseNextTime 0x7025edf0 0x0

Cycle 4:
FreeRTOS_Sockets.c;1;32214;FreeRTOS_socket 0x702843d0 32214
FreeRTOS_TCP_IP.c;1;32220;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x702843d0 32214 0x70349c20 2360
FreeRTOS_TCP_IP.c;1;32231;vSocketCloseNextTime set xSocketToClose 0x0 0x702843d0
FreeRTOS_Sockets.c;1;32231;vSocketClose 0x702843d0 32214
FreeRTOS_TCP_IP.c;1;32231;vSocketCloseNextTime 0x702843d0 0x0

Cycle 5:
FreeRTOS_Sockets.c;1;32779;FreeRTOS_socket 0x7033ace0 32779
FreeRTOS_TCP_IP.c;1;32791;xParent = pxSocket->u.xTCP.pxPeerSocket; 0x70349c20 0x7033ace0 32779 0x70349c20 2360
FreeRTOS_Sockets.c;1;33358;FreeRTOS_closesocket - 0x7027d2d8 31569
FreeRTOS_Sockets.c;1;33358;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x70349c20 2360 0x7033dab8 31698
FreeRTOS_Sockets.c;1;33358;pxClientSocket = NULL;

Observation 1:
The socket buffer with address "0x7033dab8" seem to appear with an older timestamp. Now this can be either because of one of the following reasons:

1. Stale buffer is still present
2. The "ulCreationTime" field is not cleared properly which can happen if the print statement is before the socket memory is memset to 0.

There is less possibility for a to happen because of the following prints:
FreeRTOS_Sockets.c;1;31720;vSocketClose 0x7033dab8 31698
FreeRTOS_TCP_IP.c;1;31720;vSocketCloseNextTime 0x7033dab8 0x0

Can you please confirm if point no b is not the case.

Observation 2:
Sometimes there seems to be a late close call from the application like the print "FreeRTOS_Sockets.c;1;33358;FreeRTOS_closesocket - 0x7027d2d8 31569"
Can you please ensure if the application has the right priority to maintain a steady state between opening and closing of sockets.

Will it be ok for you to share the code with the above prints. This will help us better co-relate the print sequence and the code sequence.

Thanks,
Shub

[htibosch]

I would like to propose the following change in vTCPStateChange():

 FreeRTOS_printf( ( "vTCPStateChange: Closing socket\n" ) );
 
 if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )
 {
     configASSERT( xIsCallingFromIPTask() != pdFALSE );
+ 
+    if( ( xParent != NULL ) &&
+        ( xParent->u.xTCP.pxPeerSocket == pxSocket ) )
+    {
+        xParent->u.xTCP.pxPeerSocket = NULL;
+    }
 
     vSocketCloseNextTime( pxSocket );
 }

So we'll clear the field pxPeerSocket of the parent socket before the child socket is deleted.

[ATDOR-RIH]

Hi @shubnil and @htibosch

attached you will find the following files:

• changes.patch: Patch file with the changes I made based on V4.0.0. (relative path: source)
• changes_suggestion_htibosch.patch: Patch file with the changes suggested by @htibosch.
• logs_suggestion_htibosch.txt: Logs with the changes suggested by @htibosch. (Only a small snippet.)

changes.patch
changes_suggestion_htibosch.patch
logs_suggestion_htibosch.txt

The suggested changes do not solve the issue.
D:FreeRTOS_TCP_IP.c;1;658742;vSocketCloseNextTime xParent 0x7027b4d8 pxSocket 0x7027b4d8 0x0
D:FreeRTOS_TCP_IP.c;1;658742;vSocketCloseNextTime set xSocketToClose 0x0 0x7027b4d8
D:FreeRTOS_Sockets.c;1;658742;vSocketClose 0x7027b4d8 658696
D:FreeRTOS_TCP_IP.c;1;658742;vSocketCloseNextTime 0x7027b4d8 0x0
...
D:FreeRTOS_Sockets.c;1;660547;pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket; 0x0 0x702f5068 2247 0x7027b4d8 658696

I added this log "vSocketCloseNextTime xParent 0x7027b4d8 pxSocket 0x7027b4d8 0x0" right before the suggested changes.
Here you can see that xParent is the same as pxSocket and pxSocket->u.xTCP.pxPeerSocket is NULL.

Regarding priorities:
The IP-Task has the same priority as the client tasks.

[htibosch]

@ATDOR-RIH wrote:

Regarding priorities:
The IP-Task has the same priority as the client tasks.

Normally we recommend to use these priorities:

• highest: the EMAC / Ethernet task
• high: the IP-task with ipconfigIP_TASK_PRIORITY
• normal: all tasks that make use of TCP/IP

Tasks that have nothing to do with TCP/IP are free to choose a priority.

I will comment pxPeerSocket in a later post.

[ATDOR-RIH]

Here are the extended logs:
logs_suggestion_htibosch_extended.txt

At timestamp 642815 the socket (created at timestamp 639023) is assigned as peer socket of the parent.

Is it possible to set the peer socket of pxFound in xTCPCheckNewClient or is this a bad idea?
if( ( pxFound->ucProtocol == ( uint8_t ) FREERTOS_IPPROTO_TCP ) && ( pxFound->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )
{
logll_debug( BASE_FILE_NAME, "pxSocket->u.xTCP.pxPeerSocket = pxFound; 0x%x %llu 0x%x %llu", pxSocket,
pxSocket->ulCreationTime, pxFound, pxFound->ulCreationTime );
pxSocket->u.xTCP.pxPeerSocket = pxFound;
pxFound->u.xTCP.pxPeerSocket = pxSocket;
FreeRTOS_debug_printf( ( "xTCPCheckNewClient[0]: client on port %u\n", pxSocket->usLocalPort ) );
xResult = pdTRUE;
break;
}