// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// tcp_sap.cpp - TCP service access point

// TCP Service Access Point and most of the protocol logic.

//

/**

 @file tcp_sap.cpp

*/

#include "tcp.h"

#include <in6_dstcache.h>

#include <in6_opt.h>

#include <in6_if.h>

#include <in6_dstcache_internal.h>

#include <nifman_internal.h>

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

#include <in_sock.h>

#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

// speed optimisations

#ifdef __ARMCC__

#pragma push

#pragma arm

#endif

#define SIGNED_UNSIGNED_FIX

// Copied from ip6.cpp. Should move to some common definition file?

static const TLitC8<sizeof(TInt)> KInetOptionDisable = {sizeof(TInt), {0}};

#define SYMBIAN_NETWORKING_UPS

//

//

// TCP state diagram from RFC793

//

//

//                              +---------+ ---------\      active OPEN

//                              |  CLOSED |            \    -----------

//                              +---------+<---------\   \   create TCB

//                                |     ^              \   \  snd SYN

//                   passive OPEN |     |   CLOSE        \   \.

//                   ------------ |     | ----------       \   \.

//                    create TCB  |     | delete TCB         \   \.

//                                V     |                      \   \.

//                              +---------+            CLOSE    |    \.

//                              |  LISTEN |          ---------- |     |

//                              +---------+          delete TCB |     |

//                   rcv SYN      |     |     SEND              |     |

//                  -----------   |     |    -------            |     V

// +---------+      snd SYN,ACK  /       \   snd SYN          +---------+

// |         |<-----------------           ------------------>|         |

// |   SYN   |                    rcv SYN                     |   SYN   |

// |   RCVD  |<-----------------------------------------------|   SENT  |

// |         |                    snd ACK                     |         |

// |         |------------------           -------------------|         |

// +---------+   rcv ACK of SYN  \       /  rcv SYN,ACK       +---------+

//   |           --------------   |     |   -----------

//   |                  x         |     |     snd ACK

//   |                            V     V

//   |  CLOSE                   +---------+

//   | -------                  |  ESTAB  |

//   | snd FIN                  +---------+

//   |                   CLOSE    |     |    rcv FIN

//   V                  -------   |     |    -------

// +---------+          snd FIN  /       \   snd ACK          +---------+

// |  FIN    |<-----------------           ------------------>|  CLOSE  |

// | WAIT-1  |------------------                              |   WAIT  |

// +---------+          rcv FIN  \                            +---------+

//   | rcv ACK of FIN   -------   |                            CLOSE  |

//   | --------------   snd ACK   |                           ------- |

//   V        x                   V                           snd FIN V

// +---------+                  +---------+                   +---------+

// |FINWAIT-2|                  | CLOSING |                   | LAST-ACK|

// +---------+                  +---------+                   +---------+

//   |                rcv ACK of FIN |                 rcv ACK of FIN |

//   |  rcv FIN       -------------- |    Timeout=2MSL -------------- |

//   |  -------              x       V    ------------        x       V

//    \ snd ACK                 +---------+delete TCB         +---------+

//     ------------------------>|TIME WAIT|------------------>| CLOSED  |

//                              +---------+                   +---------+

//

//  LISTEN - represents waiting for a connection request from any remote

//  TCP and port.

//

//  SYN-SENT - represents waiting for a matching connection request

//  after having sent a connection request.

//

//  SYN-RECEIVED - represents waiting for a confirming connection

//  request acknowledgment after having both received and sent a

//  connection request.

//

//  ESTABLISHED - represents an open connection, data received can be

//  delivered to the user.  The normal state for the data transfer phase

//  of the connection.

//

//  FIN-WAIT-1 - represents waiting for a connection termination request

//  from the remote TCP, or an acknowledgment of the connection

//  termination request previously sent.

//

//  FIN-WAIT-2 - represents waiting for a connection termination request

//  from the remote TCP.

//

//  CLOSE-WAIT - represents waiting for a connection termination request

//  from the local user.

//

//  CLOSING - represents waiting for a connection termination request

//  acknowledgment from the remote TCP.

//

//  LAST-ACK - represents waiting for an acknowledgment of the

//  connection termination request previously sent to the remote TCP

//  (which includes an acknowledgment of its connection termination request).

//

//  TIME-WAIT - represents waiting for enough time to pass to be sure

//  the remote TCP received the acknowledgment of its connection

//  termination request.

//

//  CLOSED - represents no connection state at all.

//

//  CONNECT - represents waiting for a network path to become ready after

//  the user has issued an active OPEN request. The request waits in this

//  state until all the necessary negotiations have been accomplished,

//  including the establishment of security and mobility bindings. CONNECT is

//  specific to this TCP implementation and is therefore not visible in the

//  state chart above. It would be located between CLOSED and SYN-SENT.

//

#ifdef _LOG

const TText *CProviderTCP6::TcpState(TUint aState)

	{

	TInt i;

	static const TText* const tcpStates[] = {

		_S("CONSTRUCTING"),

			_S("INITIAL"),

			_S("LISTEN"),

			_S("SYN-SENT"),

			_S("SYN-RECEIVED"),

			_S("ESTABLISHED"),

			_S("FIN-WAIT-1"),

			_S("FIN-WAIT-2"),

			_S("CLOSE-WAIT"),

			_S("CLOSING"),

			_S("LAST-ACK"),

			_S("TIME-WAIT"),

			_S("CLOSED"),

			_S("CONNECT"),

			_S("INVALID"),

			NULL

			};

	if (aState == ~0UL)

		aState = iState;

	for (i = 0; aState && tcpStates[i+1]; aState >>= 1)

		i++;

	return tcpStates[i];

	}

#endif

CProviderTCP6::CProviderTCP6(CProtocolInet6Base* aProtocol)

	: CProviderInet6Transport(aProtocol)

	{

	__DECLARE_NAME(_S("CProviderTCP6"));

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW	

	iWindowSetByUser = EFalse;

#endif	

	}

CProviderTCP6::~CProviderTCP6()

	{

	LOG(Log::Printf(_L("\ttcp SAP[%u] being deleted"), (TInt)this));

	Stop();

	FreeQueues();

	delete iTransmitter;

	delete iDelayAckTimer;

	delete iRetransTimer;

	delete iLingerTimer;

	// Delete server socket state

	if (iParent)

		{

		// Notify parent.

		iParent->SetChildDeleted(ETrue);

		iParent->DetachChild(this);

		}

	else if (iListenQueue)

		{

		//

		// Delete all pending child sockets. The child socket destructor will

		// call DetachChild(), removing itself from the socket queue. If the

		// socket has already been registered with the socket server, we will

		// simply detach it here.

		//

		while (iConnectCount)

			{

			ASSERT(iListenQueue[0]->iParent == this);

			if (iListenQueue[0]->iSockFlags.iAttached)

				DetachChild(iListenQueue[0]);

			else

			    {

			    if (iListenQueue[0]->InState(ETcpSynReceived))

			    	{

			    	iListenQueue[0]->ClearSYNSettings();

				    iListenQueue[0]->iSockFlags.iSendClose = ETrue;

				    iListenQueue[0]->iSockFlags.iRecvClose = ETrue;

				    iListenQueue[0]->SendSegments();

				    DetachChild(iListenQueue[0]);

			    	}

			   	else

					delete iListenQueue[0];

			    }

			}

		delete[] iListenQueue;

		}

	}

//

// Initialize a SAP with default values

//

void CProviderTCP6::InitL()

	{

	TCallBack sender(SenderCallBack, this);

	TCallBack receiver(ReceiverCallBack, this);

	TCallBack delack(DelayAckCallBack, this);

	TCallBack transmitter(TransmitterCallBack, this);

	TCallBack retransmitter(RetransmitterCallBack, this);

	TCallBack linger(LingerTimerCallBack, this);

	CProviderInet6Base::InitL();

	iFlow.SetProtocol(KProtocolInetTcp);

	iFlow.SetNotify(this);

	iSendQ.InitL(transmitter, 13);

	iRecvQ.InitL(receiver, 12);

	iTransmitter = new CAsyncCallBack(sender, KInet6DefaultPriority);

	iDelayAckTimer = new CTcpTimer(delack);

	iRetransTimer = new CTcpTimer(retransmitter);

	iLingerTimer = new CTcpTimer(linger);

	if (!iTransmitter || !iDelayAckTimer || !iRetransTimer || !iLingerTimer)

		User::Leave(KErrNoMemory);

	iDelayAckTimer->InitL();

	iRetransTimer->InitL();

	iLingerTimer->InitL();

	iSockInBufSize        = Protocol()->RecvBuf();

	iSockOutBufSize       = Protocol()->SendBuf();

	iSsthresh		= KMaxTInt32;

	iRTO			= Protocol()->InitialRTO();

	ClearRTT();

	iMSS                  = Protocol()->MSS();

	iSMSS			= KTcpStandardMSS;

	iRMSS			= KTcpStandardMSS;

	iLinger		= -1;  // linger disabled

	iFlags.iSackOk	    = Protocol()->Sack();

	iFlags.iUseTimeStamps	    = Protocol()->TimeStamps();

	iFlags.iEcn		    = (Protocol()->Ecn() != 0);

	// Report ICMP errors to application

	iSockFlags.iReportIcmp    = ETrue;

	if (iFlags.iUseTimeStamps)

		iOptions.SetTimeStamps(0, 0);

	if (iFlags.iSackOk)

		iOptions.SetSackOk();

	iOptions.SetAlignOpt(Protocol()->AlignOpt());

	iStartTime.UniversalTime();

	iState = ETcpInitial;

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    iHiddenFreeWindow 	= 0;

    iNewTcpWindow    	= 0;

    iTcpMaxRecvWin       = Protocol()->RecvMaxWnd();

#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	}

void CProviderTCP6::ReadDestinationCache()

	{

	if (!Protocol()->DstCache())  // Dest. cache is not enabled as ini parameter

		{

		return;

		}

	const TInetAddr& dstaddr = iFlow.FlowContext()->RemoteAddr();

	if (dstaddr.IsUnspecified())

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] ReadDestinationCache() : No destination address"), (TInt)this));

		return;

		}

	TInt err = KErrNone;

	MDestinationCache *dcache = NULL;

	TRAP(err, dcache = IMPORT_API_L(Protocol()->Interfacer(), MDestinationCache));

	if (err != KErrNone || dcache == NULL)

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] ReadDestinationCache() : DstCache not available"), (TInt)this));

		return;

		}

	const TCacheInfo *cinfo = dcache->Find(dstaddr);

	if (!cinfo)

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] ReadDestinationCache() : No match for address in cache"), (TInt)this));

		return;

		}

	if (cinfo->iMetrics[TCacheInfo::ESsThresh])

		{

		iSsthresh = cinfo->iMetrics[TCacheInfo::ESsThresh];

		}

	if (cinfo->iMetrics[TCacheInfo::ESRtt])

		{

		iSRTT = cinfo->iMetrics[TCacheInfo::ESRtt];

		}

	if (cinfo->iMetrics[TCacheInfo::ERto])

		{

		iRTO = cinfo->iMetrics[TCacheInfo::ERto];

		}

	LOG(Log::Printf(_L(

		"\ttcp SAP[%u] ReadDestinationCache() : Matching DstCache entry found [0x%08x] - ssthresh: %d"),

		(TInt)this, cinfo, iSsthresh));

	}

void CProviderTCP6::StoreDestinationCache()

	{

	if (!Protocol()->DstCache() || !iFlow.FlowContext())

		{

		return;

		}

	const TInetAddr& dstaddr = iFlow.FlowContext()->RemoteAddr();

	if (dstaddr.IsUnspecified())

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] StoreDestinationCache() : No destination address"), (TInt)this));

		return;

		}

	TInt err = KErrNone;

	MDestinationCache *dcache = NULL;

	TRAP(err, dcache = IMPORT_API_L(Protocol()->Interfacer(), MDestinationCache));

	if (err != KErrNone || dcache == NULL)

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] StoreDestinationCache() : DstCache not available"), (TInt)this));

		return;

		}

	TCacheInfo cinfo;

	cinfo.ClearAll();

	cinfo.iMetrics[TCacheInfo::ESsThresh] = iSsthresh;

	cinfo.iMetrics[TCacheInfo::ESRtt] = iSRTT;

	cinfo.iMetrics[TCacheInfo::ERto] = iRTO;

	TRAP(err, dcache->StoreL(dstaddr, cinfo));

	if (err != KErrNone)

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] StoreDestinationCache() : DstCache store failed"), (TInt)this));

		return;

		}

	}

void CProviderTCP6::Start()

	{

	LOG(Log::Printf(_L("Start\ttcp SAP[%u] enter"), (TInt)this));

	CProviderInet6Transport::Start();

	iFlags.iStarted = ETrue;

	//

	// Detach from parent socket

	//

	if (iParent)

		{

		iSockFlags.iNotify = ETrue;

		iParent->DetachChild(this);

		//

		// Tell ESock which network interface the child socket is using.

		//

		const MInterface *iface = Protocol()->Interfacer()->Interface(iFlow.FlowContext()->Interface());

		if (iface != NULL)

			{

			TPckgBuf<TSoIfConnectionInfo> netinfo;

			netinfo().iIAPId = iface->Scope(EScopeType_IAP);

			netinfo().iNetworkId = iface->Scope(EScopeType_NET);

			LOG(Log::Printf(_L("\ttcp SAP[%u] Bearer IAP=%d, NID=%d"), (TInt)this, netinfo().iIAPId, netinfo().iNetworkId));

			iSocket->Bearer(netinfo);

			}

		//

		// Report error if TCP has been disconnected already

		//

		if (InState(ETcpClosed))

			{

			LOG(Log::Printf(_L("\ttcp SAP[%u] %s, Error %d"), (TInt)this, TcpState(), KErrDisconnected));

			Error(KErrDisconnected);

			}

		}

	//

	// If an error has occurred, we must deliver it to the

	// socket server now that the socket notifier has been

	// initialised.

	//

	if (iLastError.iStatus != KErrNone && iErrorMask != 0)

		{

		LOG(Log::Printf(_L("\ttcp SAP[%u] Delayed error %d, mask %b delivered."),

			(TInt)this, iLastError.iStatus, iErrorMask));

		iSocket->Error(iLastError.iStatus, iErrorMask);

		}

	// Wake up the receiver. We might have something to do.

	iRecvQ.Wake();

	LOG(Log::Printf(_L("Start\ttcp SAP[%u] exit"), (TInt)this));

	}

//

// Stop all transmission (except for iSendQ, which will be allowed to drain)

//

void CProviderTCP6::Stop()

	{

	if (iTransmitter)

		CancelTransmit();

	if (iRetransTimer)

		CancelRetransmit();

	if (iDelayAckTimer)

		CancelDelayACK();

	if (iLingerTimer)

		iLingerTimer->Cancel();

	}

//

// Empty all queues

//

void CProviderTCP6::FreeQueues()

	{

	iSockInQ.Free();

	iSockInQLen = 0;

	iSockOutQ.Free();

	iSockOutQLen = 0;

	iFragQ.Free();

	iRecvQ.Free();

	iSendQ.Cancel();

	iSendQ.Free();

	}

//

// Close the socket down

//

void CProviderTCP6::Close()

	{

	StoreDestinationCache();

	iSockFlags.iSendClose = ETrue;

	iSockFlags.iRecvClose = ETrue;

	Protocol()->UnbindProvider(this);

	Stop();

	FreeQueues();

	EnterState(ETcpClosed);

	}

void CProviderTCP6::Ioctl(TUint aLevel, TUint aName, TDes8* aOption)

	{

	LOG(Log::Printf(_L("Ioctl\ttcp SAP[%u] %x, %x"), (TInt)this, aLevel, aName));

	if (aLevel == KSolInetTcp && aName == KIoctlTcpNotifyDataSent)

		{

		iFlags.iDataSentIoctl = ETrue;

		CompleteIoctl(KErrNone);

		}

	else

		CProviderInet6Transport::Ioctl(aLevel, aName, aOption);

	}

void CProviderTCP6::CancelIoctl(TUint aLevel, TUint aName)

	{

	LOG(Log::Printf(_L("CancelIoctl\ttcp SAP[%u] %x, %x"), (TInt)this, aLevel, aName));

	if (aLevel == KSolInetTcp && aName == KIoctlTcpNotifyDataSent)

		CompleteIoctl(KErrCancel);

	else

		CProviderInet6Transport::CancelIoctl(aLevel, aName);

	}

TInt CProviderTCP6::SetOption(TUint aLevel, TUint aName, const TDesC8& aOption)

	{

	TInt ret = KErrNotSupported;

	if (aLevel == KSolInetTcp)

		{

		TInt intValue;

		ret = GetOptionInt(aOption, intValue);

#ifdef _LOG

		if (ret == KErrNone)

			Log::Printf(_L("SetOpt\ttcp SAP[%u] KSolInetTcp, %d, %d"), (TInt)this, aName, intValue);

		else

			Log::Printf(_L("SetOpt\ttcp SAP[%u] KSolInetTcp, %d"), (TInt)this, aName);

#endif

		switch (aName)

			{

		case KSoTcpAsync2MslWait:

			// Not implemented. Not very useful.