// 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 "PPPLOG.H"

#include <in_sock.h>

#include "PPPCCP.H"

#include "PPP_VER.H"

#include "CCPINI.H"

#include <commsdattypeinfov1_1.h>

#include "PPPConfig.h"

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

 #define PMF(x) x

#else

 #define PMF(x) &x

#endif

//

// PPP for ESock

//

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

#pragma warning (disable:4355)

CPppCcp::CPppCcp(CPppLcp* aLcp)

	:   CBase(), MPppFsm(aLcp, EPppPhaseNetwork, KPppIdCcp),

	iRecvr(this, PMF(CPppCcp::Recv), PMF(CPppCcp::SendFlowOn), aLcp, EPppPhaseNetwork, KPppIdCcp, 

		PMF(MPppRecvr::FrameError), PMF(MPppRecvr::KillProtocol))

	{

	__DECLARE_FSM_NAME(_S("CCP"));

	}

#pragma warning (default:4355)

void	CPppCcp::RemoveRegistration()

	{

	Deregister();

	iRecvr.Deregister();

	}

CPppCcp::~CPppCcp()

	{

	CObjectCon* con;

	TInt i;

	Deregister();

	iRecvr.Deregister();

	delete iSendCallBack;

  	delete iIniFilePtr;

	//

	// OK Spin around removing all the Compressor Config information

	//

	CPppCompConfig* CompressorData;

	TSglQueIter<CPppCompConfig> Iterator(iCompressorConfig);

	Iterator.SetToFirst();

	CompressorData = Iterator++;

	while(CompressorData)

	{

		delete CompressorData;

		CompressorData = Iterator++;

	}

	if (iCompressor)

		{

		iPppLcp->PppNewCompressor(NULL);

		iCompressor->Close();

		iCompressor = NULL;

		}

	if (iDeCompressor)

		{

		iPppLcp->PppNewDeCompressor(NULL);

		iDeCompressor->Close();

		iDeCompressor = NULL;

		}

	//

	// Delete all the Containers

	//

	if(iCompressorCon)

		{

		con = iCompressorCon;

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

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

			iCompressorCon = NULL;

		}

	if(iDeCompressorCon)

		{

		con = iDeCompressorCon;

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

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

		iDeCompressorCon = NULL;

		}

	iSendQ.Free();

	if (!iRequestWorkList.IsEmpty())

		{

		iRequestWorkList.Free();

		}

	}

CPppCcp* CPppCcp::NewL(CPppLcp* aLcp)

	{

	CPppCcp* ccp = new (ELeave) CPppCcp(aLcp);

	CleanupStack::PushL(ccp);

	ccp->ConstructL();

	CleanupStack::Pop();

	return ccp;

	}

void CPppCcp::FsmTerminationPhaseComplete()

	{

	}

void CPppCcp::RemoteCompressorHasReset()

//

//

//

	{

	//

	// Increment the Reset Id

	//

	iResetId++;

	iResetId %= 256;

	}

void CPppCcp::ConstructL()

// Construct the Link Protocol Object

// This method now reads the number of compressor and its information

// incrementally. Replaces ini file code.

	{

	Register();

	iRecvr.Register();

	TCallBack scb(SendCallBack, this);	

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

	// Initialise CCP Finite State Machine

	FsmConstructL();

	// Initialise a queue 

	iCompressorConfig.SetOffset(_FOFF(CPppCompConfig,link));

  	iIniFilePtr = CPppIniData::NewL();

	// Initialise CObject containers

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

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

	//

	// Be warned this code was written expecting the ini file only to be used

	// for compressor configuration, it's not generic

	//

	CPppCompConfig* CompressorData;

	TBool			Loop;

	TUint			numberOfTurns=0;

	do 

		{

		Loop = FALSE;

		numberOfTurns++;

		CompressorData = CPppCompConfig::NewL();

		//coverity[leave_without_push]

		//Function ReadCompressorInfo is not leaveable, hence no need to push the object CompressorData into cleanup stack

		if (iIniFilePtr->ReadCompressorInfo(CompressorData, numberOfTurns))

			{

			//

			// Check there is a dll of this name

			//

			//coverity[leave_without_push]

			//Function ReadCompressorInfo is not leaveable, hence no need to push the object CompressorData into cleanup stack

			if (iPppLcp->DoesDllExist(CompressorData->Name()))

				{

				iCompressorConfig.AddLast(*CompressorData);

				}

			else

				{

				delete CompressorData;

				}

			Loop = TRUE;

			}

		}

	while (Loop);

	delete CompressorData;

	FsmOpen();

	}

void CPppCcp::SendResetRequestL()

//

// Create and Send a Reset Request

//

	{

	const TUint		pktLen = 4;

	RMBufPacket		pkt;

	RMBufPktInfo*	info = NULL;

	pkt.AllocL(pktLen);

	CleanupStack::PushL(pkt);

	info = pkt.NewInfoL();

	CleanupStack::Pop();

	info->iLength = pktLen;	

	// Construct packet header

	TUint8* ptr = pkt.First()->Ptr();

	*ptr++ = KPppCcpResetReq;

	*ptr++ = iResetId;

	BigEndian::Put16(ptr, (TUint16)pktLen);

	// Send it

	pkt.Pack();

	SendFrame(pkt);

	}

void CPppCcp::Info(TNifIfInfo& aInfo) const

//

//

//

	{

	FillInInfo(aInfo);

	}

void CPppCcp::FillInInfo(TNifIfInfo& aInfo)

//

//

//

	{

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

	aInfo.iFlags = KNifIfIsBase | KNifIfUsesNotify | KNifIfCreatedByLink;

   _LIT(KCcp, "ccp");

	aInfo.iName = KCcp;

	aInfo.iProtocolSupported=KPppIdEsock;

	}

TInt CPppCcp::State()

//

//

//

	{

	if (FsmIsThisLayerOpen())

        return (iUpperFlowOn) ? EIfUp : EIfBusy;

	else

		return EIfDown;

	}

void CPppCcp::SendFlowOn()

	{ 

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

	iLowerFlowOn = ETrue;

	if (!iSendQ.IsEmpty())

		iSendCallBack->CallBack();

	}

TInt CPppCcp::SendCallBack(TAny* aCProtocol)

	{

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

	return 0;

	}

void CPppCcp::DoSend()

	{

	if (FsmIsThisLayerOpen())

		{

		RMBufPacket pkt;

		while (iSendQ.Remove(pkt))

			{

			RMBufPktInfo*info = pkt.Unpack();

			TPppAddr addr;

			info->iDstAddr = addr;

			pkt.Pack();

			if (iRecvr.SendFrame(pkt)<=0)

				{

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

				iLowerFlowOn = EFalse;

				break;

				}

			}

		if (iLowerFlowOn&&!iUpperFlowOn)

			iUpperFlowOn = ETrue;

		}

	}

TInt CPppCcp::Send(RMBufChain& aPacket, TAny*)

//

//

//

	{

	iSendQ.Append(aPacket);

	iSendCallBack->CallBack();

	if (!FsmIsThisLayerOpen() || !iLowerFlowOn)

		iUpperFlowOn = EFalse;

	return iUpperFlowOn;

	}

//

// NCP Upcalls from FSM

//

TInt CPppCcp::FsmLayerStarted()

//

// Open the layer below.  Nothing to do here as this won't be worth running without an NCP!

//

	{

	return KErrNone;

	}

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

//

// Close the layer below.  CCP should not close the link if it terminates, so there is nothing

// to do here.

//

	{}

void CPppCcp::FsmLayerUp()

//

// Hmm the link is back up.

//

	{

	SendFlowOn();

	return;

	}

void CPppCcp::FsmLayerDown(TInt aReason)

//

// Hmmm the link has gone down 

//

	{

	if(aReason==KErrNone)

		return;

	//

	// Make a note of which compressor we were using

	//

	}

void CPppCcp::FsmFillinConfigRequestL(RPppOptionList& aRequestList)

//

// Fillin Config Request to be sent

//

	{

	if ((iSoftwareCompressionOn = iPppLcp->GetLcpConfig()->GetEnableSwComp()) == TRUE)

		{

		TSglQueIter<CPppCompConfig> Iterator(iCompressorConfig);

		Iterator.SetToFirst();

		//

		// This is the initial Config Request.

		// We then just want to fill in the 1:st option from the ini-file

		//

		AddToRequestListL(aRequestList,Iterator);

		//

		// Add _all_ supported to a temporary working list

		//

		if (!iRequestWorkList.IsEmpty())

		iRequestWorkList.Free();	

		Iterator.SetToFirst();

		do 

			{

			AddToRequestListL(iRequestWorkList,Iterator);

			}

		while(Iterator);

		}

	}

void CPppCcp::AddToRequestListL(RPppOptionList& aRequestList, TSglQueIter<CPppCompConfig>& aIterator)

	{

	CPppCompConfig* Data = aIterator++;

	if (Data)

		{

		//

		// Add this option to the list

		//

		if (Data->OptionsLength())

			{

			TPtrC8 Temp = Data->Options();

			aRequestList.CreateAndAddL(Data->ID(), Temp);

			}

		else

			{

			//

			// No options

			//

			aRequestList.CreateAndAddL(Data->ID());

			}

		}

	}

void CPppCcp::FsmCheckConfigRequest(RPppOptionList& aRequestList, RPppOptionList& aAckList, RPppOptionList& aNakList, RPppOptionList& aRejList)

//

// Check options in a recvd config request

//

	{

	// Check that software compression is turned on.

	// This may not occur as LCP also reads the database

	// and sends a Protocol Reject for CCP in this case

	if(!iSoftwareCompressionOn)

		{

		// Reject all options

		aRequestList.RemoveOptions(aRejList);

		return;

		}

	RPppOption requestedOption;

	CPppCompConfig* nakOption = NULL;

	CPppCompConfig* supportedOption = NULL;

	TSglQueIter<CPppCompConfig> supportedOptionsIter(iCompressorConfig);

	// This loop control variable ensures that after we have successfully matched

	// an algorithm we don't keep searching through supportedOptionsIter

	TBool optionMatched = EFalse;

	// If we have matched the option to an algorithm that we support, do we support the 

	// parameters of the algorithm in the request?

	TBool paramsMatched = EFalse;

	// Used as a ptr to the parameters of requestedOption during param match

	TPtrC8 requestedParams;

	// An acknowledgement should only contain one algorithm - the one that we want to accept.

	// Whilst processing, add only the first algorithm that we can acknowledge to aAckList.

	// Successive algorithms that are found to be acceptable are added to the reject list.

	TBool ackListFull = EFalse;

	//

	// Process all options in the config-request

	//

	while (aRequestList.Remove(requestedOption))

		{

		// Search supported compressor data for a match

		supportedOptionsIter.SetToFirst();

		optionMatched = EFalse;

		nakOption = NULL;

		do

			{

			supportedOption = supportedOptionsIter++;

			if (!supportedOption)

				continue;

			// Is this algorithm supported?

			if (supportedOption->ID() == requestedOption.OptType())

				{

				// Found an algorithm match - now match the parameters.

				paramsMatched = EFalse;

				requestedParams.Set(requestedOption.ValuePtr(), requestedOption.ValueLength());

				if (supportedOption->Options() == requestedParams)

					paramsMatched = ETrue;

				// Do the algorithm parameters match the ones that we use?

				if(paramsMatched)

					{

					// The parameters matched so add this option to the ack list,

					// or if we already have an option that we want to Ack, reject this option

					if (!ackListFull)

						{

						aAckList.Append(requestedOption);

						ackListFull = ETrue;

						}

					else

						aRejList.Append(requestedOption);

					// return program flow to the outer while loop

					// because we don't need to continue searching

					optionMatched = ETrue;

					}

				else

					{

					// This algorithm is a potential nak, so keep a pointer to it.

					// It cannot be added to the nak list yet, because

					// there may be a better match later on in the iterator.

					// However, we only want to keep a pointer to the first potential

					// NAK that we find - to preserve the priority implied by the order 

					// of compressors in the ini file.

					if (nakOption==NULL)

						nakOption = supportedOption;

					}

				}

			} while (supportedOptionsIter && !optionMatched);

		// Finished searching through supported compressor config

		if (!optionMatched)

			{

			// Decide whether to Nak or Reject

			if (nakOption==NULL)

				{

				// Reject this algorithm as it is not recognised

				aRejList.Append(requestedOption);

				}

			else

				{

				// Nak this algorithm as it is recognised, but the parameters are not supported

				// Modify requestedOption to contain the params from nakOption and add requestedOption to aNakList

				TRAPD(ret, requestedOption.SetL(requestedOption.OptType(), (nakOption->Options()).Ptr(), nakOption->OptionsLength()));

				if (ret == KErrNone)

					{

					aNakList.Append(requestedOption);

					}

				else

					{

					// Could not modify the RPppOption - probably not enough memory