// 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:

// in_trans.cpp - transport layer protocol base

//

#include "in_trans.h"

#include "inet6log.h"

#include <e32math.h>

#include <comms-infras/nifif_internal.h>

// speed optimisations

#ifdef __ARMCC__

#pragma push

#pragma arm

#endif

#define SYMBIAN_NETWORKING_UPS

CProtocolInet6Transport::CProtocolInet6Transport()

	{

	// Initialize random seed value

	TTime  currentTime;

	currentTime.HomeTime();

	iSeed = currentTime.Int64() + User::TickCount();

	}

void CProtocolInet6Transport::InitL(TDesC& aTag)

	{

	CProtocolInet6Base::InitL(aTag);

	}

void CProtocolInet6Transport::StartL()

	{

	CProtocolInet6Base::StartL();

	}

CProtocolInet6Transport::~CProtocolInet6Transport()

	{

	}

TInt CProtocolInet6Transport::Send(RMBufChain& /*aPacket*/,CProtocolBase* /*aSourceProtocol=NULL*/)

	{

	Panic(EInet6Panic_NotSupported);

	return 0;

	}

//

// Bind request from a protocol above us

//

void CProtocolInet6Transport::BindL(CProtocolBase* /*aProtocol*/, TUint /*aId*/)

	{

	Panic(EInet6Panic_NotSupported);

	}

//

// Find SAP based on end-point addresses.

//

// This routine is rather involved, because it is used for a number of different

// purposes. The routine returns a "best match" socket provider based on source

// and destination socket addresses (IP address & port), or NULL if no mathing

// provider is found (see below for an explanation on how matches are ranked).

//

// The method supports the following forms:

//

//  o LocateProvider(minimum rank, local socket address);  or

//    LocateProvider(minimum rank, local socket address, unspecified socket address);

//

//    This form is used when binding a socket in order to check that the port is

//    not already in use. At least local port must be specified. Local address

//    may be unspecified.  The first provider that matches the local port (and

//    local address, if given) is returned.

//

//  o LocateProvider(minimum rank, local socket address, remote socket address);

//

//    This form is used in order to locate the correct socket provider, when

//    a transport PDU has been received. For this use, the complete local

//    and remote addresses must be specified.

//

//    Another use of this form is to verify the uniqueness of the source/destination

//    socket address pair when creating a new connection. This is only an issue if

//    the source port has been explicitly bound and local address reuse has been enabled.

//    In this case, the destination socket address MUST be unique among all connections

//    terminating in the same local socket address.

//

//    Note: for the latter use, local IP address may be left unspecified. In this case,

//    it matches all addresses. Local port is mandatory.

//

//  The minimum rank parameter specifies the minimum acceptable accuracy of the match.

//  The the match with the highest rank found is returned, or NULL if no match of

//  at least the requested rank is found.

//

//  Matches are ranked as follows (highest rank first):

//

//   EMatchExact or EMatchConnection:

//

//        Both local and remote socket addresses match. Local IP address may be

//        unspecified, if the connection is waiting for a flow to become ready.

//

//        This rank is only relevant if caller specified a remote address.

//        The returned socket provider handles a connected socket.

//

//   EMatchServerSpecAddr:

//

//        Local socket address matches and remote socket address is unspecified.

//

//        This means that the returned socket provider handles a server socket

//        that has been bound to a specific local address.

//

//   EMatchServerUnspecAddr:

//

//        Local port matches. Local IP address is unspecified. Remote socket address

//        is unspecified.

//

//        This means that the returned socket provider handles a server socket

//        that has been bound to an unspecified address.

//

//   EMatchLocalPort:

//

//        Local port must match. Local IP address or remote socket address are not tested.

//

//        This means that the returned socket provider will conflict with an attempted

//        bind() if the KSoReuseAddr socket option is not used.

//

#ifndef SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

CProviderInet6Transport* CProtocolInet6Transport::LocateSap(TProviderMatchEnum aRank, TUint aFamily, 

const TInetAddr& aLocalAddr, const TInetAddr& aRemoteAddr, CProviderInet6Base *aSap)

#else

CProviderInet6Transport* CProtocolInet6Transport::LocateSap(TProviderMatchEnum aRank, TUint aFamily,

		const TInetAddr& aLocalAddr, const TInetAddr& aRemoteAddr, CProviderInet6Base *aSap,

		TUint32 aSourceIfIndex)

#endif //SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

	{

	ASSERT(aLocalAddr.Port() != KInetPortNone);

	CProviderInet6Transport *sapFound = NULL, *sap;

	TUint port = aLocalAddr.Port();

	TProviderMatchEnum rank = (TProviderMatchEnum)(aRank-1);

	// CProtocolInet6Base::LocateProvider() puts us into the right hashed queue.

	for (sap = (CProviderInet6Transport *)(aSap != NULL ? aSap : CProtocolInet6Base::LocateProvider(port));

			sap != NULL; sap = (CProviderInet6Transport *)sap->iNextSAP)

		{

		// If aSap non-NULL, return first match

		if (aSap != NULL && rank >= aRank)

			break;

		const TInetAddr& local = sap->iFlow.FlowContext()->LocalAddr();

		if (port != local.Port())

			continue;

#ifdef SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

        // In case of loopback no need to lock interface

		if(!aLocalAddr.IsLoopback())

		    {	

		    // Port matches this SAP, so if this SAP has an interface that it is

		    // locked to, confirm the inbound packet is on that interface. That is,

		    // if the SAP is locked to an interface, this code ensures that the

		    // packet is only accepted if it is coming over the same interface

		    // that the SAP is locked to.

		    TScopeType scoping = sap->iFlow.FlowContext()->LockType();

		    TUint32 interfaceNum = sap->iFlow.FlowContext()->LockId();

		    // Check that the source interface index was supplied. Also check for lock id > 0.

		    // If lock id > 0 this implies that the interface is locked down for this SAP. Also

		    // ignore the magic value lock id of KNetworkIdFromAddress.

		    if ((aSourceIfIndex > 0) && (interfaceNum > 0) && (interfaceNum != KNetworkIdFromAddress))

			    {

			    // The sap currently being checked is locked to an interface. Check to

			    // see what type of lock (scoping) it is.

			    if (scoping == EScopeType_IF)

			   	    {

			   	    // This sap is locked to EScopeType_IF

	                if (interfaceNum != aSourceIfIndex)

	            	    {

	            	    // Not the right interface, go to next SAP

	                    continue;

	                    }

            	    }

			    else 

				    {

				    // Not locked to EScopeType_IF, so now need the network ID and IAP number from the

				    // interface, to check against one of those. Fetch this from the source interface

				    // based on the interface index.

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

				    if (iface)

					    {

					    if (scoping == EScopeType_IAP)

						    {

						    // This sap is locked to EScopeType_IAP. Check if the source interface

						    // is over the same IAP.

						    TUint id = iface->Scope(EScopeType_IAP);

						    if (id != interfaceNum)

							    {

							    // IAP does not match that required

							    continue;  

							    } 							

						    }

					    else if (scoping == EScopeType_NET )

						    { 

						    // This sap is locked to EScopeType_NET. Check if the source interface

						    // is over the same network ID.

						    TUint id = iface->Scope(EScopeType_NET);

						    if (id != interfaceNum) 

							    {

							    // Network ID does not match that required

							    continue;    

							    }

						    }

					    }

				    }

			    }

			}

#endif //SYMBIAN_STRICT_EXPLICIT_SOCKET_BINDING

		const CFlowContext *const flow = sap->iFlow.FlowContext();

		TBool localMatch = aLocalAddr.CmpAddr(local) &&

			(aLocalAddr.Scope() == 0 || aLocalAddr.Scope() == local.Scope());

		if (!sap->iSockFlags.iAddressSet || localMatch)

			{

			if (sap->iSockFlags.iConnected)

				{

				if (localMatch && aRemoteAddr.CmpAddr(flow->RemoteAddr())

					&& (aRemoteAddr.Scope() == 0 || aRemoteAddr.Scope() == flow->RemoteAddr().Scope()))

					{

					rank = EMatchExact;

					sapFound = sap;

					break;

					}

				}

			else

				{

				if (rank >= EMatchServerSpecAddr)

					continue;

				if (localMatch)

					{

					rank = EMatchServerSpecAddr;

					sapFound = sap;

					continue;

					}

				if (rank >= EMatchServerUnspecAddr)

					continue;

				if (sap->iSockFamily == aFamily || sap->iSockFamily == KAFUnspec || aFamily == KAFUnspec)

					{

					rank = EMatchServerUnspecAddr;

					sapFound = sap;

					continue;

					}

				}

			}

		if (rank >= EMatchLocalPort)

			continue;

		rank = EMatchLocalPort;

		sapFound = sap;

		}

#ifdef _LOG

	TBuf<50> src, dst;

	//TBuf<50> src2, dst2;

	aLocalAddr.OutputWithScope(src);

	aRemoteAddr.OutputWithScope(dst);

	Log::Printf(_L("\t%S LocateProvider({%S,%d} <--> {%S,%d})"),

		&ProtocolName(), &src, port, &dst, aRemoteAddr.Port());

	if (sapFound)

		{

		TBuf<50> src2, dst2;

		sapFound->iFlow.FlowContext()->LocalAddr().OutputWithScope(src2);

		sapFound->iFlow.FlowContext()->RemoteAddr().OutputWithScope(dst2);

		Log::Printf(_L("\t%S SAP[%u] found {%S,%d} <--> {%S,%d}, rank=%d, family=%x"),

			&ProtocolName(), (TInt)sapFound,

			&src2, port, &dst2, sapFound->iFlow.FlowContext()->RemotePort(),

			rank, aFamily);

		}

	else

		{

		Log::Printf(_L("\t%S SAP not found, best rank=%d, family=%x"), &ProtocolName(), rank, aFamily);

		}

#endif

	return (CProviderInet6Transport *)sapFound;

	}

#ifdef _LOG

#include "tcp.h"

void CProtocolInet6Transport::LogProviders(TUint aPort)

	{

	CProviderInet6Base *sap;

	TBool title = EFalse;

	for (sap = CProtocolInet6Base::LocateProvider(aPort); sap != NULL; sap = sap->iNextSAP)

		{

		if (aPort != sap->iFlow.FlowContext()->LocalPort())

			continue;

		if (!title)

			{

			title = ETrue;

			Log::Printf(_L("Active TCBs on %S port %d:"), &ProtocolName(), aPort);

			}

		TBuf<50> src, dst;

		sap->iFlow.FlowContext()->LocalAddr().OutputWithScope(src);

		sap->iFlow.FlowContext()->RemoteAddr().OutputWithScope(dst);

		Log::Printf(_L("\t%S SAP[%u] {%S,%d} <--> {%S,%d} [reuse=%d]   %s"),

			&ProtocolName(), (TInt)sap,

			&src, sap->iFlow.FlowContext()->LocalPort(),

			&dst, sap->iFlow.FlowContext()->RemotePort(),

			((CProviderInet6Transport*)sap)->iSockFlags.iReuse,

			(sap->iFlow.FlowContext()->Protocol() == KProtocolInetTcp) ?

			((CProviderTCP6*)sap)->TcpState() : _S("UDP"));

		}

	}

#endif

//

// Pick a free port by random from the range [32768,61000].

// Random ephemeral port selection will help counter certain

// types of attacks.

//

TUint CProtocolInet6Transport::AssignAutoPort()

	{

	TUint i, port = KInetMinAutoPort + Random(KInetMaxAutoPort - KInetMinAutoPort + 1);

	for (i = KInetMinAutoPort; i <= KInetMaxAutoPort; i++)

		{

		if (CProtocolInet6Base::LocateProvider(port) == NULL)

			return port;

		if (++port > KInetMaxAutoPort)

			port = KInetMinAutoPort;

		}

	return KInetPortNone;

	}

TInt CProtocolInet6Transport::GetIniValue(	const TDesC &aSection,

											const TDesC &aName,

											TInt aDefault,

											TInt aMin,

											TInt aMax,

											TBool aBoundMode) const

/**

Reads integer value for ini parameters from tcpip.ini file.

@param aSection		Section under which ini parameter belongs ([xxx] tag).

@param aName		Name of the ini parameter.

@param aDefault		Default value for the parameter, if not given in ini file.

@param aMin			Minimum limit for the parameter value.

@param aMax			Maximum limit for the parameter value.

@param aBoundMode	If ETrue, values that exceed min or max are truncated back to the min/max

					boundary. If EFalse, exceeding values are considered invalid, and default

					is used for those parameters.

@return	Integer value for the parameter.

*/											

	{

	LOG(_LIT(KFormat, "\t[%S] %S = %d"));

	LOG(_LIT(KFormatInv, "\t[%S] %S = %d is invalid"));

	TInt value;

	if (!Interfacer()->FindVar(aSection, aName, value))

		{

		value = aDefault;

		}

	else

		{		

		if (value < aMin)

			{

			LOG(Log::Printf(KFormatInv, &aSection, &aName, value));

			value = aBoundMode ? aMin : aDefault;

			}

		else if (value > aMax)

			{

			LOG(Log::Printf(KFormatInv, &aSection, &aName, value));

			value = aBoundMode ? aMax : aDefault;

			}

		}

	LOG(Log::Printf(KFormat, &aSection, &aName, value));

	return value;

	}

//

// Transport Layer Socket Providers

//

CProviderInet6Transport::CProviderInet6Transport(CProtocolInet6Base *aProtocol)

	: CProviderInet6Base(aProtocol)

	{

	iSockFlags.iRecvClose       = EFalse;

	iSockFlags.iSendClose       = EFalse;

	iSockFlags.iConnected       = EFalse;

	iSockFlags.iFlowStopped     = EFalse;

	iSockFlags.iNotify          = ETrue;

	iSockFlags.iReuse           = EFalse;

	iSockFlags.iAttached        = ETrue;

//	iSockFlags.iRawMode         = EFalse;

//	iSockFlags.iHeaderIncluded  = EFalse;

	iSockFamily                 = KAFUnspec;

	iAppFamily                  = KAFUnspec;

	}

CProviderInet6Transport::~CProviderInet6Transport()

	{

	}

void CProviderInet6Transport::LocalName(TSockAddr &aAddr) const

	{

	aAddr = iFlow.FlowContext()->LocalAddr();

	if (iAppFamily == KAfInet)

		TInetAddr::Cast(aAddr).ConvertToV4();

	}

TInt CProviderInet6Transport::SetLocalName(TSockAddr &aAddr)

	{

#ifdef _LOG

	TBuf<50> a; TInetAddr::Cast(aAddr).OutputWithScope(a);

	LOG(Log::Printf(_L("\t%S SAP[%u] SetLocalName({%S,%d}) [reuse=%d]"),

		&ProtocolName(), (TInt)this,

		&a, aAddr.Port(), iSockFlags.iReuse));

#endif

	LOG(((CProtocolInet6Transport*)iProtocol)->LogProviders(aAddr.Port()));

	TInetAddr addr = aAddr;

	// Bound already?

	if (iFlow.FlowContext()->LocalPort() != KInetPortNone)

		return KErrAlreadyExists;

	// Convert an IPv4 address to a V4 Mapped IPv6 address

	if (addr.Family() == KAfInet)

		addr.ConvertToV4Mapped();

	// Check source address

	if (addr.Family() != KAFUnspec)

		{

		iSockFamily = addr.IsV4Mapped() ? KAfInet : KAfInet6;

		if (!addr.IsUnspecified())

			{

			if (addr.Scope() == 0)

				{

				// Check address and pick a default scope id

				addr.SetScope(iProtocol->Interfacer()->LocalScope(addr.Ip6Address(),

					iFlow.FlowContext()->LockId(), iFlow.FlowContext()->LockType()));

				if (addr.Scope() == 0)

					return KErrNotFound;

				}

			else

				{

				// Check scoped address

				if (addr.Scope() != iProtocol->Interfacer()->LocalScope(addr.Ip6Address(),

					addr.Scope(), (TScopeType)(addr.Ip6Address().Scope() - 1)))

					return KErrNotFound;

				}

			}

		}

	// Autobind requested?

	if (addr.Port() == KInetPortNone)

		{

		addr.SetPort(((CProtocolInet6Transport*)iProtocol)->AssignAutoPort());

		if (addr.Port() == KInetPortNone)

			return KErrInUse;

		}

	else

		{

		if (addr.Port() > 65535)

			return KErrTooBig;

		if (!iSockFlags.iReuse && Protocol()->LocateSap(EMatchLocalPort, aAddr.Family(), addr))

			return KErrInUse;

		}

	iAppFamily = aAddr.Family();  // aAddr here to get the original family

	CProviderInet6Base::SetLocalName(addr);

	iSockFlags.iAddressSet = iFlow.FlowContext()->IsLocalSet();

	iProtocol->BindProvider(this);

	return KErrNone;

	}

void CProviderInet6Transport::RemName(TSockAddr &aAddr) const

	{

	aAddr = iFlow.FlowContext()->RemoteAddr();

	if (iAppFamily == KAfInet)

		TInetAddr::Cast(aAddr).ConvertToV4();

	}

TInt CProviderInet6Transport::SetRemName(TSockAddr &aAddr)

	{

	//__ASSERT_DEBUG(!iSockFlags.iConnected && iFlow.FlowContext()->RemoteAddr().IsUnspecified() && iFlow.FlowContext()->RemotePort() == KInetPortNone,

	//		 Panic(EInet6Panic_NotSupported));

	TInetAddr addr = aAddr; 

#ifdef _LOG

	TBuf<50> a; addr.OutputWithScope(a);

	LOG(Log::Printf(_L("\t%S SAP[%u] SetRemName({%S,%d})"), &ProtocolName(), (TInt)this, &a, addr.Port());)

#endif

	TUint port = addr.Port(); 

	if (port < 1)

		return KErrGeneral;

	else if (port > 65535)

		return KErrTooBig;