diff -r 000000000000 -r af10295192d8 linklayerprotocols/pppnif/INC/PPPDEF.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/linklayerprotocols/pppnif/INC/PPPDEF.H Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,426 @@ +// 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 +#include +#include + +#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 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