in FreeRTOS_TCP_IP.c [3571:3811]
BaseType_t xProcessReceivedTCPPacket( NetworkBufferDescriptor_t * pxDescriptor )
{
/* Function might modify the parameter. */
NetworkBufferDescriptor_t * pxNetworkBuffer = pxDescriptor;
/* Map the buffer onto a ProtocolHeaders_t struct for easy access to the fields. */
const ProtocolHeaders_t * pxProtocolHeaders = ipCAST_CONST_PTR_TO_CONST_TYPE_PTR( ProtocolHeaders_t,
&( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) ] ) );
FreeRTOS_Socket_t * pxSocket;
uint16_t ucTCPFlags = pxProtocolHeaders->xTCPHeader.ucTCPFlags;
uint32_t ulLocalIP;
uint16_t usLocalPort = FreeRTOS_htons( pxProtocolHeaders->xTCPHeader.usDestinationPort );
uint16_t usRemotePort = FreeRTOS_htons( pxProtocolHeaders->xTCPHeader.usSourcePort );
uint32_t ulRemoteIP;
uint32_t ulSequenceNumber = FreeRTOS_ntohl( pxProtocolHeaders->xTCPHeader.ulSequenceNumber );
uint32_t ulAckNumber = FreeRTOS_ntohl( pxProtocolHeaders->xTCPHeader.ulAckNr );
BaseType_t xResult = pdPASS;
configASSERT( pxNetworkBuffer != NULL );
configASSERT( pxNetworkBuffer->pucEthernetBuffer != NULL );
const IPHeader_t * pxIPHeader;
/* Check for a minimum packet size. */
if( pxNetworkBuffer->xDataLength < ( ipSIZE_OF_ETH_HEADER + xIPHeaderSize( pxNetworkBuffer ) + ipSIZE_OF_TCP_HEADER ) )
{
xResult = pdFAIL;
}
else
{
/* Map the ethernet buffer onto the IPHeader_t struct for easy access to the fields. */
pxIPHeader = ipCAST_CONST_PTR_TO_CONST_TYPE_PTR( IPHeader_t, &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER ] ) );
ulLocalIP = FreeRTOS_htonl( pxIPHeader->ulDestinationIPAddress );
ulRemoteIP = FreeRTOS_htonl( pxIPHeader->ulSourceIPAddress );
/* Find the destination socket, and if not found: return a socket listing to
* the destination PORT. */
pxSocket = ( FreeRTOS_Socket_t * ) pxTCPSocketLookup( ulLocalIP, usLocalPort, ulRemoteIP, usRemotePort );
if( ( pxSocket == NULL ) || ( prvTCPSocketIsActive( pxSocket->u.xTCP.ucTCPState ) == pdFALSE ) )
{
/* A TCP messages is received but either there is no socket with the
* given port number or the there is a socket, but it is in one of these
* non-active states: eCLOSED, eCLOSE_WAIT, eFIN_WAIT_2, eCLOSING, or
* eTIME_WAIT. */
FreeRTOS_debug_printf( ( "TCP: No active socket on port %d (%xip:%d)\n", usLocalPort, ( unsigned ) ulRemoteIP, usRemotePort ) );
/* Send a RST to all packets that can not be handled. As a result
* the other party will get a ECONN error. There are two exceptions:
* 1) A packet that already has the RST flag set.
* 2) A packet that only has the ACK flag set.
* A packet with only the ACK flag set might be the last ACK in
* a three-way hand-shake that closes a connection. */
if( ( ( ucTCPFlags & tcpTCP_FLAG_CTRL ) != tcpTCP_FLAG_ACK ) &&
( ( ucTCPFlags & tcpTCP_FLAG_RST ) == 0U ) )
{
( void ) prvTCPSendReset( pxNetworkBuffer );
}
/* The packet can't be handled. */
xResult = pdFAIL;
}
else
{
pxSocket->u.xTCP.ucRepCount = 0U;
if( pxSocket->u.xTCP.ucTCPState == ( uint8_t ) eTCP_LISTEN )
{
/* The matching socket is in a listening state. Test if the peer
* has set the SYN flag. */
if( ( ucTCPFlags & tcpTCP_FLAG_CTRL ) != tcpTCP_FLAG_SYN )
{
/* What happens: maybe after a reboot, a client doesn't know the
* connection had gone. Send a RST in order to get a new connect
* request. */
#if ( ipconfigHAS_DEBUG_PRINTF == 1 )
{
FreeRTOS_debug_printf( ( "TCP: Server can't handle flags: %s from %xip:%u to port %u\n",
prvTCPFlagMeaning( ( UBaseType_t ) ucTCPFlags ), ( unsigned ) ulRemoteIP, usRemotePort, usLocalPort ) );
}
#endif /* ipconfigHAS_DEBUG_PRINTF */
if( ( ucTCPFlags & tcpTCP_FLAG_RST ) == 0U )
{
( void ) prvTCPSendReset( pxNetworkBuffer );
}
xResult = pdFAIL;
}
else
{
/* prvHandleListen() will either return a newly created socket
* (if bReuseSocket is false), otherwise it returns the current
* socket which will later get connected. */
pxSocket = prvHandleListen( pxSocket, pxNetworkBuffer );
if( pxSocket == NULL )
{
xResult = pdFAIL;
}
}
} /* if( pxSocket->u.xTCP.ucTCPState == eTCP_LISTEN ). */
else
{
/* This is not a socket in listening mode. Check for the RST
* flag. */
if( ( ucTCPFlags & tcpTCP_FLAG_RST ) != 0U )
{
FreeRTOS_debug_printf( ( "TCP: RST received from %xip:%u for %u\n", ( unsigned ) ulRemoteIP, usRemotePort, usLocalPort ) );
/* Implement https://tools.ietf.org/html/rfc5961#section-3.2. */
if( pxSocket->u.xTCP.ucTCPState == ( uint8_t ) eCONNECT_SYN )
{
/* Per the above RFC, "In the SYN-SENT state ... the RST is
* acceptable if the ACK field acknowledges the SYN." */
if( ulAckNumber == ( pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber + 1U ) )
{
vTCPStateChange( pxSocket, eCLOSED );
}
}
else
{
/* Check whether the packet matches the next expected sequence number. */
if( ulSequenceNumber == pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber )
{
vTCPStateChange( pxSocket, eCLOSED );
}
/* Otherwise, check whether the packet is within the receive window. */
else if( ( xSequenceGreaterThan( ulSequenceNumber, pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber ) != pdFALSE ) &&
( xSequenceLessThan( ulSequenceNumber, pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber +
pxSocket->u.xTCP.xTCPWindow.xSize.ulRxWindowLength ) != pdFALSE ) )
{
/* Send a challenge ACK. */
( void ) prvTCPSendChallengeAck( pxNetworkBuffer );
}
else
{
/* Nothing. */
}
}
/* Otherwise, do nothing. In any case, the packet cannot be handled. */
xResult = pdFAIL;
}
/* Check whether there is a pure SYN amongst the TCP flags while the connection is established. */
else if( ( ( ucTCPFlags & tcpTCP_FLAG_CTRL ) == tcpTCP_FLAG_SYN ) && ( pxSocket->u.xTCP.ucTCPState >= ( uint8_t ) eESTABLISHED ) )
{
/* SYN flag while this socket is already connected. */
FreeRTOS_debug_printf( ( "TCP: SYN unexpected from %xip:%u\n", ( unsigned ) ulRemoteIP, usRemotePort ) );
/* The packet cannot be handled. */
xResult = pdFAIL;
}
else
{
/* Update the copy of the TCP header only (skipping eth and IP
* headers). It might be used later on, whenever data must be sent
* to the peer. */
const size_t uxOffset = ipSIZE_OF_ETH_HEADER + uxIPHeaderSizeSocket( pxSocket );
( void ) memcpy( ( void * ) ( &( pxSocket->u.xTCP.xPacket.u.ucLastPacket[ uxOffset ] ) ),
( const void * ) ( &( pxNetworkBuffer->pucEthernetBuffer[ uxOffset ] ) ),
ipSIZE_OF_TCP_HEADER );
/* Clear flags that are set by the peer, and set the ACK flag. */
pxSocket->u.xTCP.xPacket.u.ucLastPacket[ uxOffset + ipTCP_FLAGS_OFFSET ] = tcpTCP_FLAG_ACK;
}
}
}
if( xResult != pdFAIL )
{
uint16_t usWindow;
/* pxSocket is not NULL when xResult != pdFAIL. */
configASSERT( pxSocket != NULL );
/* Touch the alive timers because we received a message for this
* socket. */
prvTCPTouchSocket( pxSocket );
/* Parse the TCP option(s), if present. */
/* _HT_ : if we're in the SYN phase, and peer does not send a MSS option,
* then we MUST assume an MSS size of 536 bytes for backward compatibility. */
/* When there are no TCP options, the TCP offset equals 20 bytes, which is stored as
* the number 5 (words) in the higher nibble of the TCP-offset byte. */
if( ( pxProtocolHeaders->xTCPHeader.ucTCPOffset & tcpTCP_OFFSET_LENGTH_BITS ) > tcpTCP_OFFSET_STANDARD_LENGTH )
{
xResult = prvCheckOptions( pxSocket, pxNetworkBuffer );
}
if( xResult != pdFAIL )
{
usWindow = FreeRTOS_ntohs( pxProtocolHeaders->xTCPHeader.usWindow );
pxSocket->u.xTCP.ulWindowSize = ( uint32_t ) usWindow;
#if ( ipconfigUSE_TCP_WIN == 1 )
{
/* rfc1323 : The Window field in a SYN (i.e., a <SYN> or <SYN,ACK>)
* segment itself is never scaled. */
if( ( ucTCPFlags & ( uint8_t ) tcpTCP_FLAG_SYN ) == 0U )
{
pxSocket->u.xTCP.ulWindowSize =
( pxSocket->u.xTCP.ulWindowSize << pxSocket->u.xTCP.ucPeerWinScaleFactor );
}
}
#endif /* ipconfigUSE_TCP_WIN */
/* In prvTCPHandleState() the incoming messages will be handled
* depending on the current state of the connection. */
if( prvTCPHandleState( pxSocket, &pxNetworkBuffer ) > 0 )
{
/* prvTCPHandleState() has sent a message, see if there are more to
* be transmitted. */
#if ( ipconfigUSE_TCP_WIN == 1 )
{
( void ) prvTCPSendRepeated( pxSocket, &pxNetworkBuffer );
}
#endif /* ipconfigUSE_TCP_WIN */
}
if( pxNetworkBuffer != NULL )
{
/* We must check if the buffer is unequal to NULL, because the
* socket might keep a reference to it in case a delayed ACK must be
* sent. */
vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );
#ifndef _lint
/* Clear pointers that are freed. */
pxNetworkBuffer = NULL;
#endif
}
/* And finally, calculate when this socket wants to be woken up. */
( void ) prvTCPNextTimeout( pxSocket );
}
}
}
/* pdPASS being returned means the buffer has been consumed. */
return xResult;
}