--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wlan_bearer/wlanldd/wlan_common/umac_common/inc/802dot11.h Tue Feb 02 02:03:13 2010 +0200
@@ -0,0 +1,5973 @@
+/*
+* 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