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

// dummy NCPIP.CPP

// 

//

#include <e32uid.h>

#include <cdblen.h>

#include <networking/vj.h>

#include "NCPIP.H"

#include "PPPLOG.H"

#include "PPP_VER.H"

#include <networking/pppprog.h>

//#define IPADDR(a,b,c,d) (TUint32)(((a)<<24)|((b)<<16)|((c)<<8)|(d))

//#define _LOC_ADDR IPADDR(10,0,0,1)

//#define _REM_ADDR IPADDR(10,0,0,2)

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

 #define PMF(x) x

#else

 #define PMF(x) &x

#endif

_LIT(KVjComp, "vjcomp");

//

// PPP for ESock

//

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

#pragma warning (disable:4355)

CPppNcpIp::CPppNcpIp(CPppLcp* aLcp)

	:   CNifIfBase(),

        MPppFsm(aLcp, EPppPhaseNetwork, KPppIdIpcp),

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

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

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

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

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

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

	{

	__DECLARE_FSM_NAME(_S("IPCP"));

	}

#pragma warning (default:4355)

CPppNcpIp::~CPppNcpIp()

	{

	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();*/

	}

void CPppNcpIp::ConstructL()

//

// Construct the Link Protocol Object

//

	{

	/*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();

    iVJCompressorCon = CObjectCon::NewL();

    iVJDeCompressorCon = CObjectCon::NewL();

	/*FsmConstructL();

	FsmOpen();*/

	// Create a unique interface name	

	/*TBuf<KCommsDbSvrMaxColumnNameLength> columnName=TPtrC(KCDTypeNameModemBearer);

	columnName.Append(TChar(KSlashChar));

	columnName.Append(TPtrC(KCDTypeNamePortName));

	TBuf<KCommsDbSvrMaxColumnNameLength> port;

	TInt ret = iNotify->ReadDes(columnName, port);

	if (ret==KErrNone)

		{

		port.LowerCase();

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

		}

	else

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

	}

void CPppNcpIp::BindL(TAny* /*aId*/)

//

//

//

	{

	/*if(iNetwork)

		User::Leave(KErrInUse);

	iNetwork = (CProtocolBase*) aId;*/

	}

void CPppNcpIp::Info(TNifIfInfo& /*aInfo*/) const

//

//

//

	{

	/*FillInInfo(aInfo);

	aInfo.iName.Copy(iIfName);*/

	}

void CPppNcpIp::FillInInfo(TNifIfInfo& /*aInfo*/)

//

//

//

	{

	/*aInfo.iVersion = TVersion(KPPPMajorVersionNumber, KPPPMinorVersionNumber, KPPPBuildVersionNumber);

	aInfo.iFlags = KNifIfIsBase | KNifIfUsesNotify | KNifIfCreatedByLink;

   _LIT(KIpcp, "ipcp");

	aInfo.iName = KIpcp;

	aInfo.iProtocolSupported=KProtocolInetIp;*/

	}

TInt CPppNcpIp::State()

//

//

//

	{

	/*if (FsmIsThisLayerOpen())

        return (iUpperFlowOn) ? EIfUp : EIfBusy;

	else

		return EIfDown;*/

		return 0;

	}

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

//

//

//

	{

	/*if (aLevel==KSOLInterface)

		{

		switch (aName)

			{

		case KSoIfInfo:

			{

			TSoIfInfo& opt = *(TSoIfInfo*)aOption.Ptr();

			opt.iName.Copy(iIfName);

			opt.iFeatures = KPppIpIfaceFeatures | KIfIsDialup;

			TInt rxsz, txsz;

			if (FsmIsThisLayerOpen())

				{

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

				opt.iMtu = txsz==0 ? KPppDefaultFrameSize : txsz;

				opt.iSpeedMetric = iPppLcp->PppLink()->SpeedMetric();

				}

			else

				{

				opt.iMtu = KPppDefaultFrameSize;

				opt.iSpeedMetric = 0;

				}

			iPppLcp->SetMaxTransferSize(opt.iMtu);

			return KErrNone;

			}

		case KSoIfHardwareAddr:

			return KErrNotSupported;

		case KSoIfConfig:

			{

			TSoInetIfConfig& opt = *(TSoInetIfConfig*)aOption.Ptr();

			if (opt.iFamily!=KAfInet)

				return KErrNotSupported;

			TInetAddr::Cast(opt.iConfig.iAddress).SetAddress(iLocalAddr);

			TInetAddr::Cast(opt.iConfig.iNetMask).SetAddress(iNetworkMask);

			TInetAddr::Cast(opt.iConfig.iBrdAddr).SetAddress(iRemoteAddr);

			// Nokia suggested fix to prevent a default gateway of 0.0.0.0

			// being set if PPP peer won't give us an IP address for some

			// reaspon. See defect report TEE-5DWD4F (in V4, Hurricane) and

			// subsequent discussion for details...

//			TInetAddr::Cast(opt.iConfig.iDefGate).SetAddress(iRemoteAddr);

#ifdef _DEBUG

			// Force peer IP address to 0.0.0.0 to allow this fix to be

			// tested with any phone, operator, or connection mechanism.

			//

			// Shouldn't do any harm, and it'll only be present in debug

			// builds, but nevertheless I reccomend this be commented out

			// when not actually needed!

			//

			// JMG 15-01-03

//			iRemoteAddr = 0 ;

#endif

			TInetAddr::Cast(opt.iConfig.iDefGate).SetAddress(iRemoteAddr ? iRemoteAddr : iLocalAddr);

			TInetAddr::Cast(opt.iConfig.iNameSer1).SetAddress(iPrimaryDns);

			TInetAddr::Cast(opt.iConfig.iNameSer2).SetAddress(iSecondaryDns);

#ifdef _DEBUG

			TUint ipAddressByte0 = iRemoteAddr & 0xFF;

			TUint ipAddressByte1 = (iRemoteAddr >> 8) & 0xFF;

			TUint ipAddressByte2 = (iRemoteAddr >> 16) & 0xFF;

			TUint ipAddressByte3 = (iRemoteAddr >> 24) & 0xFF;

			LOG(iPppLcp->iLogger->Printf(_L("IPCP Remote Address = %03u.%03u.%03u.%03u\r\n"),ipAddressByte3, ipAddressByte2,ipAddressByte1,ipAddressByte0);)

#endif

			return KErrNone;

			}

		case KSoIfCompareAddr:

			if(((TInetAddr&)aOption).Address()!=iLocalAddr)

				return KErrBadName;

			return KErrNone;

		case KSoIfGetConnectionInfo:

			TSoIfConnectionInfo& opt = *(TSoIfConnectionInfo*)aOption.Ptr();

			TInt err = KErrNone;

			TBuf<2*KCommsDbSvrMaxColumnNameLength+1> fieldName;

			fieldName.Copy(TPtrC(KCDTypeNameIAP));

			fieldName.Append(KSlashChar);

			fieldName.Append(TPtrC(KCDTypeNameRecordName));

			if ((err = iNotify->ReadInt(fieldName, opt.iIAPId)) != KErrNone)

				return err;

			fieldName.Copy(TPtrC(KCDTypeNameIAP));

			fieldName.Append(KSlashChar);

			fieldName.Append(TPtrC(KCDTypeNameIAPNetwork));

			if ((err = iNotify->ReadInt(fieldName, opt.iNetworkId)) != KErrNone)

				return err;

			return KErrNone;

			}

		}

	return KErrNotSupported;*/

	return KErrNone;

	}

void CPppNcpIp::SendFlowOn()

	{

	/*LOG( iPppLcp->iLogger->Printf(_L("IPCP Flow On iUpperFlowOn=%d\r\n"), iUpperFlowOn); )	

	iLowerFlowOn = ETrue;

	if (!iSendQ.IsEmpty())

		iSendCallBack->CallBack();

	if (iSendQ.IsEmpty() && iNetwork)

		{

		iUpperFlowOn = ETrue;

		LOG( iPppLcp->iLogger->Printf(_L("StartSending to IP from SendFlowOn()\r\n"));)

		iNetwork->StartSending((CProtocolBase*)this);

		}*/

	}

TInt CPppNcpIp::SendCallBack(TAny* aCProtocol)

	{

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

	return 0;

	}

void CPppNcpIp::DoSend()

	{

	/*if (FsmIsThisLayerOpen())

		{

		RMBufPacket pkt;

		while (iSendQ.Remove(pkt))

			{

			RMBufPktInfo*info = pkt.Unpack();

			TPppAddr addr;

			TUint Protocol;

			addr = info->iDstAddr;

			Protocol = addr.GetProtocol();

			pkt.Pack();

			if (iPppLcp->PppLink()->Send(pkt, Protocol) <= 0)

				{

				LOG( iPppLcp->iLogger->Printf(_L("IPCP Flow Off\r\n")); )	

				iLowerFlowOn = EFalse;

				break;

				}

			}

		if (iLowerFlowOn&&!iUpperFlowOn)

			{

			iUpperFlowOn = ETrue;

			LOG( iPppLcp->iLogger->Printf(_L("StartSending to IP from DoSend()\r\n")); )

			iNetwork->StartSending((CProtocolBase*)this);

			}

		}*/

	}

//

// NCP Upcalls from FSM

//

TInt CPppNcpIp::FsmLayerStarted()

//

// Open the layer below

//

	{

	/*return iPppLcp->PppOpen();*/

	return KErrNone;

	}

void CPppNcpIp::FsmLayerFinished(TInt /*aReason*/)

//

// Close the layer below

//

	{

	/*iPppLcp->PppClose(aReason);

	iNotify->IfProgress(EPppProgressLinkDown, KErrNone);*/

	}	

void CPppNcpIp::FsmLayerUp()

//

// Signal up event to next layer above

//

	{

	/*SendFlowOn();

	iNotify->LinkLayerUp();

    if(!iPppLcp->QueryMIP())

        {

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

        iNotify->IfProgress(EPppProgressLinkUp, KErrNone);

        }*/

	}

void CPppNcpIp::FsmLayerDown(TInt /*aReason*/)

//

// Signal down event to next layer above

//

	{

	/*if(aReason==KErrNone)

		return;

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

		{

		iNotify->LinkLayerDown(aReason, MNifIfNotify::EReconnect);

		}

	else

		{

		iNotify->LinkLayerDown(aReason, MNifIfNotify::EDisconnect);

		}

	iNotify->IfProgress(EPppProgressLinkDown, aReason);*/

	}

TInt CPppNcpIp::PresetAddr(TUint32&/* aAddr*/, const TDesC& /*aVarName*/)

/**

 * Preset IP adress in aAddr with value from CommDB. The field name

 * is given in aVarName. Examples are "IpAddr" and "IpNameServer1"

 *

 * @param aAddr    IP address to be set

 * @param aVarName name of CommDB field

 * @return KErrNone if success, global error code otherwise

 */

	{

	/*if (aAddr!=0)

		return KErrNone;

	TBuf<KCommsDbSvrMaxFieldLength> name;

	TInetAddr addr;

	(void)iNotify->ReadDes(aVarName, name); // ignore return value

	const TInt ret = addr.Input(name);

	if (ret==KErrNone)

		aAddr = addr.Address();

	return ret;*/

	return KErrNone;

	}

void CPppNcpIp::FsmFillinConfigRequestL(RPppOptionList& /*aRequestList*/)

//

// Fill in Config Request to be sent

//

	{

	/*TBool RequestDynamicIPAddress;

	// 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 (iNotify->ReadBool(TPtrC(KCDTypeNameIpAddrFromServer), RequestDynamicIPAddress) != KErrNone)

		{

		// Default behaviour

		RequestDynamicIPAddress = ETrue;

		}

	if(!RequestDynamicIPAddress)

		{

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

		PresetAddr(iLocalAddr, TPtrC(KCDTypeNameIpAddr));

		}

	else

		{

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

		iLocalAddr = 0;

		}

	TBool RequestDynamicDNSAddress;

	// 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 (iNotify->ReadBool(TPtrC(KCDTypeNameIpDNSAddrFromServer), RequestDynamicDNSAddress) != KErrNone)

		{

		// Default behaviour

		RequestDynamicDNSAddress = ETrue;

		}

	if(!RequestDynamicDNSAddress)

		{	// Static addresses

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

		PresetAddr(iPrimaryDns, TPtrC(KCDTypeNameIpNameServer1));

		PresetAddr(iSecondaryDns, TPtrC(KCDTypeNameIpNameServer2));

		}

	else

		{	// set to 0 for dynamic address request

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

		iPrimaryDns = 0;

		iSecondaryDns = 0;

		}

	iPrimaryNbns = IPADDR(0,0,0,0);

	iSecondaryNbns = IPADDR(0,0,0,0);

	PresetAddr(iNetworkMask, TPtrC(KCDTIdIpNetMask));

	if(iNetworkMask)

		{

		TUint32 mask=~1u, bits=iNetworkMask;

		while((bits&1)==0)

			{

			bits>>=1;

			mask<<=1;

			}

		iNetworkMask = mask;

		}

    PresetAddr(iRemoteAddr, TPtrC(KCDTIdIpGateway)); // Field use differently in server mode

	if (iNotify->ReadBool(TPtrC(KCDTIdEnableIpHeaderComp), iVJCompressionOn) != KErrNone)

		{

		// Default behaviour

		iVJCompressionOn = FALSE;

		}

	else if (iVJCompressionOn)

		{

      _LIT(KVJCompDll, "vjcomp.dll");

		iVJCompressionOn = iPppLcp->DoesDllExist(KVJCompDll);

		}

   if (iVJCompressionOn)

      {

	   TUint32	CompressionOptions;

	   CompressionOptions = (KPppIdVjCompTcp << 16) | ((KMaxVjSlots-1) << 8) | KVjCompSlotId;

	   aRequestList.CreateAndAddL(KPppIpcpOptIpCompressionProtocol, CompressionOptions);

      }

   if(!iPppLcp->QueryMIP())

	{

	// Don't ask for IP address if we use CDMA MIP.

	aRequestList.CreateAndAddL(KPppIpcpOptIpAddress, iLocalAddr);

	}

	if (RequestDynamicDNSAddress)

		{

		aRequestList.CreateAndAddL(KPppIpcpOptPrimaryDnsAddress, iPrimaryDns);