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

// See RFC 1662 and "PPP Design and Debugging" by James Carlson (ISBN 0201185393)

// PPP's HDLC support

// 

//

/**

 @file

*/

#include <cdblen.h>

#include <es_ini.h>

#include "PPPHDLC.H"

#include "PPPLOG.H"

#include "ncpip.h"

#include "PPPConfig.h"

#include <commsdattypeinfov1_1.h>

// Receive buffer size for the BCA layer. HDLC has a separate Rx buffer.

static const TInt KReceiveBufferSize=4096; 

// Internal flag bits (iFlags)

static const TUint KPppHdlcSendFcs16 = 0x00000001;

static const TUint KPppHdlcSendFcs32 = 0x00000002;

static const TUint KPppHdlcSendCompProt = 0x00000004;

static const TUint KPppHdlcSendCompAddrCtrl = 0x00000008;

static const TUint KPppHdlcRecvFcs16 = 0x00000010;

static const TUint KPppHdlcRecvFcs32 = 0x00000020;

static const TUint KPppHdlcRecvCompProt = 0x00000040;

static const TUint KPppHdlcRecvCompAddrCtrl = 0x00000080;

//static const TUint KPppHdlcRecvEscSeen = 0x00000100;

//static const TUint KPppHdlcSendXonXoff = 0x00000400;

//static const TUint KPppHdlcRecvXonXoff = 0x00000800;

static const TUint KPppHdlcSendBusy = 0x00001000;

static const TUint KPppHdlcRecvEscPending = 0x00002000;

static const TUint KPppHdlcCommConfigOk = 0x00004000;

static const TUint KPppHdlcApplyPending = 0x00010000;

static const TUint KPppHdlcAtApplyMark = 0x00020000;

static const TUint KPppHdlcOrigConfig = 0x000040000;

/*

#if defined(_DEBUG) && defined (__WINS__)

#include <f32file.h>

#endif

*/

//

// HDLC Support

//

static const TInt KPppLoWat = 16;

static const TInt KPppHiWat = 32;

static const TInt KOptionListLen = 6;

static const TUint8 OptionList[KOptionListLen] =

	{

	KPppLcpOptEscapeCharMap,

	KPppLcpOptProtocolCompress,

	KPppLcpOptAddrCtrlCompress,

	KPppLcpOptFcsType,

	KPppLcpOptPadding,

	KPppLcpOptCompoundFrames

	};

CPppHdlcLink::CPppHdlcLink(CPppLcp* aLcp)

	: CPppLinkBase(aLcp),

	  iError(KErrNone),

	  iLinkDown(ETrue) // By default

	{

	OptRegister(iPppLcp, OptionList, KOptionListLen);

	iSendLoWat = KPppLoWat;

	iSendHiWat = KPppHiWat;

	}

CPppHdlcLink::~CPppHdlcLink()

	{

	iSendPkt.Free();

	iSendQ.Free();

	iRecvPkt.Free();

	if (iRecvMBuf)

		{

		iRecvMBuf->Free();

		}

	iRecvQ.Free();

	delete iBcaReader;

	delete iBcaWriter;

	delete iBcaControl; // Must be deleted last, as it makes sure the BCA is closed.

	if(iBca) // Remove the BCA itself, if it was created.

		{

		iBca->Release();

		}

	}

/**

Allocates the link resources, associated with BCA 

@leave If the link cannot be created.

*/

void CPppHdlcLink::CreateL()

    {

    if (iPppLcp->GetBCAProvision() == NULL)

        {

        User::Leave(KErrNotReady);

        }

	LoadBcaL(); 

	__ASSERT_ALWAYS(iBca, User::Panic(_L("PPP Panic"), EPppPanic_NullBca));

	iBcaControl = new (ELeave)CBcaControl(*this, *iBca); 

	iBcaReader  = new (ELeave)CBcaReader( *this, *iBca, KPppHdlcCommReadPriority);

	iBcaWriter  = new (ELeave)CBcaWriter( *this, *iBca, KPppHdlcCommWritePriority);	

    }

/** 

Loads the BCA based on Comms settings 

@leave if the BCA cannot be loaded

*/

void CPppHdlcLink::LoadBcaL()

	{

	LOG( Logger().Printf(_L("CPppHdlcLink::LoadBcaL: Loading BCA.[%S]"), GetBCAName().Ptr()); )

	User::LeaveIfError(iBcaDll.iObj.Load(iPppLcp->GetBCAProvision()->GetBCAName()));

	TNewBcaFactoryL newBcaFactoryProcL = (TNewBcaFactoryL)iBcaDll.iObj.Lookup(1);

	if (!newBcaFactoryProcL)

		{

		LOG(Logger().Printf(_L("CPppHdlcLink::LoadBcaL: BCA Factory method lookup failed. ")); )

		User::Leave(KErrBadLibraryEntryPoint);	

		}

	MBcaFactory* bcaFactory = (*newBcaFactoryProcL)();

	__ASSERT_ALWAYS(bcaFactory, User::Panic(_L("PPP Panic"), EPppPanic_NullBcaFactory));

	CleanupReleasePushL(*bcaFactory);

	iBca = bcaFactory->NewBcaL(); 

	__ASSERT_ALWAYS(iBca, User::Panic(_L("PPP Panic"), EPppPanic_NullBca));

	CleanupStack::PopAndDestroy(bcaFactory); // We only need once BCA per PPP lifetime.

	LOG(Logger().Printf(_L("CPppHdlcLink::LoadBcaL: BCA successfully loaded. ")); )

	}

void CPppHdlcLink::InitEscMap()

/**

Initializes the send escape map to a conservative value.

iRecvEscMap is not set here, since Carlson says that can cause problems on

LCP renegotiation.

@post iSendEscMap is initialized

*/

	{

	// Always Escape bytes 0..31 initially

	Mem::FillZ(iSendEscMap, sizeof(iSendEscMap));

	iSendEscMap[0] = 0xffffffff;

	// Also escape the two special bytes

	SetEscMapBit(KPppHdlcFlagChar);

	SetEscMapBit(KPppHdlcEscChar);

	}

void CPppHdlcLink::SetEscMapBit(TUint8 aChar)

/**

Marks this character to be escaped when sending.

@param aChar Character

*/

	{

	iSendEscMap[aChar>>5] |= 1<<(aChar&0x1f);

	}

void CPppHdlcLink::DeferredApplyOptions()

/**

Starts using the negotiated PPP options.

Called once LCP has completed.

*/

	{

//	LOG( iPppLcp->iLogger->Printf(_L("PPP Link DeferredApplyOptions()")); )

	iFlags &= ~(KPppHdlcApplyPending|KPppHdlcAtApplyMark);

	iFlags = (iFlags & ~iPendingMask) | iPendingFlags;

	iSendEscMap[0] = iPendingEscMap;

	}

void CPppHdlcLink::GetSendRecvSize(TInt& aMaxRecvSize, TInt& aMaxSendSize)

/**

Returns the link's idea of the maximum receive and send unit sizes.

@param aMaxRecvSize Returns the MRU, or 0 for default

@param aMaxSendSize Returns the MTU, or 0 for default

*/

	{

	aMaxRecvSize = iPppLcp->MaxReceiveSize();

	aMaxSendSize = iPppLcp->MaxTransferSize();

	}

void CPppHdlcLink::OptNegotiationStarted()

	{

//	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationStarted()")); )

	InitEscMap();

// Initialize (most) flags

	iFlags = (iFlags & (KPppHdlcCommConfigOk|KPppHdlcSendBusy|KPppHdlcOrigConfig))

				| (KPppHdlcSendFcs16 | KPppHdlcRecvFcs16);

	iPendingMask = 0;

	iPendingFlags = 0;

	iPendingEscMap = iSendEscMap[0];

	iApplyConfigMarker = NULL;

	}

void CPppHdlcLink::OptNegotiationAborted()

	{

//	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationAborted()")); )

	}

void CPppHdlcLink::OptNegotiationComplete()

	{

//	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationComplete()")); )

	iFlags |= KPppHdlcApplyPending;

/*

	if (!iSendQ.IsEmpty())

		{

		RMBufChain pkt = iSendQ.Last();

		iApplyConfigMarker = pkt.First();

		}

	else

		{

		iFlags |= KPppHdlcAtApplyMark;

		if (iSendPkt.IsEmpty())

			DeferredApplyOptions();

		}

*/

	}

void CPppHdlcLink::OptFillinConfigRequestL(RPppOptionList& aRequestList)

	{

	// Add XON/XOFF bits to the ACCM read from ppp.ini

	TUint32 map = iDesiredRecvEscMap;

	if ((iOrigConfig().iHandshake & KConfigObeyXoff)!=0 ||

		(iOrigConfig().iHandshake & KConfigSendXoff)!=0)

		{

		if (iOrigConfig().iXonChar<32)

			map |= 1<<iOrigConfig().iXonChar;

		if (iOrigConfig().iXoffChar<32)

			map |= 1<<iOrigConfig().iXoffChar;

		}

	aRequestList.CreateAndAddL(KPppLcpOptEscapeCharMap,map);

	aRequestList.CreateAndAddL(KPppLcpOptProtocolCompress);

	aRequestList.CreateAndAddL(KPppLcpOptAddrCtrlCompress);

	}

TPppOptResponse CPppHdlcLink::OptCheckConfigRequest(RPppOption& aOption)

/**

Checks options in a received config request.

Called once for each option.

@param aOption LCP option

@return EPppOptAck, EPppOptNak, or EPppOptReject

*/

	{

	const TInt KBooleanOptDataLen = 0;

	const TInt KOptEscapeCharMapLen = 4;

	switch (aOption.OptType())

		{

	case KPppLcpOptEscapeCharMap:

		{		

		TUint32 remoteRecvAccm = 0;

		TBool forceNak = EFalse; // Whether the ACCM must be NAKed regardless of value.

		if(KOptEscapeCharMapLen != aOption.ValueLength()) // Invalid length: NAK 

			{

			aOption.SetValueLength(KOptEscapeCharMapLen); // Fix length. (value = 0x0)

			forceNak = ETrue; 

			}

		else // Valid length. Extract the ACCM and negotiate.

			{

			remoteRecvAccm = BigEndian::Get32(aOption.ValuePtr());

			}

		// Create the sender ACCM

		TUint32 localSendAccm = 0; // We want to escape as little as possible.

		// Add XON/XOFF bits to the sender ACCM 

		if ((iOrigConfig().iHandshake & KConfigObeyXoff)!=0 ||

				(iOrigConfig().iHandshake & KConfigSendXoff)!=0)

				{

				if (iOrigConfig().iXonChar<32)

					localSendAccm |= 1<<iOrigConfig().iXonChar;

				if (iOrigConfig().iXoffChar<32)

					localSendAccm |= 1<<iOrigConfig().iXoffChar;

				}

		// Compare the ACCMs and check if peer's proposal must be NAKed:

		// It is NAKed if there is a disagreement on ACCM, or if the option is invalid

		if ((~remoteRecvAccm & localSendAccm) || forceNak) 

		    {

			BigEndian::Put32( aOption.ValuePtr(), localSendAccm | remoteRecvAccm);

			return EPppOptNak;

			}

		return EPppOptAck;

		}

	case KPppLcpOptProtocolCompress:

		if(KBooleanOptDataLen == aOption.ValueLength())

			{

			return EPppOptAck;

			}

		else

			{

			aOption.SetValueLength(KBooleanOptDataLen);

			return EPppOptNak;

			}		

	case KPppLcpOptAddrCtrlCompress:

		if(KBooleanOptDataLen == aOption.ValueLength())

			{

			return EPppOptAck;

			}

		else

			{

			aOption.SetValueLength(KBooleanOptDataLen);

			return EPppOptNak;

			}

	case KPppLcpOptFcsType:

		{

		if (aOption.ValueLength()<1)

			return EPppOptReject;

		TUint8 fcs = *aOption.ValuePtr();

		// This only allows one FCS method at a time.

		if (fcs==KPppHdlcFcs0Flag || fcs==KPppHdlcFcs16Flag

#ifdef __LCP_EXTENSION_FCS_32

		    || fcs==KPppHdlcFcs32Flag

#endif

	    )

			{

			return EPppOptAck;

			}

		*aOption.ValuePtr() = KPppHdlcFcs16Flag;

		return EPppOptNak;

		}

	case KPppLcpOptPadding:

	case KPppLcpOptCompoundFrames:

//		if (iPppLcp->DoLcpExts())

//			{

			// handle the options

//			}

		// else fall though and reject

	default:

		return EPppOptReject;

		}

	}

void CPppHdlcLink::CallBackOptRequestGranted()

	{

	iPppLcp->CallbackRequestGranted();

	}

void CPppHdlcLink::OptApplyConfigRequest(RPppOption& aOption)

/**

Applies options in a received config request (that was ACK'd).

Called once for each option.

@param aOption LCP option

*/

	{

//	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptApplyConfigRequest() Option = %d\n"),aOption.OptType());

	switch (aOption.OptType())

		{

	case KPppLcpOptEscapeCharMap:

		iPendingEscMap = BigEndian::Get32(aOption.ValuePtr());

		break;

	case KPppLcpOptProtocolCompress:

		iPendingMask |= KPppHdlcSendCompProt;

		iPendingFlags |= KPppHdlcSendCompProt;

		break;

	case KPppLcpOptAddrCtrlCompress:

		iPendingMask |= KPppHdlcSendCompAddrCtrl;

		iPendingFlags |= KPppHdlcSendCompAddrCtrl;

		break;

	case KPppLcpOptFcsType:

		{

		TUint8 fcs = *aOption.ValuePtr();

		iPendingMask |= (KPppHdlcSendFcs16|KPppHdlcSendFcs32);

		iPendingFlags &= ~(KPppHdlcSendFcs16|KPppHdlcSendFcs32);

		if (fcs==KPppHdlcFcs16Flag)

			iPendingFlags |= KPppHdlcSendFcs16;

#ifdef __LCP_EXTENSION_FCS_32

		if (fcs==KPppHdlcFcs32Flag)

			iFlags |= KPppHdlcSendFcs32;

#endif

		}

		CallBackOptRequestGranted();

		break;

	case KPppLcpOptCallback:

		CallBackOptRequestGranted();

		break;

	case KPppLcpOptPadding:

	case KPppLcpOptCompoundFrames:

	default:

		break;

		}

	}

void CPppHdlcLink::OptRecvConfigAck(RPppOption& aOption)

/**

Receives a Config Ack - apply the option.

Called once for each option.

@param aOption LCP option

*/

	{

//	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptRecvConfigAck() Option = %d\n"),aOption.OptType());

	switch (aOption.OptType())

		{

	case KPppLcpOptEscapeCharMap:

		// Start using the new map immediately.

		// This goes against the RFC, but is recommended by Carlson

		iRecvEscMap = BigEndian::Get32(aOption.ValuePtr());

		break;

	case KPppLcpOptProtocolCompress:

		// Start using the flag immediately

		iFlags |= KPppHdlcRecvCompProt;

		break;

	case KPppLcpOptAddrCtrlCompress:

		// Start using the flag immediately

		iFlags |= KPppHdlcRecvCompAddrCtrl;

		break;

	case KPppLcpOptFcsType:

		{

		TUint8 fcs = *aOption.ValuePtr();

		iPendingMask |= (KPppHdlcRecvFcs16|KPppHdlcRecvFcs32);

		iPendingFlags &= ~(KPppHdlcRecvFcs16|KPppHdlcRecvFcs32);

		if (fcs==KPppHdlcFcs16Flag)

			iPendingFlags |= KPppHdlcRecvFcs16;

#ifdef __LCP_EXTENSION_FCS_32

		if (fcs==KPppHdlcFcs32Flag)

			iPendingFlags |= KPppHdlcRecvFcs32;

#endif		

		}

		break;

	case KPppLcpOptPadding:

	case KPppLcpOptCompoundFrames:

	default:

		break;

		}

	}

void CPppHdlcLink::OptRecvConfigNak(RPppOption& aOption, RPppOptionList& aReqList)

/**

Modifies request after receiving a Config Nak.

Called once for each option.

@param aOption LCP option

@param aReqList The associated original request to be modified

*/

	{

	switch (aOption.OptType())

		{

	case KPppLcpOptEscapeCharMap:

		// Carlson says to OR this with our original request, but this will

		// work as-is with a correctly-functioning peer

		aReqList.ReplaceOption(aOption);

		break;

	case KPppLcpOptProtocolCompress:

		aReqList.ReplaceOption(aOption);

		break;

	case KPppLcpOptAddrCtrlCompress:

		aReqList.ReplaceOption(aOption);

		break;

	case KPppLcpOptFcsType:

		aReqList.ReplaceOption(aOption);

		break;

	case KPppLcpOptPadding:

	case KPppLcpOptCompoundFrames:

	default:

		break;

		}

	}

void CPppHdlcLink::OptRecvConfigReject(RPppOption& aOption, RPppOptionList& aReqList)

/**

Modifies request after receiving a Config Reject

Called once for each option.

@param aOption LCP option

@param aReqList The associated original request to be modified

*/

	{

//	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptRecvConfigReject() Option = %d\n"),aOption.OptType());

	switch (aOption.OptType())

		{

	case KPppLcpOptEscapeCharMap:

		aReqList.RemoveOption(aOption);

		break;

	case KPppLcpOptProtocolCompress:

		aReqList.RemoveOption(aOption);

		break;

	case KPppLcpOptAddrCtrlCompress:

		aReqList.RemoveOption(aOption);