--- /dev/null
+/*\r
+ * FreeRTOS+TCP Labs Build 160919 (C) 2016 Real Time Engineers ltd.\r
+ * Authors include Hein Tibosch and Richard Barry\r
+ *\r
+ *******************************************************************************\r
+ ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ***\r
+ *** ***\r
+ *** ***\r
+ *** FREERTOS+TCP IS STILL IN THE LAB (mainly because the FTP and HTTP ***\r
+ *** demos have a dependency on FreeRTOS+FAT, which is only in the Labs ***\r
+ *** download): ***\r
+ *** ***\r
+ *** FreeRTOS+TCP is functional and has been used in commercial products ***\r
+ *** for some time. Be aware however that we are still refining its ***\r
+ *** design, the source code does not yet quite conform to the strict ***\r
+ *** coding and style standards mandated by Real Time Engineers ltd., and ***\r
+ *** the documentation and testing is not necessarily complete. ***\r
+ *** ***\r
+ *** PLEASE REPORT EXPERIENCES USING THE SUPPORT RESOURCES FOUND ON THE ***\r
+ *** URL: http://www.FreeRTOS.org/contact Active early adopters may, at ***\r
+ *** the sole discretion of Real Time Engineers Ltd., be offered versions ***\r
+ *** under a license other than that described below. ***\r
+ *** ***\r
+ *** ***\r
+ ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ***\r
+ *******************************************************************************\r
+ *\r
+ * FreeRTOS+TCP can be used under two different free open source licenses. The\r
+ * license that applies is dependent on the processor on which FreeRTOS+TCP is\r
+ * executed, as follows:\r
+ *\r
+ * If FreeRTOS+TCP is executed on one of the processors listed under the Special\r
+ * License Arrangements heading of the FreeRTOS+TCP license information web\r
+ * page, then it can be used under the terms of the FreeRTOS Open Source\r
+ * License. If FreeRTOS+TCP is used on any other processor, then it can be used\r
+ * under the terms of the GNU General Public License V2. Links to the relevant\r
+ * licenses follow:\r
+ *\r
+ * The FreeRTOS+TCP License Information Page: http://www.FreeRTOS.org/tcp_license\r
+ * The FreeRTOS Open Source License: http://www.FreeRTOS.org/license\r
+ * The GNU General Public License Version 2: http://www.FreeRTOS.org/gpl-2.0.txt\r
+ *\r
+ * FreeRTOS+TCP is distributed in the hope that it will be useful. You cannot\r
+ * use FreeRTOS+TCP unless you agree that you use the software 'as is'.\r
+ * FreeRTOS+TCP is provided WITHOUT ANY WARRANTY; without even the implied\r
+ * warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR\r
+ * PURPOSE. Real Time Engineers Ltd. disclaims all conditions and terms, be they\r
+ * implied, expressed, or statutory.\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://www.FreeRTOS.org/plus\r
+ * http://www.FreeRTOS.org/labs\r
+ *\r
+ */\r
+\r
+/*\r
+ * FreeRTOS_TCP_IP.c\r
+ * Module which handles the TCP connections for FreeRTOS+TCP.\r
+ * It depends on FreeRTOS_TCP_WIN.c, which handles the TCP windowing\r
+ * schemes.\r
+ *\r
+ * Endianness: in this module all ports and IP addresses are stored in\r
+ * host byte-order, except fields in the IP-packets\r
+ */\r
+\r
+/* Standard includes. */\r
+#include <stdint.h>\r
+#include <stdio.h>\r
+\r
+/* FreeRTOS includes. */\r
+#include "FreeRTOS.h"\r
+#include "task.h"\r
+#include "queue.h"\r
+#include "semphr.h"\r
+\r
+/* FreeRTOS+TCP includes. */\r
+#include "FreeRTOS_IP.h"\r
+#include "FreeRTOS_Sockets.h"\r
+#include "FreeRTOS_IP_Private.h"\r
+#include "FreeRTOS_UDP_IP.h"\r
+#include "FreeRTOS_TCP_IP.h"\r
+#include "FreeRTOS_DHCP.h"\r
+#include "NetworkInterface.h"\r
+#include "NetworkBufferManagement.h"\r
+#include "FreeRTOS_ARP.h"\r
+#include "FreeRTOS_TCP_WIN.h"\r
+\r
+\r
+/* Just make sure the contents doesn't get compiled if TCP is not enabled. */\r
+#if ipconfigUSE_TCP == 1\r
+\r
+/* This compile-time test was moved to here because some macro's\r
+were unknown within 'FreeRTOSIPConfigDefaults.h'. It tests whether\r
+the defined MTU size can contain at ;east a complete TCP packet. */\r
+\r
+#if ( ( ipconfigTCP_MSS + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER ) > ipconfigNETWORK_MTU )\r
+ #error The ipconfigTCP_MSS setting in FreeRTOSIPConfig.h is too large.\r
+#endif\r
+\r
+/*\r
+ * The meaning of the TCP flags:\r
+ */\r
+#define ipTCP_FLAG_FIN 0x0001u /* No more data from sender */\r
+#define ipTCP_FLAG_SYN 0x0002u /* Synchronize sequence numbers */\r
+#define ipTCP_FLAG_RST 0x0004u /* Reset the connection */\r
+#define ipTCP_FLAG_PSH 0x0008u /* Push function: please push buffered data to the recv application */\r
+#define ipTCP_FLAG_ACK 0x0010u /* Acknowledgment field is significant */\r
+#define ipTCP_FLAG_URG 0x0020u /* Urgent pointer field is significant */\r
+#define ipTCP_FLAG_ECN 0x0040u /* ECN-Echo */\r
+#define ipTCP_FLAG_CWR 0x0080u /* Congestion Window Reduced */\r
+#define ipTCP_FLAG_NS 0x0100u /* ECN-nonce concealment protection */\r
+#define ipTCP_FLAG_RSV 0x0E00u /* Reserved, keep 0 */\r
+\r
+/* A mask to filter all protocol flags. */\r
+#define ipTCP_FLAG_CTRL 0x001Fu\r
+\r
+/*\r
+ * A few values of the TCP options:\r
+ */\r
+#define TCP_OPT_END 0u /* End of TCP options list */\r
+#define TCP_OPT_NOOP 1u /* "No-operation" TCP option */\r
+#define TCP_OPT_MSS 2u /* Maximum segment size TCP option */\r
+#define TCP_OPT_WSOPT 3u /* TCP Window Scale Option (3-byte long) */\r
+#define TCP_OPT_SACK_P 4u /* Advertize that SACK is permitted */\r
+#define TCP_OPT_SACK_A 5u /* SACK option with first/last */\r
+#define TCP_OPT_TIMESTAMP 8u /* Time-stamp option */\r
+\r
+#define TCP_OPT_MSS_LEN 4u /* Length of TCP MSS option. */\r
+#define TCP_OPT_WSOPT_LEN 3u /* Length of TCP WSOPT option. */\r
+\r
+#define TCP_OPT_TIMESTAMP_LEN 10 /* fixed length of the time-stamp option */\r
+\r
+#ifndef ipconfigTCP_ACK_EARLIER_PACKET\r
+ #define ipconfigTCP_ACK_EARLIER_PACKET 1\r
+#endif\r
+\r
+/*\r
+ * The macro NOW_CONNECTED() is use to determine if the connection makes a\r
+ * transition from connected to non-connected and vice versa.\r
+ * NOW_CONNECTED() returns true when the status has one of these values:\r
+ * eESTABLISHED, eFIN_WAIT_1, eFIN_WAIT_2, eCLOSING, eLAST_ACK, eTIME_WAIT\r
+ * Technically the connection status is closed earlier, but the library wants\r
+ * to prevent that the socket will be deleted before the last ACK has been\r
+ * and thus causing a 'RST' packet on either side.\r
+ */\r
+#define NOW_CONNECTED( status )\\r
+ ( ( status >= eESTABLISHED ) && ( status != eCLOSE_WAIT ) )\r
+\r
+/*\r
+ * The highest 4 bits in the TCP offset byte indicate the total length of the\r
+ * TCP header, divided by 4.\r
+ */\r
+#define VALID_BITS_IN_TCP_OFFSET_BYTE ( 0xF0u )\r
+\r
+/*\r
+ * Acknowledgements to TCP data packets may be delayed as long as more is being expected.\r
+ * A normal delay would be 200ms. Here a much shorter delay of 20 ms is being used to\r
+ * gain performance.\r
+ */\r
+#define DELAYED_ACK_SHORT_DELAY_MS ( 2 )\r
+#define DELAYED_ACK_LONGER_DELAY_MS ( 20 )\r
+\r
+/*\r
+ * The MSS (Maximum Segment Size) will be taken as large as possible. However, packets with\r
+ * an MSS of 1460 bytes won't be transported through the internet. The MSS will be reduced\r
+ * to 1400 bytes.\r
+ */\r
+#define REDUCED_MSS_THROUGH_INTERNET ( 1400 )\r
+\r
+/*\r
+ * Each time a new TCP connection is being made, a new Initial Sequence Number shall be used.\r
+ * The variable 'ulNextInitialSequenceNumber' will be incremented with a recommended value\r
+ * of 0x102.\r
+ */\r
+#define INITIAL_SEQUENCE_NUMBER_INCREMENT ( 0x102UL )\r
+\r
+/*\r
+ * When there are no TCP options, the TCP offset equals 20 bytes, which is stored as\r
+ * the number 5 (words) in the higher niblle of the TCP-offset byte.\r
+ */\r
+#define TCP_OFFSET_LENGTH_BITS ( 0xf0u )\r
+#define TCP_OFFSET_STANDARD_LENGTH ( 0x50u )\r
+\r
+/*\r
+ * Each TCP socket is checked regularly to see if it can send data packets.\r
+ * By default, the maximum number of packets sent during one check is limited to 8.\r
+ * This amount may be further limited by setting the socket's TX window size.\r
+ */\r
+#if( !defined( SEND_REPEATED_COUNT ) )\r
+ #define SEND_REPEATED_COUNT ( 8 )\r
+#endif /* !defined( SEND_REPEATED_COUNT ) */\r
+\r
+/*\r
+ * Define a maximum perdiod of time (ms) to leave a TCP-socket unattended.\r
+ * When a TCP timer expires, retries and keep-alive messages will be checked.\r
+ */\r
+#ifndef tcpMAXIMUM_TCP_WAKEUP_TIME_MS\r
+ #define tcpMAXIMUM_TCP_WAKEUP_TIME_MS 20000u\r
+#endif\r
+\r
+/*\r
+ * The names of the different TCP states may be useful in logging.\r
+ */\r
+#if( ( ipconfigHAS_DEBUG_PRINTF != 0 ) || ( ipconfigHAS_PRINTF != 0 ) )\r
+ static const char *pcStateNames[] = {\r
+ "eCLOSED",\r
+ "eTCP_LISTEN",\r
+ "eCONNECT_SYN",\r
+ "eSYN_FIRST",\r
+ "eSYN_RECEIVED",\r
+ "eESTABLISHED",\r
+ "eFIN_WAIT_1",\r
+ "eFIN_WAIT_2",\r
+ "eCLOSE_WAIT",\r
+ "eCLOSING",\r
+ "eLAST_ACK",\r
+ "eTIME_WAIT",\r
+ "eUNKNOWN",\r
+};\r
+#endif /* ( ipconfigHAS_DEBUG_PRINTF != 0 ) || ( ipconfigHAS_PRINTF != 0 ) */\r
+\r
+/*\r
+ * Returns true if the socket must be checked. Non-active sockets are waiting\r
+ * for user action, either connect() or close().\r
+ */\r
+static BaseType_t prvTCPSocketIsActive( UBaseType_t uxStatus );\r
+\r
+/*\r
+ * Either sends a SYN or calls prvTCPSendRepeated (for regular messages).\r
+ */\r
+static int32_t prvTCPSendPacket( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * Try to send a series of messages.\r
+ */\r
+static int32_t prvTCPSendRepeated( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer );\r
+\r
+/*\r
+ * Return or send a packet to the other party.\r
+ */\r
+static void prvTCPReturnPacket( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer,\r
+ uint32_t ulLen, BaseType_t xReleaseAfterSend );\r
+\r
+/*\r
+ * Initialise the data structures which keep track of the TCP windowing system.\r
+ */\r
+static void prvTCPCreateWindow( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * Let ARP look-up the MAC-address of the peer and initialise the first SYN\r
+ * packet.\r
+ */\r
+static BaseType_t prvTCPPrepareConnect( FreeRTOS_Socket_t *pxSocket );\r
+\r
+#if( ipconfigHAS_DEBUG_PRINTF != 0 )\r
+ /*\r
+ * For logging and debugging: make a string showing the TCP flags.\r
+ */\r
+ static const char *prvTCPFlagMeaning( UBaseType_t xFlags);\r
+#endif /* ipconfigHAS_DEBUG_PRINTF != 0 */\r
+\r
+/*\r
+ * Parse the TCP option(s) received, if present.\r
+ */\r
+static void prvCheckOptions( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer );\r
+\r
+/*\r
+ * Set the initial properties in the options fields, like the preferred\r
+ * value of MSS and whether SACK allowed. Will be transmitted in the state\r
+ * 'eCONNECT_SYN'.\r
+ */\r
+static UBaseType_t prvSetSynAckOptions( FreeRTOS_Socket_t *pxSocket, TCPPacket_t * pxTCPPacket );\r
+\r
+/*\r
+ * For anti-hang protection and TCP keep-alive messages. Called in two places:\r
+ * after receiving a packet and after a state change. The socket's alive timer\r
+ * may be reset.\r
+ */\r
+static void prvTCPTouchSocket( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * Prepare an outgoing message, if anything has to be sent.\r
+ */\r
+static int32_t prvTCPPrepareSend( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer, UBaseType_t uxOptionsLength );\r
+\r
+/*\r
+ * Calculate when this socket needs to be checked to do (re-)transmissions.\r
+ */\r
+static TickType_t prvTCPNextTimeout( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * The API FreeRTOS_send() adds data to the TX stream. Add\r
+ * this data to the windowing system to it can be transmitted.\r
+ */\r
+static void prvTCPAddTxData( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * Called to handle the closure of a TCP connection.\r
+ */\r
+static BaseType_t prvTCPHandleFin( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer );\r
+\r
+#if( ipconfigUSE_TCP_TIMESTAMPS == 1 )\r
+ static UBaseType_t prvTCPSetTimeStamp( BaseType_t lOffset, FreeRTOS_Socket_t *pxSocket, TCPHeader_t *pxTCPHeader );\r
+#endif\r
+\r
+/*\r
+ * Called from prvTCPHandleState(). Find the TCP payload data and check and\r
+ * return its length.\r
+ */\r
+static BaseType_t prvCheckRxData( NetworkBufferDescriptor_t *pxNetworkBuffer, uint8_t **ppucRecvData );\r
+\r
+/*\r
+ * Called from prvTCPHandleState(). Check if the payload data may be accepted.\r
+ * If so, it will be added to the socket's reception queue.\r
+ */\r
+static BaseType_t prvStoreRxData( FreeRTOS_Socket_t *pxSocket, uint8_t *pucRecvData,\r
+ NetworkBufferDescriptor_t *pxNetworkBuffer, uint32_t ulReceiveLength );\r
+\r
+/*\r
+ * Set the TCP options (if any) for the outgoing packet.\r
+ */\r
+static UBaseType_t prvSetOptions( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer );\r
+\r
+/*\r
+ * Called from prvTCPHandleState() as long as the TCP status is eSYN_RECEIVED to\r
+ * eCONNECT_SYN.\r
+ */\r
+static BaseType_t prvHandleSynReceived( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, UBaseType_t uxOptionsLength );\r
+\r
+/*\r
+ * Called from prvTCPHandleState() as long as the TCP status is eESTABLISHED.\r
+ */\r
+static BaseType_t prvHandleEstablished( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, UBaseType_t uxOptionsLength );\r
+\r
+/*\r
+ * Called from prvTCPHandleState(). There is data to be sent.\r
+ * If ipconfigUSE_TCP_WIN is defined, and if only an ACK must be sent, it will\r
+ * be checked if it would better be postponed for efficiency.\r
+ */\r
+static BaseType_t prvSendData( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, BaseType_t xSendLength );\r
+\r
+/*\r
+ * The heart of all: check incoming packet for valid data and acks and do what\r
+ * is necessary in each state.\r
+ */\r
+static BaseType_t prvTCPHandleState( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer );\r
+\r
+/*\r
+ * Reply to a peer with the RST flag on, in case a packet can not be handled.\r
+ */\r
+static BaseType_t prvTCPSendReset( NetworkBufferDescriptor_t *pxNetworkBuffer );\r
+\r
+/*\r
+ * Set the initial value for MSS (Maximum Segment Size) to be used.\r
+ */\r
+static void prvSocketSetMSS( FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * Return either a newly created socket, or the current socket in a connected\r
+ * state (depends on the 'bReuseSocket' flag).\r
+ */\r
+static FreeRTOS_Socket_t *prvHandleListen( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer );\r
+\r
+/*\r
+ * After a listening socket receives a new connection, it may duplicate itself.\r
+ * The copying takes place in prvTCPSocketCopy.\r
+ */\r
+static BaseType_t prvTCPSocketCopy( FreeRTOS_Socket_t *pxNewSocket, FreeRTOS_Socket_t *pxSocket );\r
+\r
+/*\r
+ * prvTCPStatusAgeCheck() will see if the socket has been in a non-connected\r
+ * state for too long. If so, the socket will be closed, and -1 will be\r
+ * returned.\r
+ */\r
+#if( ipconfigTCP_HANG_PROTECTION == 1 )\r
+ static BaseType_t prvTCPStatusAgeCheck( FreeRTOS_Socket_t *pxSocket );\r
+#endif\r
+\r
+static NetworkBufferDescriptor_t *prvTCPBufferResize( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer,\r
+ int32_t lDataLen, UBaseType_t uxOptionsLength );\r
+\r
+#if( ( ipconfigHAS_DEBUG_PRINTF != 0 ) || ( ipconfigHAS_PRINTF != 0 ) )\r
+ const char *FreeRTOS_GetTCPStateName( UBaseType_t ulState );\r
+#endif\r
+\r
+#if( ipconfigUSE_TCP_WIN != 0 )\r
+ static uint8_t prvWinScaleFactor( FreeRTOS_Socket_t *pxSocket );\r
+#endif\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/* Initial Sequence Number, i.e. the next initial sequence number that will be\r
+used when a new connection is opened. The value should be randomized to prevent\r
+attacks from outside (spoofing). */\r
+uint32_t ulNextInitialSequenceNumber = 0ul;\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/* prvTCPSocketIsActive() returns true if the socket must be checked.\r
+ * Non-active sockets are waiting for user action, either connect()\r
+ * or close(). */\r
+static BaseType_t prvTCPSocketIsActive( UBaseType_t uxStatus )\r
+{\r
+ switch( uxStatus )\r
+ {\r
+ case eCLOSED:\r
+ case eCLOSE_WAIT:\r
+ case eFIN_WAIT_2:\r
+ case eCLOSING:\r
+ case eTIME_WAIT:\r
+ return pdFALSE;\r
+ default:\r
+ return pdTRUE;\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( ipconfigTCP_HANG_PROTECTION == 1 )\r
+\r
+ static BaseType_t prvTCPStatusAgeCheck( FreeRTOS_Socket_t *pxSocket )\r
+ {\r
+ BaseType_t xResult;\r
+ switch( pxSocket->u.xTCP.ucTCPState )\r
+ {\r
+ case eESTABLISHED:\r
+ /* If the 'ipconfigTCP_KEEP_ALIVE' option is enabled, sockets in\r
+ state ESTABLISHED can be protected using keep-alive messages. */\r
+ xResult = pdFALSE;\r
+ break;\r
+ case eCLOSED:\r
+ case eTCP_LISTEN:\r
+ case eCLOSE_WAIT:\r
+ /* These 3 states may last for ever, up to the owner. */\r
+ xResult = pdFALSE;\r
+ break;\r
+ default:\r
+ /* All other (non-connected) states will get anti-hanging\r
+ protection. */\r
+ xResult = pdTRUE;\r
+ break;\r
+ }\r
+ if( xResult != pdFALSE )\r
+ {\r
+ /* How much time has past since the last active moment which is\r
+ defined as A) a state change or B) a packet has arrived. */\r
+ TickType_t xAge = xTaskGetTickCount( ) - pxSocket->u.xTCP.xLastActTime;\r
+\r
+ /* ipconfigTCP_HANG_PROTECTION_TIME is in units of seconds. */\r
+ if( xAge > ( ipconfigTCP_HANG_PROTECTION_TIME * configTICK_RATE_HZ ) )\r
+ {\r
+ #if( ipconfigHAS_DEBUG_PRINTF == 1 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "Inactive socket closed: port %u rem %lxip:%u status %s\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ FreeRTOS_GetTCPStateName( ( UBaseType_t ) pxSocket->u.xTCP.ucTCPState ) ) );\r
+ }\r
+ #endif /* ipconfigHAS_DEBUG_PRINTF */\r
+\r
+ /* Move to eCLOSE_WAIT, user may close the socket. */\r
+ vTCPStateChange( pxSocket, eCLOSE_WAIT );\r
+\r
+ /* When 'bPassQueued' true, this socket is an orphan until it\r
+ gets connected. */\r
+ if( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED )\r
+ {\r
+ if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )\r
+ {\r
+ /* As it did not get connected, and the user can never\r
+ accept() it anymore, it will be deleted now. Called from\r
+ the IP-task, so it's safe to call the internal Close\r
+ function: vSocketClose(). */\r
+ vSocketClose( pxSocket );\r
+ }\r
+ /* Return a negative value to tell to inform the caller\r
+ xTCPTimerCheck()\r
+ that the socket got closed and may not be accessed anymore. */\r
+ xResult = -1;\r
+ }\r
+ }\r
+ }\r
+ return xResult;\r
+ }\r
+ /*-----------------------------------------------------------*/\r
+\r
+#endif\r
+\r
+/*\r
+ * As soon as a TCP socket timer expires, this function xTCPSocketCheck\r
+ * will be called (from xTCPTimerCheck)\r
+ * It can send a delayed ACK or new data\r
+ * Sequence of calling (normally) :\r
+ * IP-Task:\r
+ * xTCPTimerCheck() // Check all sockets ( declared in FreeRTOS_Sockets.c )\r
+ * xTCPSocketCheck() // Either send a delayed ACK or call prvTCPSendPacket()\r
+ * prvTCPSendPacket() // Either send a SYN or call prvTCPSendRepeated ( regular messages )\r
+ * prvTCPSendRepeated() // Send at most 8 messages on a row\r
+ * prvTCPReturnPacket() // Prepare for returning\r
+ * xNetworkInterfaceOutput() // Sends data to the NIC ( declared in portable/NetworkInterface/xxx )\r
+ */\r
+BaseType_t xTCPSocketCheck( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+BaseType_t xResult = 0;\r
+BaseType_t xReady = pdFALSE;\r
+\r
+ if( ( pxSocket->u.xTCP.ucTCPState >= eESTABLISHED ) && ( pxSocket->u.xTCP.txStream != NULL ) )\r
+ {\r
+ /* The API FreeRTOS_send() might have added data to the TX stream. Add\r
+ this data to the windowing system so it can be transmitted. */\r
+ prvTCPAddTxData( pxSocket );\r
+ }\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ if( pxSocket->u.xTCP.pxAckMessage != NULL )\r
+ {\r
+ /* The first task of this regular socket check is to send-out delayed\r
+ ACK's. */\r
+ if( pxSocket->u.xTCP.bits.bUserShutdown == pdFALSE_UNSIGNED )\r
+ {\r
+ /* Earlier data was received but not yet acknowledged. This\r
+ function is called when the TCP timer for the socket expires, the\r
+ ACK may be sent now. */\r
+ if( pxSocket->u.xTCP.ucTCPState != eCLOSED )\r
+ {\r
+ if( xTCPWindowLoggingLevel > 1 && ipconfigTCP_MAY_LOG_PORT( pxSocket->usLocalPort ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "Send[%u->%u] del ACK %lu SEQ %lu (len %u)\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber - pxSocket->u.xTCP.xTCPWindow.rx.ulFirstSequenceNumber,\r
+ pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber - pxSocket->u.xTCP.xTCPWindow.tx.ulFirstSequenceNumber,\r
+ ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER ) );\r
+ }\r
+\r
+ prvTCPReturnPacket( pxSocket, pxSocket->u.xTCP.pxAckMessage, ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER, ipconfigZERO_COPY_TX_DRIVER );\r
+\r
+ #if( ipconfigZERO_COPY_TX_DRIVER != 0 )\r
+ {\r
+ /* The ownership has been passed to the SEND routine,\r
+ clear the pointer to it. */\r
+ pxSocket->u.xTCP.pxAckMessage = NULL;\r
+ }\r
+ #endif /* ipconfigZERO_COPY_TX_DRIVER */\r
+ }\r
+ if( prvTCPNextTimeout( pxSocket ) > 1 )\r
+ {\r
+ /* Tell the code below that this function is ready. */\r
+ xReady = pdTRUE;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* The user wants to perform an active shutdown(), skip sending\r
+ the delayed ACK. The function prvTCPSendPacket() will send the\r
+ FIN along with the ACK's. */\r
+ }\r
+\r
+ if( pxSocket->u.xTCP.pxAckMessage != NULL )\r
+ {\r
+ vReleaseNetworkBufferAndDescriptor( pxSocket->u.xTCP.pxAckMessage );\r
+ pxSocket->u.xTCP.pxAckMessage = NULL;\r
+ }\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+\r
+ if( xReady == pdFALSE )\r
+ {\r
+ /* The second task of this regular socket check is sending out data. */\r
+ if( ( pxSocket->u.xTCP.ucTCPState >= eESTABLISHED ) ||\r
+ ( pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN ) )\r
+ {\r
+ prvTCPSendPacket( pxSocket );\r
+ }\r
+\r
+ /* Set the time-out for the next wakeup for this socket. */\r
+ prvTCPNextTimeout( pxSocket );\r
+\r
+ #if( ipconfigTCP_HANG_PROTECTION == 1 )\r
+ {\r
+ /* In all (non-connected) states in which keep-alive messages can not be sent\r
+ the anti-hang protocol will close sockets that are 'hanging'. */\r
+ xResult = prvTCPStatusAgeCheck( pxSocket );\r
+ }\r
+ #endif\r
+ }\r
+\r
+ return xResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvTCPSendPacket() will be called when the socket time-out has been reached.\r
+ * It is only called by xTCPSocketCheck().\r
+ */\r
+static int32_t prvTCPSendPacket( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+int32_t lResult = 0;\r
+UBaseType_t uxOptionsLength;\r
+TCPPacket_t *pxTCPPacket;\r
+NetworkBufferDescriptor_t *pxNetworkBuffer;\r
+\r
+ if( pxSocket->u.xTCP.ucTCPState != eCONNECT_SYN )\r
+ {\r
+ /* The connection is in a state other than SYN. */\r
+ pxNetworkBuffer = NULL;\r
+\r
+ /* prvTCPSendRepeated() will only create a network buffer if necessary,\r
+ i.e. when data must be sent to the peer. */\r
+ lResult = prvTCPSendRepeated( pxSocket, &pxNetworkBuffer );\r
+\r
+ if( pxNetworkBuffer != NULL )\r
+ {\r
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if( pxSocket->u.xTCP.ucRepCount >= 3u )\r
+ {\r
+ /* The connection is in the SYN status. The packet will be repeated\r
+ to most 3 times. When there is no response, the socket get the\r
+ status 'eCLOSE_WAIT'. */\r
+ FreeRTOS_debug_printf( ( "Connect: giving up %lxip:%u\n",\r
+ pxSocket->u.xTCP.ulRemoteIP, /* IP address of remote machine. */\r
+ pxSocket->u.xTCP.usRemotePort ) ); /* Port on remote machine. */\r
+ vTCPStateChange( pxSocket, eCLOSE_WAIT );\r
+ }\r
+ else if( ( pxSocket->u.xTCP.bits.bConnPrepared != pdFALSE_UNSIGNED ) || ( prvTCPPrepareConnect( pxSocket ) == pdTRUE ) )\r
+ {\r
+ /* Or else, if the connection has been prepared, or can be prepared\r
+ now, proceed to send the packet with the SYN flag.\r
+ prvTCPPrepareConnect() prepares 'xPacket' and returns pdTRUE if\r
+ the Ethernet address of the peer or the gateway is found. */\r
+ pxTCPPacket = ( TCPPacket_t * )pxSocket->u.xTCP.xPacket.u.ucLastPacket;\r
+\r
+ #if( ipconfigUSE_TCP_TIMESTAMPS == 1 )\r
+ {\r
+ /* When TCP time stamps are enabled, but they will only be applied\r
+ if the peer is outside the netmask, usually on the internet.\r
+ Packages sent on a LAN are usually too big to carry time stamps. */\r
+ if( ( ( pxSocket->u.xTCP.ulRemoteIP ^ FreeRTOS_ntohl( *ipLOCAL_IP_ADDRESS_POINTER ) ) & xNetworkAddressing.ulNetMask ) != 0ul )\r
+ {\r
+ pxSocket->u.xTCP.xTCPWindow.u.bits.bTimeStamps = pdTRUE_UNSIGNED;\r
+ }\r
+ }\r
+ #endif\r
+\r
+ /* About to send a SYN packet. Call prvSetSynAckOptions() to set\r
+ the proper options: The size of MSS and whether SACK's are\r
+ allowed. */\r
+ uxOptionsLength = prvSetSynAckOptions( pxSocket, pxTCPPacket );\r
+\r
+ /* Return the number of bytes to be sent. */\r
+ lResult = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+\r
+ /* Set the TCP offset field: ipSIZE_OF_TCP_HEADER equals 20 and\r
+ uxOptionsLength is always a multiple of 4. The complete expression\r
+ would be:\r
+ ucTCPOffset = ( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) / 4 ) << 4 */\r
+ pxTCPPacket->xTCPHeader.ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+\r
+ /* Repeat Count is used for a connecting socket, to limit the number\r
+ of tries. */\r
+ pxSocket->u.xTCP.ucRepCount++;\r
+\r
+ /* Send the SYN message to make a connection. The messages is\r
+ stored in the socket field 'xPacket'. It will be wrapped in a\r
+ pseudo network buffer descriptor before it will be sent. */\r
+ prvTCPReturnPacket( pxSocket, NULL, ( uint32_t ) lResult, pdFALSE );\r
+ }\r
+ }\r
+\r
+ /* Return the total number of bytes sent. */\r
+ return lResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvTCPSendRepeated will try to send a series of messages, as long as there is\r
+ * data to be sent and as long as the transmit window isn't full.\r
+ */\r
+static int32_t prvTCPSendRepeated( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer )\r
+{\r
+UBaseType_t uxIndex;\r
+int32_t lResult = 0;\r
+UBaseType_t uxOptionsLength = 0u;\r
+int32_t xSendLength;\r
+\r
+ for( uxIndex = 0u; uxIndex < ( UBaseType_t ) SEND_REPEATED_COUNT; uxIndex++ )\r
+ {\r
+ /* prvTCPPrepareSend() might allocate a network buffer if there is data\r
+ to be sent. */\r
+ xSendLength = prvTCPPrepareSend( pxSocket, ppxNetworkBuffer, uxOptionsLength );\r
+ if( xSendLength <= 0 )\r
+ {\r
+ break;\r
+ }\r
+\r
+ /* And return the packet to the peer. */\r
+ prvTCPReturnPacket( pxSocket, *ppxNetworkBuffer, ( uint32_t ) xSendLength, ipconfigZERO_COPY_TX_DRIVER );\r
+\r
+ #if( ipconfigZERO_COPY_TX_DRIVER != 0 )\r
+ {\r
+ *ppxNetworkBuffer = NULL;\r
+ }\r
+ #endif /* ipconfigZERO_COPY_TX_DRIVER */\r
+\r
+ lResult += xSendLength;\r
+ }\r
+\r
+ /* Return the total number of bytes sent. */\r
+ return lResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Return (or send) a packet the the peer. The data is stored in pxBuffer,\r
+ * which may either point to a real network buffer or to a TCP socket field\r
+ * called 'xTCP.xPacket'. A temporary xNetworkBuffer will be used to pass\r
+ * the data to the NIC.\r
+ */\r
+static void prvTCPReturnPacket( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer, uint32_t ulLen, BaseType_t xReleaseAfterSend )\r
+{\r
+TCPPacket_t * pxTCPPacket;\r
+IPHeader_t *pxIPHeader;\r
+EthernetHeader_t *pxEthernetHeader;\r
+uint32_t ulFrontSpace, ulSpace, ulSourceAddress, ulWinSize;\r
+TCPWindow_t *pxTCPWindow;\r
+NetworkBufferDescriptor_t xTempBuffer;\r
+/* For sending, a pseudo network buffer will be used, as explained above. */\r
+\r
+ if( pxNetworkBuffer == NULL )\r
+ {\r
+ memset( &xTempBuffer, '\0', sizeof( xTempBuffer ) );\r
+ pxNetworkBuffer = &xTempBuffer;\r
+\r
+ xTempBuffer.pucEthernetBuffer = pxSocket->u.xTCP.xPacket.u.ucLastPacket;\r
+ xTempBuffer.xDataLength = sizeof( pxSocket->u.xTCP.xPacket.u.ucLastPacket );\r
+ }\r
+\r
+ #if( ipconfigZERO_COPY_TX_DRIVER != 0 )\r
+ {\r
+ if( xReleaseAfterSend == pdFALSE )\r
+ {\r
+ pxNetworkBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, ( BaseType_t ) pxNetworkBuffer->xDataLength );\r
+ if( pxNetworkBuffer == NULL )\r
+ {\r
+ FreeRTOS_debug_printf( ( "prvTCPReturnPacket: duplicate failed\n" ) );\r
+ }\r
+ xReleaseAfterSend = pdTRUE;\r
+ }\r
+ }\r
+ #endif /* ipconfigZERO_COPY_TX_DRIVER */\r
+\r
+ if( pxNetworkBuffer != NULL )\r
+ {\r
+ pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+ pxIPHeader = &pxTCPPacket->xIPHeader;\r
+ pxEthernetHeader = &pxTCPPacket->xEthernetHeader;\r
+\r
+ /* Fill the packet, using hton translations. */\r
+ if( pxSocket != NULL )\r
+ {\r
+ /* Calculate the space in the RX buffer in order to advertise the\r
+ size of this socket's reception window. */\r
+ pxTCPWindow = &( pxSocket->u.xTCP.xTCPWindow );\r
+\r
+ if( pxSocket->u.xTCP.rxStream != NULL )\r
+ {\r
+ /* An RX stream was created already, see how much space is\r
+ available. */\r
+ ulFrontSpace = ( uint32_t ) uxStreamBufferFrontSpace( pxSocket->u.xTCP.rxStream );\r
+ }\r
+ else\r
+ {\r
+ /* No RX stream has been created, the full stream size is\r
+ available. */\r
+ ulFrontSpace = ( uint32_t ) pxSocket->u.xTCP.uxRxStreamSize;\r
+ }\r
+\r
+ /* Take the minimum of the RX buffer space and the RX window size. */\r
+ ulSpace = FreeRTOS_min_uint32( pxSocket->u.xTCP.ulRxCurWinSize, pxTCPWindow->xSize.ulRxWindowLength );\r
+\r
+ if( ( pxSocket->u.xTCP.bits.bLowWater != pdFALSE_UNSIGNED ) || ( pxSocket->u.xTCP.bits.bRxStopped != pdFALSE_UNSIGNED ) )\r
+ {\r
+ /* The low-water mark was reached, meaning there was little\r
+ space left. The socket will wait until the application has read\r
+ or flushed the incoming data, and 'zero-window' will be\r
+ advertised. */\r
+ ulSpace = 0u;\r
+ }\r
+\r
+ /* If possible, advertise an RX window size of at least 1 MSS, otherwise\r
+ the peer might start 'zero window probing', i.e. sending small packets\r
+ (1, 2, 4, 8... bytes). */\r
+ if( ( ulSpace < pxSocket->u.xTCP.usCurMSS ) && ( ulFrontSpace >= pxSocket->u.xTCP.usCurMSS ) )\r
+ {\r
+ ulSpace = pxSocket->u.xTCP.usCurMSS;\r
+ }\r
+\r
+ /* Avoid overflow of the 16-bit win field. */\r
+ #if( ipconfigUSE_TCP_WIN != 0 )\r
+ {\r
+ ulWinSize = ( ulSpace >> pxSocket->u.xTCP.ucMyWinScaleFactor );\r
+ }\r
+ #else\r
+ {\r
+ ulWinSize = ulSpace;\r
+ }\r
+ #endif\r
+ if( ulWinSize > 0xfffcUL )\r
+ {\r
+ ulWinSize = 0xfffcUL;\r
+ }\r
+\r
+ pxTCPPacket->xTCPHeader.usWindow = FreeRTOS_htons( ( uint16_t ) ulWinSize );\r
+\r
+ #if( ipconfigHAS_DEBUG_PRINTF != 0 )\r
+ {\r
+ if( ipconfigTCP_MAY_LOG_PORT( pxSocket->usLocalPort ) != pdFALSE )\r
+ {\r
+ if( ( xTCPWindowLoggingLevel != 0 ) && ( pxSocket->u.xTCP.bits.bWinChange != pdFALSE_UNSIGNED ) )\r
+ {\r
+ size_t uxFrontSpace;\r
+\r
+ if(pxSocket->u.xTCP.rxStream != NULL)\r
+ {\r
+ uxFrontSpace = uxStreamBufferFrontSpace( pxSocket->u.xTCP.rxStream ) ;\r
+ }\r
+ else\r
+ {\r
+ uxFrontSpace = 0u;\r
+ }\r
+\r
+ FreeRTOS_debug_printf( ( "%s: %lxip:%u: [%lu < %lu] winSize %ld\n",\r
+ pxSocket->u.xTCP.bits.bLowWater ? "STOP" : "GO ",\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ pxSocket->u.xTCP.bits.bLowWater ? pxSocket->u.xTCP.uxLittleSpace : uxFrontSpace, pxSocket->u.xTCP.uxEnoughSpace,\r
+ (int32_t) ( pxTCPWindow->rx.ulHighestSequenceNumber - pxTCPWindow->rx.ulCurrentSequenceNumber ) ) );\r
+ }\r
+ }\r
+ }\r
+ #endif /* ipconfigHAS_DEBUG_PRINTF != 0 */\r
+\r
+ /* The new window size has been advertised, switch off the flag. */\r
+ pxSocket->u.xTCP.bits.bWinChange = pdFALSE_UNSIGNED;\r
+\r
+ /* Later on, when deciding to delay an ACK, a precise estimate is needed\r
+ of the free RX space. At this moment, 'ulHighestRxAllowed' would be the\r
+ highest sequence number minus 1 that the socket will accept. */\r
+ pxSocket->u.xTCP.ulHighestRxAllowed = pxTCPWindow->rx.ulCurrentSequenceNumber + ulSpace;\r
+\r
+ #if( ipconfigTCP_KEEP_ALIVE == 1 )\r
+ if( pxSocket->u.xTCP.bits.bSendKeepAlive != pdFALSE_UNSIGNED )\r
+ {\r
+ /* Sending a keep-alive packet, send the current sequence number\r
+ minus 1, which will be recognised as a keep-alive packet an\r
+ responded to by acknowledging the last byte. */\r
+ pxSocket->u.xTCP.bits.bSendKeepAlive = pdFALSE_UNSIGNED;\r
+ pxSocket->u.xTCP.bits.bWaitKeepAlive = pdTRUE_UNSIGNED;\r
+\r
+ pxTCPPacket->xTCPHeader.ulSequenceNumber = pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber - 1UL;\r
+ pxTCPPacket->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( pxTCPPacket->xTCPHeader.ulSequenceNumber );\r
+ }\r
+ else\r
+ #endif\r
+ {\r
+ pxTCPPacket->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber );\r
+\r
+ if( ( pxTCPPacket->xTCPHeader.ucTCPFlags & ( uint8_t ) ipTCP_FLAG_FIN ) != 0u )\r
+ {\r
+ /* Suppress FIN in case this packet carries earlier data to be\r
+ retransmitted. */\r
+ uint32_t ulDataLen = ( uint32_t ) ( ulLen - ( ipSIZE_OF_TCP_HEADER + ipSIZE_OF_IPv4_HEADER ) );\r
+ if( ( pxTCPWindow->ulOurSequenceNumber + ulDataLen ) != pxTCPWindow->tx.ulFINSequenceNumber )\r
+ {\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags &= ( ( uint8_t ) ~ipTCP_FLAG_FIN );\r
+ FreeRTOS_debug_printf( ( "Suppress FIN for %lu + %lu < %lu\n",\r
+ pxTCPWindow->ulOurSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ ulDataLen,\r
+ pxTCPWindow->tx.ulFINSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber ) );\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Tell which sequence number is expected next time */\r
+ pxTCPPacket->xTCPHeader.ulAckNr = FreeRTOS_htonl( pxTCPWindow->rx.ulCurrentSequenceNumber );\r
+ }\r
+ else\r
+ {\r
+ /* Sending data without a socket, probably replying with a RST flag\r
+ Just swap the two sequence numbers. */\r
+ vFlip_32( pxTCPPacket->xTCPHeader.ulSequenceNumber, pxTCPPacket->xTCPHeader.ulAckNr );\r
+ }\r
+\r
+ pxIPHeader->ucTimeToLive = ( uint8_t ) ipconfigTCP_TIME_TO_LIVE;\r
+ pxIPHeader->usLength = FreeRTOS_htons( ulLen );\r
+ if( ( pxSocket == NULL ) || ( *ipLOCAL_IP_ADDRESS_POINTER == 0ul ) )\r
+ {\r
+ /* When pxSocket is NULL, this function is called by prvTCPSendReset()\r
+ and the IP-addresses must be swapped.\r
+ Also swap the IP-addresses in case the IP-tack doesn't have an\r
+ IP-address yet, i.e. when ( *ipLOCAL_IP_ADDRESS_POINTER == 0ul ). */\r
+ ulSourceAddress = pxIPHeader->ulDestinationIPAddress;\r
+ }\r
+ else\r
+ {\r
+ ulSourceAddress = *ipLOCAL_IP_ADDRESS_POINTER;\r
+ }\r
+ pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;\r
+ pxIPHeader->ulSourceIPAddress = ulSourceAddress;\r
+ vFlip_16( pxTCPPacket->xTCPHeader.usSourcePort, pxTCPPacket->xTCPHeader.usDestinationPort );\r
+\r
+ /* Just an increasing number. */\r
+ pxIPHeader->usIdentification = FreeRTOS_htons( usPacketIdentifier );\r
+ usPacketIdentifier++;\r
+ pxIPHeader->usFragmentOffset = 0u;\r
+\r
+ #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
+ {\r
+ /* calculate the IP header checksum, in case the driver won't do that. */\r
+ pxIPHeader->usHeaderChecksum = 0x00u;\r
+ pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0u, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );\r
+ pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );\r
+\r
+ /* calculate the TCP checksum for an outgoing packet. */\r
+ usGenerateProtocolChecksum( (uint8_t*)pxTCPPacket, pdTRUE );\r
+\r
+ /* A calculated checksum of 0 must be inverted as 0 means the checksum\r
+ is disabled. */\r
+ if( pxTCPPacket->xTCPHeader.usChecksum == 0x00u )\r
+ {\r
+ pxTCPPacket->xTCPHeader.usChecksum = 0xffffU;\r
+ }\r
+ }\r
+ #endif\r
+\r
+ #if( ipconfigUSE_LINKED_RX_MESSAGES != 0 )\r
+ {\r
+ pxNetworkBuffer->pxNextBuffer = NULL;\r
+ }\r
+ #endif\r
+\r
+ /* Important: tell NIC driver how many bytes must be sent. */\r
+ pxNetworkBuffer->xDataLength = ulLen + ipSIZE_OF_ETH_HEADER;\r
+\r
+ /* Fill in the destination MAC addresses. */\r
+ memcpy( ( void * ) &( pxEthernetHeader->xDestinationAddress ), ( void * ) &( pxEthernetHeader->xSourceAddress ),\r
+ sizeof( pxEthernetHeader->xDestinationAddress ) );\r
+\r
+ /* The source MAC addresses is fixed to 'ipLOCAL_MAC_ADDRESS'. */\r
+ memcpy( ( void * ) &( pxEthernetHeader->xSourceAddress ), ( void * ) ipLOCAL_MAC_ADDRESS, ( size_t ) ipMAC_ADDRESS_LENGTH_BYTES );\r
+\r
+ #if defined( ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
+ {\r
+ if( pxNetworkBuffer->xDataLength < ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES )\r
+ {\r
+ BaseType_t xIndex;\r
+\r
+ for( xIndex = ( BaseType_t ) pxNetworkBuffer->xDataLength; xIndex < ( BaseType_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES; xIndex++ )\r
+ {\r
+ pxNetworkBuffer->pucEthernetBuffer[ xIndex ] = 0u;\r
+ }\r
+ pxNetworkBuffer->xDataLength = ( size_t ) ipconfigETHERNET_MINIMUM_PACKET_BYTES;\r
+ }\r
+ }\r
+ #endif\r
+\r
+ /* Send! */\r
+ xNetworkInterfaceOutput( pxNetworkBuffer, xReleaseAfterSend );\r
+\r
+ if( xReleaseAfterSend == pdFALSE )\r
+ {\r
+ /* Swap-back some fields, as pxBuffer probably points to a socket field\r
+ containing the packet header. */\r
+ vFlip_16( pxTCPPacket->xTCPHeader.usSourcePort, pxTCPPacket->xTCPHeader.usDestinationPort);\r
+ pxTCPPacket->xIPHeader.ulSourceIPAddress = pxTCPPacket->xIPHeader.ulDestinationIPAddress;\r
+ memcpy( pxEthernetHeader->xSourceAddress.ucBytes, pxEthernetHeader->xDestinationAddress.ucBytes, ( size_t ) ipMAC_ADDRESS_LENGTH_BYTES );\r
+ }\r
+ else\r
+ {\r
+ /* Nothing to do: the buffer has been passed to DMA and will be released after use */\r
+ }\r
+ } /* if( pxNetworkBuffer != NULL ) */\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * The SYN event is very important: the sequence numbers, which have a kind of\r
+ * random starting value, are being synchronised. The sliding window manager\r
+ * (in FreeRTOS_TCP_WIN.c) needs to know them, along with the Maximum Segment\r
+ * Size (MSS) in use.\r
+ */\r
+static void prvTCPCreateWindow( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+ if( xTCPWindowLoggingLevel )\r
+ FreeRTOS_debug_printf( ( "Limits (using): TCP Win size %lu Water %lu <= %lu <= %lu\n",\r
+ pxSocket->u.xTCP.uxRxWinSize * ipconfigTCP_MSS,\r
+ pxSocket->u.xTCP.uxLittleSpace ,\r
+ pxSocket->u.xTCP.uxEnoughSpace,\r
+ pxSocket->u.xTCP.uxRxStreamSize ) );\r
+ vTCPWindowCreate(\r
+ &pxSocket->u.xTCP.xTCPWindow,\r
+ ipconfigTCP_MSS * pxSocket->u.xTCP.uxRxWinSize,\r
+ ipconfigTCP_MSS * pxSocket->u.xTCP.uxTxWinSize,\r
+ pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber,\r
+ pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber,\r
+ ( uint32_t ) pxSocket->u.xTCP.usInitMSS );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Connecting sockets have a special state: eCONNECT_SYN. In this phase,\r
+ * the Ethernet address of the target will be found using ARP. In case the\r
+ * target IP address is not within the netmask, the hardware address of the\r
+ * gateway will be used.\r
+ */\r
+static BaseType_t prvTCPPrepareConnect( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+TCPPacket_t *pxTCPPacket;\r
+IPHeader_t *pxIPHeader;\r
+eARPLookupResult_t eReturned;\r
+uint32_t ulRemoteIP;\r
+MACAddress_t xEthAddress;\r
+BaseType_t xReturn = pdTRUE;\r
+\r
+ #if( ipconfigHAS_PRINTF != 0 )\r
+ {\r
+ /* Only necessary for nicer logging. */\r
+ memset( xEthAddress.ucBytes, '\0', sizeof( xEthAddress.ucBytes ) );\r
+ }\r
+ #endif /* ipconfigHAS_PRINTF != 0 */\r
+\r
+ ulRemoteIP = FreeRTOS_htonl( pxSocket->u.xTCP.ulRemoteIP );\r
+\r
+ /* Determine the ARP cache status for the requested IP address. */\r
+ eReturned = eARPGetCacheEntry( &( ulRemoteIP ), &( xEthAddress ) );\r
+\r
+ switch( eReturned )\r
+ {\r
+ case eARPCacheHit: /* An ARP table lookup found a valid entry. */\r
+ break; /* We can now prepare the SYN packet. */\r
+ case eARPCacheMiss: /* An ARP table lookup did not find a valid entry. */\r
+ case eCantSendPacket: /* There is no IP address, or an ARP is still in progress. */\r
+ default:\r
+ /* Count the number of times it couldn't find the ARP address. */\r
+ pxSocket->u.xTCP.ucRepCount++;\r
+ \r
+ FreeRTOS_debug_printf( ( "ARP for %lxip (using %lxip): rc=%d %02X:%02X:%02X %02X:%02X:%02X\n",\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ FreeRTOS_htonl( ulRemoteIP ),\r
+ eReturned,\r
+ xEthAddress.ucBytes[ 0 ],\r
+ xEthAddress.ucBytes[ 1 ],\r
+ xEthAddress.ucBytes[ 2 ],\r
+ xEthAddress.ucBytes[ 3 ],\r
+ xEthAddress.ucBytes[ 4 ],\r
+ xEthAddress.ucBytes[ 5 ] ) );\r
+ \r
+ /* And issue a (new) ARP request */\r
+ FreeRTOS_OutputARPRequest( ulRemoteIP );\r
+ \r
+ xReturn = pdFALSE;\r
+ break;\r
+ }\r
+\r
+ if( xReturn != pdFALSE )\r
+ {\r
+ /* The MAC-address of the peer (or gateway) has been found,\r
+ now prepare the initial TCP packet and some fields in the socket. */\r
+ pxTCPPacket = ( TCPPacket_t * )pxSocket->u.xTCP.xPacket.u.ucLastPacket;\r
+ pxIPHeader = &pxTCPPacket->xIPHeader;\r
+\r
+ /* Reset the retry counter to zero... */\r
+ pxSocket->u.xTCP.ucRepCount = 0u;\r
+\r
+ /* ...and remember that the connect/SYN data are prepared. */\r
+ pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;\r
+\r
+ /* Now that the Ethernet address is known, the initial packet can be\r
+ prepared. */\r
+ memset( pxSocket->u.xTCP.xPacket.u.ucLastPacket, '\0', sizeof( pxSocket->u.xTCP.xPacket.u.ucLastPacket ) );\r
+\r
+ /* Write the Ethernet address in Source, because it will be swapped by\r
+ prvTCPReturnPacket(). */\r
+ memcpy( &pxTCPPacket->xEthernetHeader.xSourceAddress, &xEthAddress, sizeof( xEthAddress ) );\r
+\r
+ /* 'ipIPv4_FRAME_TYPE' is already in network-byte-order. */\r
+ pxTCPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;\r
+\r
+ pxIPHeader->ucVersionHeaderLength = 0x45u;\r
+ pxIPHeader->usLength = FreeRTOS_htons( sizeof( TCPPacket_t ) - sizeof( pxTCPPacket->xEthernetHeader ) );\r
+ pxIPHeader->ucTimeToLive = ( uint8_t ) ipconfigTCP_TIME_TO_LIVE;\r
+\r
+ pxIPHeader->ucProtocol = ( uint8_t ) ipPROTOCOL_TCP;\r
+\r
+ /* Addresses and ports will be stored swapped because prvTCPReturnPacket\r
+ will swap them back while replying. */\r
+ pxIPHeader->ulDestinationIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;\r
+ pxIPHeader->ulSourceIPAddress = FreeRTOS_htonl( pxSocket->u.xTCP.ulRemoteIP );\r
+\r
+ pxTCPPacket->xTCPHeader.usSourcePort = FreeRTOS_htons( pxSocket->u.xTCP.usRemotePort );\r
+ pxTCPPacket->xTCPHeader.usDestinationPort = FreeRTOS_htons( pxSocket->usLocalPort );\r
+\r
+ /* We are actively connecting, so the peer's Initial Sequence Number (ISN)\r
+ isn't known yet. */\r
+ pxSocket->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = 0ul;\r
+\r
+ /* Start with ISN (Initial Sequence Number). */\r
+ pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber = ulNextInitialSequenceNumber;\r
+\r
+ /* And increment it with 268 for the next new connection, which is\r
+ recommended value. */\r
+ ulNextInitialSequenceNumber += 0x102UL;\r
+\r
+ /* The TCP header size is 20 bytes, divided by 4 equals 5, which is put in\r
+ the high nibble of the TCP offset field. */\r
+ pxTCPPacket->xTCPHeader.ucTCPOffset = 0x50u;\r
+\r
+ /* Only set the SYN flag. */\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags = ipTCP_FLAG_SYN;\r
+\r
+ /* Set the values of usInitMSS / usCurMSS for this socket. */\r
+ prvSocketSetMSS( pxSocket );\r
+\r
+ /* For now this is also the advertised window size. */\r
+ pxSocket->u.xTCP.ulRxCurWinSize = pxSocket->u.xTCP.usInitMSS;\r
+\r
+ /* The initial sequence numbers at our side are known. Later\r
+ vTCPWindowInit() will be called to fill in the peer's sequence numbers, but\r
+ first wait for a SYN+ACK reply. */\r
+ prvTCPCreateWindow( pxSocket );\r
+ }\r
+\r
+ return xReturn;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/* For logging and debugging: make a string showing the TCP flags\r
+*/\r
+#if( ipconfigHAS_DEBUG_PRINTF != 0 )\r
+\r
+ static const char *prvTCPFlagMeaning( UBaseType_t xFlags)\r
+ {\r
+ static char retString[10];\r
+ snprintf(retString, sizeof( retString ), "%c%c%c%c%c%c%c%c%c",\r
+ ( xFlags & ipTCP_FLAG_FIN ) ? 'F' : '.', /* 0x0001: No more data from sender */\r
+ ( xFlags & ipTCP_FLAG_SYN ) ? 'S' : '.', /* 0x0002: Synchronize sequence numbers */\r
+ ( xFlags & ipTCP_FLAG_RST ) ? 'R' : '.', /* 0x0004: Reset the connection */\r
+ ( xFlags & ipTCP_FLAG_PSH ) ? 'P' : '.', /* 0x0008: Push function: please push buffered data to the recv application */\r
+ ( xFlags & ipTCP_FLAG_ACK ) ? 'A' : '.', /* 0x0010: Acknowledgment field is significant */\r
+ ( xFlags & ipTCP_FLAG_URG ) ? 'U' : '.', /* 0x0020: Urgent pointer field is significant */\r
+ ( xFlags & ipTCP_FLAG_ECN ) ? 'E' : '.', /* 0x0040: ECN-Echo */\r
+ ( xFlags & ipTCP_FLAG_CWR ) ? 'C' : '.', /* 0x0080: Congestion Window Reduced */\r
+ ( xFlags & ipTCP_FLAG_NS ) ? 'N' : '.'); /* 0x0100: ECN-nonce concealment protection */\r
+ return retString;\r
+ }\r
+ /*-----------------------------------------------------------*/\r
+\r
+#endif /* ipconfigHAS_DEBUG_PRINTF */\r
+\r
+/*\r
+ * Parse the TCP option(s) received, if present. It has already been verified\r
+ * that: ((pxTCPHeader->ucTCPOffset & 0xf0) > 0x50), meaning that the TP header\r
+ * is longer than the usual 20 (5 x 4) bytes.\r
+ */\r
+static void prvCheckOptions( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+TCPPacket_t * pxTCPPacket;\r
+TCPHeader_t * pxTCPHeader;\r
+const unsigned char *pucPtr;\r
+const unsigned char *pucLast;\r
+TCPWindow_t *pxTCPWindow;\r
+UBaseType_t uxNewMSS;\r
+\r
+ pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+ pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+\r
+ /* A character pointer to iterate through the option data */\r
+ pucPtr = pxTCPHeader->ucOptdata;\r
+ pucLast = pucPtr + (((pxTCPHeader->ucTCPOffset >> 4) - 5) << 2);\r
+ pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+\r
+ /* The comparison with pucLast is only necessary in case the option data are\r
+ corrupted, we don't like to run into invalid memory and crash. */\r
+ while( pucPtr < pucLast )\r
+ {\r
+ if( pucPtr[ 0 ] == TCP_OPT_END )\r
+ {\r
+ /* End of options. */\r
+ return;\r
+ }\r
+ if( pucPtr[ 0 ] == TCP_OPT_NOOP)\r
+ {\r
+ pucPtr++;\r
+\r
+ /* NOP option, inserted to make the length a multiple of 4. */\r
+ }\r
+#if( ipconfigUSE_TCP_WIN != 0 )\r
+ else if( ( pucPtr[ 0 ] == TCP_OPT_WSOPT ) && ( pucPtr[ 1 ] == TCP_OPT_WSOPT_LEN ) )\r
+ {\r
+ pxSocket->u.xTCP.ucPeerWinScaleFactor = pucPtr[ 2 ];\r
+ pxSocket->u.xTCP.bits.bWinScaling = pdTRUE_UNSIGNED;\r
+ pucPtr += TCP_OPT_WSOPT_LEN;\r
+ }\r
+#endif /* ipconfigUSE_TCP_WIN */\r
+ else if( ( pucPtr[ 0 ] == TCP_OPT_MSS ) && ( pucPtr[ 1 ] == TCP_OPT_MSS_LEN ) )\r
+ {\r
+ /* An MSS option with the correct option length. FreeRTOS_htons()\r
+ is not needed here because usChar2u16() already returns a host\r
+ endian number. */\r
+ uxNewMSS = usChar2u16( pucPtr + 2 );\r
+\r
+ if( pxSocket->u.xTCP.usInitMSS != uxNewMSS )\r
+ {\r
+ FreeRTOS_debug_printf( ( "MSS change %u -> %lu\n", pxSocket->u.xTCP.usInitMSS, uxNewMSS ) );\r
+ }\r
+\r
+ if( pxSocket->u.xTCP.usInitMSS > uxNewMSS )\r
+ {\r
+ /* our MSS was bigger than the MSS of the other party: adapt it. */\r
+ pxSocket->u.xTCP.bits.bMssChange = pdTRUE_UNSIGNED;\r
+ if( ( pxTCPWindow != NULL ) && ( pxSocket->u.xTCP.usCurMSS > uxNewMSS ) )\r
+ {\r
+ /* The peer advertises a smaller MSS than this socket was\r
+ using. Use that as well. */\r
+ FreeRTOS_debug_printf( ( "Change mss %d => %lu\n", pxSocket->u.xTCP.usCurMSS, uxNewMSS ) );\r
+ pxSocket->u.xTCP.usCurMSS = ( uint16_t ) uxNewMSS;\r
+ }\r
+ pxTCPWindow->xSize.ulRxWindowLength = ( ( uint32_t ) uxNewMSS ) * ( pxTCPWindow->xSize.ulRxWindowLength / ( ( uint32_t ) uxNewMSS ) );\r
+ pxTCPWindow->usMSSInit = ( uint16_t ) uxNewMSS;\r
+ pxTCPWindow->usMSS = ( uint16_t ) uxNewMSS;\r
+ pxSocket->u.xTCP.usInitMSS = ( uint16_t ) uxNewMSS;\r
+ pxSocket->u.xTCP.usCurMSS = ( uint16_t ) uxNewMSS;\r
+ }\r
+\r
+ #if( ipconfigUSE_TCP_WIN != 1 )\r
+ /* Without scaled windows, MSS is the only interesting option. */\r
+ break;\r
+ #else\r
+ /* Or else we continue to check another option: selective ACK. */\r
+ pucPtr += TCP_OPT_MSS_LEN;\r
+ #endif /* ipconfigUSE_TCP_WIN != 1 */\r
+ }\r
+ else\r
+ {\r
+ /* All other options have a length field, so that we easily\r
+ can skip past them. */\r
+ int len = ( int )pucPtr[ 1 ];\r
+ if( len == 0 )\r
+ {\r
+ /* If the length field is zero, the options are malformed\r
+ and we don't process them further. */\r
+ break;\r
+ }\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ /* Selective ACK: the peer has received a packet but it is missing earlier\r
+ packets. At least this packet does not need retransmission anymore\r
+ ulTCPWindowTxSack( ) takes care of this administration. */\r
+ if( pucPtr[0] == TCP_OPT_SACK_A )\r
+ {\r
+ len -= 2;\r
+ pucPtr += 2;\r
+\r
+ while( len >= 8 )\r
+ {\r
+ uint32_t ulFirst = ulChar2u32( pucPtr );\r
+ uint32_t ulLast = ulChar2u32( pucPtr + 4 );\r
+ uint32_t ulCount = ulTCPWindowTxSack( &pxSocket->u.xTCP.xTCPWindow, ulFirst, ulLast );\r
+ /* ulTCPWindowTxSack( ) returns the number of bytes which have been acked\r
+ starting from the head position.\r
+ Advance the tail pointer in txStream. */\r
+ if( ( pxSocket->u.xTCP.txStream != NULL ) && ( ulCount > 0 ) )\r
+ {\r
+ /* Just advancing the tail index, 'ulCount' bytes have been confirmed. */\r
+ uxStreamBufferGet( pxSocket->u.xTCP.txStream, 0, NULL, ( size_t ) ulCount, pdFALSE );\r
+ pxSocket->xEventBits |= eSOCKET_SEND;\r
+\r
+ #if ipconfigSUPPORT_SELECT_FUNCTION == 1\r
+ {\r
+ if( pxSocket->xSelectBits & eSELECT_WRITE )\r
+ {\r
+ /* The field 'xEventBits' is used to store regular socket events (at most 8),\r
+ as well as 'select events', which will be left-shifted */\r
+ pxSocket->xEventBits |= ( eSELECT_WRITE << SOCKET_EVENT_BIT_COUNT );\r
+ }\r
+ }\r
+ #endif\r
+\r
+ /* In case the socket owner has installed an OnSent handler,\r
+ call it now. */\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ if( ipconfigIS_VALID_PROG_ADDRESS( pxSocket->u.xTCP.pxHandleSent ) )\r
+ {\r
+ pxSocket->u.xTCP.pxHandleSent( (Socket_t *)pxSocket, ulCount );\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_CALLBACKS == 1 */\r
+ }\r
+ pucPtr += 8;\r
+ len -= 8;\r
+ }\r
+ /* len should be 0 by now. */\r
+ }\r
+ #if ipconfigUSE_TCP_TIMESTAMPS == 1\r
+ else if( pucPtr[0] == TCP_OPT_TIMESTAMP )\r
+ {\r
+ len -= 2; /* Skip option and length byte. */\r
+ pucPtr += 2;\r
+ pxSocket->u.xTCP.xTCPWindow.u.bits.bTimeStamps = pdTRUE_UNSIGNED;\r
+ pxSocket->u.xTCP.xTCPWindow.rx.ulTimeStamp = ulChar2u32( pucPtr );\r
+ pxSocket->u.xTCP.xTCPWindow.tx.ulTimeStamp = ulChar2u32( pucPtr + 4 );\r
+ }\r
+ #endif /* ipconfigUSE_TCP_TIMESTAMPS == 1 */\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN == 1 */\r
+\r
+ pucPtr += len;\r
+ }\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( ipconfigUSE_TCP_WIN != 0 )\r
+\r
+ static uint8_t prvWinScaleFactor( FreeRTOS_Socket_t *pxSocket )\r
+ {\r
+ size_t uxWinSize;\r
+ uint8_t ucFactor;\r
+\r
+ /* 'xTCP.uxRxWinSize' is the size of the reception window in units of MSS. */\r
+ uxWinSize = pxSocket->u.xTCP.uxRxWinSize * ( size_t ) pxSocket->u.xTCP.usInitMSS;\r
+ ucFactor = 0u;\r
+ while( uxWinSize > 0xfffful )\r
+ {\r
+ /* Divide by two and increase the binary factor by 1. */\r
+ uxWinSize >>= 1;\r
+ ucFactor++;\r
+ }\r
+\r
+ FreeRTOS_debug_printf( ( "prvWinScaleFactor: uxRxWinSize %lu MSS %lu Factor %u\n",\r
+ pxSocket->u.xTCP.uxRxWinSize,\r
+ pxSocket->u.xTCP.usInitMSS,\r
+ ucFactor ) );\r
+\r
+ return ucFactor;\r
+ }\r
+\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * When opening a TCP connection, while SYN's are being sent, the parties may\r
+ * communicate what MSS (Maximum Segment Size) they intend to use. MSS is the\r
+ * nett size of the payload, always smaller than MTU.\r
+*/\r
+static UBaseType_t prvSetSynAckOptions( FreeRTOS_Socket_t *pxSocket, TCPPacket_t * pxTCPPacket )\r
+{\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+uint16_t usMSS = pxSocket->u.xTCP.usInitMSS;\r
+UBaseType_t uxOptionsLength;\r
+\r
+ /* We send out the TCP Maximum Segment Size option with our SYN[+ACK]. */\r
+\r
+ pxTCPHeader->ucOptdata[ 0 ] = ( uint8_t ) TCP_OPT_MSS;\r
+ pxTCPHeader->ucOptdata[ 1 ] = ( uint8_t ) TCP_OPT_MSS_LEN;\r
+ pxTCPHeader->ucOptdata[ 2 ] = ( uint8_t ) ( usMSS >> 8 );\r
+ pxTCPHeader->ucOptdata[ 3 ] = ( uint8_t ) ( usMSS & 0xffu );\r
+\r
+ #if( ipconfigUSE_TCP_WIN != 0 )\r
+ {\r
+ pxSocket->u.xTCP.ucMyWinScaleFactor = prvWinScaleFactor( pxSocket );\r
+\r
+ pxTCPHeader->ucOptdata[ 4 ] = TCP_OPT_NOOP;\r
+ pxTCPHeader->ucOptdata[ 5 ] = ( uint8_t ) ( TCP_OPT_WSOPT );\r
+ pxTCPHeader->ucOptdata[ 6 ] = ( uint8_t ) ( TCP_OPT_WSOPT_LEN );\r
+ pxTCPHeader->ucOptdata[ 7 ] = ( uint8_t ) pxSocket->u.xTCP.ucMyWinScaleFactor;\r
+ uxOptionsLength = 8u;\r
+ }\r
+ #else\r
+ {\r
+ uxOptionsLength = 4u;\r
+ }\r
+ #endif\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 0 )\r
+ {\r
+ return uxOptionsLength;\r
+ }\r
+ #else\r
+ {\r
+ #if( ipconfigUSE_TCP_TIMESTAMPS == 1 )\r
+ if( pxSocket->u.xTCP.xTCPWindow.u.bits.bTimeStamps )\r
+ {\r
+ uxOptionsLength += prvTCPSetTimeStamp( uxOptionsLength, pxSocket, &pxTCPPacket->xTCPHeader );\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 0 ] = TCP_OPT_SACK_P; /* 4: Sack-Permitted Option. */\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 1 ] = 2u;\r
+ uxOptionsLength += 2u;\r
+ }\r
+ else\r
+ #endif\r
+ {\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 0 ] = TCP_OPT_NOOP;\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 1 ] = TCP_OPT_NOOP;\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 2 ] = TCP_OPT_SACK_P; /* 4: Sack-Permitted Option. */\r
+ pxTCPHeader->ucOptdata[ uxOptionsLength + 3 ] = 2; /* 2: length of this option. */\r
+ uxOptionsLength += 4u;\r
+ }\r
+ return uxOptionsLength; /* bytes, not words. */\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN == 0 */\r
+}\r
+\r
+/*\r
+ * For anti-hanging protection and TCP keep-alive messages. Called in two\r
+ * places: after receiving a packet and after a state change. The socket's\r
+ * alive timer may be reset.\r
+ */\r
+static void prvTCPTouchSocket( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+ #if( ipconfigTCP_HANG_PROTECTION == 1 )\r
+ {\r
+ pxSocket->u.xTCP.xLastActTime = xTaskGetTickCount( );\r
+ }\r
+ #endif\r
+\r
+ #if( ipconfigTCP_KEEP_ALIVE == 1 )\r
+ {\r
+ pxSocket->u.xTCP.bits.bWaitKeepAlive = pdFALSE_UNSIGNED;\r
+ pxSocket->u.xTCP.bits.bSendKeepAlive = pdFALSE_UNSIGNED;\r
+ pxSocket->u.xTCP.ucKeepRepCount = 0u;\r
+ pxSocket->u.xTCP.xLastAliveTime = xTaskGetTickCount();\r
+ }\r
+ #endif\r
+\r
+ ( void ) pxSocket;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Changing to a new state. Centralised here to do specific actions such as\r
+ * resetting the alive timer, calling the user's OnConnect handler to notify\r
+ * that a socket has got (dis)connected, and setting bit to unblock a call to\r
+ * FreeRTOS_select()\r
+ */\r
+void vTCPStateChange( FreeRTOS_Socket_t *pxSocket, enum eTCP_STATE eTCPState )\r
+{\r
+FreeRTOS_Socket_t *xParent = NULL;\r
+BaseType_t bBefore = ( BaseType_t ) NOW_CONNECTED( pxSocket->u.xTCP.ucTCPState ); /* Was it connected ? */\r
+BaseType_t bAfter = ( BaseType_t ) NOW_CONNECTED( eTCPState ); /* Is it connected now ? */\r
+#if( ipconfigHAS_DEBUG_PRINTF != 0 )\r
+ BaseType_t xPreviousState = ( BaseType_t ) pxSocket->u.xTCP.ucTCPState;\r
+#endif\r
+#if( ipconfigUSE_CALLBACKS == 1 )\r
+ FreeRTOS_Socket_t *xConnected = NULL;\r
+#endif\r
+\r
+ /* Has the connected status changed? */\r
+ if( bBefore != bAfter )\r
+ {\r
+ /* Is the socket connected now ? */\r
+ if( bAfter != pdFALSE )\r
+ {\r
+ /* if bPassQueued is true, this socket is an orphan until it gets connected. */\r
+ if( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED )\r
+ {\r
+ /* Now that it is connected, find it's parent. */\r
+ if( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED )\r
+ {\r
+ xParent = pxSocket;\r
+ }\r
+ else\r
+ {\r
+ xParent = pxSocket->u.xTCP.pxPeerSocket;\r
+ configASSERT( xParent != NULL );\r
+ }\r
+ if( xParent != NULL )\r
+ {\r
+ if( xParent->u.xTCP.pxPeerSocket == NULL )\r
+ {\r
+ xParent->u.xTCP.pxPeerSocket = pxSocket;\r
+ }\r
+\r
+ xParent->xEventBits |= eSOCKET_ACCEPT;\r
+\r
+ #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
+ {\r
+ /* Library support FreeRTOS_select(). Receiving a new\r
+ connection is being translated as a READ event. */\r
+ if( ( xParent->xSelectBits & eSELECT_READ ) != 0 )\r
+ {\r
+ xParent->xEventBits |= ( eSELECT_READ << SOCKET_EVENT_BIT_COUNT );\r
+ }\r
+ }\r
+ #endif\r
+\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ if( ( ipconfigIS_VALID_PROG_ADDRESS( xParent->u.xTCP.pxHandleConnected ) != pdFALSE ) &&\r
+ ( xParent->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED ) )\r
+ {\r
+ /* The listening socket does not become connected itself, in stead\r
+ a child socket is created.\r
+ Postpone a call the OnConnect event until the end of this function. */\r
+ xConnected = xParent;\r
+ }\r
+ }\r
+ #endif\r
+ }\r
+\r
+ /* Don't need to access the parent socket anymore, so the\r
+ reference 'pxPeerSocket' may be cleared. */\r
+ pxSocket->u.xTCP.pxPeerSocket = NULL;\r
+ pxSocket->u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;\r
+\r
+ /* When true, this socket may be returned in a call to accept(). */\r
+ pxSocket->u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;\r
+ }\r
+ else\r
+ {\r
+ pxSocket->xEventBits |= eSOCKET_CONNECT;\r
+\r
+ #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
+ {\r
+ if( pxSocket->xSelectBits & eSELECT_WRITE )\r
+ {\r
+ pxSocket->xEventBits |= ( eSELECT_WRITE << SOCKET_EVENT_BIT_COUNT );\r
+ }\r
+ }\r
+ #endif\r
+ }\r
+ }\r
+ else /* bAfter == pdFALSE, connection is closed. */\r
+ {\r
+ /* Notify/wake-up the socket-owner by setting a semaphore. */\r
+ pxSocket->xEventBits |= eSOCKET_CLOSED;\r
+\r
+ #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
+ {\r
+ if( ( pxSocket->xSelectBits & eSELECT_EXCEPT ) != 0 )\r
+ {\r
+ pxSocket->xEventBits |= ( eSELECT_EXCEPT << SOCKET_EVENT_BIT_COUNT );\r
+ }\r
+ }\r
+ #endif\r
+ }\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ if( ( ipconfigIS_VALID_PROG_ADDRESS( pxSocket->u.xTCP.pxHandleConnected ) != pdFALSE ) && ( xConnected == NULL ) )\r
+ {\r
+ /* The 'connected' state has changed, call the user handler. */\r
+ xConnected = pxSocket;\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_CALLBACKS */\r
+\r
+ if( prvTCPSocketIsActive( ( UBaseType_t ) pxSocket->u.xTCP.ucTCPState ) == pdFALSE )\r
+ {\r
+ /* Now the socket isn't in an active state anymore so it\r
+ won't need further attention of the IP-task.\r
+ Setting time-out to zero means that the socket won't get checked during\r
+ timer events. */\r
+ pxSocket->u.xTCP.usTimeout = 0u;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if( eTCPState == eCLOSED )\r
+ {\r
+ /* Socket goes to status eCLOSED because of a RST.\r
+ When nobody owns the socket yet, delete it. */\r
+ if( ( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED ) ||\r
+ ( pxSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "vTCPStateChange: Closing socket\n" ) );\r
+ if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )\r
+ {\r
+ FreeRTOS_closesocket( pxSocket );\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Fill in the new state. */\r
+ pxSocket->u.xTCP.ucTCPState = ( uint8_t ) eTCPState;\r
+\r
+ /* Touch the alive timers because moving to another state. */\r
+ prvTCPTouchSocket( pxSocket );\r
+\r
+ #if( ipconfigHAS_DEBUG_PRINTF == 1 )\r
+ {\r
+ if( ( xTCPWindowLoggingLevel >= 0 ) && ( ipconfigTCP_MAY_LOG_PORT( pxSocket->usLocalPort ) != pdFALSE ) )\r
+ FreeRTOS_debug_printf( ( "Socket %d -> %lxip:%u State %s->%s\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ FreeRTOS_GetTCPStateName( ( UBaseType_t ) xPreviousState ),\r
+ FreeRTOS_GetTCPStateName( ( UBaseType_t ) eTCPState ) ) );\r
+ }\r
+ #endif /* ipconfigHAS_DEBUG_PRINTF */\r
+\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ if( xConnected != NULL )\r
+ {\r
+ /* The 'connected' state has changed, call the OnConnect handler of the parent. */\r
+ xConnected->u.xTCP.pxHandleConnected( ( Socket_t * ) xConnected, bAfter );\r
+ }\r
+ }\r
+ #endif\r
+ if( xParent != NULL )\r
+ {\r
+ vSocketWakeUpUser( xParent );\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static NetworkBufferDescriptor_t *prvTCPBufferResize( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer,\r
+ int32_t lDataLen, UBaseType_t uxOptionsLength )\r
+{\r
+NetworkBufferDescriptor_t *pxReturn;\r
+int32_t lNeeded;\r
+BaseType_t xResize;\r
+\r
+ if( xBufferAllocFixedSize != pdFALSE )\r
+ {\r
+ /* Network buffers are created with a fixed size and can hold the largest\r
+ MTU. */\r
+ lNeeded = ( int32_t ) ipTOTAL_ETHERNET_FRAME_SIZE;\r
+ /* and therefore, the buffer won't be too small.\r
+ Only ask for a new network buffer in case none was supplied. */\r
+ xResize = ( pxNetworkBuffer == NULL );\r
+ }\r
+ else\r
+ {\r
+ /* Network buffers are created with a variable size. See if it must\r
+ grow. */\r
+ lNeeded = FreeRTOS_max_int32( ( int32_t ) sizeof( pxSocket->u.xTCP.xPacket.u.ucLastPacket ),\r
+ ( int32_t ) ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength ) + lDataLen );\r
+ /* In case we were called from a TCP timer event, a buffer must be\r
+ created. Otherwise, test 'xDataLength' of the provided buffer. */\r
+ if( ( pxNetworkBuffer == NULL ) || ( pxNetworkBuffer->xDataLength < (size_t)lNeeded ) )\r
+ {\r
+ xResize = pdTRUE;\r
+ }\r
+ else\r
+ {\r
+ xResize = pdFALSE;\r
+ }\r
+ }\r
+\r
+ if( xResize != pdFALSE )\r
+ {\r
+ /* The caller didn't provide a network buffer or the provided buffer is\r
+ too small. As we must send-out a data packet, a buffer will be created\r
+ here. */\r
+ pxReturn = pxGetNetworkBufferWithDescriptor( ( uint32_t ) lNeeded, 0u );\r
+\r
+ if( pxReturn != NULL )\r
+ {\r
+ /* Copy the existing data to the new created buffer. */\r
+ if( pxNetworkBuffer )\r
+ {\r
+ /* Either from the previous buffer... */\r
+ memcpy( pxReturn->pucEthernetBuffer, pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength );\r
+\r
+ /* ...and release it. */\r
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );\r
+ }\r
+ else\r
+ {\r
+ /* Or from the socket field 'xTCP.xPacket'. */\r
+ memcpy( pxReturn->pucEthernetBuffer, pxSocket->u.xTCP.xPacket.u.ucLastPacket, sizeof( pxSocket->u.xTCP.xPacket.u.ucLastPacket ) );\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* xResize is false, the network buffer provided was big enough. */\r
+ pxReturn = pxNetworkBuffer;\r
+\r
+ /* Thanks to Andrey Ivanov from swissEmbedded for reporting that the\r
+ xDataLength member must get the correct length too! */\r
+ pxNetworkBuffer->xDataLength = ( size_t ) ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength ) + ( size_t ) lDataLen;\r
+ }\r
+\r
+ return pxReturn;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Prepare an outgoing message, in case anything has to be sent.\r
+ */\r
+static int32_t prvTCPPrepareSend( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer, UBaseType_t uxOptionsLength )\r
+{\r
+int32_t lDataLen;\r
+uint8_t *pucEthernetBuffer, *pucSendData;\r
+TCPPacket_t *pxTCPPacket;\r
+size_t uxOffset;\r
+uint32_t ulDataGot, ulDistance;\r
+TCPWindow_t *pxTCPWindow;\r
+NetworkBufferDescriptor_t *pxNewBuffer;\r
+int32_t lStreamPos;\r
+\r
+ if( ( *ppxNetworkBuffer ) != NULL )\r
+ {\r
+ /* A network buffer descriptor was already supplied */\r
+ pucEthernetBuffer = ( *ppxNetworkBuffer )->pucEthernetBuffer;\r
+ }\r
+ else\r
+ {\r
+ /* For now let it point to the last packet header */\r
+ pucEthernetBuffer = pxSocket->u.xTCP.xPacket.u.ucLastPacket;\r
+ }\r
+\r
+ pxTCPPacket = ( TCPPacket_t * ) pucEthernetBuffer;\r
+ pxTCPWindow = &( pxSocket->u.xTCP.xTCPWindow );\r
+ lDataLen = 0;\r
+ lStreamPos = 0;\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags |= ipTCP_FLAG_ACK;\r
+\r
+ if( pxSocket->u.xTCP.txStream != NULL )\r
+ {\r
+ /* ulTCPWindowTxGet will return the amount of data which may be sent\r
+ along with the position in the txStream.\r
+ Why check for MSS > 1 ?\r
+ Because some TCP-stacks (like uIP) use it for flow-control. */\r
+ if( pxSocket->u.xTCP.usCurMSS > 1u )\r
+ {\r
+ lDataLen = ( int32_t ) ulTCPWindowTxGet( pxTCPWindow, pxSocket->u.xTCP.ulWindowSize, &lStreamPos );\r
+ }\r
+\r
+ if( lDataLen > 0 )\r
+ {\r
+ /* Check if the current network buffer is big enough, if not,\r
+ resize it. */\r
+ pxNewBuffer = prvTCPBufferResize( pxSocket, *ppxNetworkBuffer, lDataLen, uxOptionsLength );\r
+\r
+ if( pxNewBuffer != NULL )\r
+ {\r
+ *ppxNetworkBuffer = pxNewBuffer;\r
+ pucEthernetBuffer = pxNewBuffer->pucEthernetBuffer;\r
+ pxTCPPacket = ( TCPPacket_t * ) ( pucEthernetBuffer );\r
+\r
+ pucSendData = pucEthernetBuffer + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength;\r
+\r
+ /* Translate the position in txStream to an offset from the tail\r
+ marker. */\r
+ uxOffset = uxStreamBufferDistance( pxSocket->u.xTCP.txStream, pxSocket->u.xTCP.txStream->uxTail, ( size_t ) lStreamPos );\r
+\r
+ /* Here data is copied from the txStream in 'peek' mode. Only\r
+ when the packets are acked, the tail marker will be updated. */\r
+ ulDataGot = ( uint32_t ) uxStreamBufferGet( pxSocket->u.xTCP.txStream, uxOffset, pucSendData, ( size_t ) lDataLen, pdTRUE );\r
+\r
+ #if( ipconfigHAS_DEBUG_PRINTF != 0 )\r
+ {\r
+ if( ulDataGot != ( uint32_t ) lDataLen )\r
+ {\r
+ FreeRTOS_debug_printf( ( "uxStreamBufferGet: pos %lu offs %lu only %lu != %lu\n",\r
+ lStreamPos, uxOffset, ulDataGot, lDataLen ) );\r
+ }\r
+ }\r
+ #endif\r
+\r
+ /* If the owner of the socket requests a closure, add the FIN\r
+ flag to the last packet. */\r
+ if( ( pxSocket->u.xTCP.bits.bCloseRequested != pdFALSE_UNSIGNED ) && ( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED ) )\r
+ {\r
+ ulDistance = ( uint32_t ) uxStreamBufferDistance( pxSocket->u.xTCP.txStream, ( size_t ) lStreamPos, pxSocket->u.xTCP.txStream->uxHead );\r
+\r
+ if( ulDistance == ulDataGot )\r
+ {\r
+ #if (ipconfigHAS_DEBUG_PRINTF == 1)\r
+ {\r
+ /* the order of volatile accesses is undefined\r
+ so such workaround */\r
+ size_t uxHead = pxSocket->u.xTCP.txStream->uxHead;\r
+ size_t uxMid = pxSocket->u.xTCP.txStream->uxMid;\r
+ size_t uxTail = pxSocket->u.xTCP.txStream->uxTail;\r
+\r
+ FreeRTOS_debug_printf( ( "CheckClose %lu <= %lu (%lu <= %lu <= %lu)\n", ulDataGot, ulDistance,\r
+ uxTail, uxMid, uxHead ) );\r
+ }\r
+ #endif\r
+ /* Although the socket sends a FIN, it will stay in\r
+ ESTABLISHED until all current data has been received or\r
+ delivered. */\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags |= ipTCP_FLAG_FIN;\r
+ pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->ulOurSequenceNumber + ( uint32_t ) lDataLen;\r
+ pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ lDataLen = -1;\r
+ }\r
+ }\r
+ }\r
+\r
+ if( ( lDataLen >= 0 ) && ( pxSocket->u.xTCP.ucTCPState == eESTABLISHED ) )\r
+ {\r
+ /* See if the socket owner wants to shutdown this connection. */\r
+ if( ( pxSocket->u.xTCP.bits.bUserShutdown != pdFALSE_UNSIGNED ) &&\r
+ ( xTCPWindowTxDone( pxTCPWindow ) != pdFALSE ) )\r
+ {\r
+ pxSocket->u.xTCP.bits.bUserShutdown = pdFALSE_UNSIGNED;\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags |= ipTCP_FLAG_FIN;\r
+ pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;\r
+ pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;\r
+ pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;\r
+ vTCPStateChange( pxSocket, eFIN_WAIT_1 );\r
+ }\r
+\r
+ #if( ipconfigTCP_KEEP_ALIVE != 0 )\r
+ {\r
+ if( pxSocket->u.xTCP.ucKeepRepCount > 3u )\r
+ {\r
+ FreeRTOS_debug_printf( ( "keep-alive: giving up %lxip:%u\n",\r
+ pxSocket->u.xTCP.ulRemoteIP, /* IP address of remote machine. */\r
+ pxSocket->u.xTCP.usRemotePort ) ); /* Port on remote machine. */\r
+ vTCPStateChange( pxSocket, eCLOSE_WAIT );\r
+ lDataLen = -1;\r
+ }\r
+ if( ( lDataLen == 0 ) && ( pxSocket->u.xTCP.bits.bWinChange == pdFALSE_UNSIGNED ) )\r
+ {\r
+ /* If there is no data to be sent, and no window-update message,\r
+ we might want to send a keep-alive message. */\r
+ TickType_t xAge = xTaskGetTickCount( ) - pxSocket->u.xTCP.xLastAliveTime;\r
+ TickType_t xMax;\r
+ xMax = ( ( TickType_t ) ipconfigTCP_KEEP_ALIVE_INTERVAL * configTICK_RATE_HZ );\r
+ if( pxSocket->u.xTCP.ucKeepRepCount )\r
+ {\r
+ xMax = ( 3u * configTICK_RATE_HZ );\r
+ }\r
+ if( xAge > xMax )\r
+ {\r
+ pxSocket->u.xTCP.xLastAliveTime = xTaskGetTickCount( );\r
+ if( xTCPWindowLoggingLevel )\r
+ FreeRTOS_debug_printf( ( "keep-alive: %lxip:%u count %u\n",\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ pxSocket->u.xTCP.ucKeepRepCount ) );\r
+ pxSocket->u.xTCP.bits.bSendKeepAlive = pdTRUE_UNSIGNED;\r
+ pxSocket->u.xTCP.usTimeout = ( ( uint16_t ) pdMS_TO_TICKS( 2500 ) );\r
+ pxSocket->u.xTCP.ucKeepRepCount++;\r
+ }\r
+ }\r
+ }\r
+ #endif /* ipconfigTCP_KEEP_ALIVE */\r
+ }\r
+\r
+ /* Anything to send, a change of the advertised window size, or maybe send a\r
+ keep-alive message? */\r
+ if( ( lDataLen > 0 ) ||\r
+ ( pxSocket->u.xTCP.bits.bWinChange != pdFALSE_UNSIGNED ) ||\r
+ ( pxSocket->u.xTCP.bits.bSendKeepAlive != pdFALSE_UNSIGNED ) )\r
+ {\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags &= ( ( uint8_t ) ~ipTCP_FLAG_PSH );\r
+ pxTCPPacket->xTCPHeader.ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags |= ( uint8_t ) ipTCP_FLAG_ACK;\r
+\r
+ if( lDataLen != 0l )\r
+ {\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags |= ( uint8_t ) ipTCP_FLAG_PSH;\r
+ }\r
+\r
+ #if ipconfigUSE_TCP_TIMESTAMPS == 1\r
+ {\r
+ if( uxOptionsLength == 0u )\r
+ {\r
+ if( pxSocket->u.xTCP.xTCPWindow.u.bits.bTimeStamps )\r
+ {\r
+ TCPPacket_t * pxTCPPacket = ( TCPPacket_t * ) ( pucEthernetBuffer );\r
+ uxOptionsLength = prvTCPSetTimeStamp( 0, pxSocket, &pxTCPPacket->xTCPHeader );\r
+ }\r
+ }\r
+ }\r
+ #endif\r
+\r
+ lDataLen += ( int32_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+ }\r
+\r
+ return lDataLen;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Calculate after how much time this socket needs to be checked again.\r
+ */\r
+static TickType_t prvTCPNextTimeout ( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+TickType_t ulDelayMs = ( TickType_t ) tcpMAXIMUM_TCP_WAKEUP_TIME_MS;\r
+\r
+ if( pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN )\r
+ {\r
+ /* The socket is actively connecting to a peer. */\r
+ if( pxSocket->u.xTCP.bits.bConnPrepared )\r
+ {\r
+ /* Ethernet address has been found, use progressive timeout for\r
+ active connect(). */\r
+ if( pxSocket->u.xTCP.ucRepCount < 3u )\r
+ {\r
+ ulDelayMs = ( 3000UL << ( pxSocket->u.xTCP.ucRepCount - 1u ) );\r
+ }\r
+ else\r
+ {\r
+ ulDelayMs = 11000UL;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* Still in the ARP phase: check every half second. */\r
+ ulDelayMs = 500UL;\r
+ }\r
+\r
+ FreeRTOS_debug_printf( ( "Connect[%lxip:%u]: next timeout %u: %lu ms\n",\r
+ pxSocket->u.xTCP.ulRemoteIP, pxSocket->u.xTCP.usRemotePort,\r
+ pxSocket->u.xTCP.ucRepCount, ulDelayMs ) );\r
+ pxSocket->u.xTCP.usTimeout = ( uint16_t )pdMS_TO_MIN_TICKS( ulDelayMs );\r
+ }\r
+ else if( pxSocket->u.xTCP.usTimeout == 0u )\r
+ {\r
+ /* Let the sliding window mechanism decide what time-out is appropriate. */\r
+ BaseType_t xResult = xTCPWindowTxHasData( &pxSocket->u.xTCP.xTCPWindow, pxSocket->u.xTCP.ulWindowSize, &ulDelayMs );\r
+ if( ulDelayMs == 0u )\r
+ {\r
+ if( xResult != ( BaseType_t )0 )\r
+ {\r
+ ulDelayMs = 1UL;\r
+ }\r
+ else\r
+ {\r
+ ulDelayMs = tcpMAXIMUM_TCP_WAKEUP_TIME_MS;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* ulDelayMs contains the time to wait before a re-transmission. */\r
+ }\r
+ pxSocket->u.xTCP.usTimeout = ( uint16_t )pdMS_TO_MIN_TICKS( ulDelayMs );\r
+ }\r
+ else\r
+ {\r
+ /* field '.usTimeout' has already been set (by the\r
+ keep-alive/delayed-ACK mechanism). */\r
+ }\r
+\r
+ /* Return the number of clock ticks before the timer expires. */\r
+ return ( TickType_t ) pxSocket->u.xTCP.usTimeout;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvTCPAddTxData( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+int32_t lCount, lLength;\r
+\r
+ /* A txStream has been created already, see if the socket has new data for\r
+ the sliding window.\r
+\r
+ uxStreamBufferMidSpace() returns the distance between rxHead and rxMid. It\r
+ contains new Tx data which has not been passed to the sliding window yet.\r
+ The oldest data not-yet-confirmed can be found at rxTail. */\r
+ lLength = ( int32_t ) uxStreamBufferMidSpace( pxSocket->u.xTCP.txStream );\r
+\r
+ if( lLength > 0 )\r
+ {\r
+ /* All data between txMid and rxHead will now be passed to the sliding\r
+ window manager, so it can start transmitting them.\r
+\r
+ Hand over the new data to the sliding window handler. It will be\r
+ split-up in chunks of 1460 bytes each (or less, depending on\r
+ ipconfigTCP_MSS). */\r
+ lCount = lTCPWindowTxAdd( &pxSocket->u.xTCP.xTCPWindow,\r
+ ( uint32_t ) lLength,\r
+ ( int32_t ) pxSocket->u.xTCP.txStream->uxMid,\r
+ ( int32_t ) pxSocket->u.xTCP.txStream->LENGTH );\r
+\r
+ /* Move the rxMid pointer forward up to rxHead. */\r
+ if( lCount > 0 )\r
+ {\r
+ vStreamBufferMoveMid( pxSocket->u.xTCP.txStream, ( size_t ) lCount );\r
+ }\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvTCPHandleFin() will be called to handle socket closure\r
+ * The Closure starts when either a FIN has been received and accepted,\r
+ * Or when the socket has sent a FIN flag to the peer\r
+ * Before being called, it has been checked that both reception and transmission\r
+ * are complete.\r
+ */\r
+static BaseType_t prvTCPHandleFin( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+uint8_t ucTCPFlags = pxTCPHeader->ucTCPFlags;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+BaseType_t xSendLength = 0;\r
+uint32_t ulAckNr = FreeRTOS_ntohl( pxTCPHeader->ulAckNr );\r
+\r
+ if( ( ucTCPFlags & ipTCP_FLAG_FIN ) != 0u )\r
+ {\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber = pxTCPWindow->rx.ulFINSequenceNumber + 1u;\r
+ }\r
+ if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )\r
+ {\r
+ /* We haven't yet replied with a FIN, do so now. */\r
+ pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;\r
+ pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;\r
+ }\r
+ else\r
+ {\r
+ /* We did send a FIN already, see if it's ACK'd. */\r
+ if( ulAckNr == pxTCPWindow->tx.ulFINSequenceNumber + 1u )\r
+ {\r
+ pxSocket->u.xTCP.bits.bFinAcked = pdTRUE_UNSIGNED;\r
+ }\r
+ }\r
+\r
+ if( pxSocket->u.xTCP.bits.bFinAcked == pdFALSE_UNSIGNED )\r
+ {\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber;\r
+ pxTCPHeader->ucTCPFlags = ipTCP_FLAG_ACK | ipTCP_FLAG_FIN;\r
+\r
+ /* And wait for the final ACK. */\r
+ vTCPStateChange( pxSocket, eLAST_ACK );\r
+ }\r
+ else\r
+ {\r
+ /* Our FIN has been ACK'd, the outgoing sequence number is now fixed. */\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber + 1u;\r
+ if( pxSocket->u.xTCP.bits.bFinRecv == pdFALSE_UNSIGNED )\r
+ {\r
+ /* We have sent out a FIN but the peer hasn't replied with a FIN\r
+ yet. Do nothing for the moment. */\r
+ pxTCPHeader->ucTCPFlags = 0u;\r
+ }\r
+ else\r
+ {\r
+ if( pxSocket->u.xTCP.bits.bFinLast == pdFALSE_UNSIGNED )\r
+ {\r
+ /* This is the third of the three-way hand shake: the last\r
+ ACK. */\r
+ pxTCPHeader->ucTCPFlags = ipTCP_FLAG_ACK;\r
+ }\r
+ else\r
+ {\r
+ /* The other party started the closure, so we just wait for the\r
+ last ACK. */\r
+ pxTCPHeader->ucTCPFlags = 0u;\r
+ }\r
+\r
+ /* And wait for the user to close this socket. */\r
+ vTCPStateChange( pxSocket, eCLOSE_WAIT );\r
+ }\r
+ }\r
+\r
+ pxTCPWindow->ulOurSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;\r
+\r
+ if( pxTCPHeader->ucTCPFlags != 0u )\r
+ {\r
+ xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + pxTCPWindow->ucOptionLength );\r
+ }\r
+\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t ) ( ( ipSIZE_OF_TCP_HEADER + pxTCPWindow->ucOptionLength ) << 2 );\r
+\r
+ if( xTCPWindowLoggingLevel != 0 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: send FIN+ACK (ack %lu, cur/nxt %lu/%lu) ourSeqNr %lu | Rx %lu\n",\r
+ ulAckNr - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ pxTCPWindow->ulNextTxSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ pxTCPWindow->ulOurSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber - pxTCPWindow->rx.ulFirstSequenceNumber ) );\r
+ }\r
+\r
+ return xSendLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ipconfigUSE_TCP_TIMESTAMPS == 1\r
+\r
+ static UBaseType_t prvTCPSetTimeStamp( BaseType_t lOffset, FreeRTOS_Socket_t *pxSocket, TCPHeader_t *pxTCPHeader )\r
+ {\r
+ uint32_t ulTimes[2];\r
+ uint8_t *ucOptdata = &( pxTCPHeader->ucOptdata[ lOffset ] );\r
+\r
+ ulTimes[0] = ( xTaskGetTickCount ( ) * 1000u ) / configTICK_RATE_HZ;\r
+ ulTimes[0] = FreeRTOS_htonl( ulTimes[0] );\r
+ ulTimes[1] = FreeRTOS_htonl( pxSocket->u.xTCP.xTCPWindow.rx.ulTimeStamp );\r
+ ucOptdata[0] = ( uint8_t ) TCP_OPT_TIMESTAMP;\r
+ ucOptdata[1] = ( uint8_t ) TCP_OPT_TIMESTAMP_LEN;\r
+ memcpy( &(ucOptdata[2] ), ulTimes, 8u );\r
+ ucOptdata[10] = ( uint8_t ) TCP_OPT_NOOP;\r
+ ucOptdata[11] = ( uint8_t ) TCP_OPT_NOOP;\r
+ /* Do not return the same timestamps 2 times. */\r
+ pxSocket->u.xTCP.xTCPWindow.rx.ulTimeStamp = 0ul;\r
+ return 12u;\r
+ }\r
+\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvCheckRxData(): called from prvTCPHandleState()\r
+ *\r
+ * The first thing that will be done is find the TCP payload data\r
+ * and check the length of this data.\r
+ */\r
+static BaseType_t prvCheckRxData( NetworkBufferDescriptor_t *pxNetworkBuffer, uint8_t **ppucRecvData )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &( pxTCPPacket->xTCPHeader );\r
+int32_t lLength, lTCPHeaderLength, lReceiveLength, lUrgentLength;\r
+\r
+ /* Determine the length and the offset of the user-data sent to this\r
+ node.\r
+\r
+ The size of the TCP header is given in a multiple of 4-byte words (single\r
+ byte, needs no ntoh() translation). A shift-right 2: is the same as\r
+ (offset >> 4) * 4. */\r
+ lTCPHeaderLength = ( BaseType_t ) ( ( pxTCPHeader->ucTCPOffset & VALID_BITS_IN_TCP_OFFSET_BYTE ) >> 2 );\r
+\r
+ /* Let pucRecvData point to the first byte received. */\r
+ *ppucRecvData = pxNetworkBuffer->pucEthernetBuffer + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + lTCPHeaderLength;\r
+\r
+ /* Calculate lReceiveLength - the length of the TCP data received. This is\r
+ equal to the total packet length minus:\r
+ ( LinkLayer length (14) + IP header length (20) + size of TCP header(20 +) ).*/\r
+ lReceiveLength = ( ( int32_t ) pxNetworkBuffer->xDataLength ) - ( int32_t ) ipSIZE_OF_ETH_HEADER;\r
+ lLength = ( int32_t )FreeRTOS_htons( pxTCPPacket->xIPHeader.usLength );\r
+\r
+ if( lReceiveLength > lLength )\r
+ {\r
+ /* More bytes were received than the reported length, often because of\r
+ padding bytes at the end. */\r
+ lReceiveLength = lLength;\r
+ }\r
+\r
+ /* Subtract the size of the TCP and IP headers and the actual data size is\r
+ known. */\r
+ if( lReceiveLength > ( lTCPHeaderLength + ( int32_t ) ipSIZE_OF_IPv4_HEADER ) )\r
+ {\r
+ lReceiveLength -= ( lTCPHeaderLength + ( int32_t ) ipSIZE_OF_IPv4_HEADER );\r
+ }\r
+ else\r
+ {\r
+ lReceiveLength = 0;\r
+ }\r
+\r
+ /* Urgent Pointer:\r
+ This field communicates the current value of the urgent pointer as a\r
+ positive offset from the sequence number in this segment. The urgent\r
+ pointer points to the sequence number of the octet following the urgent\r
+ data. This field is only be interpreted in segments with the URG control\r
+ bit set. */\r
+ if( ( pxTCPHeader->ucTCPFlags & ipTCP_FLAG_URG ) != 0u )\r
+ {\r
+ /* Although we ignore the urgent data, we have to skip it. */\r
+ lUrgentLength = ( int32_t ) FreeRTOS_htons( pxTCPHeader->usUrgent );\r
+ *ppucRecvData += lUrgentLength;\r
+ lReceiveLength -= FreeRTOS_min_int32( lReceiveLength, lUrgentLength );\r
+ }\r
+\r
+ return ( BaseType_t ) lReceiveLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvStoreRxData(): called from prvTCPHandleState()\r
+ *\r
+ * The second thing is to do is check if the payload data may be accepted\r
+ * If so, they will be added to the reception queue.\r
+ */\r
+static BaseType_t prvStoreRxData( FreeRTOS_Socket_t *pxSocket, uint8_t *pucRecvData,\r
+ NetworkBufferDescriptor_t *pxNetworkBuffer, uint32_t ulReceiveLength )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+uint32_t ulSequenceNumber, ulSpace;\r
+int32_t lOffset, lStored;\r
+BaseType_t xResult = 0;\r
+\r
+ ulSequenceNumber = FreeRTOS_ntohl( pxTCPHeader->ulSequenceNumber );\r
+\r
+ if( ( ulReceiveLength > 0u ) && ( pxSocket->u.xTCP.ucTCPState >= eSYN_RECEIVED ) )\r
+ {\r
+ /* See if way may accept the data contents and forward it to the socket\r
+ owner.\r
+\r
+ If it can't be "accept"ed it may have to be stored and send a selective\r
+ ack (SACK) option to confirm it. In that case, xTCPWindowRxStore() will be\r
+ called later to store an out-of-order packet (in case lOffset is\r
+ negative). */\r
+ if ( pxSocket->u.xTCP.rxStream )\r
+ {\r
+ ulSpace = ( uint32_t )uxStreamBufferGetSpace ( pxSocket->u.xTCP.rxStream );\r
+ }\r
+ else\r
+ {\r
+ ulSpace = ( uint32_t )pxSocket->u.xTCP.uxRxStreamSize;\r
+ }\r
+\r
+ lOffset = lTCPWindowRxCheck( pxTCPWindow, ulSequenceNumber, ulReceiveLength, ulSpace );\r
+\r
+ if( lOffset >= 0 )\r
+ {\r
+ /* New data has arrived and may be made available to the user. See\r
+ if the head marker in rxStream may be advanced, only if lOffset == 0.\r
+ In case the low-water mark is reached, bLowWater will be set\r
+ "low-water" here stands for "little space". */\r
+ lStored = lTCPAddRxdata( pxSocket, ( uint32_t ) lOffset, pucRecvData, ulReceiveLength );\r
+\r
+ if( lStored != ( int32_t ) ulReceiveLength )\r
+ {\r
+ FreeRTOS_debug_printf( ( "lTCPAddRxdata: stored %ld / %lu bytes??\n", lStored, ulReceiveLength ) );\r
+\r
+ /* Received data could not be stored. The socket's flag\r
+ bMallocError has been set. The socket now has the status\r
+ eCLOSE_WAIT and a RST packet will be sent back. */\r
+ prvTCPSendReset( pxNetworkBuffer );\r
+ xResult = -1;\r
+ }\r
+ }\r
+\r
+ /* After a missing packet has come in, higher packets may be passed to\r
+ the user. */\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ /* Now lTCPAddRxdata() will move the rxHead pointer forward\r
+ so data becomes available to the user immediately\r
+ In case the low-water mark is reached, bLowWater will be set. */\r
+ if( ( xResult == 0 ) && ( pxTCPWindow->ulUserDataLength > 0 ) )\r
+ {\r
+ lTCPAddRxdata( pxSocket, 0ul, NULL, pxTCPWindow->ulUserDataLength );\r
+ pxTCPWindow->ulUserDataLength = 0;\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+ }\r
+ else\r
+ {\r
+ pxTCPWindow->ucOptionLength = 0u;\r
+ }\r
+\r
+ return xResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/* Set the TCP options (if any) for the outgoing packet. */\r
+static UBaseType_t prvSetOptions( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+UBaseType_t uxOptionsLength = pxTCPWindow->ucOptionLength;\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ if( uxOptionsLength != 0u )\r
+ {\r
+ /* TCP options must be sent because a packet which is out-of-order\r
+ was received. */\r
+ if( xTCPWindowLoggingLevel >= 0 )\r
+ FreeRTOS_debug_printf( ( "SACK[%d,%d]: optlen %lu sending %lu - %lu\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ uxOptionsLength,\r
+ FreeRTOS_ntohl( pxTCPWindow->ulOptionsData[ 1 ] ) - pxSocket->u.xTCP.xTCPWindow.rx.ulFirstSequenceNumber,\r
+ FreeRTOS_ntohl( pxTCPWindow->ulOptionsData[ 2 ] ) - pxSocket->u.xTCP.xTCPWindow.rx.ulFirstSequenceNumber ) );\r
+ memcpy( pxTCPHeader->ucOptdata, pxTCPWindow->ulOptionsData, ( size_t ) uxOptionsLength );\r
+\r
+ /* The header length divided by 4, goes into the higher nibble,\r
+ effectively a shift-left 2. */\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+ }\r
+ else\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+ if( ( pxSocket->u.xTCP.ucTCPState >= eESTABLISHED ) && ( pxSocket->u.xTCP.bits.bMssChange != pdFALSE_UNSIGNED ) )\r
+ {\r
+ /* TCP options must be sent because the MSS has changed. */\r
+ pxSocket->u.xTCP.bits.bMssChange = pdFALSE_UNSIGNED;\r
+ if( xTCPWindowLoggingLevel >= 0 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "MSS: sending %d\n", pxSocket->u.xTCP.usCurMSS ) );\r
+ }\r
+\r
+ pxTCPHeader->ucOptdata[ 0 ] = TCP_OPT_MSS;\r
+ pxTCPHeader->ucOptdata[ 1 ] = TCP_OPT_MSS_LEN;\r
+ pxTCPHeader->ucOptdata[ 2 ] = ( uint8_t ) ( ( pxSocket->u.xTCP.usCurMSS ) >> 8 );\r
+ pxTCPHeader->ucOptdata[ 3 ] = ( uint8_t ) ( ( pxSocket->u.xTCP.usCurMSS ) & 0xffu );\r
+ uxOptionsLength = 4u;\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+ }\r
+\r
+ #if( ipconfigUSE_TCP_TIMESTAMPS == 1 )\r
+ {\r
+ if( pxSocket->u.xTCP.xTCPWindow.u.bits.bTimeStamps )\r
+ {\r
+ uxOptionsLength += prvTCPSetTimeStamp( uxOptionsLength, pxSocket, pxTCPHeader );\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_TCP_TIMESTAMPS == 1 */\r
+\r
+ return uxOptionsLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvHandleSynReceived(): called from prvTCPHandleState()\r
+ *\r
+ * Called from the states: eSYN_RECEIVED and eCONNECT_SYN\r
+ * If the flags received are correct, the socket will move to eESTABLISHED.\r
+ */\r
+static BaseType_t prvHandleSynReceived( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, UBaseType_t uxOptionsLength )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( (*ppxNetworkBuffer)->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+uint8_t ucTCPFlags = pxTCPHeader->ucTCPFlags;\r
+uint32_t ulSequenceNumber = FreeRTOS_ntohl( pxTCPHeader->ulSequenceNumber );\r
+BaseType_t xSendLength = 0;\r
+\r
+ /* Either expect a ACK or a SYN+ACK. */\r
+ uint16_t usExpect = ( uint16_t ) ipTCP_FLAG_ACK;\r
+ if( pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN )\r
+ {\r
+ usExpect |= ( uint16_t ) ipTCP_FLAG_SYN;\r
+ }\r
+\r
+ if( ( ucTCPFlags & 0x17u ) != usExpect )\r
+ {\r
+ /* eSYN_RECEIVED: flags 0010 expected, not 0002. */\r
+ /* eSYN_RECEIVED: flags ACK expected, not SYN. */\r
+ FreeRTOS_debug_printf( ( "%s: flags %04X expected, not %04X\n",\r
+ pxSocket->u.xTCP.ucTCPState == eSYN_RECEIVED ? "eSYN_RECEIVED" : "eCONNECT_SYN",\r
+ usExpect, ucTCPFlags ) );\r
+ vTCPStateChange( pxSocket, eCLOSE_WAIT );\r
+ pxTCPHeader->ucTCPFlags |= ipTCP_FLAG_RST;\r
+ xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+ }\r
+ else\r
+ {\r
+ pxTCPWindow->usPeerPortNumber = pxSocket->u.xTCP.usRemotePort;\r
+ pxTCPWindow->usOurPortNumber = pxSocket->usLocalPort;\r
+\r
+ if( pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN )\r
+ {\r
+ TCPPacket_t *pxLastTCPPacket = ( TCPPacket_t * ) ( pxSocket->u.xTCP.xPacket.u.ucLastPacket );\r
+\r
+ /* Clear the SYN flag in lastPacket. */\r
+ pxLastTCPPacket->xTCPHeader.ucTCPFlags = ipTCP_FLAG_ACK;\r
+\r
+ /* This socket was the one connecting actively so now perofmr the\r
+ synchronisation. */\r
+ vTCPWindowInit( &pxSocket->u.xTCP.xTCPWindow,\r
+ ulSequenceNumber, pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber, ( uint32_t ) pxSocket->u.xTCP.usCurMSS );\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber = pxTCPWindow->rx.ulHighestSequenceNumber = ulSequenceNumber + 1u;\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber++; /* because we send a TCP_SYN [ | TCP_ACK ]; */\r
+ pxTCPWindow->ulNextTxSequenceNumber++;\r
+ }\r
+ else if( ulReceiveLength == 0u )\r
+ {\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber = ulSequenceNumber;\r
+ }\r
+\r
+ /* The SYN+ACK has been confirmed, increase the next sequence number by\r
+ 1. */\r
+ pxTCPWindow->ulOurSequenceNumber = pxTCPWindow->tx.ulFirstSequenceNumber + 1u;\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: %s %d => %lxip:%d set ESTAB (scaling %u)\n",\r
+ pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN ? "active" : "passive",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.ulRemoteIP,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ ( unsigned ) pxSocket->u.xTCP.bits.bWinScaling ) );\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+\r
+ if( ( pxSocket->u.xTCP.ucTCPState == eCONNECT_SYN ) || ( ulReceiveLength != 0u ) )\r
+ {\r
+ pxTCPHeader->ucTCPFlags = ipTCP_FLAG_ACK;\r
+ xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t ) ( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+ }\r
+ #if( ipconfigUSE_TCP_WIN != 0 )\r
+ {\r
+ if( pxSocket->u.xTCP.bits.bWinScaling == pdFALSE_UNSIGNED )\r
+ {\r
+ /* The other party did not send a scaling factor.\r
+ A shifting factor in this side must be canceled. */\r
+ pxSocket->u.xTCP.ucMyWinScaleFactor = 0;\r
+ pxSocket->u.xTCP.ucPeerWinScaleFactor = 0;\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+ /* This was the third step of connecting: SYN, SYN+ACK, ACK so now the\r
+ connection is established. */\r
+ vTCPStateChange( pxSocket, eESTABLISHED );\r
+ }\r
+\r
+ return xSendLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvHandleEstablished(): called from prvTCPHandleState()\r
+ *\r
+ * Called if the status is eESTABLISHED. Data reception has been handled\r
+ * earlier. Here the ACK's from peer will be checked, and if a FIN is received,\r
+ * the code will check if it may be accepted, i.e. if all expected data has been\r
+ * completely received.\r
+ */\r
+static BaseType_t prvHandleEstablished( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, UBaseType_t uxOptionsLength )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( (*ppxNetworkBuffer)->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+uint8_t ucTCPFlags = pxTCPHeader->ucTCPFlags;\r
+uint32_t ulSequenceNumber = FreeRTOS_ntohl( pxTCPHeader->ulSequenceNumber ), ulCount;\r
+BaseType_t xSendLength = 0, xMayClose = pdFALSE, bRxComplete, bTxDone;\r
+int32_t lDistance, lSendResult;\r
+\r
+ /* Remember the window size the peer is advertising. */\r
+ pxSocket->u.xTCP.ulWindowSize = FreeRTOS_ntohs( pxTCPHeader->usWindow );\r
+ #if( ipconfigUSE_TCP_WIN != 0 )\r
+ {\r
+ pxSocket->u.xTCP.ulWindowSize =\r
+ ( pxSocket->u.xTCP.ulWindowSize << pxSocket->u.xTCP.ucPeerWinScaleFactor );\r
+ }\r
+ #endif\r
+\r
+ if( ( ucTCPFlags & ( uint8_t ) ipTCP_FLAG_ACK ) != 0u )\r
+ {\r
+ ulCount = ulTCPWindowTxAck( pxTCPWindow, FreeRTOS_ntohl( pxTCPPacket->xTCPHeader.ulAckNr ) );\r
+\r
+ /* ulTCPWindowTxAck() returns the number of bytes which have been acked,\r
+ starting at 'tx.ulCurrentSequenceNumber'. Advance the tail pointer in\r
+ txStream. */\r
+ if( ( pxSocket->u.xTCP.txStream != NULL ) && ( ulCount > 0u ) )\r
+ {\r
+ /* Just advancing the tail index, 'ulCount' bytes have been\r
+ confirmed, and because there is new space in the txStream, the\r
+ user/owner should be woken up. */\r
+ /* _HT_ : only in case the socket's waiting? */\r
+ if( uxStreamBufferGet( pxSocket->u.xTCP.txStream, 0u, NULL, ( size_t ) ulCount, pdFALSE ) != 0u )\r
+ {\r
+ pxSocket->xEventBits |= eSOCKET_SEND;\r
+\r
+ #if ipconfigSUPPORT_SELECT_FUNCTION == 1\r
+ {\r
+ if( ( pxSocket->xSelectBits & eSELECT_WRITE ) != 0 )\r
+ {\r
+ pxSocket->xEventBits |= ( eSELECT_WRITE << SOCKET_EVENT_BIT_COUNT );\r
+ }\r
+ }\r
+ #endif\r
+ /* In case the socket owner has installed an OnSent handler,\r
+ call it now. */\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ if( ipconfigIS_VALID_PROG_ADDRESS( pxSocket->u.xTCP.pxHandleSent ) )\r
+ {\r
+ pxSocket->u.xTCP.pxHandleSent( (Socket_t *)pxSocket, ulCount );\r
+ }\r
+ }\r
+ #endif /* ipconfigUSE_CALLBACKS == 1 */\r
+ }\r
+ }\r
+ }\r
+\r
+ /* If this socket has a stream for transmission, add the data to the\r
+ outgoing segment(s). */\r
+ if( pxSocket->u.xTCP.txStream != NULL )\r
+ {\r
+ prvTCPAddTxData( pxSocket );\r
+ }\r
+\r
+ pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;\r
+\r
+ if( ( pxSocket->u.xTCP.bits.bFinAccepted != pdFALSE_UNSIGNED ) || ( ( ucTCPFlags & ( uint8_t ) ipTCP_FLAG_FIN ) != 0u ) )\r
+ {\r
+ /* Peer is requesting to stop, see if we're really finished. */\r
+ xMayClose = pdTRUE;\r
+\r
+ /* Checks are only necessary if we haven't sent a FIN yet. */\r
+ if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )\r
+ {\r
+ /* xTCPWindowTxDone returns true when all Tx queues are empty. */\r
+ bRxComplete = xTCPWindowRxEmpty( pxTCPWindow );\r
+ bTxDone = xTCPWindowTxDone( pxTCPWindow );\r
+\r
+ if( ( bRxComplete == 0 ) || ( bTxDone == 0 ) )\r
+ {\r
+ /* Refusing FIN: Rx incomp 1 optlen 4 tx done 1. */\r
+ FreeRTOS_debug_printf( ( "Refusing FIN[%u,%u]: RxCompl %lu tx done %ld\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ bRxComplete, bTxDone ) );\r
+ xMayClose = pdFALSE;\r
+ }\r
+ else\r
+ {\r
+ lDistance = ( int32_t ) ( ulSequenceNumber + ulReceiveLength - pxTCPWindow->rx.ulCurrentSequenceNumber );\r
+\r
+ if( lDistance > 1 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "Refusing FIN: Rx not complete %ld (cur %lu high %lu)\n",\r
+ lDistance, pxTCPWindow->rx.ulCurrentSequenceNumber - pxTCPWindow->rx.ulFirstSequenceNumber,\r
+ pxTCPWindow->rx.ulHighestSequenceNumber - pxTCPWindow->rx.ulFirstSequenceNumber ) );\r
+\r
+ xMayClose = pdFALSE;\r
+ }\r
+ }\r
+ }\r
+\r
+ if( xTCPWindowLoggingLevel > 0 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: FIN received, mayClose = %ld (Rx %lu Len %ld, Tx %lu)\n",\r
+ xMayClose, ulSequenceNumber - pxSocket->u.xTCP.xTCPWindow.rx.ulFirstSequenceNumber, ulReceiveLength,\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber - pxSocket->u.xTCP.xTCPWindow.tx.ulFirstSequenceNumber ) );\r
+ }\r
+\r
+ if( xMayClose != pdFALSE )\r
+ {\r
+ pxSocket->u.xTCP.bits.bFinAccepted = pdTRUE_UNSIGNED;\r
+ xSendLength = prvTCPHandleFin( pxSocket, *ppxNetworkBuffer );\r
+ }\r
+ }\r
+\r
+ if( xMayClose == pdFALSE )\r
+ {\r
+ pxTCPHeader->ucTCPFlags = ipTCP_FLAG_ACK;\r
+\r
+ if( ulReceiveLength != 0u )\r
+ {\r
+ xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+ /* TCP-offsett equals '( ( length / 4 ) << 4 )', resulting in a shift-left 2 */\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+\r
+ if( pxSocket->u.xTCP.bits.bFinSent != pdFALSE_UNSIGNED )\r
+ {\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber;\r
+ }\r
+ }\r
+\r
+ /* Now get data to be transmitted. */\r
+ /* _HT_ patch: since the MTU has be fixed at 1500 in stead of 1526, TCP\r
+ can not send-out both TCP options and also a full packet. Sending\r
+ options (SACK) is always more urgent than sending data, which can be\r
+ sent later. */\r
+ if( uxOptionsLength == 0u )\r
+ {\r
+ /* prvTCPPrepareSend might allocate a bigger network buffer, if\r
+ necessary. */\r
+ lSendResult = prvTCPPrepareSend( pxSocket, ppxNetworkBuffer, uxOptionsLength );\r
+ if( lSendResult > 0 )\r
+ {\r
+ xSendLength = ( BaseType_t ) lSendResult;\r
+ }\r
+ }\r
+ }\r
+\r
+ return xSendLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Called from prvTCPHandleState(). There is data to be sent. If\r
+ * ipconfigUSE_TCP_WIN is defined, and if only an ACK must be sent, it will be\r
+ * checked if it would better be postponed for efficiency.\r
+ */\r
+static BaseType_t prvSendData( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer,\r
+ uint32_t ulReceiveLength, BaseType_t xSendLength )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( (*ppxNetworkBuffer)->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &pxTCPPacket->xTCPHeader;\r
+TCPWindow_t *pxTCPWindow = &pxSocket->u.xTCP.xTCPWindow;\r
+/* Find out what window size we may advertised. */\r
+uint32_t ulFrontSpace;\r
+int32_t lRxSpace;\r
+#if( ipconfigUSE_TCP_WIN == 1 )\r
+ #if( ipconfigTCP_ACK_EARLIER_PACKET == 0 )\r
+ const int32_t lMinLength = 0;\r
+ #else\r
+ int32_t lMinLength;\r
+ #endif\r
+#endif\r
+ pxSocket->u.xTCP.ulRxCurWinSize = pxTCPWindow->xSize.ulRxWindowLength -\r
+ ( pxTCPWindow->rx.ulHighestSequenceNumber - pxTCPWindow->rx.ulCurrentSequenceNumber );\r
+\r
+ /* Free space in rxStream. */\r
+ if( pxSocket->u.xTCP.rxStream != NULL )\r
+ {\r
+ ulFrontSpace = ( uint32_t ) uxStreamBufferFrontSpace( pxSocket->u.xTCP.rxStream );\r
+ }\r
+ else\r
+ {\r
+ ulFrontSpace = ( uint32_t ) pxSocket->u.xTCP.uxRxStreamSize;\r
+ }\r
+\r
+ pxSocket->u.xTCP.ulRxCurWinSize = FreeRTOS_min_uint32( ulFrontSpace, pxSocket->u.xTCP.ulRxCurWinSize );\r
+\r
+ /* Set the time-out field, so that we'll be called by the IP-task in case no\r
+ next message will be received. */\r
+ lRxSpace = (int32_t)( pxSocket->u.xTCP.ulHighestRxAllowed - pxTCPWindow->rx.ulCurrentSequenceNumber );\r
+ #if ipconfigUSE_TCP_WIN == 1\r
+ {\r
+\r
+ #if( ipconfigTCP_ACK_EARLIER_PACKET != 0 )\r
+ {\r
+ lMinLength = ( ( int32_t ) 2 ) * ( ( int32_t ) pxSocket->u.xTCP.usCurMSS );\r
+ }\r
+ #endif /* ipconfigTCP_ACK_EARLIER_PACKET */\r
+\r
+ /* In case we're receiving data continuously, we might postpone sending\r
+ an ACK to gain performance. */\r
+ if( ( ulReceiveLength > 0 ) && /* Data was sent to this socket. */\r
+ ( lRxSpace >= lMinLength ) && /* There is Rx space for more data. */\r
+ ( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED ) && /* Not in a closure phase. */\r
+ ( xSendLength == ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER ) ) && /* No Tx data or options to be sent. */\r
+ ( pxSocket->u.xTCP.ucTCPState == eESTABLISHED ) && /* Connection established. */\r
+ ( pxTCPHeader->ucTCPFlags == ipTCP_FLAG_ACK ) ) /* There are no other flags than an ACK. */\r
+ {\r
+ if( pxSocket->u.xTCP.pxAckMessage != *ppxNetworkBuffer )\r
+ {\r
+ /* There was still a delayed in queue, delete it. */\r
+ if( pxSocket->u.xTCP.pxAckMessage != 0 )\r
+ {\r
+ vReleaseNetworkBufferAndDescriptor( pxSocket->u.xTCP.pxAckMessage );\r
+ }\r
+\r
+ pxSocket->u.xTCP.pxAckMessage = *ppxNetworkBuffer;\r
+ }\r
+ if( ( ulReceiveLength < ( uint32_t ) pxSocket->u.xTCP.usCurMSS ) || /* Received a small message. */\r
+ ( lRxSpace < ( int32_t ) ( 2U * pxSocket->u.xTCP.usCurMSS ) ) ) /* There are less than 2 x MSS space in the Rx buffer. */\r
+ {\r
+ pxSocket->u.xTCP.usTimeout = ( uint16_t ) pdMS_TO_MIN_TICKS( DELAYED_ACK_SHORT_DELAY_MS );\r
+ }\r
+ else\r
+ {\r
+ /* Normally a delayed ACK should wait 200 ms for a next incoming\r
+ packet. Only wait 20 ms here to gain performance. A slow ACK\r
+ for full-size message. */\r
+ pxSocket->u.xTCP.usTimeout = ( uint16_t ) pdMS_TO_MIN_TICKS( DELAYED_ACK_LONGER_DELAY_MS );\r
+ }\r
+\r
+ if( ( xTCPWindowLoggingLevel > 1 ) && ( ipconfigTCP_MAY_LOG_PORT( pxSocket->usLocalPort ) != pdFALSE ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "Send[%u->%u] del ACK %lu SEQ %lu (len %lu) tmout %u d %lu\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber - pxTCPWindow->rx.ulFirstSequenceNumber,\r
+ pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ xSendLength,\r
+ pxSocket->u.xTCP.usTimeout, lRxSpace ) );\r
+ }\r
+\r
+ *ppxNetworkBuffer = NULL;\r
+ xSendLength = 0;\r
+ }\r
+ else if( pxSocket->u.xTCP.pxAckMessage != NULL )\r
+ {\r
+ /* As an ACK is not being delayed, remove any earlier delayed ACK\r
+ message. */\r
+ if( pxSocket->u.xTCP.pxAckMessage != *ppxNetworkBuffer )\r
+ {\r
+ vReleaseNetworkBufferAndDescriptor( pxSocket->u.xTCP.pxAckMessage );\r
+ }\r
+\r
+ pxSocket->u.xTCP.pxAckMessage = NULL;\r
+ }\r
+ }\r
+ #else\r
+ {\r
+ /* Remove compiler warnings. */\r
+ ( void ) ulReceiveLength;\r
+ ( void ) pxTCPHeader;\r
+ ( void ) lRxSpace;\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+\r
+ if( xSendLength != 0 )\r
+ {\r
+ if( ( xTCPWindowLoggingLevel > 1 ) && ( ipconfigTCP_MAY_LOG_PORT( pxSocket->usLocalPort ) != pdFALSE ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "Send[%u->%u] imm ACK %lu SEQ %lu (len %lu)\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usRemotePort,\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber - pxTCPWindow->rx.ulFirstSequenceNumber,\r
+ pxTCPWindow->ulOurSequenceNumber - pxTCPWindow->tx.ulFirstSequenceNumber,\r
+ xSendLength ) );\r
+ }\r
+\r
+ /* Set the parameter 'xReleaseAfterSend' to the value of\r
+ ipconfigZERO_COPY_TX_DRIVER. */\r
+ prvTCPReturnPacket( pxSocket, *ppxNetworkBuffer, ( uint32_t ) xSendLength, ipconfigZERO_COPY_TX_DRIVER );\r
+ #if( ipconfigZERO_COPY_TX_DRIVER != 0 )\r
+ {\r
+ /* The driver has taken ownership of the Network Buffer. */\r
+ *ppxNetworkBuffer = NULL;\r
+ }\r
+ #endif\r
+ }\r
+\r
+ return xSendLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * prvTCPHandleState()\r
+ * is the most important function of this TCP stack\r
+ * We've tried to keep it (relatively short) by putting a lot of code in\r
+ * the static functions above:\r
+ *\r
+ * prvCheckRxData()\r
+ * prvStoreRxData()\r
+ * prvSetOptions()\r
+ * prvHandleSynReceived()\r
+ * prvHandleEstablished()\r
+ * prvSendData()\r
+ *\r
+ * As these functions are declared static, and they're called from one location\r
+ * only, most compilers will inline them, thus avoiding a call and return.\r
+ */\r
+static BaseType_t prvTCPHandleState( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t **ppxNetworkBuffer )\r
+{\r
+TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( (*ppxNetworkBuffer)->pucEthernetBuffer );\r
+TCPHeader_t *pxTCPHeader = &( pxTCPPacket->xTCPHeader );\r
+BaseType_t xSendLength = 0;\r
+uint32_t ulReceiveLength; /* Number of bytes contained in the TCP message. */\r
+uint8_t *pucRecvData;\r
+uint32_t ulSequenceNumber = FreeRTOS_ntohl (pxTCPHeader->ulSequenceNumber);\r
+\r
+ /* uxOptionsLength: the size of the options to be sent (always a multiple of\r
+ 4 bytes)\r
+ 1. in the SYN phase, we shall communicate the MSS\r
+ 2. in case of a SACK, Selective ACK, ack a segment which comes in\r
+ out-of-order. */\r
+UBaseType_t uxOptionsLength = 0u;\r
+uint8_t ucTCPFlags = pxTCPHeader->ucTCPFlags;\r
+TCPWindow_t *pxTCPWindow = &( pxSocket->u.xTCP.xTCPWindow );\r
+\r
+ /* First get the length and the position of the received data, if any.\r
+ pucRecvData will point to the first byte of the TCP payload. */\r
+ ulReceiveLength = ( uint32_t ) prvCheckRxData( *ppxNetworkBuffer, &pucRecvData );\r
+\r
+ if( pxSocket->u.xTCP.ucTCPState >= eESTABLISHED )\r
+ {\r
+ if ( pxTCPWindow->rx.ulCurrentSequenceNumber == ulSequenceNumber + 1u )\r
+ {\r
+ /* This is most probably a keep-alive message from peer. Setting\r
+ 'bWinChange' doesn't cause a window-size-change, the flag is used\r
+ here to force sending an immediate ACK. */\r
+ pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;\r
+ }\r
+ }\r
+\r
+ /* Keep track of the highest sequence number that might be expected within\r
+ this connection. */\r
+ if( ( ( int32_t ) ( ulSequenceNumber + ulReceiveLength - pxTCPWindow->rx.ulHighestSequenceNumber ) ) > 0 )\r
+ {\r
+ pxTCPWindow->rx.ulHighestSequenceNumber = ulSequenceNumber + ulReceiveLength;\r
+ }\r
+\r
+ /* Storing data may result in a fatal error if malloc() fails. */\r
+ if( prvStoreRxData( pxSocket, pucRecvData, *ppxNetworkBuffer, ulReceiveLength ) < 0 )\r
+ {\r
+ xSendLength = -1;\r
+ }\r
+ else\r
+ {\r
+ uxOptionsLength = prvSetOptions( pxSocket, *ppxNetworkBuffer );\r
+\r
+ if( ( pxSocket->u.xTCP.ucTCPState == eSYN_RECEIVED ) && ( ( ucTCPFlags & ipTCP_FLAG_CTRL ) == ipTCP_FLAG_SYN ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "eSYN_RECEIVED: ACK expected, not SYN: peer missed our SYN+ACK\n" ) );\r
+\r
+ /* In eSYN_RECEIVED a simple ACK is expected, but apparently the\r
+ 'SYN+ACK' didn't arrive. Step back to the previous state in which\r
+ a first incoming SYN is handled. The SYN was counted already so\r
+ decrease it first. */\r
+ vTCPStateChange( pxSocket, eSYN_FIRST );\r
+ }\r
+\r
+ if( ( ( ucTCPFlags & ipTCP_FLAG_FIN ) != 0u ) && ( pxSocket->u.xTCP.bits.bFinRecv == pdFALSE_UNSIGNED ) )\r
+ {\r
+ /* It's the first time a FIN has been received, remember its\r
+ sequence number. */\r
+ pxTCPWindow->rx.ulFINSequenceNumber = ulSequenceNumber + ulReceiveLength;\r
+ pxSocket->u.xTCP.bits.bFinRecv = pdTRUE_UNSIGNED;\r
+\r
+ /* Was peer the first one to send a FIN? */\r
+ if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )\r
+ {\r
+ /* If so, don't send the-last-ACK. */\r
+ pxSocket->u.xTCP.bits.bFinLast = pdTRUE_UNSIGNED;\r
+ }\r
+ }\r
+\r
+ switch (pxSocket->u.xTCP.ucTCPState)\r
+ {\r
+ case eCLOSED: /* (server + client) no connection state at all. */\r
+ /* Nothing to do for a closed socket, except waiting for the\r
+ owner. */\r
+ break;\r
+\r
+ case eTCP_LISTEN: /* (server) waiting for a connection request from\r
+ any remote TCP and port. */\r
+ /* The listen state was handled in xProcessReceivedTCPPacket().\r
+ Should not come here. */\r
+ break;\r
+\r
+ case eSYN_FIRST: /* (server) Just received a SYN request for a server\r
+ socket. */\r
+ {\r
+ /* A new socket has been created, reply with a SYN+ACK.\r
+ Acknowledge with seq+1 because the SYN is seen as pseudo data\r
+ with len = 1. */\r
+ uxOptionsLength = prvSetSynAckOptions( pxSocket, pxTCPPacket );\r
+ pxTCPHeader->ucTCPFlags = ipTCP_FLAG_SYN | ipTCP_FLAG_ACK;\r
+\r
+ xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + uxOptionsLength );\r
+\r
+ /* Set the TCP offset field: ipSIZE_OF_TCP_HEADER equals 20 and\r
+ uxOptionsLength is a multiple of 4. The complete expression is:\r
+ ucTCPOffset = ( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) / 4 ) << 4 */\r
+ pxTCPHeader->ucTCPOffset = ( uint8_t )( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );\r
+ vTCPStateChange( pxSocket, eSYN_RECEIVED );\r
+\r
+ pxTCPWindow->rx.ulCurrentSequenceNumber = pxTCPWindow->rx.ulHighestSequenceNumber = ulSequenceNumber + 1u;\r
+ pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->ulNextTxSequenceNumber = pxTCPWindow->tx.ulFirstSequenceNumber + 1u; /* because we send a TCP_SYN. */\r
+ }\r
+ break;\r
+\r
+ case eCONNECT_SYN: /* (client) also called SYN_SENT: we've just send a\r
+ SYN, expect a SYN+ACK and send a ACK now. */\r
+ /* Fall through */\r
+ case eSYN_RECEIVED: /* (server) we've had a SYN, replied with SYN+SCK\r
+ expect a ACK and do nothing. */\r
+ xSendLength = prvHandleSynReceived( pxSocket, ppxNetworkBuffer, ulReceiveLength, uxOptionsLength );\r
+ break;\r
+\r
+ case eESTABLISHED: /* (server + client) an open connection, data\r
+ received can be delivered to the user. The normal\r
+ state for the data transfer phase of the connection\r
+ The closing states are also handled here with the\r
+ use of some flags. */\r
+ xSendLength = prvHandleEstablished( pxSocket, ppxNetworkBuffer, ulReceiveLength, uxOptionsLength );\r
+ break;\r
+\r
+ case eLAST_ACK: /* (server + client) waiting for an acknowledgement\r
+ of the connection termination request previously\r
+ sent to the remote TCP (which includes an\r
+ acknowledgement of its connection termination\r
+ request). */\r
+ /* Fall through */\r
+ case eFIN_WAIT_1: /* (server + client) waiting for a connection termination request from the remote TCP,\r
+ * or an acknowledgement of the connection termination request previously sent. */\r
+ /* Fall through */\r
+ case eFIN_WAIT_2: /* (server + client) waiting for a connection termination request from the remote TCP. */\r
+ xSendLength = prvTCPHandleFin( pxSocket, *ppxNetworkBuffer );\r
+ break;\r
+\r
+ case eCLOSE_WAIT: /* (server + client) waiting for a connection\r
+ termination request from the local user. Nothing to\r
+ do, connection is closed, wait for owner to close\r
+ this socket. */\r
+ break;\r
+\r
+ case eCLOSING: /* (server + client) waiting for a connection\r
+ termination request acknowledgement from the remote\r
+ TCP. */\r
+ break;\r
+\r
+ case eTIME_WAIT: /* (either server or client) waiting for enough time\r
+ to pass to be sure the remote TCP received the\r
+ acknowledgement of its connection termination\r
+ request. [According to RFC 793 a connection can stay\r
+ in TIME-WAIT for a maximum of four minutes known as\r
+ a MSL (maximum segment lifetime).] These states are\r
+ implemented implicitly by settings flags like\r
+ 'bFinSent', 'bFinRecv', and 'bFinAcked'. */\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+ }\r
+\r
+ if( xSendLength > 0 )\r
+ {\r
+ xSendLength = prvSendData( pxSocket, ppxNetworkBuffer, ulReceiveLength, xSendLength );\r
+ }\r
+\r
+ return xSendLength;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static BaseType_t prvTCPSendReset( NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+ #if( ipconfigIGNORE_UNKNOWN_PACKETS == 0 )\r
+ {\r
+ TCPPacket_t *pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+ const BaseType_t xSendLength = ( BaseType_t ) ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_TCP_HEADER + 0u ); /* Plus 0 options. */\r
+\r
+ pxTCPPacket->xTCPHeader.ucTCPFlags = ipTCP_FLAG_ACK | ipTCP_FLAG_RST;\r
+ pxTCPPacket->xTCPHeader.ucTCPOffset = ( ipSIZE_OF_TCP_HEADER + 0u ) << 2;\r
+\r
+ prvTCPReturnPacket( NULL, pxNetworkBuffer, ( uint32_t ) xSendLength, pdFALSE );\r
+ }\r
+ #endif /* !ipconfigIGNORE_UNKNOWN_PACKETS */\r
+\r
+ /* Remove compiler warnings if ipconfigIGNORE_UNKNOWN_PACKETS == 1. */\r
+ ( void ) pxNetworkBuffer;\r
+\r
+ /* The packet was not consumed. */\r
+ return pdFAIL;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSocketSetMSS( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+uint32_t ulMSS = ipconfigTCP_MSS;\r
+\r
+ if( ( ( FreeRTOS_ntohl( pxSocket->u.xTCP.ulRemoteIP ) ^ *ipLOCAL_IP_ADDRESS_POINTER ) & xNetworkAddressing.ulNetMask ) != 0ul )\r
+ {\r
+ /* Data for this peer will pass through a router, and maybe through\r
+ the internet. Limit the MSS to 1400 bytes or less. */\r
+ ulMSS = FreeRTOS_min_uint32( ( uint32_t ) REDUCED_MSS_THROUGH_INTERNET, ulMSS );\r
+ }\r
+\r
+ FreeRTOS_debug_printf( ( "prvSocketSetMSS: %lu bytes for %lxip:%u\n", ulMSS, pxSocket->u.xTCP.ulRemoteIP, pxSocket->u.xTCP.usRemotePort ) );\r
+\r
+ pxSocket->u.xTCP.usInitMSS = pxSocket->u.xTCP.usCurMSS = ( uint16_t ) ulMSS;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * FreeRTOS_TCP_IP has only 2 public functions, this is the second one:\r
+ * xProcessReceivedTCPPacket()\r
+ * prvTCPHandleState()\r
+ * prvTCPPrepareSend()\r
+ * prvTCPReturnPacket()\r
+ * xNetworkInterfaceOutput() // Sends data to the NIC\r
+ * prvTCPSendRepeated()\r
+ * prvTCPReturnPacket() // Prepare for returning\r
+ * xNetworkInterfaceOutput() // Sends data to the NIC\r
+*/\r
+BaseType_t xProcessReceivedTCPPacket( NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+FreeRTOS_Socket_t *pxSocket;\r
+TCPPacket_t * pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+uint16_t ucTCPFlags = pxTCPPacket->xTCPHeader.ucTCPFlags;\r
+uint32_t ulLocalIP = FreeRTOS_htonl( pxTCPPacket->xIPHeader.ulDestinationIPAddress );\r
+uint16_t xLocalPort = FreeRTOS_htons( pxTCPPacket->xTCPHeader.usDestinationPort );\r
+uint32_t ulRemoteIP = FreeRTOS_htonl( pxTCPPacket->xIPHeader.ulSourceIPAddress );\r
+uint16_t xRemotePort = FreeRTOS_htons( pxTCPPacket->xTCPHeader.usSourcePort );\r
+BaseType_t xResult = pdPASS;\r
+\r
+ /* Find the destination socket, and if not found: return a socket listing to\r
+ the destination PORT. */\r
+ pxSocket = ( FreeRTOS_Socket_t * ) pxTCPSocketLookup( ulLocalIP, xLocalPort, ulRemoteIP, xRemotePort );\r
+\r
+ if( ( pxSocket == NULL ) || ( prvTCPSocketIsActive( ( UBaseType_t ) pxSocket->u.xTCP.ucTCPState ) == pdFALSE ) )\r
+ {\r
+ /* A TCP messages is received but either there is no socket with the\r
+ given port number or the there is a socket, but it is in one of these\r
+ non-active states: eCLOSED, eCLOSE_WAIT, eFIN_WAIT_2, eCLOSING, or\r
+ eTIME_WAIT. */\r
+\r
+ FreeRTOS_debug_printf( ( "TCP: No active socket on port %d (%lxip:%d)\n", xLocalPort, ulRemoteIP, xRemotePort ) );\r
+\r
+ /* Send a RST to all packets that can not be handled. As a result\r
+ the other party will get a ECONN error. There are two exceptions:\r
+ 1) A packet that already has the RST flag set.\r
+ 2) A packet that only has the ACK flag set.\r
+ A packet with only the ACK flag set might be the last ACK in\r
+ a three-way hand-shake that closes a connection. */\r
+ if( ( ( ucTCPFlags & ipTCP_FLAG_CTRL ) != ipTCP_FLAG_ACK ) &&\r
+ ( ( ucTCPFlags & ipTCP_FLAG_RST ) == 0u ) )\r
+ {\r
+ prvTCPSendReset( pxNetworkBuffer );\r
+ }\r
+\r
+ /* The packet can't be handled. */\r
+ xResult = pdFAIL;\r
+ }\r
+ else\r
+ {\r
+ pxSocket->u.xTCP.ucRepCount = 0u;\r
+\r
+ if( pxSocket->u.xTCP.ucTCPState == eTCP_LISTEN )\r
+ {\r
+ /* The matching socket is in a listening state. Test if the peer\r
+ has set the SYN flag. */\r
+ if( ( ucTCPFlags & ipTCP_FLAG_CTRL ) != ipTCP_FLAG_SYN )\r
+ {\r
+ /* What happens: maybe after a reboot, a client doesn't know the\r
+ connection had gone. Send a RST in order to get a new connect\r
+ request. */\r
+ #if( ipconfigHAS_DEBUG_PRINTF == 1 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: Server can't handle flags: %s from %lxip:%u to port %u\n",\r
+ prvTCPFlagMeaning( ( UBaseType_t ) ucTCPFlags ), ulRemoteIP, xRemotePort, xLocalPort ) );\r
+ }\r
+ #endif /* ipconfigHAS_DEBUG_PRINTF */\r
+\r
+ if( ( ucTCPFlags & ipTCP_FLAG_RST ) == 0u )\r
+ {\r
+ prvTCPSendReset( pxNetworkBuffer );\r
+ }\r
+ xResult = pdFAIL;\r
+ }\r
+ else\r
+ {\r
+ /* prvHandleListen() will either return a newly created socket\r
+ (if bReuseSocket is false), otherwise it returns the current\r
+ socket which will later get connected. */\r
+ pxSocket = prvHandleListen( pxSocket, pxNetworkBuffer );\r
+\r
+ if( pxSocket == NULL )\r
+ {\r
+ xResult = pdFAIL;\r
+ }\r
+ }\r
+ } /* if( pxSocket->u.xTCP.ucTCPState == eTCP_LISTEN ). */\r
+ else\r
+ {\r
+ /* This is not a socket in listening mode. Check for the RST\r
+ flag. */\r
+ if( ( ucTCPFlags & ipTCP_FLAG_RST ) != 0u )\r
+ {\r
+ /* The target socket is not in a listening state, any RST packet\r
+ will cause the socket to be closed. */\r
+ FreeRTOS_debug_printf( ( "TCP: RST received from %lxip:%u for %u\n", ulRemoteIP, xRemotePort, xLocalPort ) );\r
+ /* _HT_: should indicate that 'ECONNRESET' must be returned to the used during next API. */\r
+ vTCPStateChange( pxSocket, eCLOSED );\r
+\r
+ /* The packet cannot be handled. */\r
+ xResult = pdFAIL;\r
+ }\r
+ else if( ( ( ucTCPFlags & ipTCP_FLAG_CTRL ) == ipTCP_FLAG_SYN ) && ( pxSocket->u.xTCP.ucTCPState >= eESTABLISHED ) )\r
+ {\r
+ /* SYN flag while this socket is already connected. */\r
+ FreeRTOS_debug_printf( ( "TCP: SYN unexpected from %lxip:%u\n", ulRemoteIP, xRemotePort ) );\r
+\r
+ /* The packet cannot be handled. */\r
+ xResult = pdFAIL;\r
+ }\r
+ else\r
+ {\r
+ /* Update the copy of the TCP header only (skipping eth and IP\r
+ headers). It might be used later on, whenever data must be sent\r
+ to the peer. */\r
+ const BaseType_t lOffset = ( BaseType_t ) ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER );\r
+ memcpy( pxSocket->u.xTCP.xPacket.u.ucLastPacket + lOffset, pxNetworkBuffer->pucEthernetBuffer + lOffset, ipSIZE_OF_TCP_HEADER );\r
+ }\r
+ }\r
+ }\r
+\r
+ if( xResult != pdFAIL )\r
+ {\r
+ /* Touch the alive timers because we received a message for this\r
+ socket. */\r
+ prvTCPTouchSocket( pxSocket );\r
+\r
+ /* Parse the TCP option(s), if present. */\r
+ /* _HT_ : if we're in the SYN phase, and peer does not send a MSS option,\r
+ then we MUST assume an MSS size of 536 bytes for backward compatibility. */\r
+\r
+ /* When there are no TCP options, the TCP offset equals 20 bytes, which is stored as\r
+ the number 5 (words) in the higher niblle of the TCP-offset byte. */\r
+ if( ( pxTCPPacket->xTCPHeader.ucTCPOffset & TCP_OFFSET_LENGTH_BITS ) > TCP_OFFSET_STANDARD_LENGTH )\r
+ {\r
+ prvCheckOptions( pxSocket, pxNetworkBuffer );\r
+ }\r
+\r
+\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ pxSocket->u.xTCP.ulWindowSize = FreeRTOS_ntohs( pxTCPPacket->xTCPHeader.usWindow );\r
+ pxSocket->u.xTCP.ulWindowSize =\r
+ ( pxSocket->u.xTCP.ulWindowSize << pxSocket->u.xTCP.ucPeerWinScaleFactor );\r
+ }\r
+ #endif\r
+\r
+ /* In prvTCPHandleState() the incoming messages will be handled\r
+ depending on the current state of the connection. */\r
+ if( prvTCPHandleState( pxSocket, &pxNetworkBuffer ) > 0 )\r
+ {\r
+ /* prvTCPHandleState() has sent a message, see if there are more to\r
+ be transmitted. */\r
+ #if( ipconfigUSE_TCP_WIN == 1 )\r
+ {\r
+ prvTCPSendRepeated( pxSocket, &pxNetworkBuffer );\r
+ }\r
+ #endif /* ipconfigUSE_TCP_WIN */\r
+ }\r
+\r
+ if( pxNetworkBuffer != NULL )\r
+ {\r
+ /* We must check if the buffer is unequal to NULL, because the\r
+ socket might keep a reference to it in case a delayed ACK must be\r
+ sent. */\r
+ vReleaseNetworkBufferAndDescriptor( pxNetworkBuffer );\r
+ pxNetworkBuffer = NULL;\r
+ }\r
+\r
+ /* And finally, calculate when this socket wants to be woken up. */\r
+ prvTCPNextTimeout ( pxSocket );\r
+ /* Return pdPASS to tell that the network buffer is 'consumed'. */\r
+ xResult = pdPASS;\r
+ }\r
+\r
+ /* pdPASS being returned means the buffer has been consumed. */\r
+ return xResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static FreeRTOS_Socket_t *prvHandleListen( FreeRTOS_Socket_t *pxSocket, NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+{\r
+TCPPacket_t * pxTCPPacket = ( TCPPacket_t * ) ( pxNetworkBuffer->pucEthernetBuffer );\r
+FreeRTOS_Socket_t *pxReturn;\r
+\r
+ /* A pure SYN (without ACK) has come in, create a new socket to answer\r
+ it. */\r
+ if( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED )\r
+ {\r
+ /* The flag bReuseSocket indicates that the same instance of the\r
+ listening socket should be used for the connection. */\r
+ pxReturn = pxSocket;\r
+ pxSocket->u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;\r
+ pxSocket->u.xTCP.pxPeerSocket = pxSocket;\r
+ }\r
+ else\r
+ {\r
+ /* The socket does not have the bReuseSocket flag set meaning create a\r
+ new socket when a connection comes in. */\r
+ pxReturn = NULL;\r
+\r
+ if( pxSocket->u.xTCP.usChildCount >= pxSocket->u.xTCP.usBacklog )\r
+ {\r
+ FreeRTOS_printf( ( "Check: Socket %u already has %u / %u child%s\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usChildCount,\r
+ pxSocket->u.xTCP.usBacklog,\r
+ pxSocket->u.xTCP.usChildCount == 1 ? "" : "ren" ) );\r
+ prvTCPSendReset( pxNetworkBuffer );\r
+ }\r
+ else\r
+ {\r
+ FreeRTOS_Socket_t *pxNewSocket = (FreeRTOS_Socket_t *)\r
+ FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );\r
+\r
+ if( ( pxNewSocket == NULL ) || ( pxNewSocket == FREERTOS_INVALID_SOCKET ) )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: Listen: new socket failed\n" ) );\r
+ prvTCPSendReset( pxNetworkBuffer );\r
+ }\r
+ else if( prvTCPSocketCopy( pxNewSocket, pxSocket ) != pdFALSE )\r
+ {\r
+ /* The socket will be connected immediately, no time for the\r
+ owner to setsockopt's, therefore copy properties of the server\r
+ socket to the new socket. Only the binding might fail (due to\r
+ lack of resources). */\r
+ pxReturn = pxNewSocket;\r
+ }\r
+ }\r
+ }\r
+\r
+ if( pxReturn != NULL )\r
+ {\r
+ pxReturn->u.xTCP.usRemotePort = FreeRTOS_htons( pxTCPPacket->xTCPHeader.usSourcePort );\r
+ pxReturn->u.xTCP.ulRemoteIP = FreeRTOS_htonl( pxTCPPacket->xIPHeader.ulSourceIPAddress );\r
+ pxReturn->u.xTCP.xTCPWindow.ulOurSequenceNumber = ulNextInitialSequenceNumber;\r
+\r
+ /* Here is the SYN action. */\r
+ pxReturn->u.xTCP.xTCPWindow.rx.ulCurrentSequenceNumber = FreeRTOS_ntohl( pxTCPPacket->xTCPHeader.ulSequenceNumber );\r
+ prvSocketSetMSS( pxReturn );\r
+\r
+ prvTCPCreateWindow( pxReturn );\r
+\r
+ /* It is recommended to increase the ISS for each new connection with a value of 0x102. */\r
+ ulNextInitialSequenceNumber += INITIAL_SEQUENCE_NUMBER_INCREMENT;\r
+\r
+ vTCPStateChange( pxReturn, eSYN_FIRST );\r
+\r
+ /* Make a copy of the header up to the TCP header. It is needed later\r
+ on, whenever data must be sent to the peer. */\r
+ memcpy( pxReturn->u.xTCP.xPacket.u.ucLastPacket, pxNetworkBuffer->pucEthernetBuffer, sizeof( pxReturn->u.xTCP.xPacket.u.ucLastPacket ) );\r
+ }\r
+ return pxReturn;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Duplicates a socket after a listening socket receives a connection.\r
+ */\r
+static BaseType_t prvTCPSocketCopy( FreeRTOS_Socket_t *pxNewSocket, FreeRTOS_Socket_t *pxSocket )\r
+{\r
+struct freertos_sockaddr xAddress;\r
+\r
+ pxNewSocket->xReceiveBlockTime = pxSocket->xReceiveBlockTime;\r
+ pxNewSocket->xSendBlockTime = pxSocket->xSendBlockTime;\r
+ pxNewSocket->ucSocketOptions = pxSocket->ucSocketOptions;\r
+ pxNewSocket->u.xTCP.uxRxStreamSize = pxSocket->u.xTCP.uxRxStreamSize;\r
+ pxNewSocket->u.xTCP.uxTxStreamSize = pxSocket->u.xTCP.uxTxStreamSize;\r
+ pxNewSocket->u.xTCP.uxLittleSpace = pxSocket->u.xTCP.uxLittleSpace;\r
+ pxNewSocket->u.xTCP.uxEnoughSpace = pxSocket->u.xTCP.uxEnoughSpace;\r
+ pxNewSocket->u.xTCP.uxRxWinSize = pxSocket->u.xTCP.uxRxWinSize;\r
+ pxNewSocket->u.xTCP.uxTxWinSize = pxSocket->u.xTCP.uxTxWinSize;\r
+\r
+ #if( ipconfigSOCKET_HAS_USER_SEMAPHORE == 1 )\r
+ {\r
+ pxNewSocket->pxUserSemaphore = pxSocket->pxUserSemaphore;\r
+ }\r
+ #endif /* ipconfigSOCKET_HAS_USER_SEMAPHORE */\r
+\r
+ #if( ipconfigUSE_CALLBACKS == 1 )\r
+ {\r
+ /* In case call-backs are used, copy them from parent to child. */\r
+ pxNewSocket->u.xTCP.pxHandleConnected = pxSocket->u.xTCP.pxHandleConnected;\r
+ pxNewSocket->u.xTCP.pxHandleReceive = pxSocket->u.xTCP.pxHandleReceive;\r
+ pxNewSocket->u.xTCP.pxHandleSent = pxSocket->u.xTCP.pxHandleSent;\r
+ }\r
+ #endif /* ipconfigUSE_CALLBACKS */\r
+\r
+ #if( ipconfigSUPPORT_SELECT_FUNCTION == 1 )\r
+ {\r
+ /* Child socket of listening sockets will inherit the Socket Set\r
+ Otherwise the owner has no chance of including it into the set. */\r
+ if( pxSocket->pxSocketSet )\r
+ {\r
+ pxNewSocket->pxSocketSet = pxSocket->pxSocketSet;\r
+ pxNewSocket->xSelectBits = pxSocket->xSelectBits | eSELECT_READ | eSELECT_EXCEPT;\r
+ }\r
+ }\r
+ #endif /* ipconfigSUPPORT_SELECT_FUNCTION */\r
+\r
+ /* And bind it to the same local port as its parent. */\r
+ xAddress.sin_addr = *ipLOCAL_IP_ADDRESS_POINTER;\r
+ xAddress.sin_port = FreeRTOS_htons( pxSocket->usLocalPort );\r
+\r
+ #if( ipconfigTCP_HANG_PROTECTION == 1 )\r
+ {\r
+ /* Only when there is anti-hanging protection, a socket may become an\r
+ orphan temporarily. Once this socket is really connected, the owner of\r
+ the server socket will be notified. */\r
+\r
+ /* When bPassQueued is true, the socket is an orphan until it gets\r
+ connected. */\r
+ pxNewSocket->u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;\r
+ pxNewSocket->u.xTCP.pxPeerSocket = pxSocket;\r
+ }\r
+ #else\r
+ {\r
+ /* A reference to the new socket may be stored and the socket is marked\r
+ as 'passable'. */\r
+\r
+ /* When bPassAccept is true, this socket may be returned in a call to\r
+ accept(). */\r
+ pxNewSocket->u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;\r
+ if(pxSocket->u.xTCP.pxPeerSocket == NULL )\r
+ {\r
+ pxSocket->u.xTCP.pxPeerSocket = pxNewSocket;\r
+ }\r
+ }\r
+ #endif\r
+\r
+ pxSocket->u.xTCP.usChildCount++;\r
+\r
+ FreeRTOS_debug_printf( ( "Gain: Socket %u now has %u / %u child%s\n",\r
+ pxSocket->usLocalPort,\r
+ pxSocket->u.xTCP.usChildCount,\r
+ pxSocket->u.xTCP.usBacklog,\r
+ pxSocket->u.xTCP.usChildCount == 1u ? "" : "ren" ) );\r
+\r
+ /* Now bind the child socket to the same port as the listening socket. */\r
+ if( vSocketBind ( pxNewSocket, &xAddress, sizeof( xAddress ), pdTRUE ) != 0 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "TCP: Listen: new socket bind error\n" ) );\r
+ vSocketClose( pxNewSocket );\r
+ return pdFALSE;\r
+ }\r
+\r
+ return pdTRUE;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( ( ipconfigHAS_DEBUG_PRINTF != 0 ) || ( ipconfigHAS_PRINTF != 0 ) )\r
+\r
+ const char *FreeRTOS_GetTCPStateName( UBaseType_t ulState )\r
+ {\r
+ if( ulState >= ( UBaseType_t ) ARRAY_SIZE( pcStateNames ) )\r
+ {\r
+ ulState = ( UBaseType_t ) ARRAY_SIZE( pcStateNames ) - 1u;\r
+ }\r
+ return pcStateNames[ ulState ];\r
+ }\r
+\r
+#endif /* ( ( ipconfigHAS_DEBUG_PRINTF != 0 ) || ( ipconfigHAS_PRINTF != 0 ) ) */\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * In the API accept(), the user asks is there is a new client? As API's can\r
+ * not walk through the xBoundTCPSocketsList the IP-task will do this.\r
+ */\r
+BaseType_t xTCPCheckNewClient( FreeRTOS_Socket_t *pxSocket )\r
+{\r
+TickType_t xLocalPort = FreeRTOS_htons( pxSocket->usLocalPort );\r
+ListItem_t *pxIterator;\r
+FreeRTOS_Socket_t *pxFound;\r
+BaseType_t xResult = pdFALSE;\r
+\r
+ /* Here xBoundTCPSocketsList can be accessed safely IP-task is the only one\r
+ who has access. */\r
+ for( pxIterator = ( ListItem_t * ) listGET_HEAD_ENTRY( &xBoundTCPSocketsList );\r
+ pxIterator != ( ListItem_t * ) listGET_END_MARKER( &xBoundTCPSocketsList );\r
+ pxIterator = ( ListItem_t * ) listGET_NEXT( pxIterator ) )\r
+ {\r
+ if( listGET_LIST_ITEM_VALUE( pxIterator ) == xLocalPort )\r
+ {\r
+ pxFound = ( FreeRTOS_Socket_t * ) listGET_LIST_ITEM_OWNER( pxIterator );\r
+ if( ( pxFound->ucProtocol == FREERTOS_IPPROTO_TCP ) && ( pxFound->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )\r
+ {\r
+ pxSocket->u.xTCP.pxPeerSocket = pxFound;\r
+ FreeRTOS_debug_printf( ( "xTCPCheckNewClient[0]: client on port %u\n", pxSocket->usLocalPort ) );\r
+ xResult = pdTRUE;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ return xResult;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+#endif /* ipconfigUSE_TCP == 1 */\r
+\r
projects / freertos / blobdiff