Microchip%20TCP_IP%20stack/TCPIP%20Stack/TCP.c

/*********************************************************************
 *
 *      Transmission Control Protocol (TCP) Communications Layer
 *  Module for Microchip TCP/IP Stack
 *       -Provides reliable, handshaked transport of application stream 
 *    oriented data with flow control
 *       -Reference: RFC 793
 *
 *********************************************************************
 * FileName:        TCP.c
 * Dependencies:    string.h
 *                  StackTsk.h
 *                  Helpers.h
 *                  IP.h
 *                  MAC.h
 *                  ARP.h
 *                  Tick.h
 *                  TCP.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date            Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     5/8/01          Original        (Rev 1.0)
 * Howard Schlunder             12/11/06        Changed almost everything to 
 *                                                                      better meet RFC 793.
 ********************************************************************/
#define __TCP_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_TCP)


#define MAX_TCP_DATA_LEN                        (MAC_TX_BUFFER_SIZE - sizeof(TCP_HEADER) - sizeof(IP_HEADER) - sizeof(ETHER_HEADER))

// TCP Timeout and retransmit numbers
#define TCP_START_TIMEOUT_VAL           ((TICK)TICK_SECOND * (TICK)1)
#define TCP_TIME_WAIT_TIMEOUT_VAL   ((TICK)TICK_SECOND * (TICK)0)
#define MAX_RETRY_COUNTS    (5u)

#define TCP_AUTO_TRANSMIT_TIMEOUT_VAL   ((WORD)(TICK_SECOND/25))

// TCP Flags defined in RFC
#define FIN     (0x01)
#define SYN     (0x02)
#define RST     (0x04)
#define PSH     (0x08)
#define ACK     (0x10)
#define URG     (0x20)

// TCP Header
typedef struct _TCP_HEADER
{
        WORD    SourcePort;
        WORD    DestPort;
        DWORD   SeqNumber;
        DWORD   AckNumber;

        struct
        {
                unsigned char Reserved3      : 4;
                unsigned char Val            : 4;
        } DataOffset;

        union
        {
                struct
                {
                        unsigned char flagFIN    : 1;
                        unsigned char flagSYN    : 1;
                        unsigned char flagRST    : 1;
                        unsigned char flagPSH    : 1;
                        unsigned char flagACK    : 1;
                        unsigned char flagURG    : 1;
                        unsigned char Reserved2  : 2;
                } bits;
                BYTE byte;
        } Flags;

        WORD    Window;
        WORD    Checksum;
        WORD    UrgentPointer;
} TCP_HEADER;

// TCP Options as defined by RFC
#define TCP_OPTIONS_END_OF_LIST     (0x00u)
#define TCP_OPTIONS_NO_OP           (0x01u)
#define TCP_OPTIONS_MAX_SEG_SIZE    (0x02u)
typedef struct _TCP_OPTIONS
{
        BYTE        Kind;
        BYTE        Length;
        WORD_VAL    MaxSegSize;
} TCP_OPTIONS;

#define SwapPseudoTCPHeader(h)  (h.TCPLength = swaps(h.TCPLength))

// IP pseudo header as defined by RFC 793
typedef struct _PSEUDO_HEADER
{
        IP_ADDR SourceAddress;
        IP_ADDR DestAddress;
        BYTE Zero;
        BYTE Protocol;
        WORD TCPLength;
} PSEUDO_HEADER;

#define LOCAL_PORT_START_NUMBER (1024u)
#define LOCAL_PORT_END_NUMBER   (5000u)


// Local temp port numbers.
#ifdef STACK_CLIENT_MODE
static WORD NextPort __attribute__((persistent));
#endif

#if defined(HI_TECH_C)
        // The initializer forces this large array out of the bss section 
        // so we can link correctly.
        TCB_STUB TCBStubs[MAX_TCP_SOCKETS] = {'\0'};    
#else
        // The TCB array is very large.  With the C18 compiler, one must 
        // modify the linker script to make an array that spans more than 
        // one memory bank.  To do this, make the necessary changes to your 
        // processor's linker script (.lkr).  Here is an example showing 
        // gpr11 and 128 bytes of gpr12 being combined into one 384 byte 
        // block used exclusively by the TCB_MEM data section:
        // ...
        // //DATABANK   NAME=gpr11      START=0xB00          END=0xBFF
        // //DATABANK   NAME=gpr12      START=0xC00          END=0xCFF
        // DATABANK   NAME=gpr11b     START=0xB00          END=0xC7F           PROTECTED
        // DATABANK   NAME=gpr12      START=0xC80          END=0xCFF
        // ...
        // SECTION    NAME=TCP_TCB_RAM    RAM=gpr11b
        // ...
        #pragma udata TCB_uRAM
        TCB_STUB TCBStubs[MAX_TCP_SOCKETS];
        #pragma udata                                   // Return to any other RAM section
#endif

static TCB MyTCB;
//static TCP_SOCKET hCurrentTCB = 0;


static void HandleTCPSeg(TCP_SOCKET hTCP, TCP_HEADER *h, WORD len);
static void SendTCP(TCP_SOCKET hTCP, BYTE flags);
static TCP_SOCKET FindMatchingSocket(TCP_HEADER *h, NODE_INFO *remote);
static void SwapTCPHeader(TCP_HEADER* header);
static void CloseSocket(TCP_SOCKET hTCP);
static void LoadTCB(TCP_SOCKET hTCP);
static void SaveTCB(TCP_SOCKET hTCP);
static BYTE ProcessRXBytes(TCB_STUB *ps, TCP_HEADER *h, WORD len);


static void LoadTCB(TCP_SOCKET hTCP)
{
        WORD PtrSave;
//      if(hCurrentTCB == hTCP)
//              return;

        // Load up the new TCB
//      hCurrentTCB = hTCP;
        PtrSave = MACSetReadPtr(TCBStubs[hTCP].bufferTxStart - sizeof(MyTCB));
        MACGetArray((BYTE*)&MyTCB, sizeof(MyTCB));
        MACSetReadPtr(PtrSave);
}

static void SaveTCB(TCP_SOCKET hTCP)
{
        WORD PtrSave;

//      hCurrentTCB = hTCP;

        // Save the current TCB
        PtrSave = MACSetWritePtr(TCBStubs[hTCP].bufferTxStart - sizeof(MyTCB));
        MACPutArray((BYTE*)&MyTCB, sizeof(MyTCB));
        MACSetWritePtr(PtrSave);
}


/*********************************************************************
* Function:        void TCPInit(void)
*
* PreCondition:    None
*
* Input:           None
*
* Output:          TCP is initialized.
*
* Side Effects:    None
*
* Overview:        Initialize all socket states
*
* Note:            This function is called only once during lifetime
*                  of the application.
********************************************************************/
void TCPInit(void)
{
        TCP_SOCKET hTCP;
        TCB_STUB *ps;
        
        // Initialize all sockets.
        for(hTCP = 0; hTCP < MAX_TCP_SOCKETS; hTCP++)
        {
                ps = &TCBStubs[hTCP];

                ps->smState                     = TCP_CLOSED;
                ps->bufferTxStart       = BASE_TCB_ADDR + sizeof(TCB) + hTCP*(sizeof(TCB) + (TCP_TX_FIFO_SIZE+1) + (TCP_RX_FIFO_SIZE+1));
                ps->bufferRxStart       = ps->bufferTxStart + TCP_TX_FIFO_SIZE+1;
                ps->bufferEnd           = ps->bufferRxStart + TCP_RX_FIFO_SIZE;
                ps->Flags.bServer       = FALSE;
                ps->Flags.bTimerEnabled = FALSE;
                ps->Flags.bTimer2Enabled = FALSE;
                ps->Flags.bDelayedACKTimerEnabled = FALSE;
                ps->Flags.bOneSegmentReceived = FALSE;
                ps->Flags.bHalfFullFlush = FALSE;
                ps->Flags.bTXASAP = FALSE;
        }

        // Initialize random number generator
        srand((WORD)TickGet());
}


/*********************************************************************
* Function:        TCP_SOCKET TCPListen(WORD port)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           port    - A TCP port to be opened.
*
* Output:          Given port is opened and returned on success
*                  INVALID_SOCKET if no more sockets left.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
TCP_SOCKET TCPListen(WORD port)
{
        TCP_SOCKET hTCP;
        TCB_STUB *ps;

        for(hTCP = 0; hTCP < MAX_TCP_SOCKETS; hTCP++)
        {
                ps = &TCBStubs[hTCP];

                if(ps->smState == TCP_CLOSED)
                {
                        ps->Flags.bServer = TRUE;
                        ps->smState = TCP_LISTEN;
                        ps->remoteHash.Val = port;
                        ps->txTail = ps->bufferTxStart;
                        ps->txHead = ps->bufferTxStart;
                        ps->rxTail = ps->bufferRxStart;
                        ps->rxHead = ps->bufferRxStart;

                        MyTCB.sHoleSize = -1;
                        MyTCB.localPort.Val = port;
                        MyTCB.txUnackedTail = ps->bufferTxStart;
                        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[0] = rand();
                        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[1] = rand();
                        SaveTCB(hTCP);
                        
                        return hTCP;
                }
        }

        return INVALID_SOCKET;
}


/*********************************************************************
* FunctionL             BOOL TCPGetRemoteInfo(TCP_SOCKET hTCP, SOCKET_INFO *RemoteInfo)
*
* PreCondition: TCPInit() is already called.
*
* Input:                hTCP      - Handle of socket to read
*
* Output:               A new socket is created, connection request is
*                               sent and socket handle is returned.
*
* Side Effects: None
*
* Overview:             None
*
* Note:                 None
*
********************************************************************/
SOCKET_INFO* TCPGetRemoteInfo(TCP_SOCKET hTCP)
{
        static SOCKET_INFO      RemoteInfo;

        LoadTCB(hTCP);
        memcpy((void*)&RemoteInfo.remote, (void*)&MyTCB.remote, sizeof(NODE_INFO));
        RemoteInfo.remotePort.Val = MyTCB.remotePort.Val;

        return &RemoteInfo;
}


/*********************************************************************
* Function:        TCP_SOCKET TCPConnect(NODE_INFO* remote,
*                                      WORD remotePort)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           remote      - Remote node address info
*                  remotePort  - remote port to be connected.
*
* Output:          A new socket is created, connection request is
*                  sent and socket handle is returned.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            By default this function is not included in
*                  source.  You must define STACK_CLIENT_MODE to
*                  be able to use this function.
********************************************************************/
#ifdef STACK_CLIENT_MODE
TCP_SOCKET TCPConnect(NODE_INFO *remote, WORD remotePort)
{
        TCP_SOCKET hTCP;
        TCB_STUB *ps;

        // Find an available socket
        for(hTCP = 0; hTCP < MAX_TCP_SOCKETS; hTCP++)
        {
                ps = &TCBStubs[hTCP];

                if(ps->smState != TCP_CLOSED)
                        continue;

                // Zero out the TCB
                memset((BYTE*)&MyTCB, 0x00, sizeof(MyTCB));

                // Each new socket that is opened by this node, gets the 
                // next sequential port number.
                if(NextPort < LOCAL_PORT_START_NUMBER || NextPort > LOCAL_PORT_END_NUMBER)
                        NextPort = LOCAL_PORT_START_NUMBER;
                
                // Set the non-zero TCB fields
                MyTCB.sHoleSize = -1;
                MyTCB.localPort.Val = NextPort++;
                MyTCB.remotePort.Val = remotePort;
                memcpy((void*)&MyTCB.remote, (void*)remote, sizeof(NODE_INFO));
                ((DWORD_VAL*)(&MyTCB.MySEQ))->w[0] = rand();
                ((DWORD_VAL*)(&MyTCB.MySEQ))->w[1] = rand();
                MyTCB.retryCount = 0;
                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;

                // Zero out the buffer contents
                MyTCB.txUnackedTail     = ps->bufferTxStart;
                ps->txHead                      = ps->bufferTxStart;
                ps->txTail                      = ps->bufferTxStart;
                ps->rxHead                      = ps->bufferRxStart;
                ps->rxTail                      = ps->bufferRxStart;
                
                // Update the TCB Stub
                ps->remoteHash.Val = (remote->IPAddr.w[1]+remote->IPAddr.w[0] + remotePort) ^ MyTCB.localPort.Val;
                ps->smState = TCP_SYN_SENT;
                ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                ps->Flags.bTimerEnabled = TRUE;

                // Save the TCB
                SaveTCB(hTCP);

                // Send TCP SYNchronize (connect) request
                SendTCP(hTCP, SYN);

                return hTCP;
        }

        // If there is no socket available, return error.
        return INVALID_SOCKET;
}
#endif


/*********************************************************************
* Function:        BOOL TCPIsConnected(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           hTCP    - Socket to be checked for connection.
*
* Output:          TRUE    if given socket is connected
*                  FALSE   if given socket is not connected.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            A socket is said to be connected only if it is in 
*                                  the TCP_ESTABLISHED state
********************************************************************/
BOOL TCPIsConnected(TCP_SOCKET hTCP)
{
        return TCBStubs[hTCP].smState == TCP_ESTABLISHED;
}


/*********************************************************************
* Function:        void TCPDisconnect(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called
*
* Input:           hTCP - Socket to be disconnected.
*
* Output:          A disconnect request is sent for given socket.  
*                                  This function does nothing if the socket isn't 
*                                  currently connected.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
void TCPDisconnect(TCP_SOCKET hTCP)
{
        TCB_STUB *ps;

        ps = &TCBStubs[hTCP];
        LoadTCB(hTCP);

        switch(ps->smState)
        {
                //case TCP_CLOSED:
                //case TCP_LISTEN:
                //case TCP_LAST_ACK:
                //case TCP_FIN_WAIT_1:
                //case TCP_FIN_WAIT_2:
                //case TCP_CLOSING:
                //case TCP_TIME_WAIT:
                //      return;

                case TCP_SYN_SENT:
                        CloseSocket(hTCP);
                        break;

                case TCP_SYN_RECEIVED:
                case TCP_ESTABLISHED:
                        MyTCB.MySEQ++;
                        SendTCP(hTCP, FIN | ACK);
                        ps->smState = TCP_FIN_WAIT_1;
                        // Clear timeout info
                        MyTCB.retryCount  = 0;
                        MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                        ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                        ps->Flags.bTimerEnabled = TRUE;
                        break;

                case TCP_CLOSE_WAIT:
                        MyTCB.MySEQ++;
                        SendTCP(hTCP, FIN | ACK);
                        ps->smState = TCP_LAST_ACK;
                        // Clear timeout info
                        MyTCB.retryCount  = 0;
                        MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                        ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                        ps->Flags.bTimerEnabled = TRUE;
                        break;
        }
        
        SaveTCB(hTCP);
}

/*********************************************************************
* Function:        void TCPFlush(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           s       - Socket whose data is to be transmitted.
*
* Output:          None
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
void TCPFlush(TCP_SOCKET hTCP)
{
        TCB_STUB *ps;

        ps = &TCBStubs[hTCP];
        LoadTCB(hTCP);

        if(ps->txHead != MyTCB.txUnackedTail)
        {
                SendTCP(hTCP, PSH | ACK);

                // Clear timeout info
                MyTCB.retryCount = 0;
                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                ps->Flags.bTimerEnabled = TRUE;
        }
        SaveTCB(hTCP);
}


/*********************************************************************
* Function:        WORD TCPIsPutReady(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           hTCP: handle of socket to test
*
* Output:          Number of bytes that can be immediately placed 
*                                  in the transmit buffer.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
WORD TCPIsPutReady(TCP_SOCKET hTCP)
{
        TCB_STUB        *ps;

        ps = &TCBStubs[hTCP];

        // Unconnected sockets shouldn't be transmitting anything.
        if(!((ps->smState == TCP_ESTABLISHED) || (ps->smState == TCP_CLOSE_WAIT)))
                return 0;

        // Calculate the free space in this socket's TX FIFO
        if(ps->txHead >= ps->txTail)
                return (ps->bufferRxStart - ps->bufferTxStart - 1) - (ps->txHead - ps->txTail);
        else
                return ps->txTail - ps->txHead - 1;
}


/*********************************************************************
* Function:        BOOL TCPPut(TCP_SOCKET hTCP, BYTE byte)
*
* PreCondition:    TCPIsPutReady(s) != 0
*
* Input:           hTCP: socket handle to use
*                  byte: a data byte to send
*
* Output:          TRUE if given byte was put in transmit buffer
*                  FALSE if transmit buffer is full.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
BOOL TCPPut(TCP_SOCKET hTCP, BYTE byte)
{
        TCB_STUB *ps;
        WORD wFreeTXSpace;

        ps = &TCBStubs[hTCP];

        wFreeTXSpace = TCPIsPutReady(hTCP);
        if(wFreeTXSpace == 0u)
                return FALSE;
        else if(wFreeTXSpace == 1u) // About to run out of space, lets transmit so the remote node might send an ACK back faster
                TCPFlush(hTCP); 

        // Send all current bytes if we are crossing half full
        // This is required to improve performance with the delayed 
        // acknowledgement algorithm
        if((!ps->Flags.bHalfFullFlush) && (wFreeTXSpace <= ((ps->bufferRxStart-ps->bufferTxStart)>>1)))
        {
                TCPFlush(hTCP); 
                ps->Flags.bHalfFullFlush = TRUE;
        }

        MACSetWritePtr(ps->txHead);
        MACPut(byte);
        if(++ps->txHead >= ps->bufferRxStart)
                ps->txHead = ps->bufferTxStart;

        // Send the last byte as a separate packet (likely will make the remote node send back ACK faster)
        if(wFreeTXSpace == 1u)
                TCPFlush(hTCP);

        // If not already enabled, start a timer so this data will 
        // eventually get sent even if the application doens't call
        // TCPFlush()
        if(!ps->Flags.bTimer2Enabled)
        {
                ps->Flags.bTimer2Enabled = TRUE;
                ps->eventTime2 = (WORD)TickGet() + TCP_AUTO_TRANSMIT_TIMEOUT_VAL;
        }

        return TRUE;
}

/*********************************************************************
* Function:        WORD TCPPutArray(TCP_SOCKET hTCP, BYTE *data, WORD len)
*
* PreCondition:    None
*
* Input:           hTCP    - Socket handle to use
*                  data    - Pointer to data to put
*                                  len     - Count of bytes to put
*
* Output:          Count of bytes actually placed in the TX buffer
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
WORD TCPPutArray(TCP_SOCKET hTCP, BYTE *data, WORD len)
{
        WORD wActualLen;
        WORD wFreeTXSpace;
        WORD wRightLen = 0;
        TCB_STUB *ps;

        ps = &TCBStubs[hTCP];

        wFreeTXSpace = TCPIsPutReady(hTCP);
        if(wFreeTXSpace == 0u)
        {
                TCPFlush(hTCP);
                return 0;
        }

        wActualLen = wFreeTXSpace;
        if(wFreeTXSpace > len)
                wActualLen = len;

        // Send all current bytes if we are crossing half full
        // This is required to improve performance with the delayed 
        // acknowledgement algorithm
        if((!ps->Flags.bHalfFullFlush) && (wFreeTXSpace <= ((ps->bufferRxStart-ps->bufferTxStart)>>1)))
        {
                TCPFlush(hTCP); 
                ps->Flags.bHalfFullFlush = TRUE;
        }
        
        // See if we need a two part put
        if(ps->txHead + wActualLen >= ps->bufferRxStart)
        {
                wRightLen = ps->bufferRxStart-ps->txHead;
                MACSetWritePtr(ps->txHead);
                MACPutArray(data, wRightLen);
                data += wRightLen;
                wActualLen -= wRightLen;
                ps->txHead = ps->bufferTxStart;
        }

        MACSetWritePtr(ps->txHead);
        MACPutArray(data, wActualLen);
        ps->txHead += wActualLen;

        // Send these bytes right now if we are out of TX buffer space
        if(wFreeTXSpace <= len)
                TCPFlush(hTCP);

        // If not already enabled, start a timer so this data will 
        // eventually get sent even if the application doens't call
        // TCPFlush()
        if(!ps->Flags.bTimer2Enabled)
        {
                ps->Flags.bTimer2Enabled = TRUE;
                ps->eventTime2 = (WORD)TickGet() + TCP_AUTO_TRANSMIT_TIMEOUT_VAL;
        }

        return wActualLen + wRightLen;
}

WORD TCPPutROMArray(TCP_SOCKET hTCP, ROM BYTE *data, WORD len)
{
        WORD wActualLen;
        WORD wFreeTXSpace;
        WORD wRightLen = 0;
        TCB_STUB *ps;

        ps = &TCBStubs[hTCP];

        wFreeTXSpace = TCPIsPutReady(hTCP);
        if(wFreeTXSpace == 0u)
        {
                TCPFlush(hTCP);
                return 0;
        }

        // Send all current bytes if we are crossing half full
        // This is required to improve performance with the delayed 
        // acknowledgement algorithm
        if((!ps->Flags.bHalfFullFlush) && (wFreeTXSpace <= ((ps->bufferRxStart-ps->bufferTxStart)>>1)))
        {
                TCPFlush(hTCP); 
                ps->Flags.bHalfFullFlush = TRUE;
        }
        
        wActualLen = wFreeTXSpace;
        if(wFreeTXSpace > len)
                wActualLen = len;
        
        // See if we need a two part put
        if(ps->txHead + wActualLen >= ps->bufferRxStart)
        {
                wRightLen = ps->bufferRxStart-ps->txHead;
                MACSetWritePtr(ps->txHead);
                MACPutROMArray(data, wRightLen);
                data += wRightLen;
                wActualLen -= wRightLen;
                ps->txHead = ps->bufferTxStart;
        }

        MACSetWritePtr(ps->txHead);
        MACPutROMArray(data, wActualLen);
        ps->txHead += wActualLen;

        // Send these bytes right now if we are out of TX buffer space
        if(wFreeTXSpace <= len)
                TCPFlush(hTCP);

        // If not already enabled, start a timer so this data will 
        // eventually get sent even if the application doens't call
        // TCPFlush()
        if(!ps->Flags.bTimer2Enabled)
        {
                ps->Flags.bTimer2Enabled = TRUE;
                ps->eventTime2 = (WORD)TickGet() + TCP_AUTO_TRANSMIT_TIMEOUT_VAL;
        }

        return wActualLen + wRightLen;
}


/*********************************************************************
* Function:        WORD TCPPutString(TCP_SOCKET hTCP, BYTE *data)
*
* PreCondition:    None
*
* Input:           hTCP    - Socket handle to use
*                  data    - Pointer to null terminated string to put
*
* Output:          BYTE* - *data pointer incremented by the number of 
*                                                       bytes actually placed in the TX FIFO
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
BYTE* TCPPutString(TCP_SOCKET hTCP, BYTE *data)
{
        return data + TCPPutArray(hTCP, data, strlen((char*)data));
}

ROM BYTE* TCPPutROMString(TCP_SOCKET hTCP, ROM BYTE *data)
{
        return data + TCPPutROMArray(hTCP, data, strlenpgm((ROM char*)data));
}


/*********************************************************************
* Function:        void TCPDiscard(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           hTCP       - socket handle
*
* Output:          None
*
* Side Effects:    None
*
* Overview:        Removes all pending data from the socket's RX 
*                                  FIFO.
*
* Note:            None
********************************************************************/
void TCPDiscard(TCP_SOCKET hTCP)
{
        TCB_STUB *ps;

        if(TCPIsGetReady(hTCP))
        {
                ps = &TCBStubs[hTCP];
                LoadTCB(hTCP);
        
                // Delete all data in the RX buffer
                ps->rxTail = ps->rxHead;
        
                // Send a Window update message to the remote node
                SendTCP(hTCP, ACK);
        
                SaveTCB(hTCP);
        }
}


/*********************************************************************
* Function:        WORD TCPIsGetReady(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           hTCP       - socket to test
*
* Output:          Number of bytes that are available in socket 'hTCP' 
*                                  for immediate retrieval
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
WORD TCPIsGetReady(TCP_SOCKET hTCP)
{
        TCB_STUB        *ps;

        ps = &TCBStubs[hTCP];

        if(ps->rxHead >= ps->rxTail)
                return ps->rxHead - ps->rxTail;
        else
                return (ps->bufferEnd - ps->rxTail + 1) + (ps->rxHead - ps->bufferRxStart);
}


/*********************************************************************
* Function:        BOOL TCPGet(TCP_SOCKET hTCP, BYTE *byte)
*
* PreCondition:    TCPInit() is already called
*
* Input:           hTCP    - socket
*                  byte    - Pointer to a byte.
*
* Output:          TRUE if a byte was read.
*                  FALSE if byte was not read.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
BOOL TCPGet(TCP_SOCKET hTCP, BYTE *byte)
{
        TCB_STUB        *ps;
        WORD GetReadyCount;

        GetReadyCount = TCPIsGetReady(hTCP);
        if(GetReadyCount == 0u)
                return FALSE;

        ps = &TCBStubs[hTCP];
        MACSetReadPtr(ps->rxTail);
        *byte = MACGet();
        if(++ps->rxTail > ps->bufferEnd)
                ps->rxTail = ps->bufferRxStart;

        // Send a window update if we've run out of data
        if(GetReadyCount == 1u)
        {
                LoadTCB(hTCP);
                SendTCP(hTCP, ACK);
                SaveTCB(hTCP);
        }
        // If not already enabled, start a timer so a window 
        // update will get sent to the remote node at some point
        else if(!ps->Flags.bTimer2Enabled)
        {
                ps->Flags.bTimer2Enabled = TRUE;
                ps->eventTime2 = (WORD)TickGet() + TCP_AUTO_TRANSMIT_TIMEOUT_VAL;
        }


        return TRUE;
}


/*********************************************************************
* Function:        WORD TCPGetArray(TCP_SOCKET hTCP, BYTE *buffer,
*                                      WORD len)
*
* PreCondition:    TCPInit() is already called
*
* Input:           hTCP    - socket handle
*                  buffer  - Buffer to hold received data.
*                  len     - Buffer length
*
* Output:          Number of bytes loaded into buffer.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
WORD TCPGetArray(TCP_SOCKET hTCP, BYTE *buffer, WORD len)
{
        WORD ActualLen;
        WORD RightLen = 0;
        TCB_STUB *ps;

        ps = &TCBStubs[hTCP];

        ActualLen = TCPIsGetReady(hTCP);
        if(len > ActualLen)
                len = ActualLen;

        // See if we need a two part get
        if(ps->rxTail + len > ps->bufferEnd)
        {
                RightLen = ps->bufferEnd - ps->rxTail + 1;
                MACSetReadPtr(ps->rxTail);
                MACGetArray(buffer, RightLen);
                if(buffer)
                        buffer += RightLen;
                len -= RightLen;
                ps->rxTail = ps->bufferRxStart;
        }

        MACSetReadPtr(ps->rxTail);
        MACGetArray(buffer, len);
        ps->rxTail += len;

        // Send a window update if we've run low on data
        if(ActualLen - len <= len)
        {
                LoadTCB(hTCP);
                SendTCP(hTCP, ACK);
                SaveTCB(hTCP);
        }
        else if(!ps->Flags.bTimer2Enabled)
        // If not already enabled, start a timer so a window 
        // update will get sent to the remote node at some point
        {
                ps->Flags.bTimer2Enabled = TRUE;
                ps->eventTime2 = (WORD)TickGet() + TCP_AUTO_TRANSMIT_TIMEOUT_VAL;
        }

        return len + RightLen;
}


/*********************************************************************
* Function:             WORD TCPGetRxFIFOFree(TCP_SOCKET hTCP)
*
* PreCondition: TCPInit() is already called
*
* Input:                hTCP - TCP socket handle
*
* Output:               Number of bytes that can still fit in the RX FIFO.  
*                               0 is returned if the FIFO is completely full.
*
* Side Effects: None
*
* Overview:             None
*
* Note:                 None
********************************************************************/
WORD TCPGetRxFIFOFree(TCP_SOCKET hTCP)
{
        WORD wDataLen;
        WORD wFIFOSize;

        // Calculate total usable FIFO size
        wFIFOSize = TCBStubs[hTCP].bufferEnd - TCBStubs[hTCP].bufferRxStart;

        // Find out how many data bytes are actually in the RX FIFO
        wDataLen = TCPIsGetReady(hTCP);

        return wFIFOSize - wDataLen;
}

/*********************************************************************
* Function:             WORD TCPFindArray(TCP_SOCKET hTCP, BYTE *cFindArray, WORD wLen, WORD wStart, BOOL bTextCompare)
*
* PreCondition: TCPInit() is already called
*
* Input:                hTCP       - TCP socket handle
*                               cFindArray - Pointer to an array of bytes to look for
*                               wLen       - Length of cFindArray
*                               wStart     - Position within the RX FIFO to begin searching. 0 is the beginning of the FIFO.
*                               bTextCompare- Search using a case-insensitive algorithm if TRUE, otherwise, do a binary 1 to 1 search
*
* Output:               0xFFFF: Array not found
*                               0 to 65534: Location the array was found
*
* Side Effects: None
*
* Overview:             None
*
* Note:                 As an example, if the RX FIFO contains:
*                               "PIC MCUs are good." 
*                               and cFindArray -> "MCU"
*                               and wLen -> 3
*                               the value returned by the search function would be 4
********************************************************************/
WORD TCPFindArray(TCP_SOCKET hTCP, BYTE *cFindArray, WORD wLen, WORD wStart, BOOL bTextCompare)
{
        WORD wDataLen;
        WORD wBytesUntilWrap;
        WORD wLocation;
        WORD wLenStart;
        BYTE *cFindArrayStart;
        BYTE i, j, k;
        BYTE buffer[8];
        TCB_STUB *ps;

        if(wLen == 0u)
                return 0u;

        ps = &TCBStubs[hTCP];

        // Find out how many bytes are in the RX FIFO and return 
        // immediately if we won't possibly find a match
        wDataLen = TCPIsGetReady(hTCP);
        if(wDataLen < wLen + wStart)
                return 0xFFFFu;

        wLocation = ps->rxTail + wStart;
        if(wLocation > ps->bufferEnd)
                wLocation -= ps->bufferEnd - ps->bufferRxStart + 1;
        MACSetReadPtr(wLocation);
        wBytesUntilWrap = ps->bufferEnd - wLocation + 1;
        wLocation = wStart;
        wLenStart = wLen;
        cFindArrayStart = cFindArray;
        j = *cFindArray++;
        if(bTextCompare)
        {
                if(j >= 'a' && j <= 'z')
                        j += 'A'-'a';
        }

        // Search for the array
        while(1)
        {
                // Figure out how big of a chunk to read
                k = sizeof(buffer);
                if(k > wBytesUntilWrap)
                        k = wBytesUntilWrap;
                if((WORD)k > wLen)
                        k = wLen;

                // Read a chunk of data into the buffer
                MACGetArray(buffer, (WORD)k);
                wBytesUntilWrap -= k;

                if(wBytesUntilWrap == 0)
                {
                        MACSetReadPtr(ps->bufferRxStart);
                        wBytesUntilWrap = 0xFFFFu;
                }

                // Convert everything to uppercase
                if(bTextCompare)
                {
                        for(i = 0; i < k; i++)
                        {
                                if(buffer[i] >= 'a' && buffer[i] <= 'z')
                                        buffer[i] += 'A'-'a';

                                if(j == buffer[i])
                                {
                                        if(--wLen == 0)
                                                return wLocation-wLenStart + i + 1;
                                        j = *cFindArray++;
                                        if(j >= 'a' && j <= 'z')
                                                j += 'A'-'a';
                                }
                                else
                                {
                                        wLen = wLenStart;
                                        cFindArray = cFindArrayStart;
                                        j = *cFindArray++;
                                        if(j >= 'a' && j <= 'z')
                                                j += 'A'-'a';
                                }
                        }
                }
                else    // Compare as is
                {
                        for(i = 0; i < k; i++)
                        {
                                if(j == buffer[i])
                                {
                                        if(--wLen == 0)
                                                return wLocation-wLenStart + i + 1;
                                        j = *cFindArray++;
                                }
                                else
                                {
                                        wLen = wLenStart;
                                        cFindArray = cFindArrayStart;
                                        j = *cFindArray++;
                                }
                        }
                }

                // Check to see if it is impossible to find a match
                wDataLen -= k;
                if(wDataLen < wLen)
                        return 0xFFFFu;

                wLocation += k;
        }
}

WORD TCPFindROMArray(TCP_SOCKET hTCP, ROM BYTE *cFindArray, WORD wLen, WORD wStart, BOOL bTextCompare)
{
        WORD wDataLen;
        WORD wBytesUntilWrap;
        WORD wLocation;
        WORD wLenStart;
        ROM BYTE *cFindArrayStart;
        BYTE i, j, k;
        BYTE buffer[8];
        TCB_STUB *ps;

        if(wLen == 0u)
                return 0u;

        ps = &TCBStubs[hTCP];

        // Find out how many bytes are in the RX FIFO and return 
        // immediately if we won't possibly find a match
        wDataLen = TCPIsGetReady(hTCP);
        if(wDataLen < wLen + wStart)
                return 0xFFFFu;

        wLocation = ps->rxTail + wStart;
        if(wLocation > ps->bufferEnd)
                wLocation -= ps->bufferEnd - ps->bufferRxStart + 1;
        MACSetReadPtr(wLocation);
        wBytesUntilWrap = ps->bufferEnd - wLocation + 1;
        wLocation = wStart;
        wLenStart = wLen;
        cFindArrayStart = cFindArray;
        j = *cFindArray++;
        if(bTextCompare)
        {
                if(j >= 'a' && j <= 'z')
                        j += 'A'-'a';
        }

        // Search for the array
        while(1)
        {
                // Figure out how big of a chunk to read
                k = sizeof(buffer);
                if(k > wBytesUntilWrap)
                        k = wBytesUntilWrap;
                if((WORD)k > wLen)
                        k = wLen;

                // Read a chunk of data into the buffer
                MACGetArray(buffer, (WORD)k);
                wBytesUntilWrap -= k;

                if(wBytesUntilWrap == 0)
                {
                        MACSetReadPtr(ps->bufferRxStart);
                        wBytesUntilWrap = 0xFFFFu;
                }

                // Convert everything to uppercase
                if(bTextCompare)
                {
                        for(i = 0; i < k; i++)
                        {
                                if(buffer[i] >= 'a' && buffer[i] <= 'z')
                                        buffer[i] += 'A'-'a';

                                if(j == buffer[i])
                                {
                                        if(--wLen == 0)
                                                return wLocation-wLenStart + i + 1;
                                        j = *cFindArray++;
                                        if(j >= 'a' && j <= 'z')
                                                j += 'A'-'a';
                                }
                                else
                                {
                                        wLen = wLenStart;
                                        cFindArray = cFindArrayStart;
                                        j = *cFindArray++;
                                        if(j >= 'a' && j <= 'z')
                                                j += 'A'-'a';
                                }
                        }
                }
                else    // Compare as is
                {
                        for(i = 0; i < k; i++)
                        {
                                if(j == buffer[i])
                                {
                                        if(--wLen == 0)
                                                return wLocation-wLenStart + i + 1;
                                        j = *cFindArray++;
                                }
                                else
                                {
                                        wLen = wLenStart;
                                        cFindArray = cFindArrayStart;
                                        j = *cFindArray++;
                                }
                        }
                }

                // Check to see if it is impossible to find a match
                wDataLen -= k;
                if(wDataLen < wLen)
                        return 0xFFFFu;

                wLocation += k;
        }
}

WORD TCPFind(TCP_SOCKET hTCP, BYTE cFind, WORD wStart, BOOL bTextCompare)
{
        return TCPFindArray(hTCP, &cFind, sizeof(cFind), wStart, bTextCompare);
}


/*********************************************************************
* Function:        void TCPTick(void)
*
* PreCondition:    TCPInit() is already called.
*
* Input:           None
*
* Output:          Each socket FSM is executed for any timeout
*                  situation.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
void TCPTick(void)
{
        TCP_SOCKET hTCP;
        TCB_STUB *ps;
        BOOL bACKSent;

        // Periodically all "not closed" sockets must perform timed operations
        for(hTCP = 0; hTCP < MAX_TCP_SOCKETS; hTCP++)
        {
                ps = &TCBStubs[hTCP];

                bACKSent = FALSE;

                // Transmit ASAP data if the medium is available
                if(ps->Flags.bTXASAP)
                {
                        if(MACIsTxReady())
                        {
                                LoadTCB(hTCP);
                                SendTCP(hTCP, ACK);
                                SaveTCB(hTCP);
                                bACKSent = TRUE;
                        }
                }

                // Perform any needed window updates and data transmissions
                if(ps->Flags.bTimer2Enabled)
                {
                        // See if the timeout has occured
                        if((SHORT)(ps->eventTime2 - (WORD)TickGet()) <= (SHORT)0)
                        {
                                // Send out a window update and any bytes waiting in the TX FIFO
                                if(!bACKSent)
                                {
                                        LoadTCB(hTCP);
                                        SendTCP(hTCP, ACK);
                                        SaveTCB(hTCP);
                                        bACKSent = TRUE;
                                }
                        }
                }

                // Process Delayed ACKnowledgement timer
                if(ps->Flags.bDelayedACKTimerEnabled)
                {
                        // See if the timeout has occured
                        if((SHORT)(ps->delayedACKTime - (WORD)TickGet()) <= (SHORT)0)
                        {
                                if(!bACKSent)
                                {
                                        // Send out our delayed ACK
                                        LoadTCB(hTCP);
                                        SendTCP(hTCP, ACK);
                                        SaveTCB(hTCP);
                                        bACKSent = TRUE;
                                }
                        }
                }

                // The TCP_CLOSED, TCP_LISTEN, and sometimes the TCP_ESTABLISHED 
                // state don't need any timeout events
                if(!ps->Flags.bTimerEnabled)
                        continue;

                // If timeout has not occured, do not do anything.
                if((LONG)(TickGet() - ps->eventTime) < (LONG)0)
                        continue;

                // Load up extended MyTCB information
                // If bACKSent, then the TCB has already been loaded.  No need to do it again.
                if(!bACKSent)
                        LoadTCB(hTCP);

                // This will be one more attempt.
                MyTCB.retryCount++;

                // Update timeout value if there is need to wait longer.
                MyTCB.retryInterval <<= 1;

                // Restart timeout reference.
                ps->eventTime = TickGet() + MyTCB.retryInterval;

                // A timeout has occured.  Respond to this timeout condition
                // depending on what state this socket is in.
                switch(ps->smState)
                {
                        case TCP_SYN_SENT:
                                // Keep sending SYN until we hear from remote node.
                                // This may be for infinite time, in that case
                                // caller must detect it and do something.
                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                MyTCB.retryCount = 0;
                                SendTCP(hTCP, SYN);
                                break;
        
                        case TCP_SYN_RECEIVED:
                                // We must receive ACK before timeout expires.
                                // If not, resend SYN+ACK.
                                // Abort, if maximum attempts counts are reached.
                                if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                {
                                        SendTCP(hTCP, SYN | ACK);
                                }
                                else
                                {
                                        if(ps->Flags.bServer)
                                        {
                                                SendTCP(hTCP, RST);
                                                CloseSocket(hTCP);
                                        }
                                        else
                                        {
                                                ps->smState = TCP_SYN_SENT;
                                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                                MyTCB.retryCount = 0;
                                                SendTCP(hTCP, SYN);
                                        }
                                }
                                break;
        
                        case TCP_ESTABLISHED:
                                if(MyTCB.txUnackedTail != ps->txTail)
                                {
                                        // Retransmit any unacknowledged data
                                        if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                        {
                                                // Roll back unacknowledged TX tail pointer
                                                MyTCB.MySEQ -= (LONG)(SHORT)(MyTCB.txUnackedTail - ps->txTail);
                                                if(MyTCB.txUnackedTail < ps->txTail)
                                                        MyTCB.MySEQ -= (LONG)(SHORT)(ps->bufferRxStart - ps->bufferTxStart);
                                                MyTCB.txUnackedTail = ps->txTail;
        
                                                SendTCP(hTCP, PSH | ACK);
                                        }
                                        else
                                        {
                                                // No response back for too long, close connection
                                                // This could happen, for instance, if the communication 
                                                // medium was lost
                                                MyTCB.MySEQ++;
                                                ps->smState = TCP_FIN_WAIT_1;
                                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                                MyTCB.retryCount = 0;
        
                                                SendTCP(hTCP, FIN | ACK);
                                        }
                                }
                                break;
        
                        case TCP_FIN_WAIT_1:
                                if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                {
                                        // Roll back unacknowledged TX tail pointer
                                        MyTCB.MySEQ -= (LONG)(SHORT)(MyTCB.txUnackedTail - ps->txTail);
                                        if(MyTCB.txUnackedTail < ps->txTail)
                                                MyTCB.MySEQ -= (LONG)(SHORT)(ps->bufferRxStart - ps->bufferTxStart);
                                        MyTCB.txUnackedTail = ps->txTail;

                                        // Send another FIN
                                        SendTCP(hTCP, FIN | ACK);
                                }
                                else
                                {
                                        // Close on our own, we can't seem to communicate 
                                        // with the remote node anymore
                                        SendTCP(hTCP, RST | ACK);
                                        CloseSocket(hTCP);
                                }
                                break;
        
                        case TCP_FIN_WAIT_2:
                                // Close on our own, we can't seem to communicate 
                                // with the remote node anymore
                                SendTCP(hTCP, RST | ACK);
                                CloseSocket(hTCP);
                                break;

                        case TCP_CLOSING:
                                if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                {
                                        // Roll back unacknowledged TX tail pointer
                                        MyTCB.MySEQ -= (LONG)(SHORT)(MyTCB.txUnackedTail - ps->txTail);
                                        if(MyTCB.txUnackedTail < ps->txTail)
                                                MyTCB.MySEQ -= (LONG)(SHORT)(ps->bufferRxStart - ps->bufferTxStart);
                                        MyTCB.txUnackedTail = ps->txTail;

                                        // Send another ACK
                                        SendTCP(hTCP, ACK);
                                }
                                else
                                {
                                        // Close on our own, we can't seem to communicate 
                                        // with the remote node anymore
                                        SendTCP(hTCP, RST | ACK);
                                        CloseSocket(hTCP);
                                }
                                break;
        
                        case TCP_TIME_WAIT:
                                // Wait around for a while (2MSL) and then goto closed state
                                CloseSocket(hTCP);
                                break;
                        
                        case TCP_CLOSE_WAIT:
                                if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                {
                                        // Roll back unacknowledged TX tail pointer
                                        MyTCB.MySEQ -= (LONG)(SHORT)(MyTCB.txUnackedTail - ps->txTail);
                                        if(MyTCB.txUnackedTail < ps->txTail)
                                                MyTCB.MySEQ -= (LONG)(SHORT)(ps->bufferRxStart - ps->bufferTxStart);
                                        MyTCB.txUnackedTail = ps->txTail;

                                        // Send ACK
                                        SendTCP(hTCP, ACK);
                                }
                                else
                                {
                                        // We shouldn't get down here if the application properly closes the connection.
                                        // However, if it doesn't, we still need to ensure socket reuse, so let's forcefully close the socket.
                                        SendTCP(hTCP, RST | ACK);
                                        CloseSocket(hTCP);
                                }
                                break;
        
                        case TCP_LAST_ACK:
                                // Send some more FINs or close anyway
                                if(MyTCB.retryCount <= MAX_RETRY_COUNTS)
                                {
                                        SendTCP(hTCP, FIN | ACK);
                                }
                                else
                                {
                                        SendTCP(hTCP, RST | ACK);
                                        CloseSocket(hTCP);
                                }
                                break;
                }

                SaveTCB(hTCP);
        }
}


/*********************************************************************
* Function:        BOOL TCPProcess(NODE_INFO* remote,
*                                  IP_ADDR *localIP,
*                                  WORD len)
*
* PreCondition:    TCPInit() is already called     AND
*                  TCP segment is ready in MAC buffer
*
* Input:           remote      - Remote node info
*                  len         - Total length of TCP semgent.
*
* Output:          TRUE if this function has completed its task
*                  FALSE otherwise
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
BOOL TCPProcess(NODE_INFO *remote, IP_ADDR *localIP, WORD len)
{
        TCP_HEADER      TCPHeader;
        PSEUDO_HEADER   pseudoHeader;
        TCP_SOCKET      socket;
        WORD_VAL        checksum1;
        WORD_VAL        checksum2;
        BYTE            optionsSize;

        // Calculate IP pseudoheader checksum.
        pseudoHeader.SourceAddress      = remote->IPAddr;
        pseudoHeader.DestAddress        = *localIP;
        pseudoHeader.Zero               = 0x0;
        pseudoHeader.Protocol           = IP_PROT_TCP;
        pseudoHeader.TCPLength          = len;

        SwapPseudoTCPHeader(pseudoHeader);

        checksum1.Val = ~CalcIPChecksum((BYTE*)&pseudoHeader,
                sizeof(pseudoHeader));

        // Now calculate TCP packet checksum in NIC RAM - should match
        // pesudo header checksum
        checksum2.Val = CalcIPBufferChecksum(len);

        // Compare checksums.
        if(checksum1.Val != checksum2.Val)
        {
                MACDiscardRx();
                return TRUE;
        }

        // Retrieve TCP header.
        IPSetRxBuffer(0);
        MACGetArray((BYTE*)&TCPHeader, sizeof(TCPHeader));
        SwapTCPHeader(&TCPHeader);


        // Skip over options to retrieve data bytes
        optionsSize = (BYTE)((TCPHeader.DataOffset.Val << 2)-
                sizeof(TCPHeader));
        len = len - optionsSize - sizeof(TCPHeader);

        // Find matching socket.
        socket = FindMatchingSocket(&TCPHeader, remote);
        if(socket != INVALID_SOCKET)
        {
                HandleTCPSeg(socket, &TCPHeader, len);
                SaveTCB(socket);
        }
        else
        {
                // If this is an unknown socket, or we don't have any 
                // listening sockets available, discard it.  We can't 
                // process it right now.
                MACDiscardRx();
        }

        return TRUE;
}


/*********************************************************************
* Function:        static void SendTCP(TCP_SOCKET hTCP, BYTE flags)
*
* PreCondition:    TCPInit() is already called
*                                  LoadTCP() is called with the value of hTCP
*
* Input:           hTCP: Handle of socket to send packet with
*                                  flags: Additional TCP flags to include
*
* Output:          A TCP segment is assembled and transmitted
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            Function does not save the MyTCB data.  It is 
*                                  the caller's responsibility to save it.
********************************************************************/
static void SendTCP(TCP_SOCKET hTCP, BYTE flags)
{
        TCB_STUB                *ps;
        WORD_VAL        wVal;
        TCP_HEADER      header;
        TCP_OPTIONS     options;
        PSEUDO_HEADER   pseudoHeader;
        WORD                    len;
        WORD                    wEffectiveWindow;
        
        ps = &TCBStubs[hTCP];

        // Status will now be synched, disable automatic future 
        // status transmissions
        ps->Flags.bTimer2Enabled = 0;
        ps->Flags.bTXASAP = 0;
        ps->Flags.bDelayedACKTimerEnabled = 0;
        ps->Flags.bOneSegmentReceived = 0;

        //  Make sure that we can write to the MAC transmit area
        while(!IPIsTxReady());

        // Put all socket application data in the TX space
        if(flags & SYN)
        {
                // Don't put any data for SYN messages
                len = 0;
        }
        else
        {
                // Begin copying any application data over to the TX space
                if(ps->txHead == MyTCB.txUnackedTail)
                {
                        len = 0;
                }
                else if(ps->txHead > MyTCB.txUnackedTail)
                {
                        len = ps->txHead - MyTCB.txUnackedTail;
                        wEffectiveWindow = MyTCB.remoteWindow;
                        if(MyTCB.txUnackedTail >= ps->txTail)
                                wEffectiveWindow -= MyTCB.txUnackedTail - ps->txTail;
                        else
                                wEffectiveWindow -= (ps->bufferRxStart - ps->bufferTxStart) - (ps->txTail - MyTCB.txUnackedTail);

                        if(len > wEffectiveWindow)
                                len = wEffectiveWindow;

                        if(len > 576)
                        {
                                len = 576;
                                ps->Flags.bTXASAP = 1;
                        }

                        MACMemCopyAsync(BASE_TX_ADDR+sizeof(ETHER_HEADER)+sizeof(IP_HEADER)+sizeof(TCP_HEADER), MyTCB.txUnackedTail, len);
                        MyTCB.txUnackedTail += len;
                }
                else
                {
                        pseudoHeader.TCPLength = ps->bufferRxStart - MyTCB.txUnackedTail;
                        len = pseudoHeader.TCPLength + ps->txHead - ps->bufferTxStart;

                        wEffectiveWindow = MyTCB.remoteWindow;
                        if(MyTCB.txUnackedTail >= ps->txTail)
                                wEffectiveWindow -= MyTCB.txUnackedTail - ps->txTail;
                        else
                                wEffectiveWindow -= (ps->bufferRxStart - ps->bufferTxStart) - (ps->txTail - MyTCB.txUnackedTail);
                                
                        if(len > wEffectiveWindow)
                                len = wEffectiveWindow;

                        if(len > 576)
                        {
                                len = 576;
                                ps->Flags.bTXASAP = 1;
                        }

                        if(pseudoHeader.TCPLength > wEffectiveWindow)
                                pseudoHeader.TCPLength = wEffectiveWindow;

                        if(pseudoHeader.TCPLength > 576)
                                pseudoHeader.TCPLength = 576;

                        MACMemCopyAsync(BASE_TX_ADDR+sizeof(ETHER_HEADER)+sizeof(IP_HEADER)+sizeof(TCP_HEADER), MyTCB.txUnackedTail, pseudoHeader.TCPLength);
                        pseudoHeader.TCPLength = len - pseudoHeader.TCPLength;
        
                        // Copy any left over chunks of application data over
                        if(pseudoHeader.TCPLength)
                        {
                                MACMemCopyAsync(BASE_TX_ADDR+sizeof(ETHER_HEADER)+sizeof(IP_HEADER)+sizeof(TCP_HEADER)+(ps->bufferRxStart-MyTCB.txUnackedTail), ps->bufferTxStart, pseudoHeader.TCPLength);
                        }

                        MyTCB.txUnackedTail += len;
                        if(MyTCB.txUnackedTail >= ps->bufferRxStart)
                                MyTCB.txUnackedTail -= ps->bufferRxStart-ps->bufferTxStart;
                }
        }
        
        header.SourcePort                       = MyTCB.localPort.Val;
        header.DestPort                         = MyTCB.remotePort.Val;
        if(flags & (SYN | FIN))
                header.SeqNumber                = MyTCB.MySEQ-1;
        else
        header.SeqNumber                        = MyTCB.MySEQ;
        header.AckNumber                        = MyTCB.RemoteSEQ;
        header.Flags.bits.Reserved2     = 0;
        header.DataOffset.Reserved3     = 0;
        header.Flags.byte                       = flags;
        header.UrgentPointer        = 0;

        // For next time
        MyTCB.MySEQ += (DWORD)len;

        // Calculate the amount of free space in the RX buffer area of this socket
        if(ps->rxHead >= ps->rxTail)
                header.Window = (ps->bufferEnd - ps->bufferRxStart) - (ps->rxHead - ps->rxTail);
        else
                header.Window = ps->rxTail - ps->rxHead - 1;

        // Calculate the amount of free space in the MAC RX buffer area and adjust window if needed
        wVal.Val = MACGetFreeRxSize()-64;
        if((SHORT)wVal.Val < (SHORT)0)
                wVal.Val = 0;
        // Force the remote node to throttle back if we are running low on general RX buffer space
//      if(header.Window > wVal.Val)
        if((header.Window > wVal.Val) && (wVal.Val < 2000))
                header.Window = wVal.Val;

        SwapTCPHeader(&header);


        len += sizeof(header);

        header.DataOffset.Val   = sizeof(header) >> 2;
        if(flags & SYN)
        {
                len += sizeof(options);
                options.Kind = TCP_OPTIONS_MAX_SEG_SIZE;
                options.Length = 0x04;

                // Load MSS and swap to big endian
                options.MaxSegSize.Val = 0x4002;        // 576

                header.DataOffset.Val   += sizeof(options) >> 2;
        }

        // Calculate IP pseudoheader checksum.
        pseudoHeader.SourceAddress      = AppConfig.MyIPAddr;
        pseudoHeader.DestAddress    = MyTCB.remote.IPAddr;
        pseudoHeader.Zero           = 0x0;
        pseudoHeader.Protocol       = IP_PROT_TCP;
        pseudoHeader.TCPLength          = len;

        SwapPseudoTCPHeader(pseudoHeader);

        header.Checksum = ~CalcIPChecksum((BYTE*)&pseudoHeader, sizeof(pseudoHeader));

        MACSetWritePtr(BASE_TX_ADDR + sizeof(ETHER_HEADER));

        // Write IP header.
        IPPutHeader(&MyTCB.remote, IP_PROT_TCP, len);
        MACPutArray((BYTE*)&header, sizeof(header));
        if(flags & SYN)
                MACPutArray((BYTE*)&options, sizeof(options));

        MACSetReadPtr(BASE_TX_ADDR + sizeof(ETHER_HEADER) + sizeof(IP_HEADER));
        wVal.Val = CalcIPBufferChecksum(len);

        // Update the TCP checksum and begin transmission of the packet
        MACSetWritePtr(BASE_TX_ADDR + sizeof(ETHER_HEADER) + sizeof(IP_HEADER) + 16);
        MACPutArray((BYTE*)&wVal, sizeof(WORD));

        while(!MACIsMemCopyDone());
        MACFlush();
}


/*********************************************************************
* Function:        static TCP_SOCKET FindMatchingSocket(TCP_HEADER *h,
*                                      NODE_INFO* remote)
*
* PreCondition:    TCPInit() is already called
*
* Input:           h           - TCP Header to be matched against.
*                  remote      - Node who sent this header.
*
* Output:          A socket that matches with given header and remote
*                  node is searched.
*                  If such socket is found, its index is returned
*                  else INVALID_SOCKET is returned.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
static TCP_SOCKET FindMatchingSocket(TCP_HEADER *h, NODE_INFO *remote)
{
        TCB_STUB *ps;
        TCP_SOCKET hTCP;
        TCP_SOCKET partialMatch;
        WORD hash;

        partialMatch = INVALID_SOCKET;
        hash = (remote->IPAddr.w[1]+remote->IPAddr.w[0] + h->SourcePort) ^ h->DestPort;

        for(hTCP = 0; hTCP < MAX_TCP_SOCKETS; hTCP++ )
        {
                ps = &TCBStubs[hTCP];

                if(ps->smState == TCP_CLOSED)
                {
                        continue;
                }
                else if(ps->smState == TCP_LISTEN)
                {
                        if(ps->remoteHash.Val == h->DestPort)
                                partialMatch = hTCP;
                        continue;
                }
                else if(ps->remoteHash.Val != hash)
                {
                        continue;
                }

                LoadTCB(hTCP);
                if(     h->DestPort == MyTCB.localPort.Val &&
                        h->SourcePort == MyTCB.remotePort.Val &&
                        remote->IPAddr.Val == MyTCB.remote.IPAddr.Val)
                {
                        return hTCP;
                }
        }

        // We are not listening on this port, nor is a socket using it
        if(partialMatch == INVALID_SOCKET)
                return INVALID_SOCKET;

        // Set up the extended TCB with the info needed to establish a 
        // connection and return this socket to the caller
        ps = &TCBStubs[partialMatch];

        ps->remoteHash.Val = hash;
        ps->txHead = ps->bufferTxStart;
        ps->txTail = ps->bufferTxStart;
        ps->rxHead = ps->bufferRxStart;
        ps->rxTail = ps->bufferRxStart;
        ps->Flags.bTimerEnabled = FALSE;

        memcpy((void*)&MyTCB.remote, (void*)remote, sizeof(NODE_INFO));
        MyTCB.remotePort.Val = h->SourcePort;
        MyTCB.localPort.Val = h->DestPort;
        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[0] = rand();
        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[1] = rand();
        MyTCB.txUnackedTail     = ps->bufferTxStart;

        return partialMatch;
}


/*********************************************************************
* Function:        static void SwapTCPHeader(TCP_HEADER* header)
*
* PreCondition:    None
*
* Input:           header      - TCP Header to be swapped.
*
* Output:          Given header is swapped.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
static void SwapTCPHeader(TCP_HEADER* header)
{
        header->SourcePort      = swaps(header->SourcePort);
        header->DestPort        = swaps(header->DestPort);
        header->SeqNumber       = swapl(header->SeqNumber);
        header->AckNumber       = swapl(header->AckNumber);
        header->Window          = swaps(header->Window);
        header->Checksum        = swaps(header->Checksum);
        header->UrgentPointer   = swaps(header->UrgentPointer);
}


/*********************************************************************
* Function:        static void CloseSocket(TCP_SOCKET hTCP)
*
* PreCondition:    TCPInit() is already called
*                                  LoadTCB() must be called with the value of hTCP
*
* Input:           hTCP  - Handle of socket to close/reinitialize
*
* Output:          Given socket information is reset and any
*                  buffered bytes held by this socket are discarded.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            Function does not save the MyTCB data.  It is 
*                                  the caller's responsibility to save it.
********************************************************************/
static void CloseSocket(TCP_SOCKET hTCP)
{
        TCB_STUB *ps;
        
        ps = &TCBStubs[hTCP];

        ps->smState = ps->Flags.bServer ? TCP_LISTEN : TCP_CLOSED;
        ps->Flags.bTimerEnabled = FALSE;
        ps->Flags.bTimer2Enabled = FALSE;
        ps->Flags.bDelayedACKTimerEnabled = FALSE;
        ps->Flags.bOneSegmentReceived = FALSE;
        ps->Flags.bHalfFullFlush = FALSE;
        ps->Flags.bTXASAP = FALSE;
        ps->remoteHash.Val = MyTCB.localPort.Val;
        ps->txTail = ps->bufferTxStart;
        ps->txHead = ps->bufferTxStart;
        ps->rxTail = ps->bufferRxStart;
        ps->rxHead = ps->bufferRxStart;
        MyTCB.txUnackedTail = ps->bufferTxStart;
        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[0] = rand();
        ((DWORD_VAL*)(&MyTCB.MySEQ))->w[1] = rand();
}


/*********************************************************************
* Function:        static void HandleTCPSeg(TCP_SOCKET hTCP, TCP_HEADER *h, WORD len)
*
* PreCondition:    TCPInit() is already called     AND
*                  TCPProcess() is the caller.
*
* Input:           hTCP        - Socket that owns this segment
*                  h           - TCP Header
*                  len         - Total buffer length.
*
* Output:          TCP FSM is executed on given socket with
*                  given TCP segment.
*
* Side Effects:    None
*
* Overview:        None
*
* Note:            None
********************************************************************/
static void HandleTCPSeg(TCP_SOCKET hTCP, TCP_HEADER *h, WORD len)
{
        DWORD dwTemp;
        WORD wTemp;
        LONG lMissingBytes;
        WORD wMissingBytes;
        WORD wFreeSpace;
        TCB_STUB *ps;
        BYTE flags;

        ps = &TCBStubs[hTCP];
        flags = 0x00;


        // Reset FSM, if RST is received.
        if(h->Flags.bits.flagRST)
        {
                SendTCP(hTCP, RST);
                CloseSocket(hTCP);
                MACDiscardRx();
                return;
        }

        // Update the local stored copy of the RemoteWindow
        // If previously we had a zero window, and now we don't 
        // immediately send whatever was panding
        if((MyTCB.remoteWindow == 0u) && h->Window)
                ps->Flags.bTXASAP = 1;
        MyTCB.remoteWindow = h->Window;


        switch(ps->smState)
        {
                case TCP_LISTEN:
                        if(!h->Flags.bits.flagSYN)
                        {
                                SendTCP(hTCP, RST);
                                CloseSocket(hTCP);
                                break;
                        }
                        
                        flags = SYN | ACK;
                        ps->smState = TCP_SYN_RECEIVED;

                        // Clear timeout info
                        MyTCB.retryCount = 0;
                        MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                        ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                        ps->Flags.bTimerEnabled = TRUE;

                        // We now have a sequence number for the remote node
                        MyTCB.RemoteSEQ = h->SeqNumber + 1;

                        break;

                case TCP_SYN_SENT:
                        if(!h->Flags.bits.flagSYN)
                                break;

                        if(h->Flags.bits.flagACK)
                        {
                                // If SYN+ACK, we may need to go to TCP_ESTABLISHED state
                                if(h->AckNumber == MyTCB.MySEQ)
                                {
                                        flags = ACK;
                                        ps->smState = TCP_ESTABLISHED;
                                        ps->Flags.bTimerEnabled = FALSE;

                                        // Check for application data and make it 
                                        // available, if present
                                        flags |= ProcessRXBytes(ps, h, len);
                                }
                                else
                                {
                                        // ACK number incorrect: ignore this packet
                                        flags = RST;
                                        break;
                                }
                        }
                        else
                        {
                                // Got SYN without ACK, need to go to TCP_SYN_RECEIVED state
                                flags = SYN | ACK;
                                ps->smState = TCP_SYN_RECEIVED;

                                // Clear timeout info
                                MyTCB.retryCount  = 0;
                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                        }

                        // We now have a sequence number for the remote node
                        MyTCB.RemoteSEQ = h->SeqNumber + 1;

                        break;

                case TCP_SYN_RECEIVED:
                        if(h->Flags.bits.flagACK && (h->AckNumber == MyTCB.MySEQ))
                        {
                                ps->smState = TCP_ESTABLISHED;
                                ps->Flags.bTimerEnabled = FALSE;

                                // Check for application data and make it 
                                // available, if present
                                flags |= ProcessRXBytes(ps, h, len);
                        }

                        break;

                case TCP_ESTABLISHED:
                        // Check for application data and make it 
                        // available, if present
                        flags |= ProcessRXBytes(ps, h, len);

                        // Handle any requests to close the connection
                        if(h->Flags.bits.flagFIN)
                        {
                                MyTCB.RemoteSEQ++;

                                if(len == 0u)
                                {
                                        flags = FIN | ACK;
                                        MyTCB.MySEQ++;
                                        ps->smState = TCP_LAST_ACK;
                                }
                                else
                                {
                                        // Don't send a FIN back immediately.  The application 
                                        // may want to send a little bit more data before closing 
                                        // the socket.
                                        flags = ACK;
                                        ps->smState = TCP_CLOSE_WAIT;
                                }

                                // Clear timeout info
                                MyTCB.retryCount  = 0;
                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                                ps->Flags.bTimerEnabled = TRUE;
                        }

                        break;

                case TCP_FIN_WAIT_1:
                        if(h->Flags.bits.flagFIN && h->Flags.bits.flagACK && (h->AckNumber == MyTCB.MySEQ))
                        {
                                MyTCB.RemoteSEQ++;
                                flags = ACK;
                                ps->smState = TCP_TIME_WAIT;
                                ps->eventTime = TickGet() + TCP_TIME_WAIT_TIMEOUT_VAL;
                        }
                        else if(h->Flags.bits.flagACK && (h->AckNumber == MyTCB.MySEQ))
                        {
                                ps->smState = TCP_FIN_WAIT_2;
                        }
                        else if(h->Flags.bits.flagFIN)
                        {
                                MyTCB.RemoteSEQ++;
                                flags = ACK;
                                ps->smState = TCP_CLOSING;

                                // Clear timeout info
                                MyTCB.retryCount  = 0;
                                MyTCB.retryInterval = TCP_START_TIMEOUT_VAL;
                                ps->eventTime = TickGet() + TCP_START_TIMEOUT_VAL;
                        }

                        // Check for application data and make it 
                        // available, if present
                        flags |= ProcessRXBytes(ps, h, len);

                        break;

                case TCP_FIN_WAIT_2:
                        if(h->Flags.bits.flagFIN)
                        {
                                MyTCB.RemoteSEQ++;
                                flags = ACK;
                                ps->smState = TCP_TIME_WAIT;
                                ps->eventTime = TickGet() + TCP_TIME_WAIT_TIMEOUT_VAL;
                        }

                        // Check for application data and make it 
                        // available, if present
                        flags |= ProcessRXBytes(ps, h, len);

                        break;

                case TCP_CLOSING:
                        if(h->Flags.bits.flagACK && (h->AckNumber == MyTCB.MySEQ))
                        {
                                ps->smState = TCP_TIME_WAIT;
                                ps->eventTime = TickGet() + TCP_TIME_WAIT_TIMEOUT_VAL;
                        }

                        // Check for application data and make it 
                        // available, if present
                        flags |= ProcessRXBytes(ps, h, len);

                        break;

                case TCP_CLOSE_WAIT:
                        flags = ACK;
                        break;

                case TCP_LAST_ACK:
                        if(h->Flags.bits.flagACK && (h->AckNumber == MyTCB.MySEQ))
                        {
                                CloseSocket(hTCP);
                        }
                        break;

                case TCP_TIME_WAIT:
                        flags = RST;
                        break;
        }


        // Throw away all ACKnowledged TX data
        if(h->Flags.bits.flagACK && (ps->smState != TCP_CLOSED) && (ps->smState != TCP_LISTEN))
        {
                // Calculate what the last acknowledged sequence number was
                dwTemp = MyTCB.MySEQ - (LONG)(SHORT)(MyTCB.txUnackedTail - ps->txTail);
                if(MyTCB.txUnackedTail < ps->txTail)
                        dwTemp -= ps->bufferRxStart - ps->bufferTxStart;

                // Calcluate how many bytes were ACKed with this packet
                dwTemp = h->AckNumber - dwTemp;
                if(((LONG)(dwTemp) > 0) && (dwTemp <= ps->bufferRxStart - ps->bufferTxStart))
                {
                        ps->Flags.bHalfFullFlush = FALSE;

                        // Bytes ACKed, free up the TX FIFO space
                        ps->txTail += dwTemp;
                        if(ps->txTail >= ps->bufferRxStart)
                        {
                                ps->txTail -= ps->bufferRxStart - ps->bufferTxStart;
                        }

                        // No need to keep our retransmit timer going if we having nothing that needs ACKing anymore
                        if((ps->smState == TCP_ESTABLISHED) && (ps->txTail == MyTCB.txUnackedTail))
                                ps->Flags.bTimerEnabled = FALSE;
                }
        }


        while(!MACIsMemCopyDone());
        MACDiscardRx();

        if(flags)
                SendTCP(hTCP, flags);
}

/*********************************************************************
* Function:             static BYTE ProcessRXBytes(TCB_STUB *ps, TCP_HEADER *h, WORD len)
*
* PreCondition: None
*
* Input:        *ps: Pointer to the current TCB_STUB which needs processing
*                               *h: Pointer to the TCP_HEADER of the TCP packet we received
*                               len: Number of TCP application layer bytes available
*
* Output:               BYTE: Flags that should be transmitted back
*
* Side Effects: None
*
* Overview:             None
*
* Note:                 This is an internal TCP layer function only.
********************************************************************/
static BYTE ProcessRXBytes(TCB_STUB *ps, TCP_HEADER *h, WORD len)
{
        WORD wTemp;
        LONG lMissingBytes;
        WORD wMissingBytes;
        WORD wFreeSpace;

        // Check for application data and make it 
        // available, if present
        if(!len)
                return 0x00;

        // Calculate the number of bytes ahead of our head pointer this segment skips
        lMissingBytes = h->SeqNumber - MyTCB.RemoteSEQ;
        wMissingBytes = (WORD)lMissingBytes;
        
        // Calculate the RX FIFO space
        if(ps->rxHead >= ps->rxTail)
                wFreeSpace = (ps->bufferEnd - ps->bufferRxStart) - (ps->rxHead - ps->rxTail);
        else
                wFreeSpace = ps->rxTail - ps->rxHead - 1;
        
        // See if any of the segment data is within our RX window
        if(((LONG)wFreeSpace > lMissingBytes) && ((SHORT)wMissingBytes + (SHORT)len > (SHORT)0))
        {
                // See if there are bytes we must skip
                if((SHORT)wMissingBytes <= 0)
                {
                        // Position packet read pointer to start of useful data area.
                        IPSetRxBuffer((h->DataOffset.Val << 2) - wMissingBytes);
                        len += wMissingBytes;
                        MyTCB.RemoteSEQ += (DWORD)len;
        
                        // Copy the application data from the packet into the socket RX FIFO
                        // See if we need a two part copy (spans bufferEnd->bufferRxStart)
                        if(ps->rxHead + len > ps->bufferEnd)
                        {
                                wTemp = ps->bufferEnd - ps->rxHead + 1;
                                MACMemCopyAsync(ps->rxHead, -1, wTemp);
                                MACMemCopyAsync(ps->bufferRxStart, -1, len - wTemp);
                                ps->rxHead = ps->bufferRxStart + (len - wTemp);
                        }
                        else
                        {
                                MACMemCopyAsync(ps->rxHead, -1, len);
                                ps->rxHead += len;
                        }
        
                        // See if we have a hole and other data waiting already in the RX FIFO
                        if(MyTCB.sHoleSize != -1)
                        {
                                MyTCB.sHoleSize -= len;
                                wTemp = MyTCB.wFutureDataSize + MyTCB.sHoleSize;
        
                                // See if we just closed up a hole, and if so, advance head pointer
                                if((SHORT)wTemp < (SHORT)0)
                                {
                                        MyTCB.sHoleSize = -1;
                                }
                                else if(MyTCB.sHoleSize <= 0)
                                {
                                        MyTCB.RemoteSEQ += wTemp;
                                        ps->rxHead += wTemp;
                                        if(ps->rxHead > ps->bufferEnd)
                                                ps->rxHead -= ps->bufferEnd - ps->bufferRxStart + 1;                                                    
                                        MyTCB.sHoleSize = -1;
                                }
                        }
                } // This packet is out of order or we lost a packet, see if we can generate a hole to accomodate it
                else if((SHORT)wMissingBytes > 0)
                {
                        // Position packet read pointer to start of useful data area.
                        IPSetRxBuffer(h->DataOffset.Val << 2);
        
                        // See if we need a two part copy (spans bufferEnd->bufferRxStart)
                        if(ps->rxHead + wMissingBytes + len > ps->bufferEnd)
                        {
                                // Calculate number of data bytes to copy before wraparound
                                wTemp = ps->bufferEnd - ps->rxHead + 1 - wMissingBytes;
                                if((SHORT)wTemp >= 0)
                                {
                                        MACMemCopyAsync(ps->rxHead + wMissingBytes, -1, wTemp);
                                        MACMemCopyAsync(ps->bufferRxStart, -1, len - wTemp);
                                }
                                else
                                {
                                        MACMemCopyAsync(ps->rxHead + wMissingBytes - (ps->bufferEnd - ps->bufferRxStart + 1), -1, len);
                                }
                        }
                        else
                        {
                                MACMemCopyAsync(ps->rxHead + wMissingBytes, -1, len);
                        }
                
                        // Record the hole is here
                        if(MyTCB.sHoleSize == -1)
                        {
                                MyTCB.sHoleSize = wMissingBytes;
                                MyTCB.wFutureDataSize = len;
                        }
                        else
                        {
                                // We already have a hole, see if we can shrink the hole 
                                // or extend the future data size
                                if(wMissingBytes < (WORD)MyTCB.sHoleSize)
                                {
                                        if((wMissingBytes + len > (WORD)MyTCB.sHoleSize + MyTCB.wFutureDataSize) || (wMissingBytes + len < (WORD)MyTCB.sHoleSize))
                                                MyTCB.wFutureDataSize = len;
                                        else
                                                MyTCB.wFutureDataSize = (WORD)MyTCB.sHoleSize + MyTCB.wFutureDataSize - wMissingBytes;
                                        MyTCB.sHoleSize = wMissingBytes;
                                }
                                else if(wMissingBytes + len > (WORD)MyTCB.sHoleSize + MyTCB.wFutureDataSize)
                                {
                                        MyTCB.wFutureDataSize += wMissingBytes + len - (WORD)MyTCB.sHoleSize - MyTCB.wFutureDataSize;
                                }
                                
                        }

                        // Request a fast retransmit from remote node by sending three duplicate ACKs
                        //SendTCP(hTCP, ACK);
                        //while(!MACIsTxReady());
                        //MACFlush();
                        //while(!MACIsTxReady());
                        //MACFlush();
                }
        }

        // Make sure that we immediately send back an ack for the 
        // second segment received
        if(ps->Flags.bOneSegmentReceived)
                return ACK;

        ps->Flags.bOneSegmentReceived = TRUE;   

        // Do not send an ACK immediately back.  Instead, we will 
        // perform delayed acknowledgements.  To do this, we will 
        // just start a timer
        if(!ps->Flags.bDelayedACKTimerEnabled)
        {
                ps->Flags.bDelayedACKTimerEnabled = TRUE;
                ps->delayedACKTime = (WORD)TickGet() + (WORD)(TICK_SECOND/5);
        }
        
        return 0;
}

#endif //#if defined(STACK_USE_TCP)