diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlannwif/inc/WlanProto.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlannwif/inc/WlanProto.h Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,385 @@ +/* +* Copyright (c) 2002-2006 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: Protocol definitions +* +*/ + +/* +* %version: 8 % +*/ + +#ifndef __WLANPROTO_H__ +#define __WLANPROTO_H__ + + +#include "wlmclientserver.h" +#include "wlancontrolinterface.h" + +#include +#include + +#include +#include + +class TLanIp4Provision; +class TLanIp6Provision; + +const TUint KWlannifMajorVersionNumber = 0; +const TUint KWlannifMinorVersionNumber = 0; +const TUint KWlannifBuildVersionNumber = 0; + +const TInt KEtherMaxDataLen = 1500; +// This should actually be 1492, +// but we allow 8 bytes more because at least in WINS we may receive such packets... +const TInt KEtherLLCMaxDataLen = 1500; +// Allow 8 bytes more. Some sources say we should allow even more +// => change this if needed. (e.g. http://www.cisco.com/warp/public/105/encheat.html: +// max length field value 0x5EE (1518)) +const TInt KEtherLLCMaxLengthFieldValue = 1508; +// I guess this value is ok also for WLAN. +// (Ideally we should ask this from the drivers but there isn't any API for that at the moment.) +const TInt KEtherSpeedInKbps = 10000; +const TInt KMinEtherType = 0x0600; // 1536 + +/******************************************************************************* +* A quick intro to the Ethernet packet format: +* +* A plain frame looks like this: +* +* struct EtherFrame { +* TUint64 iDestAddr, iSrcAddr; +* TUint16 iType; // ether type, should be >= 1536 (0x0600) (must not conflict with IEEE 802.3 length field) +* TUint8 iData[1500]; // Payload. +* }; +* +* iType denotes the type of the payload, 0x0800 denotes IP. +* 0x0806 denotes ARP. +* <= 1500 denotes IEEE 802.3 encapsulation and is interpreted as length +* A frame may also contain an extra 'LLC' field which encapsulates the original +* payload in a 5 byte header. The LLC field is somewhat complex, but here we +* confine ourselves to the LLC-SNAP variant. +* +* struct EtherLLCFrame { +* TUint64 iDestAddr, iSrcAddr; +* TUint16 iLen; // length, must be <=1500 +* TUint8 iDSAP=0xAA; // Which denotes an LLC-SNAP frame. +* TUint8 iSSAP=0xAA; // Which denotes an LLC-SNAP frame. +* TUint8 iCTRL=3; // Which denotes an LLC-SNAP frame encapsulated by +* // Ethernet. +* TUint24 OUI=iDstAddr&0xffffff; // 0 is also a valid value. +* TUint16 iType; // The actual iType as described earlier. +* TUint8 iData[1492]; // Payload. +* }; +* +*******************************************************************************/ + +_LIT8(KWlanLog, "Wlannwif"); + +const TUint32 KMACByteLength = 6; +// Ethernet types (ref. e.g. http://www.iana.org/assignments/ethernet-numbers) +const TUint16 KIPFrameType = 0x0800; // IPv4 ether type +const TUint16 KIP6FrameType = 0x86DD; // IPv6 ether type +const TUint16 KArpFrameType = 0x0806; // ARP ether type +// 802.2 LLC constants +const TUint8 KLLC_SNAP_DSAP = 0xAA; +const TUint8 KLLC_SNAP_SSAP = 0xAA; +const TUint8 KLLC_SNAP_CTRL = 3; + +// Ethernet header types +enum TEtherHeaderType + { + EStandardEthernet, + ELLCEthernet + }; + +const TUint KEtherHeaderSize = 14; +const TUint KEtherLLCHeaderSize = KEtherHeaderSize + 8; + +struct TEtherFrame + { + TUint16 GetType() { return BigEndian::Get16((TUint8*)&iType); } + TUint16 iDestAddr[3]; + TUint16 iSrcAddr[3]; + TUint16 iType; + TUint8 iData[KEtherMaxDataLen]; + }; + +struct TEtherLLCFrame + { + TUint16 GetType() {return(TUint16)((iTypeHi<<8)|iTypeLo);} + void SetType(TUint16 aType) + { + iTypeHi=(TUint8)(aType>>8); + iTypeLo=(TUint8)(aType&0xff); + } + void SetDestAddr( TDesC8& aDest); + void SetSrcAddr( TDesC8& aSrc); + void SetOUI( TUint32 aOUI); + TUint16 iDestAddr[3]; + TUint16 iSrcAddr[3]; + union + { + TUint16 iLen; + TUint16 iType; + }; + TUint8 iDSAP; + TUint8 iSSAP; + TUint8 iCtrl; + TUint8 OUI[3]; + TUint8 iTypeHi; + TUint8 iTypeLo; + TUint8 iData[KEtherLLCMaxDataLen]; + }; + +/** + * User priority values as defined 802.1D specification. + */ +enum T8021DPriority + { + E8021DUserPriorityBE = 0, // Best Effort + E8021DUserPriorityBK1 = 1, // Background + E8021DUserPriorityBK2 = 2, // Background + E8021DUserPriorityEE = 3, // Excellent Effort + E8021DUserPriorityCL = 4, // Controlled Load + E8021DUserPriorityVI = 5, // Video + E8021DUserPriorityVO = 6, // Voice + E8021DUserPriorityNC = 7, // Network Control + E8021DUserPriorityMax = 8 // Defined as the upper bound + }; + +/** + * Mapping of access classes to the corresponding user priority values. + */ +const T8021DPriority KACtoUP[EWlmAccessClassMax] = + { + E8021DUserPriorityBE, // EWlmAccessClassBackground + E8021DUserPriorityBK2, // EWlmAccessClassBestEffort + E8021DUserPriorityCL, // EWlmAccessClassVideo + E8021DUserPriorityVO, // EWlmAccessClassVoice + }; + +//forward declaration +class CLANNifWLMServerCommon; +class CLANNifWLMServerPerAC; +class CPcCardPktDrv; +class CLanxBearer; + +typedef CArrayPtrFlat CLanxBearerPtrArray; + +/** +* CLANLinkCommon +*/ +class CLANLinkCommon : public ESock::CSubConnectionFlowBase, public ESock::MFlowBinderControl + { + friend class CPktDrvBase; + +public: + enum TAction + { + EReconnect, + EDisconnect + }; + + IMPORT_C static CLANLinkCommon* NewL(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf); + IMPORT_C CLANLinkCommon(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf); + IMPORT_C virtual ~CLANLinkCommon(); + IMPORT_C void ConstructL(); + + // from MFlowBinderControl + IMPORT_C virtual ESock::MLowerControl* GetControlL(const TDesC8& aProtocol); + IMPORT_C virtual ESock::MLowerDataSender* BindL(const TDesC8& aProtocol, ESock::MUpperDataReceiver* aReceiver, ESock::MUpperControl* aControl); + IMPORT_C virtual void Unbind(ESock::MUpperDataReceiver* aReceiver, ESock::MUpperControl* aControl); + virtual ESock::CSubConnectionFlowBase* Flow() + { + return this; + } + + // from MCFNode + IMPORT_C virtual void ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& aRecipient, Messages::TSignatureBase& aMessage); + + // Dispatch functions for messages received from SCPR. + + void StartFlowL(); + void CancelStartFlow(); + void StopFlow(TInt aError); + void SubConnectionGoingDown(); + void SubConnectionError(TInt aError); + void BindToL(Messages::TNodeId& aCommsBinder); + + void Destroy(); + + // Utility functions for sending messages to SCPR. + void PostProgressMessage(TInt aStage, TInt aError); + void PostDataClientStartedMessage(); + void PostFlowDownMessage(TInt aError); + void PostFlowGoingDownMessage(TInt aError, MNifIfNotify::TAction aAction); + void MaybePostDataClientIdle(); + + // CSubConnectionFlowBase + MFlowBinderControl* DoGetBinderControlL() + { + return this; + } + + void Process( RMBufChain& aPdu, TUint8* aEtherHeader, TUint8 aUPValue ); + IMPORT_C void ResumeSending(); // Flow Control unblocked + IMPORT_C void LinkLayerUp(); // Notify the Protocol that the line is up + IMPORT_C void LinkLayerDown(TInt aError, TAction aAction); // Notify the Protocol that the line is down + + IMPORT_C TInt ReadInt(const TDesC& aField, TUint32& aValue); + IMPORT_C TInt WriteInt(const TDesC& aField, TUint32 aValue); + IMPORT_C TInt ReadDes(const TDesC& aField, TDes8& aValue); + IMPORT_C TInt ReadDes(const TDesC& aField, TDes16& aValue); + IMPORT_C TInt WriteDes(const TDesC& aField, const TDesC8& aValue); + IMPORT_C TInt WriteDes(const TDesC& aField, const TDesC16& aValue); + IMPORT_C TInt ReadBool(const TDesC& aField, TBool& aValue); + IMPORT_C TInt WriteBool(const TDesC& aField, TBool aValue); + IMPORT_C void IfProgress(TInt aStage, TInt aError); + IMPORT_C void IfProgress(TSubConnectionUniqueId aSubConnectionUniqueId, TInt aStage, TInt aError); + IMPORT_C void NifEvent(TNetworkAdaptorEventType aEventType, TUint aEvent, const TDesC8& aEventData, TAny* aSource=0); + + + TUint Mtu() const; + TUint SpeedMetric() const {return KEtherSpeedInKbps;} + + const TBuf8& MacAddress() const; + + TInt FrameSend(RMBufChain& aPdu, TDesC8& aDestAddr, TUint16 aType ); + void SetAllowedBearer(CLanxBearer* aBearer); + TBool BearerIsActive(CLanxBearer* aBearer); + +public: // Admission control related functions + + /** + * The traffic mode of an access class has changed. + * + * @param aAccessClass Access class. + * @param aMode Traffic mode of the access class. + */ + void AcTrafficModeChanged( + TWlmAccessClass aAccessClass, + TWlmAcTrafficMode aMode ); + + /** + * The traffic status of an access class has changed. + * + * @param aAccessClass Access class. + * @param aStatus Traffic status of the access class. + */ + void AcTrafficStatusChanged( + TWlmAccessClass aAccessClass, + TWlmAcTrafficStatus aStatus ); + +private: + + // Configuration methods + TBool ReadMACSettings(); + void ReadEthintSettingsL(); + + TInt EtherFrame( + RMBufChain &aChain, + TDesC8& aDestAddr, + TUint16 aType, + TUint8& aDscp ); + + // checks that the packet driver has returned a valid MAC address, + TBool CheckMac( TDes8& aMacAddr ); + + + TInt GetProtocolType( + TUint8* aEtherHeader, + TUint16& aEtherType ); + + static TInt StopCb(TAny* aThisPtr); + void StopInterface(); + + /** + * DownGradePacket + * @param aUP: downgraded UP value + * @param aDrop: sets to ETrue if packet to be dropped + * Downgrades the UP value of the packet if stream is not created. Also decides if packet to be + * dropped. This can happen if ACM is set for all traffic streams and TS is not yet created + */ + void DownGradePacket(T8021DPriority& aUP, TBool& aDrop); + + + // Driver management + void LoadPacketDriverL(); + + + // Search CLanxBearer array by various keys (used in bind/unbind/provisioning) + CLanxBearer* FindBearerByProtocolName(const TDesC8& aProtocol, TInt& aIndex) const; + CLanxBearer* FindBearerByUpperControl(const ESock::MUpperControl* aUpperControl, TInt& aIndex) const; + + // Provisioning + void ProvisionConfig(const ESock::RMetaExtensionContainerC& aConfigData); + void ProvisionConfigL(); + void ProvisionBearerConfigL(const TDesC8& aName); + +protected: + + CPcCardPktDrv* iPktDrv; + + /** */ + TBuf8 iMacAddr; + + /** Handle to the NIF-WLAN engine interface class. */ + CLANNifWLMServerCommon* iWLMServerCommon; + + /** Array containing handles to per-AC instances. */ + CLANNifWLMServerPerAC* iAcArray[EWlmAccessClassMax]; + + /** indicates if iMacAddr contains a valid Mac address */ + TBool iValidMacAddr; + + enum TlanIfStatus {EIfPending, EIfUp, EIfBusy, EIfDown}; + /** */ + TlanIfStatus iState; + + /** */ + TEtherHeaderType iEtherType; + + /** Bearer List */ + CLanxBearerPtrArray *iBearers; + CLanxBearer *iOnlyThisBearer; + + /** iPeriodic and iError needed for sending DHCPRELEASE when the + * interface is being closed + */ + CPeriodic* iPeriodic; + + // Provisioning related + const TLanIp4Provision* iLanIp4Provision; // ip4 provisioning information from SCPR + const TLanIp6Provision* iLanIp6Provision; // ip6 provisioning information from SCPR + TBool iStopRequested; + + TInt iError; // Saved from StopFlow() argument + TInt iSavedError; // saved errors from processing TProvisionConfig message + + enum TMeshMashineFlowState + { + EStopped, + EStarting, + EStarted, + EStopping, + }; + TMeshMashineFlowState iMMState; +}; + +inline const TBuf8& CLANLinkCommon::MacAddress() const +{ + return iMacAddr; +} + +#endif // __WLANPROTO_H__