MCL/sf/os/wlan: comparison wlan_bearer/wlanldd/wlan_common/umac

equal deleted inserted replaced

--1:000000000000
+:c40eb8fe8501
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:   Header file mainly for 802.11 specific declarations and
+*                definitions.
+*
+*/
+/*
+* %version: 44 %
+*/
+#ifndef WLAN802DOT11_H
+#define WLAN802DOT11_H
+#include "umac_types.h"
+// for copy, equal and operator != support
+#include "algorithm.h"
+#include "pack.h"
+/**
+* Returns a TUint16 host byte order value in WLAN MAC layer byte order
+* (LSB first)
+*
+* @since S60 3.1
+* @param aNw value in network byte order
+* @return value in host byte order
+*/
+extern TUint16 os_Hton( TUint16 aHost );
+/**
+* Returns a TUint16 WLAN MAC layer byte order (LSB first) value in host byte
+* order
+*
+* @since S60 3.1
+* @param aNw value in network byte order
+* @return value in host byte order
+*/
+extern TUint16 os_Ntoh( TUint16 aNw );
+/**
+* Returns a TUint32 host byte order value in WLAN MAC layer byte order
+* (LSB first)
+*
+* @param aNw value in network byte order
+* @return value in host byte order
+*/
+extern TUint32 os_H32ton( TUint32 aHost );
+/**
+* Returns a TUint32 WLAN MAC layer byte order (LSB first) value in host byte
+* order
+*
+* @param aNw value in network byte order
+* @return value in host byte order
+*/
+extern TUint32 os_N32toh( TUint32 aNw );
+/**
+* Allows also unaligned reading of a TUint16 WLAN MAC layer byte order
+* (LSB first) value and returns the result in the byte order which
+* is in use in the host
+*
+* @since S60 3.1
+* @param aNwSource where to read the WLAN MAC layer byte order value from
+* @return the value which was read, in host byte order
+*/
+#ifdef __ARMCC_VERSION
+/* Use the __packed qualifier for ARM compilations */
+inline TUint16 ReadUint16Toh( const __packed TUint16* aNwSource )
+#else
+inline TUint16 ReadUint16Toh( const TUint16* aNwSource )
+#endif
+{
+const TUint16 loByte ( static_cast<const TUint16>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[0] ) );
+const TUint16 hiByte ( static_cast<const TUint16>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[1] ) << 8 );
+return ( os_Ntoh( loByte | hiByte ) );
+}
+/**
+* Allows also unaligned writing of a TUint16 host byte order value
+* into WLAN MAC layer byte order
+*
+* @since S60 3.1
+* @param aNwTarget where to write the WLAN MAC layer byte order value to
+* @param aHostValue the host byte order value to be written
+*/
+#ifdef __ARMCC_VERSION
+/* Use the __packed qualifier for ARM compilations */
+inline void WriteHtoUint16( __packed TUint16* aNwTarget, TUint16 aHostValue )
+#else
+inline void WriteHtoUint16( TUint16* aNwTarget, TUint16 aHostValue )
+#endif
+{
+TUint16 nwValue = os_Hton( aHostValue );
+reinterpret_cast<TUint8*>(aNwTarget)[0] =
+( reinterpret_cast<TUint8*>(&nwValue) )[0];
+reinterpret_cast<TUint8*>(aNwTarget)[1] =
+( reinterpret_cast<TUint8*>(&nwValue) )[1];
+}
+/**
+* Allows also unaligned reading of a TUint32 WLAN MAC layer byte order
+* (LSB first) value and returns the result in the byte order which
+* is in use in the host
+*
+* @param aNwSource where to read the WLAN MAC layer byte order value from
+* @return the value which was read, in host byte order
+*/
+#ifdef __ARMCC_VERSION
+/* Use the __packed qualifier for ARM compilations */
+inline TUint32 ReadUint32Toh( const __packed TUint32* aNwSource )
+#else
+inline TUint32 ReadUint32Toh( const TUint32* aNwSource )
+#endif
+{
+const TUint32 byte0 ( static_cast<const TUint32>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[0] ) );
+const TUint32 byte1 ( static_cast<const TUint32>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[1] ) << 8 );
+const TUint32 byte2 ( static_cast<const TUint32>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[2] ) << 16 );
+const TUint32 byte3 ( static_cast<const TUint32>(
+( reinterpret_cast<const TUint8*>(aNwSource) )[3] ) << 24 );
+return ( os_N32toh( byte0 | byte1 | byte2 | byte3 ) );
+}
+/**
+* Allows also unaligned writing of a TUint32 host byte order value
+* into WLAN MAC layer byte order
+*
+* @param aNwTarget where to write the WLAN MAC layer byte order value to
+* @param aHostValue the host byte order value to be written
+*/
+#ifdef __ARMCC_VERSION
+/* Use the __packed qualifier for ARM compilations */
+inline void WriteHtoUint32( __packed TUint32* aNwTarget, TUint32 aHostValue )
+#else
+inline void WriteHtoUint32( TUint32* aNwTarget, TUint32 aHostValue )
+#endif
+{
+TUint32 nwValue = os_H32ton( aHostValue );
+reinterpret_cast<TUint8*>(aNwTarget)[0] =
+( reinterpret_cast<TUint8*>(&nwValue) )[0];
+reinterpret_cast<TUint8*>(aNwTarget)[1] =
+( reinterpret_cast<TUint8*>(&nwValue) )[1];
+reinterpret_cast<TUint8*>(aNwTarget)[2] =
+( reinterpret_cast<TUint8*>(&nwValue) )[2];
+reinterpret_cast<TUint8*>(aNwTarget)[3] =
+( reinterpret_cast<TUint8*>(&nwValue) )[3];
+}
+/**
+* Reverses the byte order of a TUint16 value
+*
+* @since S60 3.1
+* @param aOriginal value whose byte order is to be reversed
+* @return the input parameter in reversed byte order
+*/
+inline TUint16 ReverseUint16( TUint16 aOriginal )
+{
+return ( ( aOriginal >> 8 ) | ( aOriginal << 8 ) );
+}
+/**
+* A measurement of time equal to 1024 µs.
+*/
+const TUint16 KTU = 1024;
+/**
+* Length of MAC header
+*/
+const TUint8 KMacHeaderLength = 24;
+/**
+* Length of QoS MAC header
+*/
+const TUint8 KQoSMacHeaderLength = 26;
+/**
+* Length of HT Control field in bytes
+*/
+const TUint32 KHtControlFieldLength = 4;
+/**
+* Length of QoS MAC header with HT Control field in bytes
+*/
+const TUint8 KHtQoSMacHeaderLength =
+KQoSMacHeaderLength + KHtControlFieldLength;
+/**
+* Maximum number of 802.11b supported rates
+* 1, 2, 5.5, 11 MBit/s
+*/
+const TUint8 KMaxNumberOfDot11bRates = 4;
+/**
+* Maximum number of actual supported rate elements in
+* supported rates information element
+*/
+const TUint8 KMaxNumberOfRates = 8;
+/**
+* Maximum number of actual 802.11 supported rate elements in
+* extended supported rates information element
+*/
+const TUint8 KMaxNumberOfExtendedRates = 255;
+/**
+* Maximum number of 802.11b plus 802.11g supported rates
+*/
+const TUint8 KMaxNumberOfDot11bAndgRates = 14;
+/**
+* Bit mask for checking is supported rate element
+* part of BSS Basic Rate Set (MSB bit is set)
+*/
+const TUint8 KBasicRateMask = 0x80;
+/**
+* Maximum length for a WEP key in BYTES
+*/
+const TUint32 KMaxWEPKeyLength = 29;    // 232 bits
+/**
+* Length of TKIP key;
+*/
+const TUint8 KTKIPKeyLength = 16;
+/**
+* Length of WEP Init.Vector in BYTES
+*/
+const TUint8 KWepIVLength = 4;
+/**
+* Length of WEP ICV in BYTES
+*/
+const TUint8 KWEPICVLength = 4;
+/**
+* Length of Extended IV field in bytes.
+*/
+const TUint8 KWepExtendedIVLength = 4;
+/**
+* Length of CCMP header in bytes.
+*/
+const TUint8 KCcmpHeaderLength = 8;
+/**
+* Length of WAPI header in bytes.
+*/
+const TUint8 KWapiHeaderLength = 18;
+/**
+* Length of WAPI MIC in bytes.
+*/
+const TUint8 KWapiMicLength = 16;
+/**
+* Mask to determine is Ext IV bit up in WEP IV
+*/
+const TUint32 KWepExtendedIvMask = 0x20000000;
+/**
+* Mask for Use Protection bit in ERP Information IE
+*/
+const TUint8 KUseProtectionMask = 0x02;
+/**
+* Length of MIC in BYTEs
+*/
+const TUint8 KMicLength = 8;
+/**
+* Length of the MIC key in BYTEs
+*/
+const TUint8 KMicKeyLength = 8;
+/**
+* Length of ID and Length fields of an information element.
+*/
+const TUint8 KInfoElementHeaderLength = 2;
+/**
+* Length of the challenge text in BYTES used in shared key authentication
+*/
+const TUint8 KChallengeTextLength = 128;
+/**
+* Ethernet header type field identifier for Bounce type packet
+*/
+const TUint16 KBounceType = 0x8013;
+/**
+* Ethernet header type field identifier for EAPOL type packet (IEEE 802.1X)
+*/
+const TUint16 KEapolType = 0x888E;
+/**
+* Ethernet header type field identifier for WAPI authentication, i.e. WAI,
+* type packet
+*/
+const TUint16 KWaiType = 0x88B4;
+/**
+* Ethernet header type field identifier for IP type packet
+*/
+const TUint16 KIpType = 0x0800;
+/**
+* Ethernet header type field identifier for IPv6 type packet
+*/
+const TUint16 KIpv6Type = 0x86DD;
+/**
+* Ethernet header type field identifier for ARP type packet
+*/
+const TUint16 KArpType = 0x0806;
+/**
+* Length of OUI field in SNAP header
+*/
+const TUint8 KOIULength = 3;
+/**
+* Maximum length of 802.11 MSDU in bytes
+*/
+const TUint16 KMaxDot11MsduLength = 2304;
+/**
+* Maximum length of 802.11 A-MSDU in bytes
+*/
+const TUint16 KMaxDot11AmsduLength = 7935;
+/**
+* Length of trailing FCS in bytes
+*/
+const TUint32 KFcsLength = 4;
+/**
+* Maximum length in bytes of security encapsulation header in a
+* 802.11 MPDU
+*/
+const TUint16 KMaxDot11SecurityHeaderLength = KWapiHeaderLength; // 18
+/**
+* Maximum length in bytes of security encapsulation trailer in a
+* 802.11 MPDU
+*/
+const TUint16 KMaxDot11SecurityTrailerLength = KWapiMicLength;   // 16
+/**
+* Maximum length in bytes of security encapsulation header and trailer in a
+* 802.11 MPDU
+*/
+const TUint16 KMaxDot11SecurityEncapsulationLength =    // 34
+KMaxDot11SecurityHeaderLength +                     // 18
+KMaxDot11SecurityTrailerLength;                     // 16
+/**
+* Maximum length of 802.11 MPDU we will receive.
+* This excludes the tailing FCS ( HW strips it )
+* and Address4 field in the MPDU header
+* ( AP-to-AP mode frames are filtered out )
+*/
+const TUint16 KMaxDot11RxMpduLength =        // 7999
+KHtQoSMacHeaderLength +                  //   30
+KMaxDot11SecurityEncapsulationLength +   //   34
+KMaxDot11AmsduLength;                    // 7935
+/**
+* Maximum length of 802.11 MPDU we will transmit.
+* This excludes the tailing FCS ( HW strips it )
+* and Address4 field in the MPDU header
+* ( AP-to-AP mode frames are filtered out )
+* Additionally we don't currently support A-MSDU Tx
+*/
+const TUint16 KMaxDot11TxMpduLength =        // 2368
+KHtQoSMacHeaderLength +                  //   30
+KMaxDot11SecurityEncapsulationLength +   //   34
+KMaxDot11MsduLength;                     // 2304
+/**
+* Maximum length of ethernet frame
+*/
+const TUint16 KMaxEthernetFrameLength = 1514;
+/**
+* Maximum value in ethernet length field
+*/
+const TUint16 KMaxEthernetLengthFieldvalue = 1500;
+/**
+* Length of the TKIP key in BYTEs
+*/
+const TUint8 KTkIpKeyLength = 16;
+/**
+* Length of IPv4 address field in BYTEs
+*/
+const TUint8 KIpv4AddrLength = 4;
+/**
+* Length of the priority field used in WPA MIC calculation
+*/
+const TUint32 KWpaPriorityVecLen = 4;
+/**
+* WPA priority field used in MIC calculation
+*/
+const TUint8 KWpaPriorityVec[KWpaPriorityVecLen] = {0,0,0,0};
+/**
+* Mask for frame type for frame control field.
+*/
+const TUint32 K802Dot11FrameTypeMask = 0xFFFF;
+/**
+* Mask to determine if U-APSD bit is up in QoS info field of WMM IE
+*/
+const TUint8 KUapsdQosInfoMask = 0x80;
+/**
+* Mask for parameter set count in QoS info field of WMM IE
+*/
+const TUint8 KParamSetCountQosInfoMask = 0x0F;
+/**
+* Length of WMM Information Element
+*/
+const TUint8 KWmmInfoElemLen = 7;
+/**
+* Length of OUI field in Information Elements
+*/
+const TUint8 KIeOuiLength = 3;
+typedef TUint8 TIeOui[KIeOuiLength];
+/**
+* OUI value of WMM Information Element and
+* WMM Parameter Element
+*/
+const TIeOui KWmmElemOui = { 0x00, 0x50, 0xF2 };
+/**
+* OUI Type value of WMM Information Element and
+* WMM Parameter Element
+*/
+const TUint8 KWmmElemOuiType = 2;
+/**
+* OUI Subtype value of WMM Information Element
+*/
+const TUint8 KWmmInfoElemOuiSubType = 0;
+/**
+* OUI Subtype value of WMM Parameter Element
+*/
+const TUint8 KWmmParamElemOuiSubtype = 1;
+/**
+* Version of WMM Information Element
+*/
+const TUint8 KWmmInfoElemVersion = 1;
+/**
+* Version of WMM Parameter Element
+*/
+const TUint8 KWmmParamElemVersion = 1;
+/**
+* AC flags in QoS info field of WMM IE
+* When a flag is set the corresponding AC is both trigger and delivery enabled
+*/
+enum TQosInfoUapsdFlag
+{
+EAcVoUapsdFlag = 0x01, // Voice
+EAcViUapsdFlag = 0x02, // Video
+EAcBkUapsdFlag = 0x04, // Background
+EAcBeUapsdFlag = 0x08  // Best Effort
+};
+/**
+* Maximum U-APSD Service Period length. Indicates the max number of MSDUs and
+* MMPDUs the WMM AP may deliver to a WMM STA during any service period
+* triggered by the WMM STA.
+*/
+enum TQosInfoUapsdMaxSpLen
+{
+EMaxSpLenAllFrames  = 0x00,
+EMaxSpLenTwoFrames  = 0x20,
+EMaxSpLenFourFrames = 0x40,
+EMaxSpLenSixFrames  = 0x60
+};
+const TUint8 K802Dot11AccessCategoryMask = 0x60;
+/**
+* WMM Access Categories
+*/
+enum TWmmAccessCategory
+{
+EAcBestEffort   = 0x00,
+EAcBackground   = 0x20,
+EAcVideo        = 0x40,
+EAcVoice        = 0x60
+};
+/**
+* Number of WMM Access Categories
+*/
+const TUint8 KNumOfWmmACs = 4;
+/**
+* Mask for the Admission Control Mandatory flag
+* in ACI/AIFSN field
+* of AC parameter Record
+* of WMM Parameter Element
+*/
+const TUint8 KWmmAdmissionCtrlMandatoryMask = 0x10;
+/**
+* Mask for the AIFSN subfiled
+* in ACI/AIFSN field
+* of AC parameter Record
+* of WMM Parameter Element
+*/
+const TUint8 KWmmAifsnMask = 0x0F;
+/**
+* Mask for the ECWmin field
+* of AC parameter Record
+* of WMM Parameter Element
+*/
+const TUint8 KWmmEcwMinMask = 0x0F;
+/**
+* Mask for the ECWmax field
+* of AC parameter Record
+* of WMM Parameter Element
+*/
+const TUint8 KWmmEcwMaxMask = 0xF0;
+/**
+* 802.11 Authentication sequence numbers
+*/
+enum T802Dot11AuthenticationSeqNmbr
+{
+E802Dot11AuthenticationSeqNmbr1   = 1,
+E802Dot11AuthenticationSeqNmbr2   = 2,
+E802Dot11AuthenticationSeqNmbr3   = 3,
+E802Dot11AuthenticationSeqNmbr4   = 4
+};
+/**
+* 802.11 supported rate bytes. Used e.g. in Beacon frames.
+*/
+enum T802Dot11SupportedRate
+{
+E802Dot11Rate1MBit              = 2,
+E802Dot11Rate2MBit              = 4,
+E802Dot11Rate5p5MBit            = 11,
+E802Dot11Rate6MBit              = 12,
+E802Dot11Rate9MBit              = 18,
+E802Dot11Rate11MBit             = 22,
+E802Dot11Rate12MBit             = 24,
+E802Dot11Rate18MBit             = 36,
+E802Dot11Rate22MBit             = 44,
+E802Dot11Rate24MBit             = 48,
+E802Dot11Rate33MBit             = 66,
+E802Dot11Rate36MBit             = 72,
+E802Dot11Rate48MBit             = 96,
+E802Dot11Rate54MBit             = 108
+};
+/**
+* Management frame information element IDs.
+*/
+enum T802Dot11InformationElementID
+{
+E802Dot11SsidIE                 = 0,
+E802Dot11SupportedRatesIE       = 1,
+E802Doi11FhParameterSetIE       = 2,
+E802Dot11DsParameterSetIE       = 3,
+E802Dot11CfParameterSetIE       = 4,
+E802Dot11TimIE                  = 5,
+E802Dot11IbssParameterSetIE     = 6,
+E802Dot11CountryIE              = 7,
+E802Dot11HoppingPatternParamIE  = 8,
+E802Dot11HoppingPatternTableIE  = 9,
+E802Dot11RequestIE              = 10,
+E802Dot11ChallengeTextIE        = 16,
+// Reserved for challenge text extension 17 - 31
+E802Dot11ErpInformationIE       = 42,
+E802Dot11HtCapabilitiesIE       = 45,
+E802Dot11ExtendedRatesIE        = 50,
+E802Dot11HtOperationIE          = 61,
+E802Dot11VendorSpecificIE       = 221
+};
+/**
+* Bit masks for bit fields ín Frame Control field.
+*/
+enum T802Dot11FrameControlBitMask
+{
+E802Dot11FrameControlProtVersionMask= 0x0003,
+E802Dot11FrameControlTypeMask       = 0x000C,
+E802Dot11FrameControlSubtypeMask    = 0x00F0,
+E802Dot11FrameControlToDsMask       = 0x0100,
+E802Dot11FrameControlFromDsMask     = 0x0200,
+E802Dot11FrameControlMoreFragMask   = 0x0400,
+E802Dot11FrameControlRetryMask      = 0x0800,
+E802Dot11FrameControlPowerMgmtMask  = 0x1000,
+E802Dot11FrameControlMoreDataMask   = 0x2000,
+E802Dot11FrameControlWepMask        = 0x4000,
+E802Dot11FrameControlOrderMask      = 0x8000
+};
+/**
+* Frame Control field type masks.
+*/
+enum T802Dot11FrameControlBasicTypeMask
+{
+E802Dot11FrameBasicTypeManagement       = 0x00,
+E802Dot11FrameBasicTypeControl          = 0x04,
+E802Dot11FrameBasicTypeData             = 0x08
+};
+/**
+* Frame Control field subtype masks.
+*/
+enum T802Dot11FrameControlTypeMask
+{
+E802Dot11FrameTypeAssociationReq        = 0x00,
+E802Dot11FrameTypeAssociationResp       = 0x10,
+E802Dot11FrameTypeReassociationReq      = 0x20,
+E802Dot11FrameTypeReassociationResp     = 0x30,
+E802Dot11FrameTypeProbeReq              = 0x40,
+E802Dot11FrameTypeProbeResp             = 0x50,
+E802Dot11FrameTypeBeacon                = 0x80,
+E802Dot11FrameTypeAtim                  = 0x90,
+E802Dot11FrameTypeDisassociation        = 0xA0,
+E802Dot11FrameTypeAuthentication        = 0xB0,
+E802Dot11FrameTypeDeauthentication      = 0xC0,
+E802Dot11FrameTypePowerSavePoll         = 0xA4,
+E802Dot11FrameTypeReqToSend             = 0xB4,
+E802Dot11FrameTypeClearToSend           = 0xC4,
+E802Dot11FrameTypeAcknowledgement       = 0xD4,
+E802Dot11FrameTypeCfEnd                 = 0xE4,
+E802Dot11FrameTypeCfEndCfAck            = 0xF4,
+E802Dot11FrameTypeData                  = 0x08,
+E802Dot11FrameTypeDataCfAck             = 0x18,
+E802Dot11FrameTypeDataCfPoll            = 0x28,
+E802Dot11FrameTypeDataCfAckCfPoll       = 0x38,
+E802Dot11FrameTypeDataNull              = 0x48,
+E802Dot11FrameTypeCfAckNoData           = 0x58,
+E802Dot11FrameTypeCfPollNoData          = 0x68,
+E802Dot11FrameTypeCfAckCfPollNoData     = 0x78,
+E802Dot11FrameTypeQosData               = 0x88,
+E802Dot11FrameTypeQosDataCfAck          = 0x98,
+E802Dot11FrameTypeQosDataCfPoll         = 0xA8,
+E802Dot11FrameTypeQosDataCfAckCfPoll    = 0xB8,
+E802Dot11FrameTypeQosDataNull           = 0xC8,
+E802Dot11FrameTypeManagementAction      = 0xD0,
+// not valid 802.11 types.
+// just used at Tx completion to distinguish separate cases
+E802Dot11FrameTypeAuthSeqNmbr1          = 0xFD,
+E802Dot11FrameTypeAuthSeqNmbr3          = 0xFE,
+E802Dot11FrameTypeDataEapol             = 0xFF,
+E802Dot11FrameTypeTestFrame             = 0xFFFF
+};
+/**
+* Bit masks for Capability Information field.
+*/
+enum T802Dot11CapabilityBitMask
+{
+E802Dot11CapabilityEssMask          = 0x0001,
+E802Dot11CapabilityIbssMask         = 0x0002,
+E802Dot11CapabilityCfPollableMask   = 0x0004,
+E802Dot11CapabilityCfPollRequestMask= 0x0008,
+E802Dot11CapabilityPrivacyMask      = 0x0010,
+// these little critters are from 802.11b spec
+E802Dot11ShortPreambleMask          = 0x0020,
+E802Dot11PbccMask                   = 0x0040,
+E802Dot11ChannelAgilityMask         = 0x0080,
+E802Dot11ShortSlotTimeMask          = 0x0400,
+E802Dot11RadioMeasurementMask       = 0x1000
+};
+/**
+* Supported authentication modes
+*/
+const TUint16 K802Dot11AuthModeOpen   = 0;
+const TUint16 K802Dot11AuthModeShared = 1;
+/**
+* 802.11 status codes
+*/
+enum T802Dot11ManagementStatusCode
+{
+E802Dot11StatusSuccess                          = 0,
+E802Dot11StatusUnspecifiedFailure               = 1,
+// 2 -9 reserved
+E802Dot11StatusUnsupportedCapabilities          = 10,
+E802Dot11StatusReAssociationDenied              = 11,
+E802Dot11StatusAssocDenied                      = 12,
+E802Dot11StatusAuthAlgorithmNotSupported        = 13,
+E802Dot11StatusAuthFrameOutOfSequence           = 14,
+E802Dot11StatusChallengeFailure                 = 15,
+E802Dot11StatusAuthRejectedTimeout              = 16,
+E802Dot11StatusAssocDeniedApFull                = 17,
+E802Dot11StatusAssocDeniedBasicRatesUnSupp      = 18,
+// following three little critters are from 802.11b spec
+E802Dot11StatusAssocDeniedShortPreambleUnSupp   = 19,
+E802Dot11StatusAssocDeniedPbccUnSupp            = 20,
+E802Dot11StatusAssocDeniedChannelAgilityUnSupp  = 21
+// 22 - 65,535 reserved
+};
+/**
+* 802.11 reason codes
+*/
+enum T802Dot11ManagementReasonCode
+{
+// 0 reserved
+E802Dot11ReasonUnspecified                = 1,
+E802Dot11ReasonAuthNoLongerValid          = 2,
+E802Dot11ReasonDeauthStationLeft          = 3,
+E802Dot11ReasonDisAssocInactivity         = 4,
+E802Dot11ReasonDisAssocAPFull             = 5,
+E802Dot11ReasonClass2FrameWhenNotAuth     = 6,
+E802Dot11ReasonClass3FrameWhenNotAssoc    = 7,
+E802Dot11ReasonDisAssocStationLeft        = 8,
+E802Dot11ReasonAssocFailNotAuth           = 9,
+// 10 - 12 reserved
+// WPA stuff
+E802Dot11ReasonInvalidIe                  = 13,
+E802Dot11ReasonMicFailure                 = 14,
+E802Dot11ReasonHandshakeTimeout           = 15,
+E802Dot11ReasonGroupKeyUpdateTimeout      = 16,
+E802Dot11ReasonIeMismatch                 = 17,
+E802Dot11ReasonMulticastChipherNotValid   = 18,
+E802Dot11ReasonUnicastChipherNotValid     = 19,
+E802Dot11ReasonAkmpNotValid               = 20,
+E802Dot11ReasonUnsupportedRsneVersion     = 21,
+E802Dot11ReasonInvalidRsneCapabilities    = 22,
+E802Dot11Reason1xAuthenticationFailed     = 23,
+// 24 - 65,535 reserved
+};
+/**
+* 802.11 management frame fixed field and IE lengths in bytes
+*/
+const TUint KTimeStampFixedFieldLength                = 8;
+const TUint KBeaconIntervalFixedFieldLength           = 2;
+const TUint KCapabilityInformationFixedFieldLength    = 2;
+const TUint K802Dot11ErpInformationIeDataLen          = 1;
+/**
+* 802.11 management frame IE data part min/max lengths in bytes
+*/
+const TUint K802Dot11SupportedRatesIeDataMinLen = 1;
+const TUint K802Dot11TimIeDataMinLen = 4;
+const TUint K802Dot11TimIeDataMaxLen = 254;
+const TUint K802Dot11ExtendedRatesIeDataMinLen = 1;
+/**
+* 802.11 BSS Membership Selector values for different features
+*/
+enum T802Dot11BssMembershipSelector
+{
+E802Dot11HtPhy = 127 | KBasicRateMask  // 255
+};
+/**
+* operator== for TMacAddress
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const TMacAddress& aLhs, const TMacAddress& aRhs )
+{
+return ( equal( (aLhs.iMacAddress),
+(aLhs.iMacAddress) + KMacAddressLength,
+aRhs.iMacAddress) );
+}
+/**
+* Sets or clears the group bit of the MAC address
+* @param aMac the address
+* @param aSet set or clear the bit
+*/
+inline void GroupBit( TMacAddress& aMac, TBool aSet = ETrue )
+{
+if ( aSet )
+{
+aMac.iMacAddress[0] |= KBit0;
+}
+else
+{
+aMac.iMacAddress[0] &= ~KBit0;
+}
+}
+/**
+* Evaluates if the group bit of the MAC address is set
+* @param aMac the address
+* @return ETrue if group bit is set EFalse in other case
+*/
+inline TBool IsGroupBitSet( const TMacAddress& aMac )
+{
+return (aMac.iMacAddress[0] & KBit0);
+}
+/**
+* Sets or clears the local bit of the MAC address
+* @param aMac the address
+* @param aSet set or clear the bit
+*/
+inline void LocalBit( TMacAddress& aMac, TBool aSet = ETrue )
+{
+if ( aSet )
+{
+aMac.iMacAddress[0] |= KBit1;
+}
+else
+{
+aMac.iMacAddress[0] &= ~KBit1;
+}
+}
+/**
+* Evaluates if the local bit of the MAC address is set
+* @param aMac the address
+* @return ETrue if group bit is set EFalse in other case
+*/
+inline TBool IsLocalBitSet( const TMacAddress& aMac )
+{
+return (aMac.iMacAddress[0] & KBit1);
+}
+/**
+* 802.11 information element header
+*/
+#pragma pack( 1 )
+struct SInformationElementHeader
+{
+/** the element ID */
+const TUint8    iElementID;
+/** length of the following IE */
+TUint8          iLength;
+/**
+* Ctor
+* @param aElementID element ID used
+*/
+explicit SInformationElementHeader(
+T802Dot11InformationElementID aElementID )
+: iElementID( static_cast<TUint8>(aElementID) ), iLength( 0 ) {};
+/**
+* Ctor
+* @param aElementID element ID used
+* @param aLength length of the information element following this header
+*/
+SInformationElementHeader( T802Dot11InformationElementID aElementID,
+const TUint8 aLength )
+: iElementID( static_cast<TUint8>(aElementID) ), iLength( aLength ) {};
+private:
+/** Prohibit assignment operator */
+SInformationElementHeader& operator= ( const SInformationElementHeader& );
+/** Prohibit copy constructor */
+SInformationElementHeader( const SInformationElementHeader& );
+} __PACKED; // 2 bytes
+/**
+* operator== for SInformationElementHeader
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SInformationElementHeader& aLhs,
+const SInformationElementHeader& aRhs )
+{
+return static_cast<TBool>(( aLhs.iElementID == aRhs.iElementID
+&& aLhs.iLength == aRhs.iLength ));
+}
+/**
+* 802.11 SSID information element
+*/
+#pragma pack( 1 )
+struct  SSsIdIE
+{
+/** information element header */
+SInformationElementHeader   iHeader;                    // 2 bytes
+/** SSID information element */
+TUint8                      iSsIdIe[KMaxSSIDLength];    // 32 bytes
+/**
+* Ctor
+*/
+inline SSsIdIE();
+/**
+* Ctor
+* @param aData pointer to SSID
+* @param aLength length of aData
+*/
+inline SSsIdIE( const TUint8* aData, TUint8 aLength );
+/**
+* Returns information elements length ( the element + its header )
+* @return see above
+*/
+TUint8 GetIeLength() const { return static_cast<TUint8>(
+(iHeader.iLength + sizeof( SInformationElementHeader ) ) ); }
+private:
+/** Prohibit assignment operator */
+SSsIdIE& operator= ( const SSsIdIE& );
+/** Prohibit copy constructor */
+SSsIdIE( const SSsIdIE& );
+} __PACKED; // 34 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SSsIdIE::SSsIdIE() : iHeader( E802Dot11SsidIE )
+{
+os_memset( iSsIdIe, 0, sizeof( iSsIdIe ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SSsIdIE::SSsIdIE( const TUint8* aData, TUint8 aLength )
+: iHeader( E802Dot11SsidIE )
+{
+iHeader.iLength =  aLength;
+os_memcpy( &(iSsIdIe[0]), aData, aLength );
+}
+/**
+* operator== for SSsIdIE
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal EFalse not equal
+*/
+inline TBool operator== (
+const SSsIdIE& aLhs,
+const SSsIdIE& aRhs)
+{
+return static_cast<TBool>(( ( aLhs.iHeader == aRhs.iHeader )
+&& !(os_memcmp( aLhs.iSsIdIe, aRhs.iSsIdIe, aLhs.iHeader.iLength )) ));
+}
+/**
+* 802.11 supported rates information element
+*/
+#pragma pack( 1 )
+struct SSupportedRatesIE
+{
+/** information element header */
+SInformationElementHeader iHeader;                      // 2
+/**
+* supported rates information element
+* NOTE! The 802.11 standard specifies that the max length of the
+* information part of this IE is eight rates (eight bytes).
+* However at least some APs seem to put all their supported rates
+* into this element. In order to be able to associate with those
+* APs we allocate enough space to incorporate all 802.11b/g rates
+* in this IE. We ourselves will still always advertise max eight
+* rates using this IE (and the rest using the Extended Supported
+* Rates IE).
+*/
+TUint8 iSupportedRatesIE[KMaxNumberOfDot11bAndgRates];  // 14
+/**
+* Ctor
+*/
+inline SSupportedRatesIE();
+/**
+* operator[] to get supported rates element at given index
+* @param aIdx index to be get
+* @return value in given index
+*/
+inline TUint8 operator[] ( TUint8 aIdx ) const;
+/**
+* sets IE data also sets the IE headers length field
+* @param aIeData actual IE data
+* @param aLength length of aIeData
+*/
+inline void SetIeData( const TUint8* aIeData, const TUint8 aLength);
+/**
+* Returns information element's actual length
+* ( element's size + its header )
+* @return see above
+*/
+inline TUint8 GetIeLength() const;
+/**
+* Returns only the information element's actual length ( header excluded )
+* @return see above
+*/
+inline TUint8 GetElementLength() const;
+/** Marks IE zero length size */
+inline void Clear();
+/**
+* Appends a single rate element to IE
+* @param aRate rate element to be appended
+*/
+inline void Append( TUint8 aRate );
+private:
+/** Prohibit assignment operator */
+SSupportedRatesIE& operator= ( const SSupportedRatesIE& );
+/** Prohibit copy constructor */
+SSupportedRatesIE( const SSupportedRatesIE& );
+} __PACKED; // 16 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SSupportedRatesIE::SSupportedRatesIE()
+: iHeader( E802Dot11SupportedRatesIE, KMaxNumberOfRates )
+{
+os_memset( iSupportedRatesIE, 0, sizeof( iSupportedRatesIE ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SSupportedRatesIE::SetIeData(
+const TUint8* aIeData,
+const TUint8 aLength)
+{
+iHeader.iLength = aLength;
+os_memcpy( iSupportedRatesIE, aIeData, aLength );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SSupportedRatesIE::operator[] ( TUint8 aIdx ) const
+{
+return iSupportedRatesIE[aIdx];
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SSupportedRatesIE::GetIeLength() const
+{
+return static_cast<TUint8>(
+( iHeader.iLength + sizeof( SInformationElementHeader ) ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SSupportedRatesIE::GetElementLength() const
+{
+return iHeader.iLength;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SSupportedRatesIE::Clear()
+{
+iHeader.iLength = 0;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SSupportedRatesIE::Append( TUint8 aRate )
+{
+iSupportedRatesIE[iHeader.iLength] = aRate;
+++(iHeader.iLength);
+}
+/**
+* operator== for SSupportedRatesIE
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SSupportedRatesIE& aLhs,
+const SSupportedRatesIE& aRhs )
+{
+return static_cast<TBool>(( ( aLhs.iHeader == aRhs.iHeader )
+&& !(os_memcmp( aLhs.iSupportedRatesIE,
+aRhs.iSupportedRatesIE, aLhs.iHeader.iLength )) ));
+}
+/**
+* 802.11 extended supported rates information element
+*/
+#pragma pack( 1 )
+struct SExtendedSupportedRatesIE
+{
+	enum { KPad = 1 };
+/** information element header */
+SInformationElementHeader   iHeader;                                        // 2
+/** supported rates information element */
+TUint8                      iSupportedRatesIE[KMaxNumberOfExtendedRates];   // 255
+	/** padding */
+	TUint8						iPad[KPad];				                        // 1
+/**
+* Ctor
+*/
+inline SExtendedSupportedRatesIE();
+/**
+* operator[] to get supported rates element at given index
+* @param aIdx index to be get
+* @return value in given index
+*/
+inline TUint8 operator[] ( TUint8 aIdx ) const;
+/**
+* Sets IE data and the IE header's length field
+* @param aIeData actual IE data
+* @param aLength length of aIeData
+*/
+inline void SetIeData( const TUint8* aIeData, const TUint8 aLength);
+/**
+* Returns information element's actual length
+* ( element's size + its header )
+* @return see above
+*/
+inline TUint8 GetIeLength() const;
+/**
+* Returns only the information element's actual length ( header excluded )
+* @return see above
+*/
+inline TUint8 GetElementLength() const;
+/** Marks IE zero length size */
+inline void Clear();
+/**
+* Appends a single rate element to IE
+* @param aRate rate element to be appended
+*/
+inline void Append( TUint8 aRate );
+private:
+/** Prohibit assignment operator */
+SExtendedSupportedRatesIE& operator= ( const SExtendedSupportedRatesIE& );
+/** Prohibit copy constructor */
+SExtendedSupportedRatesIE( const SExtendedSupportedRatesIE& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SExtendedSupportedRatesIE::SExtendedSupportedRatesIE()
+: iHeader( E802Dot11ExtendedRatesIE, KMaxNumberOfExtendedRates )
+{
+os_memset( iSupportedRatesIE, 0, sizeof( iSupportedRatesIE ) );
+os_memset( iPad, 0, sizeof( iPad ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SExtendedSupportedRatesIE::SetIeData(
+const TUint8* aIeData,
+const TUint8 aLength)
+{
+iHeader.iLength = aLength;
+os_memcpy( iSupportedRatesIE, aIeData, aLength );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SExtendedSupportedRatesIE::operator[] ( TUint8 aIdx ) const
+{
+return iSupportedRatesIE[aIdx];
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SExtendedSupportedRatesIE::GetIeLength() const
+{
+return static_cast<TUint8>(
+( iHeader.iLength + sizeof( SInformationElementHeader ) ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SExtendedSupportedRatesIE::GetElementLength() const
+{
+return iHeader.iLength;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SExtendedSupportedRatesIE::Clear()
+{
+iHeader.iLength = 0;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SExtendedSupportedRatesIE::Append( TUint8 aRate )
+{
+iSupportedRatesIE[iHeader.iLength] = aRate;
+++(iHeader.iLength);
+}
+/**
+* operator== for SExtendedSupportedRatesIE
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SExtendedSupportedRatesIE& aLhs,
+const SExtendedSupportedRatesIE& aRhs )
+{
+return static_cast<TBool>(( ( aLhs.iHeader == aRhs.iHeader )
+&& !(os_memcmp( aLhs.iSupportedRatesIE,
+aRhs.iSupportedRatesIE, aLhs.iHeader.iLength )) ));
+}
+#pragma pack( 1 )
+struct SDsParameterSetIE
+{
+SInformationElementHeader   iHeader;                // 2
+TUint8                      iValue;                 // 1
+inline SDsParameterSetIE( const TUint32 aValue );
+private:
+/** Prohibit assignment operator */
+SDsParameterSetIE& operator= ( const SDsParameterSetIE& aObj );
+/** Prohibit copy constructor */
+SDsParameterSetIE( const SDsParameterSetIE& );
+} __PACKED;     // 3 bytes
+inline SDsParameterSetIE::SDsParameterSetIE( const TUint32 aValue ) :
+iHeader( E802Dot11DsParameterSetIE, sizeof( iValue ) ),
+iValue( aValue )
+{
+}
+const TUint K802Dot11DsParameterSetIeDataLen =
+sizeof( SDsParameterSetIE ) - sizeof( SInformationElementHeader );
+#pragma pack( 1 )
+struct SIbssParameterSetIE
+{
+SInformationElementHeader   iHeader;                // 2
+TUint16                     iValue;                 // 2
+inline SIbssParameterSetIE( const TUint16 aValue );
+inline TUint16 AtimWindow() const;
+private:
+/** Prohibit default contructor */
+SIbssParameterSetIE();
+/** Prohibit assignment operator */
+SIbssParameterSetIE& operator= ( const SIbssParameterSetIE& aObj );
+/** Prohibit copy constructor */
+SIbssParameterSetIE( const SIbssParameterSetIE& );
+} __PACKED;     // 4 bytes
+inline SIbssParameterSetIE::SIbssParameterSetIE( const TUint16 aValue ) :
+iHeader( E802Dot11IbssParameterSetIE, sizeof( iValue ) )
+{
+WriteHtoUint16( &iValue, aValue );
+}
+inline TUint16 SIbssParameterSetIE::AtimWindow() const
+{
+return ( ReadUint16Toh( &iValue ) );
+}
+const TUint K802Dot11IbssParameterSetIeDataLen =
+sizeof( SIbssParameterSetIE ) - sizeof( SInformationElementHeader );
+/**
+* Inbound WMM information element without IE header
+*/
+#pragma pack( 1 )
+struct SRxWmmIeData
+{
+TIeOui                      iOui;           // 3
+TUint8                      iOuiType;       // 1
+TUint8                      iOuiSubType;    // 1
+TUint8                      iVersion;       // 1
+/** information element */
+TUint8                      iQosInfo;       // 1
+/**
+* Evaluates if U-APSD bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsUapsdBitSet() const;
+/**
+* Gets the the parameter set count
+* @return parameter set count
+*/
+inline TUint8 ParameterSetCount() const;
+private:
+/** Prohibit default constructor */
+SRxWmmIeData();
+/** Prohibit assignment operator */
+SRxWmmIeData& operator= ( const SRxWmmIeData& aObj );
+/** Prohibit copy constructor */
+SRxWmmIeData( const SRxWmmIeData& );
+} __PACKED;     // 7 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SRxWmmIeData::IsUapsdBitSet() const
+{
+return ( (iQosInfo & KUapsdQosInfoMask )? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SRxWmmIeData::ParameterSetCount() const
+{
+return ( iQosInfo & KParamSetCountQosInfoMask );
+}
+/**
+* Outbound WMM information element
+*/
+#pragma pack( 1 )
+struct STxWmmIE
+{
+/** information element header */
+SInformationElementHeader   iHeader;        // 2
+TIeOui                      iOui;           // 3
+TUint8                      iOuiType;       // 1
+TUint8                      iOuiSubType;    // 1
+TUint8                      iVersion;       // 1
+/** information element */
+TUint8                      iQosInfo;       // 1
+/**
+* Ctor
+*/
+inline STxWmmIE() : iHeader( E802Dot11VendorSpecificIE, KWmmInfoElemLen ),
+iOuiType( KWmmElemOuiType ),
+iOuiSubType( KWmmInfoElemOuiSubType ), iVersion( KWmmInfoElemVersion ),
+iQosInfo( 0 )
+{
+os_memcpy( iOui, KWmmElemOui, KIeOuiLength );
+}
+/**
+* Sets the U-APSD flags for different ACs
+* @param aFlags flag(s) to be set
+*/
+inline void SetUapsdFlags( TQosInfoUapsdFlag aFlags );
+/**
+* Sets the maximum service period length
+* @param aMaxSpLen length of the service period
+*/
+inline void SetMaxSpLen( TQosInfoUapsdMaxSpLen aMaxSpLen );
+/**
+* Returns information elements total length, i.e.
+* element's length + header length
+* @return see above
+*/
+inline TUint8 GetIeLength() const;
+/** Clears the IE content, i.e. the iQosInfo field */
+inline void Clear();
+private:
+/** Prohibit assignment operator */
+STxWmmIE& operator= ( const STxWmmIE& aObj );
+/** Prohibit copy constructor */
+STxWmmIE( const STxWmmIE& );
+} __PACKED;     // 9 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void STxWmmIE::SetUapsdFlags( TQosInfoUapsdFlag aFlags )
+{
+iQosInfo |= aFlags;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void STxWmmIE::SetMaxSpLen( TQosInfoUapsdMaxSpLen aMaxSpLen )
+{
+iQosInfo |= aMaxSpLen;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 STxWmmIE::GetIeLength() const
+{
+return static_cast<TUint8>(
+( iHeader.iLength + sizeof( SInformationElementHeader ) ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void STxWmmIE::Clear()
+{
+iQosInfo = 0;
+}
+/**
+* AC parameters record of WMM parameter element
+*/
+#pragma pack( 1 )
+struct SAcParamsRecord
+{
+TUint8                      iAciAifsn;      // 1
+TUint8                      iEcwMinMax;     // 1
+TUint16                     iTxOpLimit;     // 2
+inline TWmmAccessCategory AccessCategory() const;
+inline TBool AdmissionControlMandatory() const;
+inline TUint8 Aifsn() const;
+inline TUint16 CwMin() const;
+inline TUint16 CwMax() const;
+inline TUint16 TxOpLimit() const;
+private:
+/** Prohibit default constructor */
+SAcParamsRecord();
+/** Prohibit assignment operator */
+SAcParamsRecord& operator= ( const SAcParamsRecord& aObj );
+/** Prohibit copy constructor */
+SAcParamsRecord( const SAcParamsRecord& );
+} __PACKED;     // 4 bytes
+inline TWmmAccessCategory SAcParamsRecord::AccessCategory() const
+{
+return ( static_cast<TWmmAccessCategory>(iAciAifsn & K802Dot11AccessCategoryMask) );
+}
+inline TBool SAcParamsRecord::AdmissionControlMandatory() const
+{
+return ( iAciAifsn & KWmmAdmissionCtrlMandatoryMask );
+}
+inline TUint8 SAcParamsRecord::Aifsn() const
+{
+return ( iAciAifsn & KWmmAifsnMask );
+}
+inline TUint16 SAcParamsRecord::CwMin() const
+{
+return ( ( static_cast<TUint16>( 1 ) <<
+( iEcwMinMax & KWmmEcwMinMask ) ) - 1 );
+}
+inline TUint16 SAcParamsRecord::CwMax() const
+{
+return ( ( static_cast<TUint16>( 1 ) <<
+( ( iEcwMinMax & KWmmEcwMaxMask ) >> 4 ) ) - 1 );
+}
+inline TUint16 SAcParamsRecord::TxOpLimit() const
+{
+// the TxOpLimit value in the AC parameters record is in units of 32
+// microseconds, but the value we need to return is in microseconds.
+// Hence we need to multiply the nw provided value by 32
+const TUint16 KTxOpLimitMultiplier = 32;
+// the value provided by the nw cannot, in practice, be bigger than
+// the value below. However, if the nw still provides a bigger value, we
+// will return the microsecond value corresponding to this value
+const TUint16 KTxOpLimitMaxNwValueInPractice = 2047;
+const TUint16 KTxOpLimitNwValue = ReadUint16Toh( &iTxOpLimit );
+return ( KTxOpLimitNwValue <= KTxOpLimitMaxNwValueInPractice ?
+KTxOpLimitNwValue * KTxOpLimitMultiplier :
+KTxOpLimitMaxNwValueInPractice * KTxOpLimitMultiplier );
+}
+/**
+* WMM Parameter Element without element header
+*/
+#pragma pack( 1 )
+struct SWmmParamElemData
+{
+/** information element header */
+TIeOui                      iOui;                    // 3
+TUint8                      iOuiType;                // 1
+TUint8                      iOuiSubType;             // 1
+TUint8                      iVersion;                // 1
+/** information element fields: */
+TUint8                      iQosInfo;                // 1
+TUint8                      iReserved;               // 1
+SAcParamsRecord             iAcParams[KNumOfWmmACs]; // 16
+/**
+* Evaluates if U-APSD bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsUapsdBitSet() const;
+/**
+* Gets the the parameter set count
+* @return parameter set count
+*/
+inline TUint8 ParameterSetCount() const;
+private:
+/** Prohibit default constructor */
+SWmmParamElemData();
+/** Prohibit assignment operator */
+SWmmParamElemData& operator= ( const SWmmParamElemData& aObj );
+/** Prohibit copy constructor */
+SWmmParamElemData( const SWmmParamElemData& );
+} __PACKED;     // 24
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SWmmParamElemData::IsUapsdBitSet() const
+{
+return ( (iQosInfo & KUapsdQosInfoMask )? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SWmmParamElemData::ParameterSetCount() const
+{
+return ( iQosInfo & KParamSetCountQosInfoMask );
+}
+/**
+* HT capabilities element without IE header
+*/
+#pragma pack( 1 )
+struct SHtCapabilitiesIeData
+{
+/**
+* Bit masks for HT capabilities info field
+*/
+enum TCapabilitiesInfoBitMask
+{
+ELdpcRxMask             = 0x0001,
+EFortyMhzOperationMask  = 0x0002,
+EGreenfieldFormatMask   = 0x0010,
+EShortGiFor20MhzMask    = 0x0020,
+EShortGiFor40MhzMask    = 0x0040,
+EStbcTxMask             = 0x0080,
+EStbcRxMask             = 0x0300,
+EDelayedBlockAckMask    = 0x0400,
+EDsssCckIn40MhzMask     = 0x1000,
+EPsmpMask               = 0x2000,
+ELsigTxopProtectionMask = 0x8000
+};
+/**
+* Offsets for HT capabilities info field
+*/
+enum TCapabilitiesInfoOffset
+{
+EOffsetToStbcRx         = 8
+};
+/**
+* Bit masks for SM power save subfield of
+* HT capabilities info field
+*/
+enum TSmPowerSave
+{
+ESmPowerSaveStatic      = 0x0000,
+ESmPowerSaveDynamic     = 0x0004,
+ESmPowerSaveDisabled    = 0x000C
+};
+/**
+* Bit masks for A-MPDU parameters field
+*/
+enum TAmpduParametersBitMask
+{
+EMaxAmpduLenExpMask         = 0x03,
+EMinMpduStartSpacingMask    = 0x1C
+};
+/**
+* Offsets for A-MPDU parameters field
+*/
+enum TAmpduParametersOffset
+{
+EOffsetToMinMpduStartSpacing = 2
+};
+/**
+* Bit masks for iTxInfo subfield of
+* Supported MCS set field
+*/
+enum TTxInfoMask
+{
+ETxMcsSetDefinedMask      = 0x01,
+ETxRxMcsSetNotEqualMask   = 0x02
+};
+/**
+* Bit masks for HT extended capabilities field
+*/
+enum TExtCapabilitiesBitMask
+{
+EPcoMask                = 0x0001,
+EMcsFeedbackMask        = 0x0300,
+EHtcMask                = 0x0400,
+ERdResponderMask        = 0x0800
+};
+/** HT capabilities info */
+TUint16                      iCapabilitiesInfo;     //  2
+/** A-MPDU parameters */
+TUint8                       iAmpdu;                //  1
+/** Supported MCS set */
+TUint8                       iRxMcsBitmask[10];     // 10
+TUint16                      iRxDataRate;           //  2
+TUint8                       iTxInfo;               //  1
+TUint8                       iReserved[3];          //  3
+/** HT extended capabilities */
+TUint16                      iExtCapabilities;      //  2
+/** Transmit beamforming capabilities */
+TUint32                      iTransBeamfCapa;       //  4
+/** ASEL capabilities */
+TUint8                       iAsel;                 //  1
+/**
+* Constructor
+*/
+inline SHtCapabilitiesIeData();
+/**
+* Evaluates if receiving LDPC coded packets is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool LdpcRx() const;
+/**
+* Sets support for receiving LDPC coded packets
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetLdpcRx( TBool aValue );
+/**
+* Evaluates if 40 MHz operation is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool FortyMhzOperation() const;
+/**
+* Sets support for 40 MHz operation
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetFortyMhzOperation( TBool aValue );
+/**
+* Sets support for SM power save
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetSmPowerSave( TSmPowerSave aSmPowerSave );
+/**
+* Evaluates if reception of HT Greenfield format PPDUs is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool GreenfieldFormat() const;
+/**
+* Sets support for reception of HT Greenfield format PPDUs
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetGreenfieldFormat( TBool aValue );
+/**
+* Evaluates if short GI reception of 20 Mhz packets is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool ShortGiFor20Mhz() const;
+/**
+* Sets support for short GI reception of 20 Mhz packets
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetShortGiFor20Mhz( TBool aValue );
+/**
+* Evaluates if short GI reception of 40 Mhz packets is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool ShortGiFor40Mhz() const;
+/**
+* Sets support for short GI reception of 40 Mhz packets
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetShortGiFor40Mhz( TBool aValue );
+/**
+* Evaluates if Tx of PPDUs using STBC is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool StbcTx() const;
+/**
+* Sets support for Tx of PPDUs using STBC
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetStbcTx( TBool aValue );
+/**
+* Returns STBC Rx support information
+* @return see above
+*/
+inline TUint8 StbcRx() const;
+/**
+* Sets STBC Rx support information
+* @param aValue STBC Rx
+*/
+inline void SetStbcRx( TUint8 aValue );
+/**
+* Evaluates if HT delayed block ack is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool DelayedBlockAck() const;
+/**
+* Sets support for HT delayed block ack
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetDelayedBlockAck( TBool aValue );
+/**
+* Sets max A-MSDU length
+* @param aValue 0 for 3839 octets, 1 for 7935 octets
+*/
+inline void SetMaxAmsduLength( TUint8 aValue );
+/**
+* Evaluates if DSSS/CCK in 40 Mhz is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool DsssCckIn40Mhz() const;
+/**
+* Sets support for DSSS/CCK in 40 Mhz
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetDsssCckIn40Mhz( TBool aValue );
+/**
+* Evaluates if PSMP operation is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool Psmp() const;
+/**
+* Sets support for PSMP operation
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetPsmp( TBool aValue );
+/**
+* Evaluates if L-SIG TXOP protection is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool LsigTxopProtection() const;
+/**
+* Sets support for L-SIG TXOP protection
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetLsigTxopProtection( TBool aValue );
+/**
+* Returns max A-MPDU length exponent
+* @return see above
+*/
+inline TUint8 MaxAmpduLenExponent() const;
+/**
+* Sets max A-MPDU length exponent
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetMaxAmpduLenExponent( TUint8 aValue );
+/**
+* Returns min MPDU start spacing
+* @return see above
+*/
+inline TUint8 MinMpduStartSpacing() const;
+/**
+* Sets min MPDU start spacing
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetMinMpduStartSpacing( TUint8 aValue );
+/**
+* Sets max supported Rx data rate
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetMaxRxDataRate( TUint16 aValue );
+/**
+* Sets Tx MCS set defined
+* @param aValue ETrue if defined, EFalse otherwise
+*/
+inline void SetTxMcsSetDefined( TBool aValue );
+/**
+* Sets Tx Rx MCS set not equal
+* @param aValue ETrue if not equal, EFalse otherwise
+*/
+inline void SetTxRxMcsSetNotEqual( TBool aValue );
+/**
+* Evaluates if PCO is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool Pco() const;
+/**
+* Sets support for PCO
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetPco( TBool aValue );
+/**
+* Sets PCO transition time
+* @param aValue PCO transition time
+*/
+inline void SetPcoTransitionTime( TUint8 aValue );
+/**
+* Returns MCS feedback
+* @return see above
+*/
+inline TUint8 McsFeedback() const;
+/**
+* Sets MCS feedback
+* @param see above
+*/
+inline void SetMcsFeedback( TUint8 aValue );
+/**
+* Evaluates if +HTC is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool Htc() const;
+/**
+* Sets support for +HTC
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetHtc( TBool aValue );
+/**
+* Evaluates if RD responder is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool RdResponder() const;
+/**
+* Sets support for RD responder
+* @param aValue ETrue if supported, EFalse otherwise
+*/
+inline void SetRdResponder( TBool aValue );
+/**
+* Returns Transmit beamforming capabilities
+* @return see above
+*/
+inline TUint32 TransmitBeamformingCapabilities() const;
+/**
+* Returns ASEL capabilities
+* @return see above
+*/
+inline TUint8 AselCapabilities() const;
+private:
+/** Prohibit assignment operator */
+SHtCapabilitiesIeData& operator= ( const SHtCapabilitiesIeData& aObj );
+/** Prohibit copy constructor */
+SHtCapabilitiesIeData( const SHtCapabilitiesIeData& aObj );
+} __PACKED;     // 26 bytes
+// ---------------------------------------------------------------------------
+// Note that byte order is not an issue when the data members are
+// initialized to zero, which is the case here
+// ---------------------------------------------------------------------------
+//
+inline SHtCapabilitiesIeData::SHtCapabilitiesIeData() :
+iAmpdu( 0 ),
+iTxInfo( 0 ),
+iAsel( 0 )
+{
+WriteHtoUint16( &iCapabilitiesInfo, 0 );
+WriteHtoUint16( &iRxDataRate, 0 );
+WriteHtoUint16( &iExtCapabilities, 0 );
+WriteHtoUint32( &iTransBeamfCapa, 0 );
+os_memset( iRxMcsBitmask, 0, sizeof( iRxMcsBitmask ) );
+os_memset( iReserved, 0, sizeof( iReserved ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::LdpcRx() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & ELdpcRxMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetLdpcRx( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+ELdpcRxMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16( &iCapabilitiesInfo, temp & ( ~ELdpcRxMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::FortyMhzOperation() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EFortyMhzOperationMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetFortyMhzOperation( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EFortyMhzOperationMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EFortyMhzOperationMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetSmPowerSave( TSmPowerSave aSmPowerSave )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+aSmPowerSave );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::GreenfieldFormat() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EGreenfieldFormatMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetGreenfieldFormat( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EGreenfieldFormatMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EGreenfieldFormatMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::ShortGiFor20Mhz() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EShortGiFor20MhzMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetShortGiFor20Mhz( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EShortGiFor20MhzMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EShortGiFor20MhzMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::ShortGiFor40Mhz() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EShortGiFor40MhzMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetShortGiFor40Mhz( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EShortGiFor40MhzMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EShortGiFor40MhzMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::StbcTx() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EStbcTxMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetStbcTx( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EStbcTxMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EStbcTxMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIeData::StbcRx() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EStbcRxMask )
+>> EOffsetToStbcRx );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetStbcRx( TUint8 aValue )
+{
+const TUint16 KnewStbcRx ( aValue << EOffsetToStbcRx );
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+KnewStbcRx );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::DelayedBlockAck() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EDelayedBlockAckMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetDelayedBlockAck( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EDelayedBlockAckMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EDelayedBlockAckMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetMaxAmsduLength( TUint8 aValue )
+{
+const TUint8 KOffsetToMaxAmsduLength ( 11 );
+TUint16 KnewMaxAmsduLength ( aValue << KOffsetToMaxAmsduLength );
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+KnewMaxAmsduLength );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::DsssCckIn40Mhz() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EDsssCckIn40MhzMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetDsssCckIn40Mhz( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EDsssCckIn40MhzMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EDsssCckIn40MhzMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::Psmp() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & EPsmpMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetPsmp( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+EPsmpMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~EPsmpMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::LsigTxopProtection() const
+{
+return ( ( ReadUint16Toh( &iCapabilitiesInfo ) & ELsigTxopProtectionMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetLsigTxopProtection( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iCapabilitiesInfo,
+ReadUint16Toh( &iCapabilitiesInfo ) |
+ELsigTxopProtectionMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iCapabilitiesInfo ) );
+WriteHtoUint16(
+&iCapabilitiesInfo,
+temp & ( ~ELsigTxopProtectionMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIeData::MaxAmpduLenExponent() const
+{
+return iAmpdu & EMaxAmpduLenExpMask;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetMaxAmpduLenExponent( TUint8 aValue )
+{
+iAmpdu |= aValue;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIeData::MinMpduStartSpacing() const
+{
+return ( ( iAmpdu & EMinMpduStartSpacingMask )
+>> EOffsetToMinMpduStartSpacing );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetMinMpduStartSpacing( TUint8 aValue )
+{
+iAmpdu |= ( aValue << EOffsetToMinMpduStartSpacing );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetMaxRxDataRate( TUint16 aValue )
+{
+WriteHtoUint16( &iRxDataRate, aValue );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetTxMcsSetDefined( TBool aValue )
+{
+if ( aValue )
+{
+iTxInfo |= ETxMcsSetDefinedMask;
+}
+else
+{
+iTxInfo &= ( ~ETxMcsSetDefinedMask );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetTxRxMcsSetNotEqual( TBool aValue )
+{
+if ( aValue )
+{
+iTxInfo |= ETxRxMcsSetNotEqualMask;
+}
+else
+{
+iTxInfo &= ( ~ETxRxMcsSetNotEqualMask );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::Pco() const
+{
+return ( ( ReadUint16Toh( &iExtCapabilities ) & EPcoMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetPco( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iExtCapabilities,
+ReadUint16Toh( &iExtCapabilities ) |
+EPcoMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iExtCapabilities ) );
+WriteHtoUint16( &iExtCapabilities, temp & ( ~EPcoMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetPcoTransitionTime( TUint8 aValue )
+{
+const TUint8 KOffsetToPcoTransitionTime ( 1 );
+const TUint16 KnewPcoTransitionTime (
+aValue << KOffsetToPcoTransitionTime );
+WriteHtoUint16( &iExtCapabilities,
+ReadUint16Toh( &iExtCapabilities ) |
+KnewPcoTransitionTime );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIeData::McsFeedback() const
+{
+const TUint8 KOffsetToMcsFeedback ( 8 );
+return ( ( ReadUint16Toh( &iExtCapabilities ) & EMcsFeedbackMask )
+>> KOffsetToMcsFeedback );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetMcsFeedback( TUint8 aValue )
+{
+const TUint8 KOffsetToMcsFeedback ( 8 );
+const TUint16 KnewMcsFeedback ( aValue << KOffsetToMcsFeedback );
+WriteHtoUint16( &iExtCapabilities,
+ReadUint16Toh( &iExtCapabilities ) |
+KnewMcsFeedback );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::Htc() const
+{
+return ( ( ReadUint16Toh( &iExtCapabilities ) & EHtcMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetHtc( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iExtCapabilities,
+ReadUint16Toh( &iExtCapabilities ) |
+EHtcMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iExtCapabilities ) );
+WriteHtoUint16( &iExtCapabilities, temp & ( ~EHtcMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtCapabilitiesIeData::RdResponder() const
+{
+return ( ( ReadUint16Toh( &iExtCapabilities ) & ERdResponderMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIeData::SetRdResponder( TBool aValue )
+{
+if ( aValue )
+{
+WriteHtoUint16( &iExtCapabilities,
+ReadUint16Toh( &iExtCapabilities ) |
+ERdResponderMask );
+}
+else
+{
+const TUint16 temp ( ReadUint16Toh( &iExtCapabilities ) );
+WriteHtoUint16( &iExtCapabilities, temp & ( ~ERdResponderMask ) );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint32 SHtCapabilitiesIeData::TransmitBeamformingCapabilities() const
+{
+return ReadUint32Toh( &iTransBeamfCapa );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIeData::AselCapabilities() const
+{
+return iAsel;
+}
+const TUint K802Dot11HtCapabilitiesIeDataLen = sizeof( SHtCapabilitiesIeData );
+/**
+* HT capabilities element
+*/
+#pragma pack( 1 )
+struct SHtCapabilitiesIE
+{
+/** information element header */
+SInformationElementHeader   iHeader;        // 2
+/** information element data */
+SHtCapabilitiesIeData       iData;          // 26
+/**
+* Constructor
+*/
+inline SHtCapabilitiesIE() :
+iHeader( E802Dot11HtCapabilitiesIE, sizeof( SHtCapabilitiesIeData ) )
+{
+}
+/**
+* Returns information element's total length, i.e.
+* element's length + header length
+* @return see above
+*/
+inline TUint8 GetIeLength() const;
+/**
+* Sets IE data and the IE header's length field
+* @param aIeData actual IE data
+* @param aLength length of aIeData
+*/
+inline void SetIeData( const TUint8* aIeData, const TUint8 aLength);
+private:
+/** Prohibit assignment operator */
+SHtCapabilitiesIE& operator= ( const SHtCapabilitiesIE& aObj );
+/** Prohibit copy constructor */
+SHtCapabilitiesIE( const SHtCapabilitiesIE& aObj );
+} __PACKED;     // 28 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtCapabilitiesIE::GetIeLength() const
+{
+return static_cast<TUint8>(
+( iHeader.iLength + sizeof( SInformationElementHeader ) ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtCapabilitiesIE::SetIeData(
+const TUint8* aIeData,
+const TUint8 aLength)
+{
+iHeader.iLength = aLength;
+os_memcpy( reinterpret_cast<TUint8*>(&iData), aIeData, aLength );
+}
+/**
+* HT Operation element without IE header
+*/
+#pragma pack( 1 )
+struct SHtOperationIeData
+{
+/**
+* Bit masks for byte2 field
+*/
+enum TByte2BitMask
+{
+ESecondaryChOffsetMask      = 0x03,
+EChWidthMask                = 0x04,
+ERifsModeMask               = 0x08
+};
+/**
+* Bit masks for bytes3_4 field
+*/
+enum TBytes3_4BitMask
+{
+EHtProtectionMask           = 0x0003,
+ENonGreenfieldPresentMask   = 0x0004
+};
+/**
+* Bit masks for bytes5_6 field
+*/
+enum TBytes5_6BitMask
+{
+EDualBeaconMask             = 0x0040,
+EDualCtsProtectionMask      = 0x0080,
+ELsigTxopProtectionMask     = 0x0200,
+EPcoActiveMask              = 0x0400
+};
+/** Primary channel */
+TUint8                       iPrimaryChannel;       //  1
+TUint8                       iByte2;                //  1
+TUint16                      iBytes3_4;             //  2
+TUint16                      iBytes5_6;             //  2
+/** Basic MCS set */
+TUint8                       iBasicMcsSet[10];      // 10
+TUint8                       iPadding[6];           //  6
+/**
+* Constructor
+*/
+inline SHtOperationIeData();
+/**
+* Returns secondary channel offset
+* @return see above
+*/
+inline TUint8 SecondaryChOffset() const;
+/**
+* Returns channel width
+* @return see above
+*/
+inline TUint8 ChWidth() const;
+/**
+* Evaluates if RIFS mode is supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool RifsMode() const;
+/**
+* Returns HT protection mode
+* @return see above
+*/
+inline TUint8 HtProtection() const;
+/**
+* Evaluates if non-greefield HT STAs are present
+* @return ETrue if present, EFalse otherwise
+*/
+inline TBool NonGreenfieldPresent() const;
+/**
+* Evaluates if dual beacon is transmitted
+* @return ETrue if transmitted, EFalse otherwise
+*/
+inline TBool DualBeacon() const;
+/**
+* Evaluates if dual CTS protection is required
+* @return ETrue if required, EFalse otherwise
+*/
+inline TBool DualCtsProtection() const;
+/**
+* Evaluates if L-SIG TXOP protection is fully supported
+* @return ETrue if supported, EFalse otherwise
+*/
+inline TBool LsigTxopProtection() const;
+/**
+* Evaluates if PCO is active in the BSS
+* @return ETrue if active, EFalse otherwise
+*/
+inline TBool PcoActive() const;
+private:
+/** Prohibit assignment operator */
+SHtOperationIeData& operator= ( const SHtOperationIeData& );
+/** Prohibit copy constructor */
+SHtOperationIeData( const SHtOperationIeData& );
+} __PACKED;     // 22 bytes
+// ---------------------------------------------------------------------------
+// Note that byte order is not an issue when the data members are
+// initialized to zero; which is the case here
+// ---------------------------------------------------------------------------
+//
+inline SHtOperationIeData::SHtOperationIeData() :
+iPrimaryChannel( 0 ),
+iByte2( 0 )
+{
+WriteHtoUint16( &iBytes3_4, 0 );
+WriteHtoUint16( &iBytes5_6, 0 );
+os_memset( iBasicMcsSet, 0, sizeof( iBasicMcsSet ) );
+os_memset( iPadding, 0, sizeof( iPadding ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtOperationIeData::SecondaryChOffset() const
+{
+return iByte2 & ESecondaryChOffsetMask;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtOperationIeData::ChWidth() const
+{
+const TUint8 KOffsetToChWidth ( 2 );
+return ( ( iByte2 & EChWidthMask ) >> KOffsetToChWidth );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::RifsMode() const
+{
+return ( (iByte2 & ERifsModeMask ) ? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SHtOperationIeData::HtProtection() const
+{
+return iBytes3_4 & EHtProtectionMask;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::NonGreenfieldPresent() const
+{
+return ( ( ReadUint16Toh( &iBytes3_4 ) & ENonGreenfieldPresentMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::DualBeacon() const
+{
+return ( ( ReadUint16Toh( &iBytes5_6 ) & EDualBeaconMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::DualCtsProtection() const
+{
+return ( ( ReadUint16Toh( &iBytes5_6 ) & EDualCtsProtectionMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::LsigTxopProtection() const
+{
+return ( ( ReadUint16Toh( &iBytes5_6 ) & ELsigTxopProtectionMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SHtOperationIeData::PcoActive() const
+{
+return ( ( ReadUint16Toh( &iBytes5_6 ) & EPcoActiveMask )
+? ETrue : EFalse );
+}
+const TUint K802Dot11HtOperationIeDataLen = sizeof( SHtOperationIeData );
+/**
+* HT Operation element
+*/
+#pragma pack( 1 )
+struct SHtOperationIE
+{
+/** information element header */
+SInformationElementHeader   iHeader;        //  2
+/** information element data */
+SHtOperationIeData          iData;          // 22
+/**
+* Constructor
+*/
+inline SHtOperationIE() :
+iHeader( E802Dot11HtOperationIE, sizeof( SHtOperationIeData ) )
+{
+}
+/**
+* Sets IE data and the IE header's length field
+* @param aIeData actual IE data
+* @param aLength length of aIeData
+*/
+inline void SetIeData( const TUint8* aIeData, const TUint8 aLength);
+private:
+/** Prohibit assignment operator */
+SHtOperationIE& operator= ( const SHtOperationIE& );
+/** Prohibit copy constructor */
+SHtOperationIE( const SHtOperationIE& );
+} __PACKED;     // 24 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtOperationIE::SetIeData(
+const TUint8* aIeData,
+const TUint8 aLength)
+{
+iHeader.iLength = aLength;
+os_memcpy( reinterpret_cast<TUint8*>(&iData), aIeData, aLength );
+}
+// capability information fixed-field
+//
+// bit 14 - 15     13     11 - 12    10        8-9       7         6
+//   ----------+-------+-----------+-------+---------+----------+-------
+//    reserved | DSSS- | reserved  | short | reserved|  Channel |   PBCC
+//             | OFDM  |           | slot  |         |  Agility |
+//   ----------+-------+-----------+-------+---------+----------+--------
+// bit        5           4         3          2          1          0
+//        ----------+----------+----------+----------+----------+----------+
+//           Short  |  Privacy |  CF-Poll |   CF     |   IBSS   |    ESS   |
+//          Preamble|   (WEP)  |  Request | Pollable |          |          |
+//        ----------+----------+----------+----------+----------+----------+
+/**
+* 802.11 management frame body capability information fixed-field
+*/
+#pragma pack( 1 )
+struct SCapabilityInformationField
+{
+enum { KReservedFieldsMask = 0xEB00 };
+/** capability information fixed field */
+TUint16 iCapabilityInformationField;
+/**
+* Ctor
+*/
+inline SCapabilityInformationField();
+/**
+* Ctor
+* @param aParam value used in iCapabilityInformationField field
+*/
+explicit inline SCapabilityInformationField( const TUint16 aParam );
+/**
+* Assignment operator for TUint16 type
+* @param aParam value used as iCapabilityInformationField
+*/
+inline SCapabilityInformationField& operator= ( const TUint16 aParam );
+/**
+* Returns the value of the Capability Information Field
+* @return
+*/
+inline TUint16 CapabilityInformationField() const;
+/**
+* Evaluates if ESS bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsEssBitSet() const;
+/**
+* Evaluates if IBSS bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsIbssBitSet() const;
+/**
+* Evaluates if Privaecy bit bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsPrivacyBitSet() const;
+/**
+* Evaluates if Short Preamble bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsShortPreambleBitSet() const;
+/**
+* Evaluates if PBCC bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsPbccBitSet() const;
+/**
+* Evaluates if Channel Agility bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsChannelAgilityBitSet() const;
+/**
+* Evaluates if short slot time bit is up
+* @return ETrue if bit is up, otherwise EFalse
+*/
+inline TBool IsShortSlotTimeBitSet() const;
+/**
+* Clears both CF bits
+*/
+inline void ClearCfFields();
+/**
+* Clear CF pollable field
+*/
+inline void ClearCfPollable();
+/**
+* Clears both CF poll request field
+*/
+inline void ClearCfPollRequest();
+/**
+* Sets the short preamble bit
+*/
+inline void SetShortPreamble();
+/**
+* Clears the short preamble bit
+*/
+inline void ClearShortPreamble();
+/**
+* sets the pbcc bit
+*/
+inline void SetPbcc();
+/**
+* sets the IBSS bit
+*/
+inline void SetIbss();
+/**
+* Clear PBCC bit
+*/
+inline void ClearPbcc();
+/** Clear reserved fields */
+inline void ClearReservedFields();
+/** Set WEP bit */
+inline void SetWepBit();
+/** Clear WEP bit */
+inline void ClearWepBit();
+/** Set RM bit */
+inline void SetRMBit();
+/** Clear RM bit */
+inline void ClearRMBit();
+private:
+/** Prohibit copy constructor */
+SCapabilityInformationField( const SCapabilityInformationField& );
+} __PACKED; // 2 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SCapabilityInformationField::SCapabilityInformationField()
+{
+WriteHtoUint16( &iCapabilityInformationField, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SCapabilityInformationField::SCapabilityInformationField(
+const TUint16 aParam )
+{
+WriteHtoUint16( &iCapabilityInformationField, aParam );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SCapabilityInformationField& SCapabilityInformationField::operator= (
+const TUint16 aParam )
+{
+WriteHtoUint16( &iCapabilityInformationField, aParam );
+return (*this);
+}
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+inline TUint16 SCapabilityInformationField::CapabilityInformationField() const
+{
+return ( ReadUint16Toh( &iCapabilityInformationField ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsEssBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11CapabilityEssMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsIbssBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11CapabilityIbssMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsPrivacyBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11CapabilityPrivacyMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsShortPreambleBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11ShortPreambleMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsPbccBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11PbccMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsChannelAgilityBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11ChannelAgilityMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SCapabilityInformationField::IsShortSlotTimeBitSet() const
+{
+return ( ( ReadUint16Toh( &iCapabilityInformationField ) &
+E802Dot11ShortSlotTimeMask )
+? ETrue : EFalse );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearCfFields()
+{
+ClearCfPollable();
+ClearCfPollRequest();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearCfPollable()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11CapabilityCfPollableMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearCfPollRequest()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11CapabilityCfPollRequestMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::SetShortPreamble()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) |
+E802Dot11ShortPreambleMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::SetPbcc()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) |
+E802Dot11PbccMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::SetIbss()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) |
+E802Dot11CapabilityIbssMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearShortPreamble()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11ShortPreambleMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearPbcc()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11PbccMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearReservedFields()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~KReservedFieldsMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::SetRMBit()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) |
+E802Dot11RadioMeasurementMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearRMBit()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11RadioMeasurementMask ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::SetWepBit()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) |
+E802Dot11CapabilityPrivacyMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SCapabilityInformationField::ClearWepBit()
+{
+WriteHtoUint16( &iCapabilityInformationField,
+ReadUint16Toh( &iCapabilityInformationField ) &
+( ~E802Dot11CapabilityPrivacyMask ) );
+}
+/**
+* operator== for SCapabilityInformationField
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SCapabilityInformationField& aLhs,
+const SCapabilityInformationField& aRhs)
+{
+return static_cast<TBool>( aLhs.CapabilityInformationField()
+== aRhs.CapabilityInformationField() );
+}
+/**
+* 802.11 management frame body listen interval fixed-field
+*/
+#pragma pack( 1 )
+struct SListenIntervalField
+{
+/** listen interval fixed field */
+TUint16 iListenInterval;
+/**
+* Ctor
+*/
+inline SListenIntervalField();
+/**
+* Ctor
+* @param aParam value used in iListenInterval
+*/
+explicit inline SListenIntervalField( const TUint16 aParam );
+/**
+* Returns the value of the Listen Interval
+* @return Listen Interval
+*/
+inline TUint16 ListenInterval() const;
+/**
+* assignment operator for TUint16 type
+* @param aInterval listen interval fixed field
+*/
+inline SListenIntervalField& operator= ( const TUint16 aInterval );
+private:
+/** Prohibit assignment operator */
+SListenIntervalField& operator= ( const SListenIntervalField& );
+/** Prohibit copy constructor */
+SListenIntervalField( const SListenIntervalField& );
+} __PACKED; // 2 bytes
+inline SListenIntervalField::SListenIntervalField()
+{
+WriteHtoUint16( &iListenInterval, 0 );
+}
+inline SListenIntervalField::SListenIntervalField( const TUint16 aParam )
+{
+WriteHtoUint16( &iListenInterval, aParam );
+}
+inline TUint16 SListenIntervalField::ListenInterval() const
+{
+return ( ReadUint16Toh( &iListenInterval ) );
+}
+inline SListenIntervalField& SListenIntervalField::operator= (
+const TUint16 aInterval )
+{
+WriteHtoUint16( &iListenInterval, aInterval );
+return (*this);
+}
+/**
+* operator== for SListenIntervalField
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SListenIntervalField& aLhs,
+const SListenIntervalField& aRhs)
+{
+return static_cast<TBool>( aLhs.ListenInterval() == aRhs.ListenInterval() );
+}
+/*
+802.11 DATA Frame
++----------------+
+|                |
+|  Frame Control |
+|    2 bytes     |
++----------------+
+|                |
+|  Duration ID   |
+|    2 bytes     |
++----------------+
+|                |
+|   Address 1    |
+|    6 bytes     |
++----------------+
+|                |
+|   Address 2    |
+|    6 bytes     |
++----------------+
+|                |
+|   Address 3    |
+|    6 bytes     |
++----------------+
+|                |
+| Sequence Cntrl |
+|    2 bytes     |
++----------------+
+|                |
+|   Address 4    |
+|    6 bytes     |
++----------------+
+|  DSAP - 1 byte | = 0xAA ( SNAP )
++----------------+
+|  SSAP - 1 byte | = 0xAA ( SNAP )
++----------------+
+|Control - 1 byte| = 0x03
++----------------+
+| OUI - 3 bytes  | = 0x0
+|                |
++----------------+
+| Type - 2 bytes |  = Ethernet type (IP=0x0800)
++----------------+
+|                |
+|      Data      |
+|                |
+~                ~
+~                ~
+|   46 to 1500   |
+|     bytes      |
+|                |
++----------------+
+|      FCS       |
+|    4 bytes     |
++----------------+
+*/
+// FrameControl field of the 802.11 header
+//
+// |--------------------- control -----------------------|
+//
+// bit 15    14     13     12     11     10      9     8
+// +-------+-----+------+-----+-------+------+------+----+
+// | Order | WEP | More | Pwr | Retry | More | From | To |
+// |       |     | Data | Mgmt|       | Frag | DS   | DS |
+// +-------+-----+------+-----+-------+------+------+----+
+//    1      1      1     1      1       1      1     1
+//--------- type ------------|
+//
+//   7-4     3-2      1-0
+//---------+------+----------+
+// Subtype | Type | Protocol |
+//         |      | Version  |
+//---------+------+----------+
+//    4       2        2
+/**
+* 802.11 Frame Control field
+*/
+#pragma pack( 1 )
+struct SFrameControl
+{
+/** type field */
+TUint8 iType;
+/** control filed */
+TUint8 iControl;
+/**
+* Ctor
+* @param aType type field
+* @param aControl control field
+*/
+SFrameControl(
+T802Dot11FrameControlTypeMask aType,
+T802Dot11FrameControlBitMask aControl )
+: iType( static_cast<TUint8>(aType) ),
+iControl( static_cast<TUint8>(aControl) ) {};
+/**
+* Returns type and control fields combined as a single TUint16 value
+* @return see above
+*/
+inline TUint16 operator()() const;
+private:
+/** Prohibit assignment operator */
+SFrameControl& operator= ( const SFrameControl& aObj );
+/** Prohibit copy constructor */
+SFrameControl( const SFrameControl& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SFrameControl::operator()() const
+{
+TUint16 value( iType );
+return ( static_cast<TUint16>(( value << 8 ) + iControl ));
+}
+/**
+* operator== for SFrameControl
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SFrameControl& aLhs,
+const SFrameControl& aRhs)
+{
+return static_cast<TBool>( aLhs.iType == aRhs.iType
+&& aLhs.iControl == aRhs.iControl );
+}
+#pragma pack( 1 )
+struct SPsPoll
+{
+const SFrameControl   iFrameControl;  // 2 bytes
+TUint16               iAid;           // 2 bytes
+const TMacAddress     iBssId;         // 6 bytes
+const TMacAddress     iTa;            // 6 bytes
+inline SPsPoll(
+TUint16 aAid,
+const TMacAddress& aBssId,
+const TMacAddress& aTa );
+private:
+/** Prohibit default contructor */
+SPsPoll();
+/** Prohibit assignment operator */
+SPsPoll& operator= ( const SPsPoll& );
+/** Prohibit copy constructor */
+SPsPoll( const SPsPoll& );
+} __PACKED; // 16 bytes
+inline SPsPoll::SPsPoll(
+TUint16 aAid,
+const TMacAddress& aBssId,
+const TMacAddress& aTa )
+: iFrameControl( E802Dot11FrameTypePowerSavePoll,
+static_cast<T802Dot11FrameControlBitMask>(0) ),
+iBssId( aBssId ), iTa( aTa )
+{
+// AID always has the 2 most significant bits set to 1
+WriteHtoUint16( &iAid, ( aAid | 0xC000  ) );
+}
+// SequenceControl field of the 802.11 header
+//
+// bit      15 - 4         3 - 0
+// +-------------------+-----------+
+// |  Sequence Number  | Fragment  |
+// |                   |  Number   |
+// +-------------------+-----------+
+//          12              4
+/**
+* 802.11 data frame MAC header
+*/
+#pragma pack( 1 )
+struct SDataFrameHeader
+{
+/** frame control field */
+SFrameControl   iFrameControl;  // 2 bytes
+/** duration field */
+TUint16   iDuration;            // 2 bytes
+/** address1 field */
+TMacAddress     iAddress1;      // 6 bytes
+/** address2 field */
+TMacAddress     iAddress2;      // 6 bytes
+/** address3 field */
+TMacAddress     iAddress3;      // 6 bytes
+/** sequence control field */
+TUint16   iSeqCtl;              // 2 bytes
+// this littly piggy is only used in AP-AP mode
+// which we don't do, so it is omitted
+// const TMacAddress iAddress4;      // 6 bytes
+/**
+* Ctor
+*/
+inline SDataFrameHeader();
+/**
+* Sets WEP bit from Frame Control field
+*/
+inline void SetWepBit();
+/**
+* Clears WEP bit from Frame Control field
+*/
+inline void ClearWepBit();
+/**
+* Sets ToDS bit from Frame Control field
+*/
+inline void SetToDsBit();
+/**
+* Clears ToDS bit from Frame Control field
+*/
+inline void ClearToDsBit();
+/**
+* Clears FromDS bit from Frame Control field
+*/
+inline void ClearFromDsBit();
+/**
+* Evaluates is FromDS bit set from Frame Control field
+*/
+inline TBool IsFromDsBitSet() const;
+inline TBool IsToDsBitSet() const;
+/**
+* Evaluates is WEP bit set from Frame Control field
+*/
+inline TBool IsWepBitSet() const;
+/**
+* Evaluates is Order bit set from Frame Control field
+*/
+inline TBool IsOrderBitSet() const;
+/**
+* Sets Order bit from Frame Control field
+*/
+inline void SetOrderBit();
+/**
+* Clears Order bit from Frame Control field
+*/
+inline void ClearOrderBit();
+/**
+* Gets Frame Control field
+* @return reference to the frame control field
+*/
+inline const SFrameControl& GetFrameControl() const;
+/**
+* Returns Sequence Number from iSeqCtl field
+* @return Sequence Number
+*/
+inline TUint16 SequenceNumber() const;
+private:
+/** Prohibit assignment operator */
+SDataFrameHeader& operator= ( const SDataFrameHeader& aObj );
+/** Prohibit copy constructor */
+SDataFrameHeader( const SDataFrameHeader& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SDataFrameHeader::SDataFrameHeader() :
+iFrameControl( E802Dot11FrameTypeData,
+static_cast<T802Dot11FrameControlBitMask>(0) ),
+iAddress1( KZeroMacAddr ),
+iAddress2( KZeroMacAddr ),
+iAddress3( KZeroMacAddr )
+{
+WriteHtoUint16( &iDuration, 0 );
+WriteHtoUint16( &iSeqCtl, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::SetWepBit()
+{
+iFrameControl.iControl |= ( E802Dot11FrameControlWepMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::ClearWepBit()
+{
+iFrameControl.iControl &= ~( E802Dot11FrameControlWepMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::SetToDsBit()
+{
+iFrameControl.iControl |= ( E802Dot11FrameControlToDsMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::ClearToDsBit()
+{
+iFrameControl.iControl &= ~( E802Dot11FrameControlToDsMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::ClearFromDsBit()
+{
+iFrameControl.iControl &= ~( E802Dot11FrameControlFromDsMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SDataFrameHeader::IsFromDsBitSet() const
+{
+return static_cast<TBool>( iFrameControl.iControl & (
+E802Dot11FrameControlFromDsMask >> 8 ));
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SDataFrameHeader::IsToDsBitSet() const
+{
+return static_cast<TBool>( iFrameControl.iControl & (
+E802Dot11FrameControlToDsMask >> 8 ));
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SDataFrameHeader::IsWepBitSet() const
+{
+return static_cast<TBool>( iFrameControl.iControl & (
+E802Dot11FrameControlWepMask >> 8 ));
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SDataFrameHeader::IsOrderBitSet() const
+{
+return static_cast<TBool>( iFrameControl.iControl & (
+E802Dot11FrameControlOrderMask >> 8 ));
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::SetOrderBit()
+{
+iFrameControl.iControl |= ( E802Dot11FrameControlOrderMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDataFrameHeader::ClearOrderBit()
+{
+iFrameControl.iControl &= ~( E802Dot11FrameControlOrderMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline const SFrameControl& SDataFrameHeader::GetFrameControl() const
+{
+return iFrameControl;
+}
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+inline TUint16 SDataFrameHeader::SequenceNumber() const
+{
+return ( ReadUint16Toh( &iSeqCtl ) >> 4 );
+}
+typedef SDataFrameHeader SNullDataFrame;
+typedef SDataFrameHeader Sdot11MacHeader;
+typedef TUint16 T802Dot11QosControl;
+/**
+* Bits 0-2 of the QoS Control field of a QoS Data Frame determine the user
+* priority of the frame. This is a mask for those bits
+*/
+const T802Dot11QosControl KWmmUserPriorityMask = 0x0007;
+/**
+* Bit 7 of the QoS Control field of a QoS Data Frame indicates the presence
+* of an A-MSDU in the frame (1: present, 0: not present) (IEEE 802.11n/D6.04).
+* This is the mask for that bit
+*/
+const T802Dot11QosControl KAmsduPresentMask = 0x0080;
+/**
+* 802.11 QoS data frame MAC header
+*/
+#pragma pack( 1 )
+struct SQosDataFrameHeader
+{
+/** 802.11 data frame MAC header */
+SDataFrameHeader iHdr;              // 24 bytes
+/** QoS control field */
+T802Dot11QosControl iQosControl;    // 2 bytes
+/**
+* Ctor
+*/
+inline SQosDataFrameHeader();
+/**
+* Resets the QoS Control field to zero
+*/
+inline void ResetQosControl();
+/**
+* Sets the WMM user priority (3 lowest bits) of the QoS Control field
+*/
+inline void SetUserPriority( TUint8 aPriority );
+/**
+* Returns the WMM user priority (3 lowest bits) of the QoS Control field
+* @return WMM user priority
+*/
+inline TUint8 UserPriority() const;
+/**
+* Returns A-MSDU presence
+* @return ETrue if A-MSDU is present
+*         EFalse otherwise
+*/
+inline TBool AmsduPresent() const;
+private:
+/** Prohibit assignment operator */
+SQosDataFrameHeader& operator= ( const SQosDataFrameHeader& );
+/** Prohibit copy constructor */
+SQosDataFrameHeader( const SQosDataFrameHeader& );
+} __PACKED; // 26 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SQosDataFrameHeader::SQosDataFrameHeader()
+{
+WriteHtoUint16( &iQosControl, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SQosDataFrameHeader::ResetQosControl()
+{
+WriteHtoUint16( &iQosControl, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SQosDataFrameHeader::SetUserPriority( TUint8 aPriority )
+{
+// clear old priority
+WriteHtoUint16( &iQosControl,
+ReadUint16Toh( &iQosControl ) &
+( ~KWmmUserPriorityMask ) );
+// set new priority
+WriteHtoUint16( &iQosControl,
+ReadUint16Toh( &iQosControl ) |
+aPriority );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint8 SQosDataFrameHeader::UserPriority() const
+{
+return ( ReadUint16Toh( &iQosControl ) & KWmmUserPriorityMask );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TBool SQosDataFrameHeader::AmsduPresent() const
+{
+return ( ReadUint16Toh( &iQosControl ) & KAmsduPresentMask );
+}
+typedef SQosDataFrameHeader SQosNullDataFrame;
+/**
+* 802.11 QoS data frame MAC header with HT Control field
+*/
+#pragma pack( 1 )
+struct SHtQosDataFrameHeader
+{
+/** 802.11 data frame MAC header */
+SQosDataFrameHeader iQosDataFrameHdr;   // 26 bytes
+/** HT control field */
+TUint32 iHtControl;                     // 4 bytes
+/**
+* Constructor
+*/
+inline SHtQosDataFrameHeader();
+/**
+* Resets the HT Control field to zero
+*/
+inline void ResetHtControl();
+} __PACKED; // 30 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SHtQosDataFrameHeader::SHtQosDataFrameHeader()
+{
+WriteHtoUint32( &iHtControl, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtQosDataFrameHeader::ResetHtControl()
+{
+WriteHtoUint32( &iHtControl, 0 );
+}
+typedef SHtQosDataFrameHeader SHtQosNullDataFrame;
+/**
+* 802.11 A-MSDU subframe header
+*/
+#pragma pack( 1 )
+struct SAmsduSubframeHeader
+{
+/** destination MAC address */
+TMacAddress     iDa;                    // 6 bytes
+/** source MAC address */
+TMacAddress     iSa;                    // 6 bytes
+/** length of the MSDU in bytes */
+TUint16 iLength;                        // 2 bytes
+/**
+* Returns the length of the MSDU in bytes
+*/
+inline TUint16 Length() const;
+private:
+/** Prohibit default contructor */
+SAmsduSubframeHeader();
+/** Prohibit assignment operator */
+SAmsduSubframeHeader& operator= ( const SAmsduSubframeHeader&);
+/** Prohibit copy constructor */
+SAmsduSubframeHeader( const SAmsduSubframeHeader& );
+} __PACKED; // 14 bytes
+// ---------------------------------------------------------------------------
+// We need to reverse the byte order as according to IEEE 802.11n/D6.04
+// "The order of these fields and the bits within these fields (#2061) is
+// the same as the IEEE 802.3 frame format", and IEEE 802.3 specifies the
+// byte order of this field to be MSB first. WLAN MAC layer, however, uses
+// LSB first byte order
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SAmsduSubframeHeader::Length() const
+{
+return ReverseUint16( ReadUint16Toh( &iLength ) );
+}
+/**
+* 802.11 management frame MAC header
+*/
+#pragma pack( 1 )
+struct SManagementFrameHeader
+{
+/** frame control field */
+SFrameControl   iFrameControl;  // 2 bytes
+/** duration field */
+TUint16   iDuration;            // 2 bytes
+/** DA address field */
+TMacAddress     iDA;            // 6 bytes frames destination = AP
+/** SA address field */
+TMacAddress     iSA;            // 6 bytes source address
+/** BSSID address field */
+TMacAddress     iBSSID;         // 6 bytes BSS identifier = iDA
+/** sequence control field */
+TUint16   iSeqCtl;              // 2 bytes
+/**
+* Ctor
+* @param aTypeMask frame control type mask
+* @param aControlMask frame control control mask
+*/
+inline SManagementFrameHeader(
+T802Dot11FrameControlTypeMask aTypeMask,
+T802Dot11FrameControlBitMask aControlMask
+= static_cast<T802Dot11FrameControlBitMask>( 0 ) );
+/**
+* Set WEP bit from Frame Control Field
+*/
+inline void SetWepBit();
+/**
+* Clear WEP bit from Frame Control Field
+*/
+inline void ClearWepBit();
+/**
+* Sets Order bit from Frame Control field
+*/
+inline void SetOrderBit();
+private:
+/** Prohibit default constructor */
+SManagementFrameHeader();
+/** Prohibit assignment operator */
+SManagementFrameHeader& operator= ( const SManagementFrameHeader& aObj );
+/** Prohibit copy constructor */
+SManagementFrameHeader( const SManagementFrameHeader& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SManagementFrameHeader::SManagementFrameHeader(
+T802Dot11FrameControlTypeMask aTypeMask,
+T802Dot11FrameControlBitMask aControlMask ) :
+iFrameControl( aTypeMask, aControlMask ),
+iDA( KZeroMacAddr ),
+iSA( KZeroMacAddr ),
+iBSSID( KZeroMacAddr )
+{
+WriteHtoUint16( &iDuration, 0 );
+WriteHtoUint16( &iSeqCtl, 0 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SManagementFrameHeader::SetWepBit()
+{
+iFrameControl.iControl |= ( E802Dot11FrameControlWepMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SManagementFrameHeader::ClearWepBit()
+{
+iFrameControl.iControl &= ~( E802Dot11FrameControlWepMask >> 8 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SManagementFrameHeader::SetOrderBit()
+{
+iFrameControl.iControl |= ( E802Dot11FrameControlOrderMask >> 8 );
+}
+/**
+* 802.11 management frame MAC header with HT Control field
+*/
+#pragma pack( 1 )
+struct SHtManagementFrameHeader
+{
+/** 802.11 management frame MAC header */
+SManagementFrameHeader  iMgmtFrameHdr;  // 24 bytes
+/** HT control field */
+TUint32                 iHtControl;     //  4 bytes
+/**
+* Resets the HT Control field to zero
+*/
+inline void ResetHtControl();
+private:
+/** Prohibit default contructor */
+SHtManagementFrameHeader();
+/** Prohibit assignment operator */
+SHtManagementFrameHeader& operator= ( const SHtManagementFrameHeader& );
+/** Prohibit copy constructor */
+SHtManagementFrameHeader( const SHtManagementFrameHeader& );
+} __PACKED; // 28 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtManagementFrameHeader::ResetHtControl()
+{
+WriteHtoUint32( &iHtControl, 0 );
+}
+/**
+* 802.11 fixed fields of beacon and probe response frames
+*
+* @since S60 v3.2
+*/
+#pragma pack( 1 )
+struct SScanResponseFixedFields
+{
+enum { KTimestampLenInWords = 2 };
+/** timestamp fixed field */
+TUint32 iTimestamp[KTimestampLenInWords];   // 8 bytes
+/** beacon interval fixed field */
+TUint16 iBeaconInterval;                    // 2 bytes
+/** capability fixed field */
+SCapabilityInformationField iCapability;    // 2 bytes
+/**
+* Returns the beacon interval
+*
+* @since S60 3.2
+* @return beacon interval
+*/
+inline TUint16 BeaconInterval() const;
+private:
+/** Prohibit default constructor */
+SScanResponseFixedFields();
+/** Prohibit assignment operator */
+SScanResponseFixedFields& operator= (
+const SScanResponseFixedFields& );
+/** Prohibit copy constructor */
+SScanResponseFixedFields( const SScanResponseFixedFields& );
+} __PACKED;
+inline TUint16 SScanResponseFixedFields::BeaconInterval() const
+{
+return ( ReadUint16Toh( &iBeaconInterval ) );
+}
+/**
+* 802.11 fixed length components required in
+* authentication request management frame
+*/
+#pragma pack( 1 )
+struct SAuthenticationFixedFields
+{
+/** algorithm number */
+TUint16   iAlgorithmNumber;     // 2 bytes
+/** sequence number */
+TUint16   iSequenceNmbr;        // 2 bytes
+/** status code */
+TUint16   iStatusCode;          // 2 bytes
+/**
+* Ctor
+* @param aAlgorithm authentication mode used
+* @param aSeqNmbr sequence number used
+* @param aStatusCode status code used
+*/
+inline SAuthenticationFixedFields(
+const  TUint16 aAlgorithm = K802Dot11AuthModeOpen,
+const TUint16 aSeqNmbr = E802Dot11AuthenticationSeqNmbr1,
+const T802Dot11ManagementStatusCode aStatusCode
+= E802Dot11StatusSuccess );
+/**
+* Returns the authentication transaction algorithm number
+* @return sequence number
+*/
+inline TUint16 AlgorithmNumber() const;
+/**
+* Sets the authentication transaction algorithm number
+* @param aSequenceNumber value to be set
+*/
+inline void SetAlgorithmNumber(
+TUint16 aAlgorithmNumber );
+/**
+* Returns the authentication transaction sequence number
+* @return sequence number
+*/
+inline TUint16 SequenceNumber() const;
+/**
+* Sets the authentication transaction sequence number
+* @param aSequenceNumber value to be set
+*/
+inline void SetSequenceNumber( TUint16 aSequenceNumber );
+/**
+* Returns the authentication transaction status code
+* @return status code
+*/
+inline TUint16 StatusCode() const;
+} __PACKED;
+inline SAuthenticationFixedFields::SAuthenticationFixedFields(
+const  TUint16 aAlgorithm,
+const TUint16 aSeqNmbr,
+const T802Dot11ManagementStatusCode aStatusCode )
+{
+WriteHtoUint16( &iAlgorithmNumber, static_cast<TUint16>( aAlgorithm ) );
+WriteHtoUint16( &iSequenceNmbr, static_cast<TUint16>( aSeqNmbr ) );
+WriteHtoUint16( &iStatusCode, static_cast<TUint16>( aStatusCode ) );
+}
+inline TUint16 SAuthenticationFixedFields::AlgorithmNumber() const
+{
+return ( ReadUint16Toh( &iAlgorithmNumber ) );
+}
+inline void SAuthenticationFixedFields::SetAlgorithmNumber( TUint16 aAlgorithmNumber )
+{
+WriteHtoUint16( &iAlgorithmNumber, aAlgorithmNumber );
+}
+inline TUint16 SAuthenticationFixedFields::SequenceNumber() const
+{
+return ( ReadUint16Toh( &iSequenceNmbr ) );
+}
+inline void SAuthenticationFixedFields::SetSequenceNumber(
+TUint16 aSequenceNumber )
+{
+WriteHtoUint16( &iSequenceNmbr, aSequenceNumber );
+}
+inline TUint16 SAuthenticationFixedFields::StatusCode() const
+{
+return ( ReadUint16Toh( &iStatusCode ) );
+}
+/**
+* 802.11 authentication management frame
+*/
+#pragma pack( 1 )
+struct SAuthenticationFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;                // 24 bytes
+/** authentication frame fixed fields */
+SAuthenticationFixedFields  iAuthenticationFields;  // 6 bytes
+/** Ctor */
+SAuthenticationFrame()
+: iHeader( E802Dot11FrameTypeAuthentication ) {};
+/** Increments sequnece number to next number we shall send */
+inline void IncrementSeqNmbr();
+/** Resets sequnece number to initial value */
+inline void ResetSeqNmbr();
+/**
+* Gets the frames sequence number
+* @return frames sequence number
+*/
+inline TUint16 GetSeqNmbr() const;
+/**
+* Gets the frames status code field
+* @return frames status code field
+*/
+inline TUint16 GetStatusCode() const;
+/**
+* Gets the algorithm number
+* @return algorithm number
+*/
+inline TUint16 GetAlgorithmNumber() const;
+/** Sets the WEP bit from frame control field */
+inline void SetWepBit();
+/** Clears the WEP bit from frame control field */
+inline void ClearWepBit();
+/**
+* Sets the the algorithm number field
+* @param aAlgorithm algorithm to be used
+*/
+inline void SetAlgorithmNmbr( TUint16 aAlgorithm );
+private:
+/** Prohibit assignment operator */
+SAuthenticationFrame& operator= ( const SAuthenticationFrame& );
+/** Prohibit copy constructor */
+SAuthenticationFrame( const SAuthenticationFrame& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAuthenticationFrame::IncrementSeqNmbr()
+{
+iAuthenticationFields.SetSequenceNumber(
+iAuthenticationFields.SequenceNumber() + 2 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAuthenticationFrame::ResetSeqNmbr()
+{
+iAuthenticationFields.SetSequenceNumber( E802Dot11AuthenticationSeqNmbr1 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SAuthenticationFrame::GetSeqNmbr() const
+{
+return ( iAuthenticationFields.SequenceNumber() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SAuthenticationFrame::GetStatusCode() const
+{
+return ( iAuthenticationFields.StatusCode() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAuthenticationFrame::SetAlgorithmNmbr(
+TUint16 aAlgorithm )
+{
+iAuthenticationFields.SetAlgorithmNumber( aAlgorithm );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SAuthenticationFrame::GetAlgorithmNumber() const
+{
+return ( iAuthenticationFields.AlgorithmNumber() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAuthenticationFrame::SetWepBit()
+{
+iHeader.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAuthenticationFrame::ClearWepBit()
+{
+iHeader.ClearWepBit();
+}
+/**
+* 802.11 authentication management frame with HT Control field
+*/
+#pragma pack( 1 )
+struct SHtAuthenticationFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;                // 24 bytes
+/** HT control field */
+TUint32                     iHtControl;             //  4 bytes
+/** authentication frame fixed fields */
+SAuthenticationFixedFields  iAuthenticationFields;  //  6 bytes
+/** Ctor */
+SHtAuthenticationFrame()
+: iHeader( E802Dot11FrameTypeAuthentication )
+{
+WriteHtoUint32( &iHtControl, 0 );
+// as the HT Control field is present, the order bit needs to be set
+iHeader.SetOrderBit();
+};
+/** Increments sequnece number to next number we shall send */
+inline void IncrementSeqNmbr();
+/** Resets sequnece number to initial value */
+inline void ResetSeqNmbr();
+/**
+* Gets the frames sequence number
+* @return frames sequence number
+*/
+inline TUint16 GetSeqNmbr() const;
+/**
+* Gets the frames status code field
+* @return frames status code field
+*/
+inline TUint16 GetStatusCode() const;
+/**
+* Gets the algorithm number
+* @return algorithm number
+*/
+inline TUint16 GetAlgorithmNumber() const;
+/** Sets the WEP bit from frame control field */
+inline void SetWepBit();
+/** Clears the WEP bit from frame control field */
+inline void ClearWepBit();
+/**
+* Sets the the algorithm number field
+* @param aAlgorithm algorithm to be used
+*/
+inline void SetAlgorithmNmbr( TUint16 aAlgorithm );
+private:
+/** Prohibit assignment operator */
+SHtAuthenticationFrame& operator= ( const SHtAuthenticationFrame& );
+/** Prohibit copy constructor */
+SHtAuthenticationFrame( const SHtAuthenticationFrame& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAuthenticationFrame::IncrementSeqNmbr()
+{
+iAuthenticationFields.SetSequenceNumber(
+iAuthenticationFields.SequenceNumber() + 2 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAuthenticationFrame::ResetSeqNmbr()
+{
+iAuthenticationFields.SetSequenceNumber( E802Dot11AuthenticationSeqNmbr1 );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SHtAuthenticationFrame::GetSeqNmbr() const
+{
+return ( iAuthenticationFields.SequenceNumber() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SHtAuthenticationFrame::GetStatusCode() const
+{
+return ( iAuthenticationFields.StatusCode() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAuthenticationFrame::SetAlgorithmNmbr(
+TUint16 aAlgorithm )
+{
+iAuthenticationFields.SetAlgorithmNumber( aAlgorithm );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SHtAuthenticationFrame::GetAlgorithmNumber() const
+{
+return ( iAuthenticationFields.AlgorithmNumber() );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAuthenticationFrame::SetWepBit()
+{
+iHeader.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAuthenticationFrame::ClearWepBit()
+{
+iHeader.ClearWepBit();
+}
+/**
+* 802.11 fixed length components required
+* in association request management frame
+*/
+#pragma pack( 1 )
+struct SAssociationRequestFixedFields
+{
+/** capability info fixed field */
+SCapabilityInformationField iCapabilityInfo;    // 2 bytes
+/** listeninterval fixed field */
+SListenIntervalField iListenInterval;           // 2 bytes
+/** Ctor */
+SAssociationRequestFixedFields() {};
+private:
+/** Prohibit assignment operator */
+SAssociationRequestFixedFields& operator= (
+const SAssociationRequestFixedFields& );
+/** Prohibit copy constructor */
+SAssociationRequestFixedFields(
+const SAssociationRequestFixedFields& );
+} __PACKED;
+/**
+* operator== for SAssociationRequestFixedFields
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SAssociationRequestFixedFields& aLhs,
+const SAssociationRequestFixedFields& aRhs)
+{
+return static_cast<TBool>( aLhs.iCapabilityInfo == aRhs.iCapabilityInfo
+&& aLhs.iListenInterval == aRhs.iListenInterval );
+}
+/**
+* 802.11 association request management frame
+* excluding variable length information elements
+* - SSID
+* - supported rates
+*/
+#pragma pack( 1 )
+struct SAssociationRequestFrame
+{
+/** management frame header */
+SManagementFrameHeader          iHeader;        // 24 bytes
+/** association request fixed fields */
+SAssociationRequestFixedFields  iFixedFields;   // 4 bytes
+/** Ctor */
+SAssociationRequestFrame()
+: iHeader( E802Dot11FrameTypeAssociationReq ),
+iFixedFields() {};
+/**
+* Helper function to set short preamble bit in capability info
+*/
+inline void SetCapabilityShortPreamble();
+/**
+* Helper function to clear short preamble bit in capability info
+*/
+inline void ClearCapabilityShortPreamble();
+/**
+* Helper function to set PBCC bit in capability info
+*/
+inline void SetCapabilityPbcc();
+/**
+* Helper function to clear PBCC bit in capability info
+*/
+inline void ClearCapabilityPbcc();
+/**
+* Helper function to clear CF fields from capability info
+*/
+inline void ClearCFfields();
+/** Helper function to clear reserved fields */
+inline void ClearReservedFields();
+/** Helper function to set WEP bit from the capability info fixed field */
+inline void SetWepBit();
+/**
+* Helper function to clear WEP bit from
+* the capability info fixed field
+*/
+inline void ClearWepBit();
+/** Helper function to set Radio measurement bit from the capability info fixed field */
+inline void SetRMBit();
+/**
+* Helper function to clear Radio measurement bit from
+* the capability info fixed field
+*/
+inline void ClearRMBit();
+private:
+/** Prohibit assignment operator */
+SAssociationRequestFrame& operator= (
+const SAssociationRequestFrame& );
+/** Prohibit copy constructor */
+SAssociationRequestFrame(
+const SAssociationRequestFrame& );
+} __PACKED; // 28 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::SetCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.SetShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.ClearShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::SetCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.SetPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.ClearPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearCFfields()
+{
+iFixedFields.iCapabilityInfo.ClearCfFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearReservedFields()
+{
+iFixedFields.iCapabilityInfo.ClearReservedFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::SetRMBit()
+{
+iFixedFields.iCapabilityInfo.SetRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearRMBit()
+{
+iFixedFields.iCapabilityInfo.ClearRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::SetWepBit()
+{
+iFixedFields.iCapabilityInfo.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SAssociationRequestFrame::ClearWepBit()
+{
+iFixedFields.iCapabilityInfo.ClearWepBit();
+}
+/**
+* 802.11 association request management frame with HT Control field
+* excluding variable length information elements
+* - SSID
+* - supported rates
+*/
+#pragma pack( 1 )
+struct SHtAssociationRequestFrame
+{
+/** management frame header */
+SManagementFrameHeader          iHeader;        // 24 bytes
+/** HT control field */
+TUint32                         iHtControl;     //  4 bytes
+/** association request fixed fields */
+SAssociationRequestFixedFields  iFixedFields;   //  4 bytes
+/** Ctor */
+SHtAssociationRequestFrame()
+: iHeader( E802Dot11FrameTypeAssociationReq ),
+iFixedFields()
+{
+WriteHtoUint32( &iHtControl, 0 );
+// as the HT Control field is present, the order bit needs to be set
+iHeader.SetOrderBit();
+};
+/**
+* Helper function to set short preamble bit in capability info
+*/
+inline void SetCapabilityShortPreamble();
+/**
+* Helper function to clear short preamble bit in capability info
+*/
+inline void ClearCapabilityShortPreamble();
+/**
+* Helper function to set PBCC bit in capability info
+*/
+inline void SetCapabilityPbcc();
+/**
+* Helper function to clear PBCC bit in capability info
+*/
+inline void ClearCapabilityPbcc();
+/**
+* Helper function to clear CF fields from capability info
+*/
+inline void ClearCFfields();
+/** Helper function to clear reserved fields */
+inline void ClearReservedFields();
+/** Helper function to set WEP bit from the capability info fixed field */
+inline void SetWepBit();
+/**
+* Helper function to clear WEP bit from
+* the capability info fixed field
+*/
+inline void ClearWepBit();
+/** Helper function to set Radio measurement bit from the capability info fixed field */
+inline void SetRMBit();
+/**
+* Helper function to clear Radio measurement bit from
+* the capability info fixed field
+*/
+inline void ClearRMBit();
+private:
+/** Prohibit assignment operator */
+SHtAssociationRequestFrame& operator= (
+const SHtAssociationRequestFrame& );
+/** Prohibit copy constructor */
+SHtAssociationRequestFrame(
+const SHtAssociationRequestFrame& );
+} __PACKED; // 32 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::SetCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.SetShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.ClearShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::SetCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.SetPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.ClearPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearCFfields()
+{
+iFixedFields.iCapabilityInfo.ClearCfFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearReservedFields()
+{
+iFixedFields.iCapabilityInfo.ClearReservedFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::SetRMBit()
+{
+iFixedFields.iCapabilityInfo.SetRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearRMBit()
+{
+iFixedFields.iCapabilityInfo.ClearRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::SetWepBit()
+{
+iFixedFields.iCapabilityInfo.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtAssociationRequestFrame::ClearWepBit()
+{
+iFixedFields.iCapabilityInfo.ClearWepBit();
+}
+/**
+* 802.11 association response frame fixed fields
+*/
+#pragma pack( 1 )
+struct SAssociationResponseFixedFields
+{
+/** capability info fixed field */
+SCapabilityInformationField iCapabilityInfo;    // 2 bytes
+/** status code fixed field */
+TUint16                     iStatusCode;        // 2 bytes
+/** AID fixed field */
+TUint16                     iAID;               // 2 bytes
+/**
+* Returns the association response status code
+* @return status code
+*/
+inline TUint16 StatusCode() const;
+/**
+* Returns the Association ID (AID)
+* @return AID
+*/
+inline TUint16 Aid() const;
+private:
+/** Prohibit default constructor */
+SAssociationResponseFixedFields();
+/** Prohibit assignment operator */
+SAssociationResponseFixedFields& operator= (
+const SAssociationResponseFixedFields& );
+/** Prohibit copy constructor */
+SAssociationResponseFixedFields( const SAssociationResponseFixedFields& );
+} __PACKED;
+inline TUint16 SAssociationResponseFixedFields::StatusCode() const
+{
+return ( ReadUint16Toh( &iStatusCode ) );
+}
+inline TUint16 SAssociationResponseFixedFields::Aid() const
+{
+return ( ReadUint16Toh( &iAID ) );
+}
+/**
+* 802.11 fixed length components required in deauthenticate frame
+*/
+#pragma pack( 1 )
+struct SDeauthenticateFixedFields
+{
+/** reason code fixed field */
+TUint16 iReasonCode;
+/** Ctor */
+inline SDeauthenticateFixedFields();
+/*
+* Returns the reason code
+* @return Reason code
+*/
+inline TUint16 ReasonCode() const;
+/** Setter for the reason code */
+inline void SetReasonCode( TUint16 aReasonCode );
+private:
+/** Prohibit assignment operator */
+SDeauthenticateFixedFields& operator= (
+const SDeauthenticateFixedFields& );
+/** Prohibit copy constructor */
+SDeauthenticateFixedFields( const SDeauthenticateFixedFields& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SDeauthenticateFixedFields::SDeauthenticateFixedFields()
+{
+WriteHtoUint16( &iReasonCode, E802Dot11ReasonDeauthStationLeft );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SDeauthenticateFixedFields::ReasonCode() const
+{
+return ( ReadUint16Toh( &iReasonCode ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDeauthenticateFixedFields::SetReasonCode( TUint16 aReasonCode )
+{
+WriteHtoUint16( &iReasonCode, aReasonCode );
+}
+/**
+* operator== for SDeauthenticateFixedFields
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SDeauthenticateFixedFields& aLhs,
+const SDeauthenticateFixedFields& aRhs)
+{
+return static_cast<TBool>(
+aLhs.ReasonCode() == aRhs.ReasonCode() );
+}
+/**
+* 802.11 deauthenticate management frame
+*/
+#pragma pack( 1 )
+struct SDeauthenticateFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;        // 24 bytes
+/** reason code fixed field  */
+SDeauthenticateFixedFields  iReasonCode;    // 2 bytes
+/** Ctor */
+SDeauthenticateFrame()
+: iHeader( E802Dot11FrameTypeDeauthentication ),
+iReasonCode() {};
+private:
+/** Prohibit assignment operator */
+SDeauthenticateFrame& operator= ( const SDeauthenticateFrame& );
+/** Prohibit copy constructor */
+SDeauthenticateFrame( const SDeauthenticateFrame& );
+} __PACKED;
+/**
+* operator== for SDeauthenticateFrame
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SDeauthenticateFrame& aLhs,
+const SDeauthenticateFrame& aRhs)
+{
+return ( aLhs == aRhs );
+}
+/**
+* 802.11 deauthenticate management frame with HT Control field
+*/
+#pragma pack( 1 )
+struct SHtDeauthenticateFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;        // 24 bytes
+/** HT control field */
+TUint32                     iHtControl;     //  4 bytes
+/** reason code fixed field  */
+SDeauthenticateFixedFields  iReasonCode;    //  2 bytes
+/** Ctor */
+SHtDeauthenticateFrame()
+: iHeader( E802Dot11FrameTypeDeauthentication ),
+iReasonCode()
+{
+WriteHtoUint32( &iHtControl, 0 );
+// as the HT Control field is present, the order bit needs to be set
+iHeader.SetOrderBit();
+};
+private:
+/** Prohibit assignment operator */
+SHtDeauthenticateFrame& operator= ( const SHtDeauthenticateFrame& );
+/** Prohibit copy constructor */
+SHtDeauthenticateFrame( const SHtDeauthenticateFrame& );
+} __PACKED;
+/**
+* operator== for SHtDeauthenticateFrame
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SHtDeauthenticateFrame& aLhs,
+const SHtDeauthenticateFrame& aRhs)
+{
+return ( aLhs == aRhs );
+}
+/**
+* 802.11 fixed length components required in disassociate frame
+*/
+#pragma pack( 1 )
+struct SDisAssociateFixedFields
+{
+/** reason code fixed field */
+TUint16 iReasonCode;
+/** Ctor */
+inline SDisAssociateFixedFields();
+/*
+* Returns the reason code
+* @return Reason code
+*/
+inline TUint16 ReasonCode() const;
+/** Setter for the reason code */
+inline void SetReasonCode( TUint16 aReasonCode );
+private:
+// Prohibit assignment operator
+SDisAssociateFixedFields& operator= ( const SDisAssociateFixedFields& );
+// Prohibit copy constructor
+SDisAssociateFixedFields( const SDisAssociateFixedFields& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SDisAssociateFixedFields::SDisAssociateFixedFields()
+{
+WriteHtoUint16( &iReasonCode, E802Dot11ReasonClass3FrameWhenNotAssoc );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SDisAssociateFixedFields::ReasonCode() const
+{
+return ( ReadUint16Toh( &iReasonCode ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SDisAssociateFixedFields::SetReasonCode( TUint16 aReasonCode )
+{
+WriteHtoUint16( &iReasonCode, aReasonCode );
+}
+/**
+* operator== for SDisAssociateFixedFields
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SDisAssociateFixedFields& aLhs,
+const SDisAssociateFixedFields& aRhs)
+{
+return static_cast<TBool>(
+aLhs.ReasonCode() == aRhs.ReasonCode() );
+}
+/**
+* 802.11 disassociate management frame
+*/
+#pragma pack( 1 )
+struct SDisassociateFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;        // 24 bytes
+/** reason code fixed field  */
+SDisAssociateFixedFields    iReasonCode;    // 2 bytes
+/** Ctor */
+SDisassociateFrame()
+: iHeader( E802Dot11FrameTypeDisassociation ),
+iReasonCode() {};
+private:
+/** Prohibit assignment operator */
+SDisassociateFrame& operator= ( const SDisassociateFrame& );
+/** Prohibit copy constructor */
+SDisassociateFrame( const SDisassociateFrame& );
+} __PACKED; // 26 bytes
+/**
+* operator== for SDisassociateFrame
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SDisassociateFrame& aLhs,
+const SDisassociateFrame& aRhs)
+{
+return ( aLhs == aRhs );
+}
+/**
+* 802.11 disassociate management frame with HT Control field
+*/
+#pragma pack( 1 )
+struct SHtDisassociateFrame
+{
+/** management frame header */
+SManagementFrameHeader      iHeader;        // 24 bytes
+/** HT control field */
+TUint32                     iHtControl;     //  4 bytes
+/** reason code fixed field  */
+SDisAssociateFixedFields    iReasonCode;    //  2 bytes
+/** Ctor */
+SHtDisassociateFrame()
+: iHeader( E802Dot11FrameTypeDisassociation ),
+iReasonCode()
+{
+WriteHtoUint32( &iHtControl, 0 );
+// as the HT Control field is present, the order bit needs to be set
+iHeader.SetOrderBit();
+};
+private:
+/** Prohibit assignment operator */
+SHtDisassociateFrame& operator= ( const SHtDisassociateFrame& );
+/** Prohibit copy constructor */
+SHtDisassociateFrame( const SHtDisassociateFrame& );
+} __PACKED; // 30 bytes
+/**
+* operator== for SHtDisassociateFrame
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SHtDisassociateFrame& aLhs,
+const SHtDisassociateFrame& aRhs)
+{
+return ( aLhs == aRhs );
+}
+/**
+* 802.11 fixed length components required
+* in reassociation request management frame
+*/
+#pragma pack( 1 )
+struct SReassociationRequestFixedFields
+{
+/** capability info fixed field */
+SCapabilityInformationField iCapabilityInfo;    // 2 bytes
+/** listeninterval fixed field */
+SListenIntervalField iListenInterval;           // 2 bytes
+/** current AP address fixed field */
+TMacAddress iCurrentApAddress;                  // 6 bytes
+/** Ctor */
+inline SReassociationRequestFixedFields();
+private:
+/** Prohibit assignment operator */
+SReassociationRequestFixedFields& operator= (
+const SReassociationRequestFixedFields& );
+/** Prohibit copy constructor */
+SReassociationRequestFixedFields(
+const SReassociationRequestFixedFields& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline SReassociationRequestFixedFields::SReassociationRequestFixedFields() :
+iCurrentApAddress( KZeroMacAddr )
+{
+}
+/**
+* operator== for SReassociationRequestFixedFields
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SReassociationRequestFixedFields& aLhs,
+const SReassociationRequestFixedFields& aRhs)
+{
+return static_cast<TBool>( aLhs.iCapabilityInfo == aRhs.iCapabilityInfo
+&& aLhs.iListenInterval == aRhs.iListenInterval
+&& aLhs.iCurrentApAddress == aRhs.iCurrentApAddress );
+}
+/**
+* 802.11 reassociation request management frame
+* excluding variable length information elements
+*/
+#pragma pack( 1 )
+struct SReassociationRequestFrame
+{
+/** management frame header */
+SManagementFrameHeader          iHeader;        // 24 bytes
+/** association request fixed fields */
+SReassociationRequestFixedFields  iFixedFields; // 10 bytes
+/** Ctor */
+SReassociationRequestFrame()
+: iHeader( E802Dot11FrameTypeReassociationReq ),
+iFixedFields() {};
+/**
+* Helper function to set short preamble bit in capability info
+*/
+inline void SetCapabilityShortPreamble();
+/**
+* Helper function to clear short preamble bit in capability info
+*/
+inline void ClearCapabilityShortPreamble();
+/**
+* Helper function to set PBCC bit in capability info
+*/
+inline void SetCapabilityPbcc();
+/**
+* Helper function to clear PBCC bit in capability info
+*/
+inline void ClearCapabilityPbcc();
+/**
+* Helper function to clear CF fields from capability info
+*/
+inline void ClearCFfields();
+/** Helper function to clear reserved fields */
+inline void ClearReservedFields();
+/** Helper function to set WEP bit from the capability info fixed field */
+inline void SetWepBit();
+/**
+* Helper function to clear WEP bit from
+* the capability info fixed field
+*/
+inline void ClearWepBit();
+/** Helper function to set Radio measurement bit from the capability info fixed field */
+inline void SetRMBit();
+/**
+* Helper function to clear Radio measurement bit from
+* the capability info fixed field
+*/
+inline void ClearRMBit();
+private:
+/** Prohibit assignment operator */
+SReassociationRequestFrame& operator= (
+const SReassociationRequestFrame& );
+/** Prohibit copy constructor */
+SReassociationRequestFrame(
+const SReassociationRequestFrame& );
+} __PACKED; // 34 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::SetCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.SetShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.ClearShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::SetCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.SetPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.ClearPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearCFfields()
+{
+iFixedFields.iCapabilityInfo.ClearCfFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearReservedFields()
+{
+iFixedFields.iCapabilityInfo.ClearReservedFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::SetRMBit()
+{
+iFixedFields.iCapabilityInfo.SetRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearRMBit()
+{
+iFixedFields.iCapabilityInfo.ClearRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::SetWepBit()
+{
+iFixedFields.iCapabilityInfo.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SReassociationRequestFrame::ClearWepBit()
+{
+iFixedFields.iCapabilityInfo.ClearWepBit();
+}
+/**
+* 802.11 reassociation request management frame with HT Control field
+* excluding variable length information elements
+*/
+#pragma pack( 1 )
+struct SHtReassociationRequestFrame
+{
+/** management frame header */
+SManagementFrameHeader          iHeader;        // 24 bytes
+/** HT control field */
+TUint32                         iHtControl;     //  4 bytes
+/** association request fixed fields */
+SReassociationRequestFixedFields  iFixedFields; // 10 bytes
+/** Ctor */
+SHtReassociationRequestFrame()
+: iHeader( E802Dot11FrameTypeReassociationReq ),
+iFixedFields()
+{
+WriteHtoUint32( &iHtControl, 0 );
+// as the HT Control field is present, the order bit needs to be set
+iHeader.SetOrderBit();
+};
+/**
+* Helper function to set short preamble bit in capability info
+*/
+inline void SetCapabilityShortPreamble();
+/**
+* Helper function to clear short preamble bit in capability info
+*/
+inline void ClearCapabilityShortPreamble();
+/**
+* Helper function to set PBCC bit in capability info
+*/
+inline void SetCapabilityPbcc();
+/**
+* Helper function to clear PBCC bit in capability info
+*/
+inline void ClearCapabilityPbcc();
+/**
+* Helper function to clear CF fields from capability info
+*/
+inline void ClearCFfields();
+/** Helper function to clear reserved fields */
+inline void ClearReservedFields();
+/** Helper function to set Radio measurement bit from the capability info fixed field */
+inline void SetRMBit();
+/**
+* Helper function to clear Radio measurement bit from
+* the capability info fixed field
+*/
+inline void ClearRMBit();
+/** Helper function to set WEP bit from the capability info fixed field */
+inline void SetWepBit();
+/**
+* Helper function to clear WEP bit from
+* the capability info fixed field
+*/
+inline void ClearWepBit();
+private:
+/** Prohibit assignment operator */
+SHtReassociationRequestFrame& operator= (
+const SHtReassociationRequestFrame& );
+/** Prohibit copy constructor */
+SHtReassociationRequestFrame(
+const SHtReassociationRequestFrame& );
+} __PACKED; // 38 bytes
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::SetCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.SetShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearCapabilityShortPreamble()
+{
+iFixedFields.iCapabilityInfo.ClearShortPreamble();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::SetCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.SetPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearCapabilityPbcc()
+{
+iFixedFields.iCapabilityInfo.ClearPbcc();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearCFfields()
+{
+iFixedFields.iCapabilityInfo.ClearCfFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearReservedFields()
+{
+iFixedFields.iCapabilityInfo.ClearReservedFields();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::SetRMBit()
+{
+iFixedFields.iCapabilityInfo.SetRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearRMBit()
+{
+iFixedFields.iCapabilityInfo.ClearRMBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::SetWepBit()
+{
+iFixedFields.iCapabilityInfo.SetWepBit();
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline void SHtReassociationRequestFrame::ClearWepBit()
+{
+iFixedFields.iCapabilityInfo.ClearWepBit();
+}
+/**
+* 802.11 reassociation response frame fixed fields
+*/
+#pragma pack( 1 )
+struct SReassociationResponseFixedFields
+{
+/** capability info fixed field */
+SCapabilityInformationField iCapabilityInfo;    // 2 bytes
+/** status code fixed field */
+TUint16                     iStatusCode;        // 2 bytes
+/** AID fixed field */
+TUint16                     iAID;               // 2 bytes
+/*
+* Returns the reassociation response status code
+* @return status code
+*/
+inline TUint16 StatusCode() const;
+/*
+* Returns the Asociation ID (AID)
+* @return AID
+*/
+inline TUint16 Aid() const;
+private:
+/** Prohibit default constructor */
+SReassociationResponseFixedFields();
+/** Prohibit assignment operator */
+SReassociationResponseFixedFields& operator= (
+const SReassociationResponseFixedFields& );
+/** Prohibit copy constructor */
+SReassociationResponseFixedFields( const SReassociationResponseFixedFields& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SReassociationResponseFixedFields::StatusCode() const
+{
+return ( ReadUint16Toh( &iStatusCode ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SReassociationResponseFixedFields::Aid() const
+{
+return ( ReadUint16Toh( &iAID ) );
+}
+/**
+* SNAP header
+*/
+#pragma pack( 1 )
+struct SSnapHeader
+{
+/** destination service access point */
+TUint8 iDSAP;
+/** source service access point */
+TUint8 iSSAP;
+/** control field */
+TUint8 iControl;
+/** organizationally unique identifier */
+TUint8 iOUI[KOIULength];    // 3
+} __PACKED; // 6 bytes
+/**
+* operator== for SSnapHeader
+* @param aLhs left hand side
+* @param aRhs right hand side
+* @return ETrue equal, EFalse not equal
+*/
+inline TBool operator== (
+const SSnapHeader& aLhs,
+const SSnapHeader& aRhs)
+{
+return ( equal( reinterpret_cast<const TUint8*>(&aLhs),
+reinterpret_cast<const TUint8*>(&aLhs) + sizeof(SSnapHeader),
+reinterpret_cast<const TUint8*>(&aRhs) ));
+}
+/**
+* RFC 1042 encapsulation SNAP header
+*/
+const SSnapHeader KEncapsulatingRfc1042SnapHeader
+= { 0xAA, 0xAA, 0x03, { 0x00, 0x00, 0x00 } };
+/**
+* 802.1 h SNAP header
+*/
+const SSnapHeader KEncapsulating802_1hSnapHeader
+= { 0xAA, 0xAA, 0x03, { 0x00, 0x00, 0xF8 } };
+/**
+* 802.11 data frame encapsulation header
+*/
+#pragma pack( 1 )
+struct SDataFrameEncapsulationHeader
+{
+/** SNAP header */
+SSnapHeader     iSnapHeader;    // 6
+} __PACKED;
+/**
+* 802.11 data frame and its encapsulation header combined
+*/
+#pragma pack( 1 )
+struct SDataMpduHeader
+{
+/** Ctor */
+SDataMpduHeader()
+{
+iEncHdr.iSnapHeader = KEncapsulatingRfc1042SnapHeader;
+}
+/** 802.11 data frame header */
+SDataFrameHeader iHdr;                  // 24
+/** 802.11 data frame encapsulation header */
+SDataFrameEncapsulationHeader iEncHdr;  // 6
+} __PACKED; // 30
+/*
+802.2 SNAP DATA Frame
++----------------+
+|                |
+|  Destination   |
+|    6 bytes     |
++----------------+
+|                |
+|     Source     |
+|    6 bytes     |
++----------------+
+|  Frame Length  | Must be <= 1500 Dec.
+|    2 bytes     |
++----------------+
+|  DSAP - 1 byte | = 0xAA ( SNAP )
++----------------+
+|  SSAP - 1 byte | = 0xAA ( SNAP )
++----------------+
+|Control - 1 byte| = 0x03
++----------------+
+| OUI - 3 bytes  | = 0x0
+|                |
++----------------+
+| Type - 2 bytes |  = Ethernet type (IP=0x0800)
++----------------+
+|                |
+|      Data      |
+|                |
+~                ~
+~                ~
+|   46 to 1500   |
+|     bytes      |
+|                |
++----------------+
+|      FCS       |
+|    4 bytes     |
++----------------+
+*/
+/*
+This is an Ethernet Version 2 frame:
++--------------+
+|              | The destination address is a six byte Media Access
+| Destination  | Control (MAC) address, usually burned into the
+|   6 bytes    | ROM of the Ethernet card.
++--------------+
+|              | The source address is a six byte MAC address, and
+|   Source     | can signify a physical station or a broadcast.
+|   6 bytes    |
++--------------+
+|     Type     | The Type field it must be grater then 1500 dec.
+|    2 bytes   |
++--------------+
+|              |  Any higher layer information is placed in the
+|    Data      |  data field, which could contain protocol
+|              |  information or user data.
+~              ~
+~              ~
+|  46 to 1500  |
+|    bytes     |
+|              |
++--------------+
+|     FCS      |
+|   4 bytes    |
++--------------+
+*/
+/**
+* 802.11 QoS data frame and its encapsulation header combined
+*/
+#pragma pack( 1 )
+struct SQosDataMpduHeader
+{
+/** Ctor */
+SQosDataMpduHeader()
+{
+iEncHdr.iSnapHeader = KEncapsulatingRfc1042SnapHeader;
+}
+/** 802.11 QoS data frame header */
+SQosDataFrameHeader iHdr;               // 26
+/** 802.11 data frame encapsulation header */
+SDataFrameEncapsulationHeader iEncHdr;  // 6
+} __PACKED; // 33
+const TUint16 KUint16HiByteMask = 0xFF00;
+/**
+* Ethernet 14-byte Header (RFC 894)
+*/
+#pragma pack( 1 )
+struct SEthernetHeader
+{
+/** destination MAC address */
+TMacAddress iDA;    // 6
+/** source MAC address */
+TMacAddress iSA;    // 6
+/** ethernet type field */
+TUint16     iType;  // 2
+/**
+* Returns the Ethernet Type
+* @return ethernet type
+*/
+inline TUint16 Type() const;
+private:
+/** Prohibit default contructor */
+SEthernetHeader();
+/** Prohibit assignment operator */
+SEthernetHeader& operator= ( const SEthernetHeader& );
+/** Prohibit copy constructor */
+SEthernetHeader( const SEthernetHeader& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+// We need to reverse the byte order as the IP world uses different byter
+// order (MSB first) as WLAN MAC layer (LSB first)
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SEthernetHeader::Type() const
+{
+return ReverseUint16( ReadUint16Toh( &iType ) );
+}
+/**
+* Ethernet type field
+*/
+#pragma pack( 1 )
+struct SEthernetType
+{
+/** type field */
+TUint16     iType;      // 2
+/**
+* Returns the Ethernet Type
+* @return ethernet type
+*/
+inline TUint16 Type() const;
+private:
+/** Prohibit default contructor */
+SEthernetType();
+/** Prohibit assignment operator */
+SEthernetType& operator= ( const SEthernetType& );
+/** Prohibit copy constructor */
+SEthernetType( const SEthernetType& );
+} __PACKED;
+// ---------------------------------------------------------------------------
+// We need to reverse the byte order as the IP world uses different byte
+// order (MSB first) as WLAN MAC layer (LSB first)
+// ---------------------------------------------------------------------------
+//
+inline TUint16 SEthernetType::Type() const
+{
+return ReverseUint16( ReadUint16Toh( &iType ) );
+}
+// pop the pragma pack stack to return to normal alignment of structures
+#pragma pack( )
+#endif      // WLAN802DOT11_H

changeset 0	c40eb8fe8501
child 7	0abc8c98be24