| /* | |
| * FreeRTOS+TCP Labs Build 160919 (C) 2016 Real Time Engineers ltd. | |
| * Authors include Hein Tibosch and Richard Barry | |
| * | |
| ******************************************************************************* | |
| ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE *** | |
| *** *** | |
| *** *** | |
| *** FREERTOS+TCP IS STILL IN THE LAB (mainly because the FTP and HTTP *** | |
| *** demos have a dependency on FreeRTOS+FAT, which is only in the Labs *** | |
| *** download): *** | |
| *** *** | |
| *** FreeRTOS+TCP is functional and has been used in commercial products *** | |
| *** for some time. Be aware however that we are still refining its *** | |
| *** design, the source code does not yet quite conform to the strict *** | |
| *** coding and style standards mandated by Real Time Engineers ltd., and *** | |
| *** the documentation and testing is not necessarily complete. *** | |
| *** *** | |
| *** PLEASE REPORT EXPERIENCES USING THE SUPPORT RESOURCES FOUND ON THE *** | |
| *** URL: http://www.FreeRTOS.org/contact Active early adopters may, at *** | |
| *** the sole discretion of Real Time Engineers Ltd., be offered versions *** | |
| *** under a license other than that described below. *** | |
| *** *** | |
| *** *** | |
| ***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE *** | |
| ******************************************************************************* | |
| * | |
| * FreeRTOS+TCP can be used under two different free open source licenses. The | |
| * license that applies is dependent on the processor on which FreeRTOS+TCP is | |
| * executed, as follows: | |
| * | |
| * If FreeRTOS+TCP is executed on one of the processors listed under the Special | |
| * License Arrangements heading of the FreeRTOS+TCP license information web | |
| * page, then it can be used under the terms of the FreeRTOS Open Source | |
| * License. If FreeRTOS+TCP is used on any other processor, then it can be used | |
| * under the terms of the GNU General Public License V2. Links to the relevant | |
| * licenses follow: | |
| * | |
| * The FreeRTOS+TCP License Information Page: http://www.FreeRTOS.org/tcp_license | |
| * The FreeRTOS Open Source License: http://www.FreeRTOS.org/license | |
| * The GNU General Public License Version 2: http://www.FreeRTOS.org/gpl-2.0.txt | |
| * | |
| * FreeRTOS+TCP is distributed in the hope that it will be useful. You cannot | |
| * use FreeRTOS+TCP unless you agree that you use the software 'as is'. | |
| * FreeRTOS+TCP is provided WITHOUT ANY WARRANTY; without even the implied | |
| * warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR | |
| * PURPOSE. Real Time Engineers Ltd. disclaims all conditions and terms, be they | |
| * implied, expressed, or statutory. | |
| * | |
| * 1 tab == 4 spaces! | |
| * | |
| * http://www.FreeRTOS.org | |
| * http://www.FreeRTOS.org/plus | |
| * http://www.FreeRTOS.org/labs | |
| * | |
| */ | |
| /* | |
| * FreeRTOS_TCP_WIN.c | |
| * Module which handles the TCP windowing schemes for FreeRTOS-PLUS-TCP | |
| */ | |
| #ifndef FREERTOS_TCP_WIN_H | |
| #define FREERTOS_TCP_WIN_H | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| extern BaseType_t xTCPWindowLoggingLevel; | |
| typedef struct xTCPTimer | |
| { | |
| uint32_t ulBorn; | |
| } TCPTimer_t; | |
| typedef struct xTCP_SEGMENT | |
| { | |
| uint32_t ulSequenceNumber; /* The sequence number of the first byte in this packet */ | |
| int32_t lMaxLength; /* Maximum space, number of bytes which can be stored in this segment */ | |
| int32_t lDataLength; /* Actual number of bytes */ | |
| int32_t lStreamPos; /* reference to the [t|r]xStream of the socket */ | |
| TCPTimer_t xTransmitTimer; /* saves a timestamp at the moment this segment gets transmitted (TX only) */ | |
| union | |
| { | |
| struct | |
| { | |
| uint32_t | |
| ucTransmitCount : 8,/* Number of times the segment has been transmitted, used to calculate the RTT */ | |
| ucDupAckCount : 8, /* Counts the number of times that a higher segment was ACK'd. After 3 times a Fast Retransmission takes place */ | |
| bOutstanding : 1, /* It the peer's turn, we're just waiting for an ACK */ | |
| bAcked : 1, /* This segment has been acknowledged */ | |
| bIsForRx : 1; /* pdTRUE if segment is used for reception */ | |
| } bits; | |
| uint32_t ulFlags; | |
| } u; | |
| #if( ipconfigUSE_TCP_WIN != 0 ) | |
| struct xLIST_ITEM xQueueItem; /* TX only: segments can be linked in one of three queues: xPriorityQueue, xTxQueue, and xWaitQueue */ | |
| struct xLIST_ITEM xListItem; /* With this item the segment can be connected to a list, depending on who is owning it */ | |
| #endif | |
| } TCPSegment_t; | |
| typedef struct xTCP_WINSIZE | |
| { | |
| uint32_t ulRxWindowLength; | |
| uint32_t ulTxWindowLength; | |
| } TCPWinSize_t; | |
| /* | |
| * If TCP time-stamps are being used, they will occupy 12 bytes in | |
| * each packet, and thus the message space will become smaller | |
| */ | |
| /* Keep this as a multiple of 4 */ | |
| #if( ipconfigUSE_TCP_WIN == 1 ) | |
| #if( ipconfigUSE_TCP_TIMESTAMPS == 1 ) | |
| #define ipSIZE_TCP_OPTIONS ( 16u + 12u ) | |
| #else | |
| #define ipSIZE_TCP_OPTIONS 16u | |
| #endif | |
| #else | |
| #if ipconfigUSE_TCP_TIMESTAMPS == 1 | |
| #define ipSIZE_TCP_OPTIONS ( 12u + 12u ) | |
| #else | |
| #define ipSIZE_TCP_OPTIONS 12u | |
| #endif | |
| #endif | |
| /* | |
| * Every TCP connection owns a TCP window for the administration of all packets | |
| * It owns two sets of segment descriptors, incoming and outgoing | |
| */ | |
| typedef struct xTCP_WINDOW | |
| { | |
| union | |
| { | |
| struct | |
| { | |
| uint32_t | |
| bHasInit : 1, /* The window structure has been initialised */ | |
| bSendFullSize : 1, /* May only send packets with a size equal to MSS (for optimisation) */ | |
| bTimeStamps : 1; /* Socket is supposed to use TCP time-stamps. This depends on the */ | |
| } bits; /* party which opens the connection */ | |
| uint32_t ulFlags; | |
| } u; | |
| TCPWinSize_t xSize; | |
| struct | |
| { | |
| uint32_t ulFirstSequenceNumber; /* Logging & debug: the first segment received/sent in this connection | |
| * for Tx: initial send sequence number (ISS) | |
| * for Rx: initial receive sequence number (IRS) */ | |
| uint32_t ulCurrentSequenceNumber;/* Tx/Rx: the oldest sequence number not yet confirmed, also SND.UNA / RCV.NXT | |
| * In other words: the sequence number of the left side of the sliding window */ | |
| uint32_t ulFINSequenceNumber; /* The sequence number which carried the FIN flag */ | |
| uint32_t ulHighestSequenceNumber;/* Sequence number of the right-most byte + 1 */ | |
| #if( ipconfigUSE_TCP_TIMESTAMPS == 1 ) | |
| uint32_t ulTimeStamp; /* The value of the TCP timestamp, transmitted or received */ | |
| #endif | |
| } rx, tx; | |
| uint32_t ulOurSequenceNumber; /* The SEQ number we're sending out */ | |
| uint32_t ulUserDataLength; /* Number of bytes in Rx buffer which may be passed to the user, after having received a 'missing packet' */ | |
| uint32_t ulNextTxSequenceNumber; /* The sequence number given to the next byte to be added for transmission */ | |
| int32_t lSRTT; /* Smoothed Round Trip Time, it may increment quickly and it decrements slower */ | |
| uint8_t ucOptionLength; /* Number of valid bytes in ulOptionsData[] */ | |
| #if( ipconfigUSE_TCP_WIN == 1 ) | |
| List_t xPriorityQueue; /* Priority queue: segments which must be sent immediately */ | |
| List_t xTxQueue; /* Transmit queue: segments queued for transmission */ | |
| List_t xWaitQueue; /* Waiting queue: outstanding segments */ | |
| TCPSegment_t *pxHeadSegment; /* points to a segment which has not been transmitted and it's size is still growing (user data being added) */ | |
| uint32_t ulOptionsData[ipSIZE_TCP_OPTIONS/sizeof(uint32_t)]; /* Contains the options we send out */ | |
| List_t xTxSegments; /* A linked list of all transmission segments, sorted on sequence number */ | |
| List_t xRxSegments; /* A linked list of reception segments, order depends on sequence of arrival */ | |
| #else | |
| /* For tiny TCP, there is only 1 outstanding TX segment */ | |
| TCPSegment_t xTxSegment; /* Priority queue */ | |
| #endif | |
| uint16_t usOurPortNumber; /* Mostly for debugging/logging: our TCP port number */ | |
| uint16_t usPeerPortNumber; /* debugging/logging: the peer's TCP port number */ | |
| uint16_t usMSS; /* Current accepted MSS */ | |
| uint16_t usMSSInit; /* MSS as configured by the socket owner */ | |
| } TCPWindow_t; | |
| /*============================================================================= | |
| * | |
| * Creation and destruction | |
| * | |
| *=============================================================================*/ | |
| /* Create and initialize a window */ | |
| void vTCPWindowCreate( TCPWindow_t *pxWindow, uint32_t ulRxWindowLength, | |
| uint32_t ulTxWindowLength, uint32_t ulAckNumber, uint32_t ulSequenceNumber, uint32_t ulMSS ); | |
| /* Destroy a window (always returns NULL) | |
| * It will free some resources: a collection of segments */ | |
| void vTCPWindowDestroy( TCPWindow_t *pxWindow ); | |
| /* Initialize a window */ | |
| void vTCPWindowInit( TCPWindow_t *pxWindow, uint32_t ulAckNumber, uint32_t ulSequenceNumber, uint32_t ulMSS ); | |
| /*============================================================================= | |
| * | |
| * Rx functions | |
| * | |
| *=============================================================================*/ | |
| /* if true may be passed directly to user (segment expected and window is empty) | |
| * But pxWindow->ackno should always be used to set "BUF->ackno" */ | |
| int32_t lTCPWindowRxCheck( TCPWindow_t *pxWindow, uint32_t ulSequenceNumber, uint32_t ulLength, uint32_t ulSpace ); | |
| /* When lTCPWindowRxCheck returned false, please call store for this unexpected data */ | |
| BaseType_t xTCPWindowRxStore( TCPWindow_t *pxWindow, uint32_t ulSequenceNumber, uint32_t ulLength ); | |
| /* This function will be called as soon as a FIN is received. It will return true | |
| * if there are no 'open' reception segments */ | |
| BaseType_t xTCPWindowRxEmpty( TCPWindow_t *pxWindow ); | |
| /* _HT_ Temporary function for testing/debugging | |
| * Not used at this moment */ | |
| void vTCPWinShowSegments( TCPWindow_t *pxWindow, BaseType_t bForRx ); | |
| /*============================================================================= | |
| * | |
| * Tx functions | |
| * | |
| *=============================================================================*/ | |
| /* Adds data to the Tx-window */ | |
| int32_t lTCPWindowTxAdd( TCPWindow_t *pxWindow, uint32_t ulLength, int32_t lPosition, int32_t lMax ); | |
| /* Check data to be sent and calculate the time period we may sleep */ | |
| BaseType_t xTCPWindowTxHasData( TCPWindow_t *pxWindow, uint32_t ulWindowSize, TickType_t *pulDelay ); | |
| /* See if anything is left to be sent | |
| * Function will be called when a FIN has been received. Only when the TX window is clean, | |
| * it will return pdTRUE */ | |
| BaseType_t xTCPWindowTxDone( TCPWindow_t *pxWindow ); | |
| /* Fetches data to be sent. | |
| * apPos will point to a location with the circular data buffer: txStream */ | |
| uint32_t ulTCPWindowTxGet( TCPWindow_t *pxWindow, uint32_t ulWindowSize, int32_t *plPosition ); | |
| /* Receive a normal ACK */ | |
| uint32_t ulTCPWindowTxAck( TCPWindow_t *pxWindow, uint32_t ulSequenceNumber ); | |
| /* Receive a SACK option */ | |
| uint32_t ulTCPWindowTxSack( TCPWindow_t *pxWindow, uint32_t ulFirst, uint32_t ulLast ); | |
| #ifdef __cplusplus | |
| } /* extern "C" */ | |
| #endif | |
| #endif /* FREERTOS_TCP_WIN_H */ |