/*

* Copyright (c) 2005-2010 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:   Implementation of the WlanDot11Associated class

*

*/

/*

*/

#include "config.h"

#include "UmacDot11Associated.h"

#include "UmacContextImpl.h"

#include "UmacWsaWriteMib.h"

#include "umacinternaldefinitions.h"

/**

* Mask to determine the used encryption from WHA::ReceivePacket's aFlags 

* parameter

*/

const TUint32 KReceivePacketEncryptionMask = 0x00038000;

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void WlanDot11Associated::OnBeaconFrameRx( 

    WlanContextImpl& aCtxImpl,

    const TAny* /*aFrame*/,

    const TUint32 /*aLength*/,

    WHA::TRcpi /*aRcpi*/,

    TUint8* aBuffer )

    {

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void WlanDot11Associated::OnProbeResponseFrameRx( 

    WlanContextImpl& aCtxImpl,

    const TAny* /*aFrame*/,

    const TUint32 /*aLength*/,

    WHA::TRcpi /*aRcpi*/,

    TUint8* aBuffer )

    {

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void WlanDot11Associated::OnDeauthenticateFrameRx( 

    WlanContextImpl& aCtxImpl,

    TUint8* aBuffer )

    {

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void WlanDot11Associated::OnDisassociateFrameRx( 

    WlanContextImpl& aCtxImpl,

    TUint8* aBuffer )

    {

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TSnapStatus WlanDot11Associated::ValiDateSnapHeader( 

    WlanContextImpl& aCtxImpl,

    const TUint8* aStartOfSnap ) const

    {

    TSnapStatus snapStatus( ESnapUnknown );

    if ( !os_memcmp( 

            aStartOfSnap, 

            &KEncapsulatingRfc1042SnapHeader, 

            sizeof( KEncapsulatingRfc1042SnapHeader ) ) )

        {

        snapStatus = ESnapDot11Ok;

        }

    else if ( !os_memcmp( 

                aStartOfSnap, 

                &KEncapsulating802_1hSnapHeader, 

                sizeof( KEncapsulating802_1hSnapHeader ) ) )

        {

        snapStatus = ESnapDot11Ok;

        }

    else

        {

        // unknown SNAP. Status already correct. No action needed

        }

    if ( snapStatus == ESnapUnknown &&

         aCtxImpl.NetworkOperationMode() == WHA::EBSS &&

         aCtxImpl.GetProprietarySnapHeader() != KUndefinedSnapHeader )

        {

        // SNAP still unknown, but we a are in a infrastructure network and

        // a proprietary SNAP header has been defined.

        // Check if the SNAP is this proprietary SNAP header

        if ( !os_memcmp( 

                aStartOfSnap, 

                &(aCtxImpl.GetProprietarySnapHeader()), 

                sizeof( aCtxImpl.GetProprietarySnapHeader() ) ) )

            {

            snapStatus = ESnapProprietaryOk;

            }        

        }

    return snapStatus;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

inline TBool WlanDot11Associated::RxDataMpduValid(

    const TUint32 aLength,

    const SDataFrameHeader& aFrameHeader,

    TBool aQosData,

    TBool aAmsdu,

    TUint aHtControlLen,

    TUint aSecurityHeaderLen,

    TUint aSecurityTrailerLen ) const

    {

    //========================================================================

    // validate frame length

    //========================================================================

    const TUint KMinAcceptableRxDataMpduLen ( 

        MinAcceptableRxDataMpduLen( 

            aQosData,

            aAmsdu,

            aHtControlLen,

            aSecurityHeaderLen,

            aSecurityTrailerLen ) );

    if ( aLength < KMinAcceptableRxDataMpduLen )

        {

        // frame shorter than min acceptable length; reject it 

        OsTracePrint( KRxFrame | KWarningLevel, (TUint8*)

            ("UMAC: WlanDot11Associated::RxDataMpduValid: WARNING: MPDU rejected because its shorter than min acceptable length of %d"),

            KMinAcceptableRxDataMpduLen );        

        return EFalse;

        }

    //========================================================================

    // validate To DS & From DS bits

    //========================================================================

    if ( !DoIsValidAddressBitCombination( aFrameHeader ) )

        {

        OsTracePrint( KRxFrame, (TUint8*)

            ("UMAC: WlanDot11Associated::RxDataMpduValid: MPDU rejected because of invalid To DS and/or From DS bit values") );

        return EFalse;

        }

    return ETrue;

    }

// ---------------------------------------------------------------------------

// defines the minimum acceptable Data MPDU length as:

// dot11 MAC header length including SNAP and possibly existing HT Control 

// field

// + security header length

// + subframe header length if the QoS Data MPDU contains an A-MSDU

// + security trailer length

// + Ethernet type field length

// ---------------------------------------------------------------------------

//

inline TUint WlanDot11Associated::MinAcceptableRxDataMpduLen(

    TBool aQosData,

    TBool aAmsdu,

    TUint aHtControlLen,

    TUint aSecurityHeaderLen,

    TUint aSecurityTrailerLen ) const

    {

    return aQosData ? 

        sizeof( SQosDataMpduHeader ) + aHtControlLen

        + aSecurityHeaderLen

        + ( aAmsdu ? sizeof( SAmsduSubframeHeader ) : 0 )

        + aSecurityTrailerLen

        + sizeof( SEthernetType )

        :         

        sizeof( SDataMpduHeader )

        + aSecurityHeaderLen

        + aSecurityTrailerLen

        + sizeof( SEthernetType );

    }

// ---------------------------------------------------------------------------

// Note that address 1 is the DA (Destination Address) both in infrastructure

// and IBSS network Rx frames

// ---------------------------------------------------------------------------

//

inline TDaType WlanDot11Associated::RxFrameDaType(

    const SDataFrameHeader& aFrameHeader ) const

    {

    if ( IsGroupBitSet( aFrameHeader.iAddress1 ) )

        {

        // a multicast

        if ( aFrameHeader.iAddress1 == KBroadcastMacAddr )

            {

            // also a brodcast

            return EBroadcastAddress;

            }

        else

            {

            // a multicast but not a broadcast

            return EMulticastAddress;

            }

        }

    else

        {

        // a unicast

        return EUnicastAddress;

        }

    }

// ---------------------------------------------------------------------------

//  

// ---------------------------------------------------------------------------

//

inline TBool WlanDot11Associated::RxMsduValid(

    WlanContextImpl& aCtxImpl,

    const SDataFrameHeader& aFrameHeader,

    const SAmsduSubframeHeader* aSubFrameHeader,

    const TUint8* aStartOfSnap,

    TUint16 aEtherType,

    TBool aMulticast,

    TUint32 aFlags,

    TSnapStatus& aSnapStatus ) const

    {

    //========================================================================

    // validate SNAP header

    //========================================================================

    aSnapStatus = ValiDateSnapHeader( aCtxImpl, aStartOfSnap );

    if ( aSnapStatus == ESnapUnknown )

        {

        // SNAP header is invalid

        OsTracePrint( KRxFrame, (TUint8*)

            ("UMAC: WlanDot11Associated::RxMsduValid: MSDU rejected because of invalid snap:"),

            aStartOfSnap, aStartOfSnap + sizeof( SSnapHeader ) );    

        return EFalse;

        }

    // determine if SA is our MAC address

    const TBool KSaIsOurMac ( 

        DoIsRxFrameSAourAddress( aCtxImpl, aFrameHeader, aSubFrameHeader ) );           

    //========================================================================

    // if this is a proprietary test MSDU but not sent by us, its not valid 

    // for us

    //========================================================================

    if ( aEtherType == KBounceType && !KSaIsOurMac )

        {

#ifndef NDEBUG

        OsTracePrint( KRxFrame, (TUint8*)

            ("UMAC: WlanDot11Associated::RxMsduValid: proprietary test MSDU, but not sent by us. MSDU rejected") );

        if ( aSubFrameHeader )

            {

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Subframe DA:"), aSubFrameHeader->iDa );                

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Subframe SA:"), aSubFrameHeader->iSa );                

            }

        else

            {

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address1:"), aFrameHeader.iAddress1);    

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address2:"), aFrameHeader.iAddress2);    

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address3:"), aFrameHeader.iAddress3);

            }

#endif        

        return EFalse;

        }

    //========================================================================

    // non-test multicast MSDUs sent by us are not relevant for us

    //========================================================================

    if ( // SA is our MAC address

         KSaIsOurMac

         // AND this is a multicast frame

         && aMulticast

         // AND this is not a test frame

         && aEtherType != KBounceType )

        {

        // we have received a non-test multicast frame that was sent by us.

        // Ignore it.

#ifndef NDEBUG

        OsTracePrint( KRxFrame, (TUint8*)

            ("UMAC: WlanDot11Associated::RxMsduValid: MSDU rejected because its a non-test multicast MSDU sent by us"));

        if ( aSubFrameHeader )

            {

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Subframe DA:"), aSubFrameHeader->iDa );                

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Subframe SA:"), aSubFrameHeader->iSa );                

            }

        else

            {

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address1:"), aFrameHeader.iAddress1);    

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address2:"), aFrameHeader.iAddress2);    

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: Address3:"), aFrameHeader.iAddress3);

            }

#endif

        return EFalse;

        }

    // determine the encryption of the frame

    const TUint32 KEncryption ( aFlags & KReceivePacketEncryptionMask );

    if ( aSnapStatus != ESnapProprietaryOk )

        {

        //====================================================================

        // validate MSDU with the applicable privacy mode filter

        //====================================================================

        if ( !aCtxImpl.ExecuteActivePrivacyModeFilter(

                aFrameHeader,

                aCtxImpl.iEnableUserData,

                aEtherType,

                aCtxImpl.PairWiseKeyType() != WHA::EKeyNone,

                ( KEncryption == WHA::KEncryptAes || 

                  KEncryption == WHA::KEncryptTkip ||

                  KEncryption == WHA::KEncryptWapi ) ) )

            {

            return EFalse;

            }

        }

    // this MSDU has passed all our checks, so it is valid for us

    return ETrue;

    }

// ---------------------------------------------------------------------------

//  

// ---------------------------------------------------------------------------

//

inline TUint WlanDot11Associated::RxMsduEthernetPayloadLength(

    const TUint32 aMpduLength, 

    TUint aSubframeLength, 

    TBool aQosData,

    TUint aHtControlLen,

    TUint aSecurityHeaderLen,

    TUint aSecurityTrailerLen ) const

    {

    TUint length ( 0 );

    if ( aSubframeLength )

        {

        // this ethernet payload is carried in an A-MSDU subframe

        length = aSubframeLength - sizeof( SSnapHeader );

        OsTracePrint( KRxFrame, (TUint8*)

            ("UMAC: subframe eth payload len: %d"),

            length );                        

        }

    else

        {

        // this ethernet payload is carried in a non-A-MSDU frame

        if ( aQosData )

            {

            length = 

                // total length of the Rx frame

                aMpduLength

                // - MAC header length including SNAP

                - ( sizeof( SQosDataMpduHeader ) + aHtControlLen )

                // - security header length

                - aSecurityHeaderLen

                // - security trailer length

                - aSecurityTrailerLen;

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: qos data eth payload len: %d"),

                length );                        

            }

        else

            {

            length =

                // total length of the Rx frame

                aMpduLength

                // MAC header length including SNAP

                - sizeof( SDataMpduHeader )

                // - security header length

                - aSecurityHeaderLen

                // - security trailer length

                - aSecurityTrailerLen;

            OsTracePrint( KRxFrame, (TUint8*)

                ("UMAC: non-qos data eth payload len: %d"),

                length );                        

            }

        }

    return length;

    }

// ---------------------------------------------------------------------------

//   

// ---------------------------------------------------------------------------

//

inline TUint8* WlanDot11Associated::NewBufForMgmtClientRxFrame(

    WlanContextImpl& aCtxImpl,

    TBool aProprieatarySnapFrame,

    TBool aQosFrame,

    TUint aHtControlLen,

    TUint aEtherPayloadLength ) const

    {

    TUint requiredLength ( 0 );

    if ( aProprieatarySnapFrame )

        {

        // forwarded as a Data MPDU

        requiredLength = aQosFrame ? 

            sizeof( SQosDataFrameHeader ) 

            + aHtControlLen 

            + aEtherPayloadLength :

            sizeof( SDataFrameHeader ) 

            + aEtherPayloadLength;        

        }

    else

        {

        // forwarded as Ethernet frame

        requiredLength = 2 * sizeof( TMacAddress ) + aEtherPayloadLength;

        }

    // request for a new Rx buffer

    return aCtxImpl.GetRxBuffer( 

        requiredLength, 

        // tell that this is an internally triggered buffer request

        ETrue );

    }

// ---------------------------------------------------------------------------

//  

// ---------------------------------------------------------------------------

//

inline TBool WlanDot11Associated::RxMsduForUser(

    TUint16 aEtherType,

    TSnapStatus aSnapstatus ) const

    {

    if ( // not an EAPOL frame AND

         aEtherType != KEapolType &&

         // not a WAI frame AND

         aEtherType != KWaiType &&

         // not a WLAN Mgmt Client test frame

         aEtherType != KBounceType &&

         // not a proprietary SNAP frame

         aSnapstatus != ESnapProprietaryOk )

        {

        // a user data / protocol stack data frame

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

// ---------------------------------------------------------------------------

//  

// ---------------------------------------------------------------------------

//

inline void WlanDot11Associated::UpdateDataFrameRxStatistics(

    WlanContextImpl& aCtxImpl,

    TUint16 aEtherType,

    TBool aMulticast,

    WHA::TQueueId aAccessCategory ) const

    {

    if ( aEtherType != KBounceType )

        {

        // other than WLAN Mgmt Client test data frame received

        if ( aMulticast )

            {

            // multicast frame

            OsTracePrint( KRxFrame, (TUint8*)