/*

* Copyright (c) 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: 

*

*/

#include <e32std.h>

#include <eui_addr.h>

#include <ip4_hdr.h>

#include <udp_hdr.h>

#include <tcp_hdr.h>

#include <in_chk.h>

#include <in_iface.h>

#include <comms-infras/nifif.h>

#include <in_sock.h>

#include "var.h"

#include "binder.h"

#include "provision.h"

#ifdef SYMBIAN_ZERO_COPY_NETWORKING

#include <comms-infras/commsbuf.h>

#include <comms-infras/commsbufpond.h>

#include <comms-infras/commsbufpondop.h>

#else

#include <comms-infras/mbufmanager.h>

#endif

using namespace ESock;

#ifdef _DEBUG

_LIT8(KNif,"Legacy");

_LIT8(KBinder4,"Binder4");

_LIT8(KBinder6,"Binder6");

#endif

//

// CLegacyLoopbackBinder4 //

//

CLegacyLoopbackBinder4::CLegacyLoopbackBinder4(CLegacyLoopbackSubConnectionFlow& aLegacyLoopbackSubConnectionFlow) : iLegacyLoopbackSubConnectionFlow(aLegacyLoopbackSubConnectionFlow)

	{

    __FLOG_OPEN(KNif, KBinder4);

   	// generate my local ip address (ip4) - vals potentially will be overwritten by any derived classes

	iLocalAddressBase = KLegacyLoopbackLocalAddressBase; // also used later in control method

	TUint32 id = ((TUint32)this) % 255;

	// Avoid the reserved address (least significant byte KLegacyLoopbackReservedHostId) that

	// is never to be allocated as a local address.

	if (id == KLegacyLoopbackReservedHostId)

		{

		++id;

		}

	iLocalAddress = iLocalAddressBase + id;

    __FLOG_3(_L8("CLegacyLoopbackBinder4 %08x:\tCLegacyLoopbackBinder4(CLegacyLoopbackSubConnectionFlow& %08x): iLocalAddress %08x"), this, &aLegacyLoopbackSubConnectionFlow, iLocalAddress);

}

CLegacyLoopbackBinder4::~CLegacyLoopbackBinder4()

/** 

Destroys 'this'

*/

    {

    if (iTestSubscriber)

    	{

    	iTestSubscriber->Cancel();

    	}

    delete iTestSubscriber;

    delete iDrvReceiver;

    delete iDrvSender;

    __FLOG_1(_L8("CLegacyLoopbackBinder4 %08x:\t~CLegacyLoopbackBinder4()"), this);

    ASSERT(iUpperControl == NULL);

    ASSERT(iUpperReceiver == NULL);

	ASSERT(!iErrorOneShot.IsActive());

    RDebug::Printf("closing driver\n");

    iDrv.Close();

    __FLOG_CLOSE;

    }

CLegacyLoopbackBinder4* CLegacyLoopbackBinder4::NewL(CLegacyLoopbackSubConnectionFlow& aLegacyLoopbackSubConnectionFlow)

	{

	CLegacyLoopbackBinder4* self = new (ELeave) CLegacyLoopbackBinder4(aLegacyLoopbackSubConnectionFlow);

	CleanupStack::PushL(self);

	const TProviderInfo& providerInfo = static_cast<const TProviderInfoExt&>(

		aLegacyLoopbackSubConnectionFlow.AccessPointConfig().FindExtensionL(

			STypeId::CreateSTypeId(TProviderInfoExt::EUid, TProviderInfoExt::ETypeId))).iProviderInfo;

	TInt ap = providerInfo.APId();

	if(CLegacyLoopbackFlowTestingSubscriber::ShouldRun(ap))

		{

		ASSERT(self->iTestSubscriber==NULL);

		self->iTestSubscriber = CLegacyLoopbackFlowTestingSubscriber::NewL(aLegacyLoopbackSubConnectionFlow, ap);

		}

	// The send and receive paths each have an AO

	self->iDrvReceiver = new(ELeave) CDrvReceiver(CActive::EPriorityHigh);

	self->iDrvSender = new(ELeave) CDrvSender(CActive::EPriorityHigh);

	CleanupStack::Pop(self);

	return self;

	}

void CLegacyLoopbackBinder4::LogPacketDetails(TInet6HeaderIP4* aIp4, const TDesC8& aCaption)

    {

    static_cast<void>(aIp4);

    static_cast<void>(aCaption);

#if defined __FLOG_ACTIVE

    TBuf8<KLogBufferSize> log;

    TInet6HeaderUDP* udp = NULL;

    TInet6HeaderTCP* tcp = NULL;

    TBuf8<10> prot;

    TBuf8<40> length;

    TInt srcPort = -1;

    TInt dstPort = -1;

    if(aIp4->Protocol() == KProtocolInetUdp)

        {

        udp = (TInet6HeaderUDP*) aIp4->EndPtr();

        prot = _L8("UDP");

        length.Format(_L8("payload %d"), udp->Length());

        srcPort = udp->SrcPort();

        dstPort = udp->DstPort();

        }

    else if(aIp4->Protocol() == KProtocolInetTcp)

        {

        tcp = (TInet6HeaderTCP*) aIp4->EndPtr();

        prot = _L8("TCP");

        length.Format(_L8("payload %d"), aIp4->TotalLength() - aIp4->HeaderLength() - tcp->HeaderLength());

        srcPort = tcp->SrcPort();

        dstPort = tcp->DstPort();

        }

    else

        {

        prot.Format(_L8("%d"), aIp4->Protocol());

        length.Format(_L8("tot_len %d"), aIp4->TotalLength());

        }	

    TDes8IgnoreOverflow overflow;

    log.AppendFormat(_L8("%S %S %S src %08x:%d, dst %08x:%d"), &overflow, &aCaption, &prot, &length,

            aIp4->SrcAddr(), srcPort, aIp4->DstAddr(), dstPort);

    __FLOG(log);

#endif    

    }

void CLegacyLoopbackBinder4::UpdateHeaders(TInet6HeaderIP4* aIp4, TInet6HeaderUDP* aUdp)

/**

Update the IPv4 and UDP headers to allow the packet to be looped back.

*/

{

	__FLOG_STMT( LogPacketDetails(aIp4, _L8("CLegacyLoopbackBinder4:\tUpdateHeaders(...): ")) );

	// swap over the destination and source addresses

	TUint32 temp;

	temp = aIp4->SrcAddr();

	aIp4->SetSrcAddr(aIp4->DstAddr());

	aIp4->SetDstAddr(temp);

   	// swap over the destination and source ports

	if (aUdp)

		{

		TUint tempPort;

		tempPort = aUdp->DstPort();

		aUdp->SetDstPort(aUdp->SrcPort());

		aUdp->SetSrcPort(tempPort);

		}

	// NB: don't need to recalculate any checksums since luckily IP sums don't detect transposition

	__FLOG_4(_L("CLegacyLoopbackBinder4:\tUpdateHeaders(...): became src %08x:%d, dst %08x:%d"), 

			aIp4->SrcAddr(), aUdp? (TInt)aUdp->SrcPort(): -1, (TInt)aIp4->DstAddr(), aUdp? (TInt)aUdp->DstPort(): -1);

}

MLowerDataSender::TSendResult CLegacyLoopbackBinder4::Send(RMBufChain& aData)

/**

Entry point for receiving IPv4 outgoing data

@param aData MBuf chain containing data to send

@return an indication of whether the upper layer should block.

*/

	{

    RMBufPacket& pkt = static_cast<RMBufPacket&>(aData);

    pkt.Unpack();

	TInet6HeaderIP4* ip4 = (TInet6HeaderIP4*) pkt.First()->Ptr();

    __FLOG_STMT( LogPacketDetails(ip4, _L8("CLegacyLoopbackBinder4:\tSend(...): ")) );

	if (ip4->Protocol() == KProtocolInetUdp || ip4->Protocol() == KProtocolInetTcp)

		{

		// get the "udp" header as well - cheating & relying upon UDP & TCP being in same place

		TInet6HeaderUDP* udp = (TInet6HeaderUDP*) ip4->EndPtr();

		// use the source or destination port number to decide whether or not to pass it through the loopback driver

		// very weak this; dynamic ports could overlap. Really should do this for all packets and

		// fix any impacted test code

		TUint srcPort = udp->SrcPort();

		TUint dstPort = udp->DstPort();

		if(dstPort >= KDriverReflectionRangeStartPort && dstPort <= KDriverReflectionRangeEndPort ||

			srcPort >= KDriverReflectionRangeStartPort && srcPort <= KDriverReflectionRangeEndPort)

			{

			if(!iLoopbackLoadAttempted)

				{

				iLoopbackLoadAttempted = ETrue;

				TInt r = User::LoadPhysicalDevice(KLegacyLoopbackPddFileName);

				RDebug::Printf("Loading PDD - %d\n", r);

				if(r == KErrNone || r == KErrAlreadyExists)

					{

					r = User::LoadLogicalDevice(KLegacyLoopbackLddFileName);

					RDebug::Printf("Loading LDD - %d\n", r);

					if(r == KErrNone || r == KErrAlreadyExists)

						{

						r = iDrv.Open();

						RDebug::Printf("Opening driver - %d\n", r);

						if(r == KErrNone)

							{

							// Prime the pathways

							iDrvReceiver->Start(this, iDrv);

							iDrvSender->Start(this, iDrv);

							}

						}

					}

				}

			if(iDrv.Handle())

				{

				// Swap the ports, because the receipt path also unconditionally swaps them (probably

				// some test needs this 

				// ugh! should use a queue here when the write is still busy

				udp->SetDstPort(srcPort);

				udp->SetSrcPort(dstPort);

				__FLOG_4(_L("CLegacyLoopbackBinder4:\tSend(...): passing packet to driver as src %08x:%d, dst %08x:%d"),  

						ip4->SrcAddr(), dstPort, ip4->DstAddr(), srcPort);

				iDrvSender->QueueForSend(pkt);

				return ESendAccepted;

				}

			}

		else if(dstPort >= KBearerReflectionRangeStartPort && dstPort <= KBearerReflectionRangeEndPort ||

					srcPort >= KBearerReflectionRangeStartPort && srcPort <= KBearerReflectionRangeEndPort)

			{

			// Swap the ports, because the receipt path also unconditionally swaps them (probably

			// some test needs this 

			udp->SetDstPort(srcPort);

			udp->SetSrcPort(dstPort);

			}

		}

	// Loop the data straight back into the TCP/IP stack

	pkt.Pack();

	ProcessPacket(aData);

	return ESendAccepted;

	}

MLowerDataSender* CLegacyLoopbackBinder4::Bind(MUpperDataReceiver& aUpperReceiver, MUpperControl& aUpperControl)

/**

Return the MLowerDataSender instance (CLegacyLoopbackBinder4) that we

previously allocated.

*/

	{

    __FLOG_3(_L8("CLegacyLoopbackBinder4 %08x:\tBind(aUpperReceiver %08x, aUpperControl %08x)"), this, &aUpperReceiver, &aUpperControl);

	iUpperReceiver = &aUpperReceiver;

	iUpperControl = &aUpperControl;

	// Signal upper layer that we are ready

	BinderReady();

	return this;

	}

void CLegacyLoopbackBinder4::Unbind(MUpperDataReceiver& aUpperReceiver, MUpperControl& aUpperControl)

/**

Forget our association with upper layer.

*/

	{

    static_cast<void>(aUpperReceiver);

    static_cast<void>(aUpperControl);

    __FLOG_1(_L8("CLegacyLoopbackBinder4 %08x:\tUnbind()"), this);

    ASSERT(&aUpperReceiver == iUpperReceiver);

    ASSERT(&aUpperControl == iUpperControl);

    iUpperReceiver = NULL;

    iUpperControl = NULL;

	}

void CLegacyLoopbackBinder4::BinderReady()

/**

Signal upper layer that we are ready

*/

	{

    __FLOG_1(_L8("CLegacyLoopbackBinder4 %08x:\tBinderReady()"), this);

	iUpperControl->StartSending();

	}

void CLegacyLoopbackBinder4::ProcessPacket(RMBufChain& aPdu)

/**

Process incoming data

*/

    {

	// this received data has already been looped back...

	// get the ip header from the RMBufChain

	TInet6HeaderIP4* ip4 = (TInet6HeaderIP4*) aPdu.First()->Next()->Ptr();

	if (ip4->Protocol() != KProtocolInetUdp && ip4->Protocol() != KProtocolInetTcp)

		{

		//Non UDP traffic goes here!

		__FLOG_3(_L("CLegacyLoopbackBinder4 %08x:\tProcessPacket(): IPv4 length %d, protocol %d"), this, ip4->TotalLength(), ip4->Protocol());

		UpdateHeaders(ip4, NULL);

		// now process it (pass up the stack)

		iUpperReceiver->Process(aPdu);

		return;

		}

	// get the udp header as well - assume only udp traffic here

    __FLOG_STMT( LogPacketDetails(ip4, _L8("CLegacyLoopbackBinder4:\tProcessPacket(...): ")) );

	TInet6HeaderUDP* udp = (TInet6HeaderUDP*) ip4->EndPtr();

	// depending on the contents, pass it on up thru the stack 

	// or maybe do something else

	// use the destination port number to decide whether or not the payload is a command

	TUint dstPort = udp->DstPort();

	if (KLegacyLoopbackCmdPort == dstPort)

    	{

		// let's use the first payload byte as the command byte

		switch (*(udp->EndPtr()))

    		{

		    case KForceDisconnect:

			    __FLOG(_L("KForceDisconnect command"));

			    // do some action

	            Flow()->Progress(KLinkLayerClosed, KErrCommsLineFail);

	            Flow()->FlowDown(KErrCommsLineFail, MNifIfNotify::EDisconnect);

			    // no return code so all we can do is respond with what we got

			    UpdateHeaders(ip4, udp);

			    iUpperReceiver->Process(aPdu);

			    break;

		    case KForceReconnect:

			    __FLOG(_L("KForceReconnect command"));

			    // do some action

	            Flow()->Progress(KLinkLayerClosed, KErrCommsLineFail);

	            Flow()->FlowDown(KErrCommsLineFail, MNifIfNotify::EReconnect);

			    // no return code so all we can do is respond with what we got

			    UpdateHeaders(ip4, udp);

			    iUpperReceiver->Process(aPdu);

			    break;

		    case KSendNotification:

			    __FLOG(_L("KSendNotification command"));

			    //let's write the result in the next byte of the reply

			    if (Flow()->AgentProvision()->IsDialIn() == KErrNotSupported)

				    udp->EndPtr()[1] = (unsigned char) KErrNone;

			    else

				    udp->EndPtr()[1] = (unsigned char) KErrGeneral; // this will lose it's sign :-(

			    UpdateHeaders(ip4, udp);

                iUpperReceiver->Process(aPdu);

			    break;

			case KForceFinishedSelection:

				__FLOG(_L("KForceFinishedSelection command"));

				// force subConn into KFinishedSelection State

	            Flow()->Progress(KFinishedSelection, KErrNone);

				UpdateHeaders(ip4, udp);

				aPdu.Free();

				break;

    		case KForceBinderError:

			    __FLOG(_L("KForceBinderError command"));

				// We cannot signal an error whilst in the middle of a send in the TCP/IP stack,

				// as the act of signalling the error will eventually result in the CNifIfBase binder

				// being destructed by the TCP/IP stack whilst we're in the middle of using it.

				// Consequently, we would panic on exit from this routine.  So make the call

				// via an asynchronous callback.

				if (!iErrorOneShot.IsActive())

					{

					iErrorOneShot.Schedule(iUpperControl);

					}

    			aPdu.Free();

    			break;

    		case KColourDataByLinkTierAccessPointId:

				{

				const TProviderInfoExt* providerInfo = static_cast<const TProviderInfoExt*>(

					iLegacyLoopbackSubConnectionFlow.AccessPointConfig().FindExtension(

						STypeId::CreateSTypeId(TProviderInfoExt::EUid, TProviderInfoExt::ETypeId)));

				ASSERT(providerInfo); // Should always be present

				// We are going to simply add the access point id to the command byte

				// A test client can then validate that the socket is connected on the expected access point

			    __FLOG(_L("KColourDataByAccessPointId command"));

				*(udp->EndPtr()) += static_cast<TUint8>(providerInfo->iProviderInfo.APId());

				// Update the udp headers and forward on

				UpdateHeaders(ip4, udp);

				iUpperReceiver->Process(aPdu);

				}

				break;

		    default:

			    __FLOG(_L("Unknown command - ignoring it"));

			    aPdu.Free();

			    // unknown command, just ignore this packet???

		    }

	    }

	else

	    {

        __FLOG(_L("Standard echo packet"));

        if (iTestSubscriber && !iTestSubscriber->IsEnabled())

        	{

        	__FLOG(_L("Bearer not available. Packet dropped."));

        	aPdu.Free();

        	return;

        	}

        // just echo the packet back to the original sender

		// update the headers (addresses, checksums etc)

		UpdateHeaders(ip4, udp);

		// now process it (pass up the stack)

		iUpperReceiver->Process(aPdu);

		}

    }

TInt CLegacyLoopbackBinder4::GetConfig(TBinderConfig& aConfig)

/**

Return IPv4 configuration information.

Called from upper layer.

@param aConfig structure to populate with IPv4 configuration

*/

	{

    TBinderConfig4* config = TBinderConfig::Cast<TBinderConfig4>(aConfig);

	if(config == NULL)

		{

		return KErrNotSupported;

		}

	// Setup config

	config->iInfo.iFeatures = KIfCanBroadcast | KIfCanMulticast;

	config->iInfo.iMtu = KLoopbackBearerMTU;

	config->iInfo.iRMtu = KLoopbackBearerMTU;

	config->iInfo.iSpeedMetric = 0;

	config->iFamily = KAfInet6;

    TUint32 address;

	const TInt KPort = 65;

    config->iFamily = KAfInet;

	__FLOG_2(_L8("CLegacyLoopbackBinder4 %08x:\tGetConfig(): iLocalAddress %08x"), this, iLocalAddress);        

	config->iAddress.SetAddress(iLocalAddress);

	config->iAddress.SetPort(KPort);

	// network mask

	config->iNetMask.SetAddress(KInetAddrNetMaskC);	// 255.255.255.0

	config->iNetMask.SetPort(KPort);

	// broadcast address

	address = iLocalAddressBase + KBroadcastAddressSuffix;

	config->iBrdAddr.SetAddress(address);

	config->iBrdAddr.SetPort(KPort);

	// default gateway

	address = iLocalAddressBase + KDefaultGatewayAddressSuffix;

	config->iDefGate.SetAddress(address);

	config->iDefGate.SetPort(KPort);

	// primary DNS, just make same as default gateway

	config->iNameSer1.SetAddress(address);

	config->iNameSer1.SetPort(KPort);

	// secondary DNS

	address = iLocalAddressBase + KSecondaryDnsAddressSuffix;

	config->iNameSer2.SetAddress(address);

	config->iNameSer2.SetPort(KPort);

	return KErrNone;

	}

TInt CLegacyLoopbackBinder4::Control(TUint aLevel, TUint aName, TDes8& aOption)

/**

Called from upper layer for special control functionality.

*/

	{	

	(void) aLevel;

	(void) aName;

 	(void) aOption;

	__FLOG_3(_L("CLegacyLoopbackBinder4 %08x:\tControl(aLevel %x, aName %x)"), this, aLevel, aName);

	return KErrNotSupported;

	}

TInt CLegacyLoopbackBinder4::GetName(TDes& aName)

/**

Called from upper layer to retrieve the binder name.

@param aName populated with name

@return KErrNone on success, else a system wide error code.

*/

	{

	// This name matches the NIF-based DummyNif to match any potential

	// test code expectations on the name.

	aName.Format(_L("legacy_loopback[0x%08x]"), this);

	__FLOG_2(_L("CLegacyLoopbackBinder4 %08x:\tGetName(): %S"), this, &aName);

	return KErrNone;

	}

TInt CLegacyLoopbackBinder4::BlockFlow(MLowerControl::TBlockOption /*aOption*/)

	{

    __FLOG_1(_L8("CLegacyLoopbackBinder4 %08x:\tBlockFlow()"), this);