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

//

/**

 @file

 @internalComponent 

*/

#ifndef __PPPDEF_H__

#define __PPPDEF_H__

#include <nifutl.h>

#include <nifmbuf.h>

#include <networking/pppsock.h>

#if !defined INLINE

#if defined( _DEBUG )

#define	INLINE

#else

#define	INLINE	inline

#endif

#endif

class CPppLcp;

class CNifFactory;

class RPppOptionList;

//

// PPP Interface to Link protocols - accepts frames from Lcp's demux

//

class MPppRecvr

	{

public:

	MPppRecvr(CPppLcp* aPppLcp, TPppPhase aPhase, TUint aPppId=KPppIdUnknown);

// The following constructor and Init function is a provisional fix,

// since according to Symbian Coding Standard M classes (mixins) are

// not supposed to have state - data members - and should contain no

// costructors or destructors.  MPppRecvr is not in fact a valid

// "mixin class", because it does not fulfill these requirements.

	void Init(CPppLcp* aPppLcp, TPppPhase aPhase, TUint aPppId=KPppIdUnknown);

	virtual ~MPppRecvr();

	//

	inline TInt SendFrame(RMBufChain& aPacket);

	inline void SetId(TUint aPppId);

	inline void SetPhase(TPppPhase aPhase);

	void Register(TUint aPpdId=KPppIdAsIs);

	void Reregister(TUint aPpdId, TPppPhase aPhase);

	void Deregister();

	void Deque();

/**

   Delivers a data link frame to this receiver for processing.

   @param aPacket [in] A reference to the RMBufChain object containing

   the data link frame.

   @return EFalse

*/

   virtual TBool RecvFrame(RMBufChain& aPacket)=0;

/**

   Notifies that a CRC error has been detected in the data link frame

   that has been received.

*/

	virtual void FrameError()=0;

/**

   Deactivates this receiver object, preventing any processing of the

   data link frames being received.

*/

	virtual void KillProtocol()=0;

	IMPORT_C virtual void FlowOn();

/**

   Notifies this receiver that the lower layer is up, i.e. that the

   PPP link is now in a phase when this receiver is active and that

   this receiver should get ready for processing the data frames being

   received, as the data frames being received will be delivered to

   it.

*/

	virtual void LowerLayerUp();

/**

   Notifies this receiver that the lower layer is down, i.e. that the

   PPP link is now in a phase when this receiver is inactive and the

   data frames being received will not be delivered to it.

   @param aStatus [in] A status code that may indicate a special

   reason for which this receiver was deactivated.

*/

	virtual void LowerLayerDown(TInt aStatus);

protected:

	CNifFactory* FindPppFactoryL(const TDesC& aFilename, TUid aUid2, CObjectCon& aCon);

	MPppRecvr();

//	virtual void PhaseChanged(TPppPhase aOldPhase, TPppPhase aNewPhase, TInt aReason)=0;

protected:

	TUint iPppId;

	TPppPhase iActivePhase;

	CPppLcp* iPppLcp;

	TInt iPppAbortCode;

private:

	friend class CPppLcp;

	TDblQueLink iPppRecvrListLink;

	};

class RPppOption;

class TPppFcs32;

class MPppOptionHandler;

//

// PPP Options

//

class RPppOptionList : public RMBufPktQ

	{

public:

	void SetL(RMBufChain& aList, TInt aLength=0);

	TInt CopyL(RMBufChain& aPacket, TInt aHdrLen=0) const;

	TInt RemoveOption(RPppOption& aOption);

	TInt ReplaceOption(RPppOption& aOption);

	TInt RemoveOptions(RPppOptionList& aRejectList);

	TInt ReplaceOptions(RPppOptionList& aReplaceList);

	void CreatePacketL(RMBufPacket& aPacket, TUint aPppId, TUint8 aType, TUint8 aId, TBool aCreateEmptyPacket = EFalse);

	void CreateAndAddL(TUint8 aType);

	void CreateAndAddL(TUint8 aType, TUint8 aValue);

	void CreateAndAddL(TUint8 aType, TUint16 aValue);

	void CreateAndAddL(TUint8 aType, TUint32 aValue);

	void CreateAndAddL(TUint8 aType, const TUint8*  aBuf, TInt aLen );	// CSW

	void CreateAndAddL(TUint8 aType, TPtrC8& aValue);

	void Crc32(TPppFcs32& aFcs, TBool aInitFcs=ETrue);

	TBool EqualTo(RPppOptionList& aList);

	TBool IsSubsetOf(RPppOptionList& aList);

	};

class MPppOptionsExtender

	{

public:

	MPppOptionsExtender();

	void ExtOptRegister(MPppOptionHandler* aHandler);

	void ExtOptDeregister(MPppOptionHandler* aHandler);

	void ExtOptNegotiationStarted();

	void ExtOptNegotiationAborted();

	void ExtOptNegotiationComplete();

	void ExtOptFillinConfigRequestL(RPppOptionList& aRequestList);

	void ExtOptCheckConfigRequest(RPppOption& aOption, RPppOptionList &aAckList, RPppOptionList &aNakList, RPppOptionList &aRejList);

	void ExtOptApplyConfigRequest(RPppOption& aOption);

	void ExtOptRecvConfigAck(RPppOption& aOption);

	void ExtOptRecvConfigNak(RPppOption& aOption, RPppOptionList& aReqList);

	void ExtOptRecvConfigReject(RPppOption& aOption, RPppOptionList& aReqList);

	MPppOptionHandler* ExtOptLookup(TUint8 aOptId);

private:

	TDblQue<MPppOptionHandler> iExtOptHandlerList;

	};

//

// PPP Finite State Machine

//

enum TPppFsmState

	{

	EPppFsmInitial, EPppFsmStarting,

	EPppFsmClosed, EPppFsmStopped,

	EPppFsmClosing, EPppFsmStopping,

	EPppFsmReqSent, EPppFsmAckRecvd,

	EPppFsmAckSent, EPppFsmOpened

	};

class MPppFsm : public MPppRecvr, public MTimer

	{

public:

	MPppFsm(CPppLcp* aPppLcp, TPppPhase aPhase, TUint aPppId);

	virtual ~MPppFsm();

	void FsmConstructL();

	// Open the state machine

	TInt FsmOpen();

	// Close the state machine

	void FsmClose(TInt aReason);

	// Abort, similar to close, but enters stopped/closed states

	void FsmAbort(TInt aReason);

	// Enquire if this layer is in the Opened state

	TBool FsmIsThisLayerOpen();

	TUint8 FsmNewId();

	void FsmRejectPacket(RMBufChain& aPacket, TUint aReason=KPppLcpCodeReject, TUint aPppId=KPppIdAsIs);

	void TerminateLink();

	inline void ChangeTimers(TBool aLengthen);

	inline void ConnectionPersist(TBool aPersist);

protected:

	// Open the layer below

	virtual TInt FsmLayerStarted()=0;

	// Close the layer below

	virtual void FsmLayerFinished(TInt aReason=KErrNone)=0;

	// Signal up event to next layer above

	virtual void FsmLayerUp()=0;

	// Signal down event to next layer above

	virtual void FsmLayerDown(TInt aReason=KErrNone)=0;

	// Fillin Config Request to be sent

	virtual void FsmFillinConfigRequestL(RPppOptionList& aRequestList)=0;

	// Check options in a recvd config request

	virtual void FsmCheckConfigRequest(RPppOptionList& aRequestList, RPppOptionList& aAckList, RPppOptionList& aNakList, RPppOptionList& aRejList)=0;

	// Apply options in a recvd config request - no-one has complained

	virtual void FsmApplyConfigRequest(RPppOptionList& aRequestList)=0;

	// Recvd a Config Ack

	virtual void FsmRecvConfigAck(RPppOptionList& aReplyList)=0;

	// Recvd a Config Nak - The associated original request is in aReqList

	virtual void FsmRecvConfigNak(RPppOptionList& aReplyList, RPppOptionList& aReqList)=0;

	// Recvd a Config Reject - The associated original request is in aReqList

	virtual void FsmRecvConfigReject(RPppOptionList& aReplyList, RPppOptionList& aReqList)=0;

	// Recvd an unrecognised opcode - has a default implementation

	virtual void FsmTerminationPhaseComplete()=0;

	virtual TBool FsmRecvUnknownCode(TUint8 aCode, TUint8 aId, TInt aLength, RMBufChain& aPacket);	

	IMPORT_C virtual void KillProtocol();

	virtual TBool FsmAckOptionsValid(RPppOptionList& aList, RPppOptionList& aRequestList);

	virtual TBool FsmRejectOptionsValid(RPppOptionList& aList, RPppOptionList& aRequestList);

	virtual TBool FsmConfigRequestOptionsValid(RPppOptionList& aList);

	//PG Moved to protected so it can be called by CPppCcp::KillProtocol

	void SetState(TPppFsmState aState);

 	//SL Added to return current state for CPppLcp::LinkRecv

 	inline TPppFsmState FsmState() const;

	TUint8* NewPacket(RMBufPacket& aPkt, TUint aLength);

protected:

	/**

 	Is RFC compliant termination phase for Administrative close enabled?	*/

 	TBool iTerminateRequestEnabled;

 	/**

	Is RFC compliant termination phase for incoming TerminateRequest enabled?	*/

	TBool iTerminateAckEnabled;

	/** Why PPP is shutting down */

	TInt iFsmTerminationCauseError;

private:

	// MPppRecvr upcalls handled by FSM

	IMPORT_C virtual TBool RecvFrame(RMBufChain& aPacket);

	IMPORT_C virtual void FrameError();

  	IMPORT_C virtual void LowerLayerUp();

	IMPORT_C virtual void LowerLayerDown(TInt aStatus=KErrNone);

	// MTimer upcall

	IMPORT_C virtual void TimerComplete(TInt aStatus);

	// Internal functions

	void InitRestartCountForConfig();

	void InitRestartCountForTerminate();

	void ZeroRestartCount();

	void SendConfigRequest();

	void SendInitialConfigRequest();

	void SendConfigRequestAfterNak(RPppOptionList& aOptList);

	void SendConfigRequestAfterReject(RPppOptionList& aOptList);

	void SendConfigReply(RPppOptionList& aOptList, TUint8 aType, TUint8 aId);

	void SendInitialTerminateRequest();

	void SendTerminateRequest();

	void SendTerminateAck(TUint8 aId);

	void ProcessConfig(TUint8 aCode, TUint8 aId, TInt aLength, RMBufChain& aPacket);

    TBool ProcessEmptyConfigReq();

	void ProcessReject(TUint8 aCode, TUint8 aId, TInt aLength, RMBufChain& aPacket);

	void ProcessTerminate(TUint8 aCode, TUint8 aId, TInt aLength, RMBufChain& aPacket);

	void ThisLayerUp();

	void ThisLayerDown();

	void ThisLayerStarted();

	void ThisLayerFinished();

	TInt InitialiseConfigRequest();

	void ReadIniFileL();

	inline TBool MaxFailureExceeded() const;

	inline void  DecrementMaxFailure();

	inline void	 InitMaxFailure();

public:

	const TText* __iFsmName;

private:

	TUint8 iCurrentId;

	TUint iTerminateId;

	TUint iRequestId;

	RPppOptionList iRequestList;

	// RFC 1661 4.6

	TInt iMaxRestartConfig;

	TInt iRestartCount;

	TPppFsmState iState;

	// RFC 1661 4.6

	TInt iWaitTimeConfig;

	TInt iWaitTime;

	TInt iConsecCfgReq;

	TUint32 iLastCfgReqFcs;

	// RFC 1661 4.6

	TInt iMaxFailureConfig;

	TInt iMaxFailureCount;

	//

 	// Termination phase support.

 	// CDMA2000 requires RFC compliant behavior for terminating the PPP link.	

 	//

 	/**

 	Maximum TerminateRequest transmissions.	*/

 	TInt iMaxTerminateRequest;

 	/**

 	TerminateRequest retransmission timeout */

 	TInt iTerminateRequestTimeout;

	/**

	Terminate Ack timeout period*/

	TInt iTerminateAckTimeout;

	TBool iLengthenTimers:1;

	TBool iPersist:1;

	/** If MPppFsm is to be terminated.*/

	TBool iFsmTermination:1;	

	/** The physical layer may block on its own retries when trying to send an initial config packet

	which then blocks the LCP from shutting down until attempts to send a disconnect packet have timed

	out. To allow for a quick shutdown in such cases where there is no evidence that the link layer

	is working the EPppFsmStarting state also sets this flag. This is driven by INC85191.

	*/

	TBool iNoEvidenceOfPeer:1;

	/**

	Whether restart timer period doubles or not */

	TBool iWaitTimeNoIncrease:1;

	};

inline void MPppFsm::ChangeTimers(TBool aLengthen)

	{

	iLengthenTimers=aLengthen;

	}

inline void MPppFsm::ConnectionPersist(TBool aPersist)

	{

	iPersist=aPersist;

	}

inline TPppFsmState MPppFsm::FsmState() const

	{

	return iState;

	}

inline TBool MPppFsm::MaxFailureExceeded() const

	{

	return iMaxFailureCount == 0;

	}

inline void  MPppFsm::DecrementMaxFailure()

	{

	iMaxFailureCount--;

	}

inline void	 MPppFsm::InitMaxFailure()

	{

	iMaxFailureCount = iMaxFailureConfig;

	}

//

// [lcp]

// PPPEnableMaxFailure = 0:disabled/1:enabled

// PPPMaxFailureCount = 5 default

_LIT(LCPSECTIONNAME,"lcp");

_LIT(PPPMAXFAILUREENTRYNAME_ENABLE,"PPPEnableMaxFailure");

_LIT(PPPMAXFAILUREENTRYNAME_COUNT,"PPPMaxFailureCount");

const TInt KPppMaxFailureDefault = 5;

// [lcp]

// PPPEnableMaxRestart = 0:disabled/1:enabled

// PPPMaxRestartCount = 20 default

_LIT(PPPMAXRESTARTENTRYNAME_ENABLE,"PPPEnableMaxRestart");

_LIT(PPPMAXRESTARTENTRYNAME_COUNT,"PPPMaxRestartCount");

// [lcp]

// PPPEnableRestartTimer = 0:disabled/1:enabled

// PPPRestartPeriod= 3000 default 3 Seconds

_LIT(PPPRESTARTTIMERENTRYNAME_ENABLE,"PPPEnableRestartTimer");

_LIT(PPPRESTARTTIMERENTRYNAME_PERIOD,"PPPRestartPeriod");

_LIT(PPP_RESTARTTIMER_ENTRYNAME_MODE,"PPPRestartTimerMode");

//

// Termination sequence support

// Doesn't follow the macro naming convention deliberately

//

//[lcp]

// PPPEnableMaxTerminateRestart = 0:disabled/1:enabled

_LIT(TERMINATE_REQUEST_ENABLE, "PPPEnableTerminateRequest");

// PPPEnableMaxTerminateRestart = 0:disabled/1:enabled

// PPPMaxTerminateRequestCount: Max TerminateRequests to be sent

_LIT(MAX_TERMINATE_REQUEST_ENABLE, "PPPEnableMaxTerminateRequest");

_LIT(MAX_TERMINATE_REQUEST_COUNT,  "PPPMaxTerminateRequestCount");

// [lcp]

// PPPEnableTerminateRestartTimer 0:disabled/1:enabled

// PPPTerminateRestartPeriod time to TerminateRequest retransmission

_LIT(TERMINATE_REQUEST_TIMER_ENABLE, "PPPEnableTerminateRequestTimer");

_LIT(TERMINATE_REQUEST_TIMER_PERIOD, "PPPTerminateRequestPeriod");

// [lcp]

// PPPEnableTerminateAck = 0: disabled / 1: enabled

_LIT(TERMINATE_ACK_ENABLE,       "PPPEnableTerminateAck");

// PPPEnableTerminateAckTimer = 0: disabled / 1: enabled

// PPPTerminateAckPeriod the time to wait after sending TerminateAck

_LIT(TERMINATE_ACK_TIMER_ENABLE, "PPPEnableTerminateAckTimer");

_LIT(TERMINATE_ACK_TIMER_PERIOD, "PPPTerminateAckPeriod");

#endif