diff -r 000000000000 -r af10295192d8 linklayerprotocols/pppnif/INC/PPPBASE.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/linklayerprotocols/pppnif/INC/PPPBASE.H Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,339 @@ +// 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 +*/ + +#if !defined(__PPPBASE_H__) +#define __PPPBASE_H__ + +#include +#include +#include + +#include +#include +#include +#include + +#include + +// This initialization file is used when PPP is configured as a client (IfServerMode=FALSE) +_LIT(PPP_INI_FILE,"ppp.ini"); + +// This initialization file is used when PPP is configured as a server (IfServerMode=TRUE) +_LIT(PPP_SERVER_INI_FILE,"pppd.ini"); + +enum TPppPanic + { + EPppPanic_PPPHDLCIsAlreadyActive, + EPppPanic_PPPDBReadCallback, + EPppPanic_PPPNoMemory, + EPppPanic_PPPNotSupported, + EPppPanic_PacketHeaderTooBig, + EPppPanic_PPPInvalidCallback, + EPppPanic_PPPNoCallbackInfo, + EPppPanic_PPPLcpRequired, + EPppPanic_PPPNoNifIfNotify, + EPppPanic_IETFCalbackInvalid, + EPppPanic_IETFNoCalback, + EPppPanic_IncorrectNcpNotif, + EPppPanic_InvalidData, + EPppPanic_NullBcaFactory, + EPppPanic_NullBca, + EPppPanic_UnexpectedBcaOpen, + EPppPanic_BcaStartupAlreadyActive, + EPppPanic_IllegalBcaControlStep, + EPppPanic_IllegalHdlcState, + EPppPanic_UnexpectedSCPRMessage, + EPppPanic_SpuriousError, + EPppPanic_LCPFailedToStart + }; + +// +// Panic +// + +static inline void PppPanic(TPppPanic aPanic) +// +// Panic the Protocol +// + { + _LIT(KPppDesc, "PPP"); + User::Panic(KPppDesc,aPanic); + } + + +// +// PPP Internal LCP Constants +// + +const TInt KPppDefaultFrameSize = 1500; + +enum TMSCBCPAction + { + EMSCBCPActionRequireClientSpecifiedNumber = ECallbackActionMSCBCPRequireClientSpecifiedNumber, + EMSCBCPActionAcceptServerSpecifiedNumber = ECallbackActionMSCBCPAcceptServerSpecifiedNumber, + EMSCBCPActionOverrideServerSpecifiedNumber = ECallbackActionMSCBCPOverrideServerSpecifiedNumber + }; + +// + +class TPppFcs16; +class TPppFcs32; +class MPppRecvr; +class MPppFsm; +class CPppLcp; +class CPppLinkBase; +class CNifFactory; + +// +// Other simple PPP Frame Receivers +// + +/** +Adds extra PPP Recv channels to a class T +*/ +template +class TPppExtraRecvr : public MPppRecvr + { +public: + TPppExtraRecvr(T* aClass, void (T::*aRecvFn)(RMBufChain&), void (T::*aFlowFn)(), + CPppLcp* aLcp, TPppPhase aPhase, TUint aId, void (T::*aFrameErrFn)(), void (T::*aKillFn)()) + : MPppRecvr(aLcp, aPhase, aId), iClass(aClass), iRecvFn(aRecvFn), iFlowFn(aFlowFn), + iFrameErrFn(aFrameErrFn), iKillFn(aKillFn){} + virtual void FrameError() + { (iClass->*iFrameErrFn)(); } + virtual void KillProtocol() + { (iClass->*iKillFn)(); } + + virtual TBool RecvFrame(RMBufChain& aPacket) + { (iClass->*iRecvFn)(aPacket); return ETrue; }; + virtual void FlowOn() + { (iClass->*iFlowFn)(); } +private: + T* iClass; + void (T::*iRecvFn)(RMBufChain&); + void (T::*iFlowFn)(); + void (T::*iFrameErrFn)(); + void (T::*iKillFn)(); + }; + +// +// PPP Options +// + +class RPppOption : public RMBufChain + { +public: + RPppOption(); + RPppOption(RMBufChain& aChain); + inline const RPppOption& operator=(const RMBufChain& aChain); + void SetL(TUint8 aType, const TAny* aPtr, TInt aLen); + TUint8 OptType() const; + void SetType(const TUint8 aType); + TInt ValueLength() const; + void SetValueLength(TInt aLen); + TUint8* ValuePtr(); + const TUint8* ValuePtr() const; + inline static RPppOption& Cast(RMBufChain& aChain); + inline static const RPppOption& Cast(const RMBufChain& aChain); +private: + // These probably belong in the MBuf manager + TInt MaxLength() const; + TInt SetLength(TInt aLen); + }; + +enum TPppOptResponse + { + EPppOptAck, + EPppOptNak, + EPppOptReject + }; + +class MPppOptionsExtender; +NONSHARABLE_CLASS(MPppOptionHandler) + { + friend class MPppOptionsExtender; +protected: + MPppOptionHandler(); + void OptRegister(MPppOptionsExtender* aExtender, const TUint8* aOptList, TInt aNumOpts); + virtual void OptNegotiationStarted(); + virtual void OptNegotiationAborted(); + virtual void OptNegotiationComplete(); + virtual void OptFillinConfigRequestL(RPppOptionList& aRequestList); + virtual TPppOptResponse OptCheckConfigRequest(RPppOption& aOption); + virtual void OptApplyConfigRequest(RPppOption& aOption); + virtual void OptRecvConfigAck(RPppOption& aOption); + virtual void OptRecvConfigNak(RPppOption& aOption, RPppOptionList& aReqList); + virtual void OptRecvConfigReject(RPppOption& aOption, RPppOptionList& aReqList); +protected: + TInt iNumOptions; + const TUint8* iOptionList; +private: + TDblQueLink iOptHandlerLink; + }; + +// +// PPP Finite State Machine +// + +const TInt KPppFsmTerminateRequestTimeout = 3000; // RFC 1661 4.6 +const TInt KPppFsmTerminateTimeout = KPppFsmTerminateRequestTimeout; // For back compatibility +const TInt KPppFsmLengthenedTerminateTimeout = 30000; // 30 secs +const TInt KPppFsmTerminateRequestRetries = 2; // RFC 1661 4.6 +const TInt KPppFsmTerminateAckTimeout = 500 + KPppFsmTerminateRequestTimeout; // RFC 1661 3.7 +const TInt KPppFsmRequestTimeout = 3000; +const TInt KPppFsmRequestMaxTimeout = 60000; +const TInt KPppFsmLengthenedRequestTimeout = 40000; // 40 secs +const TInt KPppFsmRequestRetries = 10; +const TInt KPppFsmTimerPriority = 10; + +#define __DECLARE_FSM_NAME(t) __iFsmName=t + +const TInt KPppFsmNonConvergeLimit = 4; +const TUint KPppRequestIdAnswered = 0x80000000; + +// +// PPP Link Protocols +// + +/** +Calculates the CCITT CRC-16 used by PPP in HDLC framing. +@internalTechnology +*/ +class TPppFcs16 + { +public: + inline TPppFcs16(); + inline void Init(); + void Calc(const TUint8* aPtr, const TUint8* aEnd); + inline void CalcByte(TUint8 aByte); + inline TUint16 Fcs() const; + inline TBool IsGood() const; + +private: + // WINS can't handle static const members initialized here, so use an enum + enum + { + /** Initial FCS value */ + KPppInitFcs16 = 0xffff, + /** Good final FCS value */ + KPppGoodFcs16 = 0xf0b8 + }; + /** CRC value */ + TUint16 iFcs; + /** Fast CRC calculation table */ + static const TUint16 FcsTable[256]; + }; + +/** +Calculates the CCITT CRC-32 used as an option by PPP in HDLC framing. +@internalTechnology +*/ +class TPppFcs32 + { +public: + inline TPppFcs32(); + inline void Init(); + void Calc(const TUint8* aPtr, const TUint8* aEnd); + inline void CalcByte(TUint8 aByte); + inline TUint32 Fcs() const; + inline TBool IsGood() const; + +private: + // WINS can't handle static const members initialized here, so use an enum + enum + { + /** Initial FCS value */ + KPppInitFcs32 = 0xffffffff, + /** Good final FCS value */ + KPppGoodFcs32 = 0xdebb20e3 + }; + /** CRC value */ + TUint32 iFcs; + /** Fast CRC calculation table */ + static const TUint32 FcsTable[256]; + }; + +/* +// Support for PPP components as external DLLs +class CPppExtDllRef : public CAsyncOneShot + { +public: + CPppDllRef(); + ~CPppDllRef(); + void UnloadMe(); +protected: + virtual void RunL(); +private: + RLibrary iDll; + TDblQueLink iLink; + }; + +class MPppExtDll + { +public: + IMPORT_C virtual ~MPppExtDll(); + virtual void DllInstallL()=0; + virtual void DllRemove()=0; +private: + friend class CPppExtDllRef; + CPppExtDllRef* iPppDllRef; + }; +*/ + +// +// Other simple PPP Frame Receivers +// + +/** +Base class for link protocols +@internalTechnology +*/ +NONSHARABLE_CLASS(CPppLinkBase) : public CBase + { +public: + virtual ~CPppLinkBase(); + // Implemented by link protocols + virtual void CreateL()=0; + virtual TInt Send(RMBufChain& aPacket, TUint aPppId=KPppIdAsIs)=0; + virtual void OpenL()=0; // Open/Close from LCP + virtual void Close()=0; + virtual void StartL()=0; + virtual void Stop(TInt aReason, TBool aLinkDown=ETrue)=0; + virtual void GetSendRecvSize(TInt& aMaxRecvSize, TInt& aMaxSendSize)=0; + virtual void GetDataTransfer(RPacketContext::TDataVolume&)=0; + virtual TInt SpeedMetric()=0; + inline void NewCompressor(const CPppCompressor* aCompressor); + inline void NewDeCompressor(const CPppDeCompressor* aDeCompressor); + CPppLinkBase* PppCreateLinkL(CPppLcp* aLcp, const TDesC& aNifName); +protected: + CPppLinkBase(CPppLcp* aLcp); + // Used by link protocols + inline void NotifyLinkUp(); + inline void NotifyLinkDown(TInt aReason); + inline void DeliverToLcp(RMBufChain& aPacket); +protected: + CPppLcp* iPppLcp; + CPppCompressor* iPppCompressor; + CPppDeCompressor* iPppDecompressor; + }; + +#include + +#endif