// Copyright (c) 1997-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 <e32uid.h>

#include <networking/vj.h>

#include "ncpip.h"

#include "PPPLOG.H"

#include "PPP_VER.H"

#include <networking/pppprog.h>

#include <networking/pppdebug.h>

#include <commsdattypeinfov1_1.h>

#include <comms-infras/ss_subconnprov.h>

#include <networking/pppbase.h>

#include <networking/pppconfig.h>

using namespace ESock;

#if defined(__VC32__) && (_MSC_VER < 1300)

 #define PMF(x) x

#else

 #define PMF(x) &x

#endif

_LIT(KVjComp, "vjcomp");

#ifdef __FLOG_ACTIVE

_LIT8(KNif,"Ppp");

_LIT8(KPPPBinderIP4,"IP4");

#endif

//

// PPP for ESock

//

#ifdef __VC32__

// warning C4355: 'this' : used in base member initializer list

#pragma warning (disable:4355)

#endif

CPppBinderIp4::CPppBinderIp4(CPppLcp* aLcp)

	:   MPppFsm(aLcp, EPppPhaseNetwork, KPppIdIpcp),

        iPppNifSubConnectionFlow(aLcp),

		iIpRecvr(this, PMF(CPppBinderIp4::RecvIp), PMF(CPppBinderIp4::SendFlowOn), aLcp, EPppPhaseNetwork,

			KPppIdIp, PMF(CPppBinderIp4::IpFrameError), PMF(CPppBinderIp4::IpKillProtocol)),

		iVjCompTcpRecvr(this, PMF(CPppBinderIp4::RecvVjCompTcp), PMF(CPppBinderIp4::SendFlowOn), aLcp, EPppPhaseNetwork,

			KPppIdVjCompTcp, PMF(CPppBinderIp4::VjCompTcpFrameError), PMF(CPppBinderIp4::VjCompTcpKillProtocol)),

		iVjUncompTcpRecvr(this, PMF(CPppBinderIp4::RecvVjUncompTcp), PMF(CPppBinderIp4::SendFlowOn), aLcp, EPppPhaseNetwork,

			KPppIdVjUncompTcp, PMF(CPppBinderIp4::VjUncompTcpFrameError), PMF(CPppBinderIp4::VjUncompTcpKillProtocol))

	{

	__DECLARE_FSM_NAME(_S("IPCP"));

    __FLOG_OPEN(KNif, KPPPBinderIP4);

    __FLOG_2(_L8("this:%08x\tCPppBinderIp4::CPppBinderIp4(CPppLcp& %08x)"), this, &iPppNifSubConnectionFlow);

	}

#ifdef __VC32__

#pragma warning (default:4355)

#endif

CPppBinderIp4* CPppBinderIp4::NewL(CPppLcp* aLcp)

	{

	CPppBinderIp4* pppBinderIp4 = new(ELeave) CPppBinderIp4(aLcp);

	CleanupStack::PushL(pppBinderIp4);

	pppBinderIp4->ConstructL();

	CleanupStack::Pop(pppBinderIp4);

	return pppBinderIp4;

	}

CPppBinderIp4::~CPppBinderIp4()

	{

	CObjectCon* con;

	TInt		i;

	Deregister();

	iIpRecvr.Deregister();

	iVjCompTcpRecvr.Deregister();

	iVjUncompTcpRecvr.Deregister();

	delete iSendCallBack;

	if (iVJCompressor)

		{

		iVJCompressor->Close();

		iVJCompressor = NULL;

		}

	if (iVJDecompressor)

		{

		iVJDecompressor->Close();

		iVJDecompressor = NULL;

		}

	//

	// Delete all the Containers

	//

	if(iVJCompressorCon)

		{

		con = iVJCompressorCon;

		for(i=0 ; i<con->Count() ; ++i)

			CNifFactory::ControlledDelete((*con)[i]);

			iVJCompressorCon = NULL;

		}

	if(iVJDeCompressorCon)

		{

		con = iVJDeCompressorCon;

		for(i=0 ; i<con->Count() ; ++i)

			CNifFactory::ControlledDelete((*con)[i]);

		iVJDeCompressorCon = NULL;

		}

	iSendQ.Free();

    __FLOG_CLOSE;

	}

/**

Construct the Link Protocol Object

*/

void CPppBinderIp4::ConstructL()

	{

    const CIPConfig* ncpConfig = Flow()->GetNcpConfig();

    if (NULL == ncpConfig)

        {

        User::Leave(KErrCorrupt);

        }

	Register();

	iIpRecvr.Register();

	iVjCompTcpRecvr.Register();

	iVjUncompTcpRecvr.Register();

	TCallBack scb(SendCallBack, this);

	iSendCallBack = new(ELeave) CAsyncCallBack(scb, KIpcpSendPriority);

	iVJCompressorCon = (iPppLcp->ContainerForDlls())->CreateL();

	iVJDeCompressorCon = (iPppLcp->ContainerForDlls())->CreateL();

	FsmConstructL();

	FsmOpen();

	// Create a unique interface name

	TBuf<KCommsDbSvrMaxColumnNameLength> port(ncpConfig->GetPortName());

	if (port.Length() != 0)

		{

		port.LowerCase();

		iIfName.Format(_L("ipcp::%S"), &port);

		}

	else

    	{

    	iIfName.Format(_L("ipcp[0x%08x]"), this);

    	}

	}

// from MLowerDataSender

/**

Called by the IP stack to send a packet.

The packet is first VJ compressed if compression was negotiated.

@param aPacket MBuf chain containing packet

@param aSource ignored

@return 1 for a successful send, 0 to tell upper layer to flow off

*/

MLowerDataSender::TSendResult CPppBinderIp4::Send(RMBufChain& aPacket)

	{

	RMBufPacket packet;

	packet.Assign(aPacket);

	TInt Protocol;

	if (iVJCompressor)

		{

		Protocol = iVJCompressor->VJCompressFrame(packet);

		return SendProtFrame(packet, Protocol );

		}

	else

		{

		//	Send normal IP frame

		return SendProtFrame(packet, KPppIdIp);

		}

	}

// from MLowerControl

TInt CPppBinderIp4::GetName(TDes& aName)

    {

    __FLOG(_L8("CPppNifBinder4:\tGetName()"));

	aName.Copy(iIfName);

	return KErrNone;

    }

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

    {

    iLowerFlowOn = ESendBlocked;

    return KErrNone;

    }

TInt CPppBinderIp4::GetConfig(TBinderConfig& aConfig)

    {

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

   	if(config == NULL)

   		{

   		return KErrNotSupported;

   		}	

   	config->iFamily = KAfInet;

    config->iInfo.iFeatures = KPppIpIfaceFeatures | KIfIsDialup;		/* Feature flags */

    TInt rxsz, txsz;

    if (FsmIsThisLayerOpen())

    {

		iPppLcp->PppLink()->GetSendRecvSize(rxsz, txsz);

		config->iInfo.iMtu = txsz==0 ? KPppDefaultFrameSize : txsz;

		config->iInfo.iRMtu = rxsz==0 ? KPppDefaultFrameSize : rxsz;

		config->iInfo.iSpeedMetric = iPppLcp->PppLink()->SpeedMetric() / 1024;

	}

    else

	{

		config->iInfo.iMtu = KPppDefaultFrameSize;

		config->iInfo.iRMtu = KPppDefaultFrameSize;

		config->iInfo.iSpeedMetric = 0;

	}

    iPppLcp->SetMaxTransferSize(config->iInfo.iMtu);

    config->iAddress.SetAddress(iLocalAddr);		/* Interface IP address. */

    config->iNetMask.SetAddress(iNetworkMask);	/* IP netmask. */

    config->iBrdAddr.SetAddress(iRemoteAddr);	/* IP broadcast address. */

    config->iDefGate.SetAddress(iRemoteAddr ? iRemoteAddr : iLocalAddr);		/* IP default gateway or peer address (if known). */

    config->iNameSer1.SetAddress(iPrimaryDns);	/* IP primary name server (if any). */

    config->iNameSer2.SetAddress(iSecondaryDns);	/* IP secondary name server (if any). */

    return KErrNone;

    }

/**

Called by the TCP/IP stack to get/set PPP NIF parameters.

@param aLevel Must be KSOLInterface

@param aName Option name

@param aOption Data for the given option

@param aSource ignored

*/

TInt CPppBinderIp4::Control(TUint aLevel, TUint aName, TDes8& /*aOption*/)

    {

    __FLOG(_L8("CPppNifBinder4::\tControl()"));

	if (aLevel==KSOLInterface)

		{

		switch (aName)

			{

#ifdef _DEBUG

		// Forces PPP to renegotiate the connection

		case KSoIfForceRenegotiatePPP:

			{

			FsmOpen();

			return KErrNone;

			}

#endif

		case KSoIfHardwareAddr:

		default:

			break;

			}

		}

	return KErrNotSupported;

	}

// from MUpperControl

/**

Notifies the TCP/IP stack that it may start sending data.

*/

void CPppBinderIp4::SendFlowOn()

    {

    __FLOG_1(_L("IPCP Flow On iUpperFlowOn=%d"), iUpperFlowOn);

    // unblock call from lower layer, therefore immediately unblock

	iLowerFlowOn = ESendAccepted;

    // Ensure Send queue is empty before reopening upper flow

	if (!iSendQ.IsEmpty())

		iSendCallBack->CallBack();

	if (iSendQ.IsEmpty())

		{

		iUpperFlowOn = ESendAccepted ;

        __FLOG(_L("Start Sending to IP from Ready()"));

        iUpperControl->StartSending();

		}

    }

void CPppBinderIp4::Error(TInt aError)

    {

    iUpperControl->Error(aError);

    }

/**

Binds NCPIP to the TCP/IP stack.

@param aId Pointer to network stack object (CProtocolBase*)

*/

MLowerDataSender* CPppBinderIp4::BindL(MUpperDataReceiver& aUpperReceiver, MUpperControl& aControl)

	{

    __FLOG_1(_L8("CPppBinderIp4:\tBind(MUpperDataReceiver %08x)"), &aUpperReceiver);

	if(iUpperControl)

		User::Leave(KErrInUse);

    iUpperControl = &aControl;

	iUpperReceiver = &aUpperReceiver;

	return this;

	}

void CPppBinderIp4::UnBind(MUpperDataReceiver& aUpperReceiver, MUpperControl& aUpperControl)

	{

	(void)aUpperReceiver;

	(void)aUpperControl;

    __FLOG(_L8("CDummyNifBinder4:\tUnbind()"));

    ASSERT(&aUpperReceiver == iUpperReceiver);

    ASSERT(&aUpperControl == iUpperControl);

    iUpperReceiver = NULL;

    iUpperControl = NULL;

	}

TBool CPppBinderIp4::MatchesUpperControl(const MUpperControl* aUpperControl) const

/**

Comparison routine used by Flow to determine which binder is being referred to

in an MFlowBinderControl::Unbind() call.

@param aUpperControl MUpperControl object to compare against this binder

@return ETrue if this binder is associated with aUpperControl, else EFalse.

*/

	{

	return iUpperControl == aUpperControl;

	}

/**

Static function called asynchronously to send packets out the link.

@param aCProtocol Pointer to this NCPIP object

@return 0

*/

TInt CPppBinderIp4::SendCallBack(TAny* aCProtocol)

	{

	((CPppBinderIp4*)aCProtocol)->DoSend();

	return 0;

	}

/**

Dequeues packets and sends them out the link.

*/

void CPppBinderIp4::DoSend()

	{

	if (FsmIsThisLayerOpen())

		{

		RMBufPacket pkt;

		while (iSendQ.Remove(pkt))

			{

			RMBufPktInfo*info = pkt.Unpack();

			TPppAddr addr;

			addr = info->iDstAddr;

    		TUint protocol = addr.GetProtocol();

			pkt.Pack();

           	if (Flow()->Send(pkt, protocol) <= 0)

			    {

			    LOG( Flow()->iLogger->Printf(_L("IPCP Flow Off")); )

			    iLowerFlowOn = ESendBlocked;

			    break;

			    }

			}

		if (iLowerFlowOn&&!iUpperFlowOn)

			{

			iUpperFlowOn = ESendAccepted;

			LOG( Flow()->iLogger->Printf(_L("StartSending to IP from DoSend()")); )

			Flow()->StartSending();

			}

		}

	}

//

// NCP Upcalls from FSM

//

/**

Opens the layer below

*/

TInt CPppBinderIp4::FsmLayerStarted()

	{

	return iPppLcp->PppOpen();

	}

/**

Closes the layer below

*/

void CPppBinderIp4::FsmLayerFinished(TInt aReason)

	{

	iPppLcp->PppClose(aReason);

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

	}

/**

Signals up event to next layer above

*/

void CPppBinderIp4::FsmLayerUp()

	{

	// PPP is up. Inform the stakeholders.

	// Note:

    // It is important to signal Link Up first, then Flow On.

    // Some clients, (e.g SPUD) may make assumptions as to the order of these notifications.

    // Until LinkLayer Up is received, SPUD assumes that the NIF is not ready.

    // Sending Flow On before LinkLayer Up may cause these clients to make the wrong conclusions and misbehave.

	iPppLcp->NcpUp(); // Inform control path: Link is up. 

    SendFlowOn(); // Inform data path: ready to process data.

	if(!iPppLcp->QueryExternalIPConfiguration())

        {

        // Only send the LinkUp progress if we're not

        // doing Mobile IP.  If we are doing MIP then

        // the LinkUp progress should be generated in

        // the MIP plugin module after it has finished

        // its own negotiation

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

        Flow()->BinderLinkUp(CPppLcp::EPppIp4);

        }

	}

/**

Signals down event to next layer above

*/

void CPppBinderIp4::FsmLayerDown(TInt aReason)

	{

	LOG( iPppLcp->iLogger->Printf(_L("CPppBinderIp4::FsmLayerDown reason[%d]."),aReason); )

	// Mobile IP Inter-PDSN Handoff support.

	if(KErrNone == aReason)

		{

		Flow()->FlowDown(aReason, MNifIfNotify::ENoAction);

		return;

		}

	// If the layer is down due to an error, it means that the FSM is terminating.

	// RFC1661 compliant Termination sequence support:

	if(iTerminateRequestEnabled || iTerminateAckEnabled)

		{

		// LCP signals the Down event on all NCPs:

 		// We don't want to signal to Nifman from here, because LCP is not finished yet.

 		// We let LCP handle disconnection notification to Nifman

		return;

		}

	// Legacy shutdown support:

	// Notify SCPR.

	// When legacy shutdown is no longer required, this code can be safely removed.

	if(KErrCommsLineFail == aReason && FsmIsThisLayerOpen())

		{

		// This is a legacy EReconnect scenario

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

		}

	else

		{

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

		}

    Flow()->Progress(EPppProgressLinkDown, aReason);

	}

/**

Fills in Config Request to be sent

*/

void CPppBinderIp4::FsmFillinConfigRequestL(RPppOptionList& aRequestList)

	{

	const CIPConfig* ncpConfig = Flow()->GetNcpConfig();

	// See whether we are configured to request a dynamic IP address. If so, make

	// sure we get one by setting iLocalAddr to 0.0.0.0

	if(!ncpConfig->GetIpAddrFromServer())

		{

		LOG(iPppLcp->iLogger->Printf(_L("Requesting static IP address"));)

		iLocalAddr = ncpConfig->GetIpAddress();

		}

	else

		{

		LOG(iPppLcp->iLogger->Printf(_L("Requesting dynamic IP address"));)

		iLocalAddr = KInetAddrNone;

		}

	// See whether we are configured to request a dynamic DNS address. If so, make

	// sure we get one by setting iPrimaryDns and iSecondaryDns to 0.0.0.0

	if(!ncpConfig->GetIp4DNSAddrFromServer())

		{	// Static addresses

		LOG(iPppLcp->iLogger->Printf(_L("Requesting static DNS address"));)

		iPrimaryDns = ncpConfig->GetIp4NameServer1();

		iSecondaryDns = ncpConfig->GetIp4NameServer2();

		}

	else

		{	// set to 0 for dynamic address request

		LOG(iPppLcp->iLogger->Printf(_L("Requesting dynamic DNS address"));)

		iPrimaryDns = KInetAddrNone;

		iSecondaryDns = KInetAddrNone;

		}

	iPrimaryNbns = KInetAddrNone;

	iSecondaryNbns = KInetAddrNone;

	iNetworkMask = ncpConfig->GetIpNetMask();

	if(iNetworkMask)

		{

		TUint32 mask=~1u, bits=iNetworkMask;

		while((bits&1)==0)

			{

			bits>>=1;

			mask<<=1;

			}

		iNetworkMask = mask;

		}