/*

* 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 WlanDot11InfrastructureMode class

*

*/

/*

*/

#include "config.h"

#include "UmacDot11InfrastructureMode.h"

#include "UmacWsaAddKey.h"

#include "umacaddbroadcastwepkey.h"

#include "UmacContextImpl.h"

#include "UmacWsaKeyIndexMapper.h"

#include "UmacWsaWriteMib.h"

#include "umacelementlocator.h"

#include "umacwhaconfigureac.h"

#include "FrameXferBlock.h"

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

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

// 

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

//

TBool WlanDot11InfrastructureMode::Connect(

    WlanContextImpl& aCtxImpl,

    const TSSID& aSSID,                 

    const TMacAddress& aBSSID,          

    TUint16 aAuthAlgorithmNbr,      

    TEncryptionStatus aEncryptionStatus,

    TBool /*aIsInfra*/,

    TUint16 aScanResponseFrameBodyLength,

    const TUint8* aScanResponseFrameBody,

    const TUint8* aIeData,

    TUint16 aIeDataLength )

    {

    // store data for later access.

    // Pointers supplied are valid to the point the

    // corresponding completion method is called

    aCtxImpl.SetScanResponseFrameBody( aScanResponseFrameBody );

    aCtxImpl.SetScanResponseFrameBodyLength( aScanResponseFrameBodyLength );            

    aCtxImpl.IeData( aIeData );

    aCtxImpl.IeDataLength( aIeDataLength );

    return Connect( 

        aCtxImpl, 

        aSSID, 

        aBSSID, 

        aAuthAlgorithmNbr, 

        aEncryptionStatus

        );

    }

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

// 

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

//

TBool WlanDot11InfrastructureMode::Connect(

    WlanContextImpl& aCtxImpl,

    const TSSID& aSSID,                 

    const TMacAddress& aBSSID,          

    TUint16 aAuthAlgorithmNbr,      

    TEncryptionStatus aEncryptionStatus )

    {

    // construct disassociation frame

    // note that we don't have to set SA because we have already set it

    // in the initialize phase of the dot11 state machine

    //

    // set the BSSID of the existing network

    (aCtxImpl.GetDisassociationFrame()).iHeader.iBSSID = aCtxImpl.GetBssId();

    (aCtxImpl.GetHtDisassociationFrame()).iHeader.iBSSID = aCtxImpl.GetBssId();

    // set the DA

    (aCtxImpl.GetDisassociationFrame()).iHeader.iDA = aCtxImpl.GetBssId();

    (aCtxImpl.GetHtDisassociationFrame()).iHeader.iDA = aCtxImpl.GetBssId();

    // set current BSSID in reassociation request frame

    (aCtxImpl.GetReassociationRequestFrame()).iFixedFields.iCurrentApAddress = 

        aCtxImpl.GetBssId();

    (aCtxImpl.GetHtReassociationRequestFrame()).iFixedFields.iCurrentApAddress = 

        aCtxImpl.GetBssId();

    // ... and make a note that we need to perform reassociation 

    // instead of association later on towards the new AP

    aCtxImpl.Reassociate( ETrue );

    // Store parameters of the new BSS to connect to

    //

    (aCtxImpl.GetBssId())= aBSSID;   

    (aCtxImpl.GetSsId()) = aSSID;   

    (aCtxImpl.EncryptionStatus()) = aEncryptionStatus;   

    // set values in authentication frame

    //

    (aCtxImpl.AuthenticationAlgorithmNumber()) = aAuthAlgorithmNbr;

    // set the BSSID field

    (aCtxImpl.GetAuthenticationFrame()).iHeader.iBSSID = aBSSID;

    (aCtxImpl.GetHtAuthenticationFrame()).iHeader.iBSSID = aBSSID;

    // set the DA field

    (aCtxImpl.GetAuthenticationFrame()).iHeader.iDA = aBSSID;

    (aCtxImpl.GetHtAuthenticationFrame()).iHeader.iDA = aBSSID;

    // set the SA field

    (aCtxImpl.GetAuthenticationFrame()).iHeader.iSA 

        = aCtxImpl.iWlanMib.dot11StationId;

    (aCtxImpl.GetHtAuthenticationFrame()).iHeader.iSA 

        = aCtxImpl.iWlanMib.dot11StationId;

    aCtxImpl.NetworkOperationMode( WHA::EBSS );

    if ( aCtxImpl.DisassociatedByAp() )

        {

        // if the AP has already sent us a disassociation or deauthentication

        // frame, we won't send it a disassociation frame any more. So in this

        // case we skip the dot11DisassociationPending state and go directly to 

        // dot11Synchronize state.        

        aCtxImpl.DisassociatedByAp( EFalse ); // also reset the flag

        ChangeState( aCtxImpl, 

            *this,                                          // prev state

            aCtxImpl.iStates.iSynchronizeState              // next state

            );        

        }

    else

        {

        // the most common case, i.e. we are still associated with the current

        // AP. So make a state change to dot11DisassociationPending

        ChangeState( aCtxImpl, 

            *this,                                          // prev state

            aCtxImpl.iStates.iDisassociationPendingState    // next state

            );

        }

    // signal caller that state transition occurred

    return ETrue;

    }

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

// 

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

//

TBool WlanDot11InfrastructureMode::SetRcpiTriggerLevel(

    WlanContextImpl& aCtxImpl,

    TUint32 aRcpiTrigger)

    {

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11InfrastructureMode::SetRcpiTriggerLevel: aRcpiTrigger: %d"), 

        aRcpiTrigger );

    // update the MIB. Also request the WLAN mgmt client request

    // to be completed

    return SetRcpiTriggerLevelMib(aCtxImpl, aRcpiTrigger, ETrue );

    }

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

// 

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

//

TBool WlanDot11InfrastructureMode::SetRcpiTriggerLevelMib(

    WlanContextImpl& aCtxImpl,

    TUint32 aRcpiTrigger,

    TBool aCompleteManagementRequest )

    {

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11InfrastructureMode::SetRcpiTriggerLevelMib: aRcpiTrigger: %d"), 

        aRcpiTrigger );

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11InfrastructureMode::SetRcpiTriggerLevelMib: aCompleteManagementRequest: %d"), 

        aCompleteManagementRequest );

    // allocate memory for the mib to write

    WHA::SrcpiThreshold* mib = static_cast<WHA::SrcpiThreshold*>

        (os_alloc( sizeof(WHA::SrcpiThreshold) )); 

    if ( !mib )

        {

        // allocation failed

        // simulate macnotresponding error

        OsTracePrint( KWarningLevel, (TUint8*)

            ("UMAC: WlanDot11InfrastructureMode::SetRcpiTriggerLevelMib: abort") );

        return DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

        }

    mib->iThreshold = aRcpiTrigger;

    WlanWsaWriteMib& wha_cmd = aCtxImpl.WsaWriteMib();

    wha_cmd.Set( aCtxImpl, WHA::KMibRcpiThreshold, sizeof(*mib), mib );

    const TUint32 KNoNeedToCompleteManagementRequest = 0;

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        wha_cmd,            // next state

        aCompleteManagementRequest ? KCompleteManagementRequest : 

                                     KNoNeedToCompleteManagementRequest

        );   

    os_free( mib ); // release the memory

    // signal caller that a state transition occurred

    return ETrue;

    }

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

// 

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

//

void WlanDot11InfrastructureMode::OnDeauthenticateFrameRx( 

    WlanContextImpl& aCtxImpl,

    TUint8* aBuffer )

    {

    // note that the AP has disassociated us (as the AP deauthenticated us

    // we are also disassociated)

    aCtxImpl.DisassociatedByAp( ETrue );

    aCtxImpl.StopVoiceOverWlanCallMaintenance();

    aCtxImpl.StopKeepAlive();

    OnInDicationEvent( aCtxImpl, EMediaDisconnect );

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

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

// 

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

//

void WlanDot11InfrastructureMode::OnDisassociateFrameRx( 

    WlanContextImpl& aCtxImpl,

    TUint8* aBuffer )

    {

    // note that the AP has disassociated us

    aCtxImpl.DisassociatedByAp( ETrue );

    aCtxImpl.StopVoiceOverWlanCallMaintenance();

    aCtxImpl.StopKeepAlive();

    OnInDicationEvent( aCtxImpl, EMediaDisconnect );

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer );

    }

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

// 

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

//

void WlanDot11InfrastructureMode::OnBeaconFrameRx( 

    WlanContextImpl& aCtxImpl,

    const TAny* aFrame,

    const TUint32 aLength,

    WHA::TRcpi /*aRcpi*/,

    TUint8* aBuffer )

    {

    OsTracePrint( KRxFrame, (TUint8*)

        ("UMAC: WlanDot11InfrastructureMode::OnBeaconFrameRx()"));

    // buffer begin

    const TUint8* ptr = reinterpret_cast<const TUint8*>(aFrame);

    // bypass mac header, timestamp fixed field, beacon interval fixed field

    // and capability fixed field

    const TUint8 offset = 

        KMacHeaderLength 

        + KTimeStampFixedFieldLength 

        + KBeaconIntervalFixedFieldLength

        + KCapabilityInformationFixedFieldLength;        

    ptr += offset; // we now point to the beginning of IEs

    if ( aLength > offset )

        {

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

        // Check if any dynamic nw parameters, that we are monitoring, have 

        // changed. If they have, take the new parameters into use

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

        WlanElementLocator elementLocator( ptr, aLength - offset );

        ValidateErpParams( aCtxImpl, elementLocator );

        if ( aCtxImpl.QosEnabled() )

            {

            ValidateAcParams( aCtxImpl, elementLocator );

            }

        else

            {

            // this is not a QoS connection => not relevant to check

            // for AC parameter changes

            }

        if ( aCtxImpl.HtSupportedByNw() )

            {

            ValidateHtBssOperationParams( aCtxImpl, elementLocator );

            }

        else

            {

            // this is not a HT connection => not relevant to check

            // for HT operation parameter changes

            }

        }

    else

        {

        // frame too short to contain any IEs => ignore it

        OsTracePrint( KRxFrame | KWarningLevel, (TUint8*)

            ("UMAC: WlanDot11InfrastructureMode::OnBeaconFrameRx: WARNING: frame too short to contain any IEs => ignored") );        

        }

    // release the Rx buffer

    aCtxImpl.iUmac.MarkRxBufFree( aBuffer);

    }

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

// 

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

//

void WlanDot11InfrastructureMode::ValidateErpParams( 

    WlanContextImpl& aCtxImpl,

    WlanElementLocator& aElementLocator )

    {

    TUint8 length( 0 );

    const TUint8* elementData( NULL );

    if ( WlanElementLocator::EWlanLocateOk == 

         aElementLocator.InformationElement( 

            E802Dot11ErpInformationIE, 

            length, 

            &elementData ) )

        {

        // ERP IE found

        OsTracePrint( KInfoLevel, (TUint8*)

            ("UMAC: WlanDot11InfrastructureMode::ValidateErpParams(): ERP IE present"));

        if ( ( *elementData & KUseProtectionMask ) != aCtxImpl.ProtectionBitSet() )            

            {

            OsTracePrint( KInfoLevel, (TUint8*)

                ("UMAC: WlanDot11InfrastructureMode::ValidateErpParams(): use protection setting changed, is now: %d"),

                *elementData & KUseProtectionMask );

            // use protection setting has changed, update the setting & 

            // re-set the MIB

            //

            aCtxImpl.ProtectionBitSet( *elementData & KUseProtectionMask );

            if ( !(aCtxImpl.WsaCmdActive()) )

                {

                SetCtsToSelfMib( aCtxImpl );

                }

            else

                {

                // WHA command is in progress so we must defer this access

                aCtxImpl.RegisterEvent( KSetCtsToSelf );

                }

            }

        }

    }

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

// 

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

//

void WlanDot11InfrastructureMode::ValidateAcParams( 

    WlanContextImpl& aCtxImpl,

    WlanElementLocator& aElementLocator )

    {

    TUint8 length( 0 );

    const TUint8* elementData( NULL );

    // is WMM Parameter Element present                        

    if ( aElementLocator.InformationElement( 

            E802Dot11VendorSpecificIE,

            KWmmElemOui,

            KWmmElemOuiType,

            KWmmParamElemOuiSubtype,

            length, 

            &elementData ) 

        == WlanElementLocator::EWlanLocateOk )    

        {

        // element found

        OsTracePrint( KQos, (TUint8*)

            ("UMAC: WlanDot11InfrastructureMode::ValidateAcParams(): WMM param elem present"));

        if ( (reinterpret_cast<const SWmmParamElemData*>(elementData))->ParameterSetCount() 

            != aCtxImpl.WmmParameterSetCount() )

            {

            // AC parameters have changed => parse them again

            //

            OsTracePrint( KQos, (TUint8*)

                ("UMAC: WlanDot11InfrastructureMode::ValidateAcParams(): WMM param set count changed (value: %d) => params changed"),

                (reinterpret_cast<const SWmmParamElemData*>(elementData))->ParameterSetCount() );

            ParseAcParameters( aCtxImpl,

                reinterpret_cast<const SWmmParamElemData&>(*elementData ) );

            // we also need to configure the ACs again

            //

            if ( !(aCtxImpl.WsaCmdActive()) )

                {

                ConfigureAcParams( aCtxImpl );

                }

            else

                {

                // WHA command is in progress so we must defer this access

                aCtxImpl.RegisterEvent( KAcParamUpdate );

                }

            }

        }

    }

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

// 

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

//

void WlanDot11InfrastructureMode::ValidateHtBssOperationParams( 

    WlanContextImpl& aCtxImpl,

    WlanElementLocator& aElementLocator )

    {

    TUint8 length( 0 );

    const TUint8* elementData( NULL );

    if ( WlanElementLocator::EWlanLocateOk == 

         aElementLocator.InformationElement( 

            E802Dot11HtOperationIE, 

            length, 

            &elementData ) )

        {

        // HT Operation element found

        OsTracePrint( KInfoLevel, (TUint8*)

            ("UMAC: WlanDot11InfrastructureMode::ValidateHtBssOperationParams: element present"));

        if ( os_memcmp( 

                 elementData, 

                 &(aCtxImpl.GetNwHtOperationIe().iData), 

                 sizeof( SHtOperationIeData ) ) )            

            {

            // content of the element has changed 

            OsTracePrint( KInfoLevel, (TUint8*)

                ("UMAC: element changed"));

            // store the changed element content to our context

            aCtxImpl.GetNwHtOperationIe().SetIeData( 

                elementData, 

                length );

            // inform the lower layers about the new HT operation 

            // configuration 

            if ( !(aCtxImpl.WsaCmdActive()) )

                {

                ConfigureHtBssOperation( aCtxImpl );

                }

            else

                {

                // WHA command is in progress so we must defer this access

                aCtxImpl.RegisterEvent( KSetHtBssOperation );

                }

            }

        }

    }

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

// 

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

//

void WlanDot11InfrastructureMode::DoSetTxMpduDaAddress( 

    SDataFrameHeader& aDataFrameHeader, 

    const TMacAddress& aMac ) const

    {

    aDataFrameHeader.iAddress3 = aMac;

    }

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

// 

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

//

TBool WlanDot11InfrastructureMode::DoIsRxFrameSAourAddress( 

    WlanContextImpl& aCtxImpl,

    const SDataFrameHeader& aFrameHeader,

    const SAmsduSubframeHeader* aSubFrameHeader ) const

    {

    if ( aSubFrameHeader )

        {

        // the MSDU is part of an A-MSDU and the caller wants to use the

        // SA in the subframe header for this check

        return aSubFrameHeader->iSa == aCtxImpl.iWlanMib.dot11StationId;

        }

    else

        {

        // the caller wants to use the SA in the MAC header for this check

        return aFrameHeader.iAddress3 == aCtxImpl.iWlanMib.dot11StationId;

        }

    }

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

// 

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

//

TBool WlanDot11InfrastructureMode::DoIsValidAddressBitCombination(

    const SDataFrameHeader& aFrameHeader ) const

    {

    return (aFrameHeader.IsFromDsBitSet() && !(aFrameHeader.IsToDsBitSet()));

    }

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

// 

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

//

void WlanDot11InfrastructureMode::DoBuildEthernetFrame(

    TDataBuffer& aBuffer,

    const SDataMpduHeader& aDot11DataMpdu,

    const TUint8* aStartOfEtherPayload,

    TUint aEtherPayloadLength,

    TBool aAmsdu,

    TUint8* aCopyBuffer )