/*

* Copyright (c) 2002-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 WlanDot11State class.

*

*/

/*

*/

#include "config.h"

#include "UmacDot11State.h"

#include "UmacWsaAddKey.h"

#include "UmacWsaKeyIndexMapper.h"

#include "umacaddbroadcastwepkey.h"

#include "UmacWsaWriteMib.h"

#include "UmacWsaReadMib.h"

#include "umacwhaconfigurequeue.h"

#include "umacwhaconfigureac.h"

#include "umacconfiguretxautoratepolicy.h"

#include "UmacContextImpl.h"

#include "wha_mibDefaultvalues.h"

#include "FrameXferBlock.h"

#include "umacelementlocator.h"

struct TRate2NwsaRate

    {

    TRate       iTrate;

    WHA::TRate  iNwsaRate;

    };

const TRate2NwsaRate KTRate2NwsaRateTable[] =

    {

        { E1Mbps, WHA::KRate1Mbits },

        { E2Mbps, WHA::KRate2Mbits },

        { E5_5Mbps, WHA::KRate5_5Mbits },

        { E11Mbps, WHA::KRate11Mbits },

        { E22Mbps, WHA::KRate22Mbits },

    };

class TRate2NwsaRatePredicate

    {

public:

    explicit TRate2NwsaRatePredicate( const TRate aRate )

        : iKey( aRate ) {};

    TBool operator() ( const TRate2NwsaRate& aEntry ) const

        {

        return aEntry.iTrate == iKey;

        }

private:

    // Prohibit copy constructor.

    TRate2NwsaRatePredicate ( const TRate2NwsaRatePredicate & );

    // Prohibit assigment operator.

    TRate2NwsaRatePredicate& operator= ( const TRate2NwsaRatePredicate & );

    const TRate iKey;

    };

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

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

// 

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

//

TBool WlanDot11State::Scan(

    WlanContextImpl& aCtxImpl,

    TScanMode aMode,                    

    const TSSID& aSSID,                 

    TRate aScanRate, 

    SChannels& aChannels,

    TUint32 aMinChannelTime,            

    TUint32 aMaxChannelTime,

    TBool aSplitScan )

    {

    WHA::TRate rate( 0 );

    ResolveScanRate( aCtxImpl, aScanRate, rate );

    // call the "real scan"

    return RealScan( aCtxImpl, aMode, aSSID, rate, aChannels, 

        aMinChannelTime, aMaxChannelTime, aSplitScan );

    }

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

// 

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

//

TBool WlanDot11State::StopScan( WlanContextImpl& aCtxImpl )

    {

    // as we are here it means that we have received a stop scan request

    // even though there is no scan ongoing. This should only happen if the

    // mgmt client has been in the process of making a stop scan request and 

    // hasn't noticed that the scan has already completed. Anyhow in this 

    // case we just complete the request

    OnOidComplete( aCtxImpl, KErrNone );

    // signal caller that no state transition occurred

    return EFalse;    

    }

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

// 

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

//

TBool WlanDot11State::SetPowerMode(

    WlanContextImpl& aCtxImpl,

    TPowerMode aPowerMode,

    TBool aDisableDynamicPowerModeManagement,

    TWlanWakeUpInterval aWakeupModeInLightPs, 

    TUint8 aListenIntervalInLightPs,

    TWlanWakeUpInterval aWakeupModeInDeepPs,

    TUint8 aListenIntervalInDeepPs )

    {

    OsTracePrint( KPwrStateTransition, (TUint8*)

        ("UMAC: WlanDot11State::SetPowerMode: aPowerMode: %d"), aPowerMode );

    TBool ret( EFalse );

    // store desired new dot11 power management mode by WLAN Mgmt Client

    aCtxImpl.ClientDot11PwrMgmtMode( aPowerMode );

    aCtxImpl.DynamicPwrModeMgtDisabled( aDisableDynamicPowerModeManagement );

    if ( aDisableDynamicPowerModeManagement )

        {

        aCtxImpl.StopPowerModeManagement();

        }

    // it is now also our desired dot11 power management mode

    aCtxImpl.DesiredDot11PwrMgmtMode( aCtxImpl.ClientDot11PwrMgmtMode() );

    aCtxImpl.SetClientLightPsModeConfig( 

        aWakeupModeInLightPs, 

        aListenIntervalInLightPs );

    aCtxImpl.SetClientDeepPsModeConfig( 

            aWakeupModeInDeepPs, 

            aListenIntervalInDeepPs );

    // in case WLAN Mgmt Client wishes to use PS mode, Light PS is the initial

    // desired PS mode configuration

    aCtxImpl.SetDesiredPsModeConfig( 

        aCtxImpl.ClientLightPsModeConfig() );

    if ( aCtxImpl.CurrentDot11PwrMgmtMode() !=

         aCtxImpl.ClientDot11PwrMgmtMode() )

        {

        // there is a difference in current dot11 power management mode and 

        // WLAN Mgmt Client's desired dot11 power management mode

        // callee will complete the mgmt command

        ret = OnDot11PwrMgmtTransitRequired( aCtxImpl );

        }

    else

        {

        // no dot11 power management mode transition required.

        // See if there is difference in desired vs. current wake-up setting,

        // which we only need to worry about if the requested pwr mgmt

        // mode is PS

        if ( aPowerMode == EPowerModePs && 

             DifferenceInPsModeWakeupSettings( aCtxImpl ) )

            {

            // callee shall complete the request

            ret = OnWlanWakeUpIntervalChange( aCtxImpl );

            }

        else

            {

            // no action required regarding the wake-up setting, either

            // one possibility is that the following has happened: WLAN Mgmt

            // client has requested us to use PS mode when possible, but we 

            // have dynamically changed to CAM mode because of data traffic. 

            // If that is the case and now the WLAN Mgmt client wants us

            // to stay in CAM mode, make sure that the dynamic power mode 

            // management is deactivated

            if ( aPowerMode == EPowerModeCam )

                {

                OsTracePrint( KPwrStateTransition, (TUint8*)

                    ("UMAC: WlanDot11State::SetPowerMode: CAM requested when we already are in CAM. Make sure that dynamic pwr mode mgmt is not active") );

                aCtxImpl.StopPowerModeManagement();                    

                }

            else

                {

                if ( !aDisableDynamicPowerModeManagement )

                    {

                    // in case the only change is that now dynamic pwr

                    // mode mgmt is again allowed, make sure it is active

                    aCtxImpl.StartPowerModeManagement();

                    }

                }

            }

        // complete the mgmt command

        OnOidComplete( aCtxImpl );

        }

    return ret;

    }

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

// 

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

//

TBool WlanDot11State::EnableUserData(

    WlanContextImpl& aCtxImpl )

    {

    TBool stateChange( EFalse );

    aCtxImpl.iEnableUserData = ETrue;

    OnOidComplete( aCtxImpl, KErrNone );

    aCtxImpl.iUmac.UserDataReEnabled();

    // signal global state transition event

    return stateChange;

    }

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

// 

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

//

TBool WlanDot11State::DisableUserData(

    WlanContextImpl& aCtxImpl )

    {

    aCtxImpl.iEnableUserData = EFalse;

    OnOidComplete( aCtxImpl, KErrNone );

    // signal caller that no state transition occurred

    return EFalse;

    }

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

// 

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

//

void WlanDot11State::OnConfigureUmacMib(

    WlanContextImpl& aCtxImpl,

    TUint16 aRTSThreshold,             

    TUint32 aMaxTxMSDULifetime )        

    {

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11State::OnConfigureUmacMib") );

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11State::OnConfigureUmacMib: RTSThreshold: %d"), 

        aRTSThreshold );

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanDot11State::OnConfigureUmacMib: maxTxMSDULifetime: %d"), 

        aMaxTxMSDULifetime );

    aCtxImpl.iWlanMib.dot11RTSThreshold = aRTSThreshold;

    for ( TUint i = 0; i < WHA::EQueueIdMax; ++i )

        {

        aCtxImpl.iWlanMib.dot11MaxTransmitMSDULifetime[i] = aMaxTxMSDULifetime;

        }

    aCtxImpl.iWlanMib.dot11MaxTransmitMSDULifetimeDefault = aMaxTxMSDULifetime;

    for ( TUint i = 0; i < WHA::EQueueIdMax; ++i )

        {

        aCtxImpl.iWlanMib.iMediumTime[i] = KDot11MediumTimeDefault;

        }        

    }

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

// 

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

//

void WlanDot11State::AddDefaultBroadcastWepKeyComplete( 

    WlanContextImpl& aCtxImpl ) const

    {

    OnOidComplete( aCtxImpl );

    }

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

// 

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

//

void WlanDot11State::ResolveScanRate( 

    WlanContextImpl& /*aCtxImpl*/,

    const TRate aRate, 

    WHA::TRate& aScanRate )

    {

    const TRate2NwsaRatePredicate unary_predicate( aRate );

    const TRate2NwsaRate* const end 

        = KTRate2NwsaRateTable 

        + (sizeof(KTRate2NwsaRateTable) / sizeof(TRate2NwsaRate));

    const TRate2NwsaRate* pos 

        = find_if( KTRate2NwsaRateTable, end, unary_predicate );

    if ( pos == end )

        {

        // not found; an implementation error

        OsAssert( (TUint8*)("UMAC: panic"),(TUint8*)(WLAN_FILE), __LINE__ );

        }

    aScanRate = pos->iNwsaRate;

    }

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

// 

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

//

TBool WlanDot11State::NetworkCapabilityInformationMet(

    WlanContextImpl& aCtxImpl)

    {

    if ( // do this if channel agility bit is not set    

        ( !aCtxImpl.GetCapabilityInformation().IsChannelAgilityBitSet() ))        

        {

        // mimic the preamble bit from AP

        // as some APs might not let us in if not matched

        if ( aCtxImpl.GetCapabilityInformation().IsShortPreambleBitSet() )

            {

            (aCtxImpl.GetAssociationRequestFrame())

                .SetCapabilityShortPreamble();

            (aCtxImpl.GetHtAssociationRequestFrame())

                .SetCapabilityShortPreamble();

            (aCtxImpl.GetReassociationRequestFrame())

                .SetCapabilityShortPreamble();

            (aCtxImpl.GetHtReassociationRequestFrame())

                .SetCapabilityShortPreamble();                

            aCtxImpl.UseShortPreamble( ETrue );

            }

        else

            {

            (aCtxImpl.GetAssociationRequestFrame())

                .ClearCapabilityShortPreamble();

            (aCtxImpl.GetHtAssociationRequestFrame())

                .ClearCapabilityShortPreamble();

            (aCtxImpl.GetReassociationRequestFrame())

                .ClearCapabilityShortPreamble();

            (aCtxImpl.GetHtReassociationRequestFrame())

                .ClearCapabilityShortPreamble();                

            aCtxImpl.UseShortPreamble( EFalse );

            }

        // clear both CF fields as we don't support PCF

        aCtxImpl.GetAssociationRequestFrame().ClearCFfields();

        aCtxImpl.GetHtAssociationRequestFrame().ClearCFfields();

        aCtxImpl.GetReassociationRequestFrame().ClearCFfields();

        aCtxImpl.GetHtReassociationRequestFrame().ClearCFfields();

        // clear also all the fields we don't understand

        aCtxImpl.GetAssociationRequestFrame().ClearReservedFields();

        aCtxImpl.GetHtAssociationRequestFrame().ClearReservedFields();

        aCtxImpl.GetReassociationRequestFrame().ClearReservedFields();

        aCtxImpl.GetHtReassociationRequestFrame().ClearReservedFields();

        // we don't do PBCC

        aCtxImpl.GetAssociationRequestFrame().ClearCapabilityPbcc();

        aCtxImpl.GetHtAssociationRequestFrame().ClearCapabilityPbcc();

        aCtxImpl.GetReassociationRequestFrame().ClearCapabilityPbcc();

        aCtxImpl.GetHtReassociationRequestFrame().ClearCapabilityPbcc();

        if ( aCtxImpl.EncryptionStatus() != EEncryptionDisabled )

            {

            // privacy desired

            aCtxImpl.GetAssociationRequestFrame().SetWepBit();

            aCtxImpl.GetHtAssociationRequestFrame().SetWepBit();

            aCtxImpl.GetReassociationRequestFrame().SetWepBit();

            aCtxImpl.GetHtReassociationRequestFrame().SetWepBit();                

            }

        else

            {

            aCtxImpl.GetAssociationRequestFrame().ClearWepBit();

            aCtxImpl.GetHtAssociationRequestFrame().ClearWepBit();

            aCtxImpl.GetReassociationRequestFrame().ClearWepBit();

            aCtxImpl.GetHtReassociationRequestFrame().ClearWepBit();                

            }

        if ( aCtxImpl.RadioMeasurement() != EFalse )

            {

            // Radio measurements desired

            OsTracePrint (KInfoLevel, (TUint8 *)("UMAC: Radio measurements enabled"));

            aCtxImpl.GetAssociationRequestFrame().SetRMBit();

            aCtxImpl.GetHtAssociationRequestFrame().SetRMBit();

            aCtxImpl.GetReassociationRequestFrame().SetRMBit();

            aCtxImpl.GetHtReassociationRequestFrame().SetRMBit();                

            }

        else

            {

            OsTracePrint (KInfoLevel, (TUint8 *)("UMAC: Radio measurements disabled"));

            aCtxImpl.GetAssociationRequestFrame().ClearRMBit();

            aCtxImpl.GetHtAssociationRequestFrame().ClearRMBit();

            aCtxImpl.GetReassociationRequestFrame().ClearRMBit();

            aCtxImpl.GetHtReassociationRequestFrame().ClearRMBit();                

            }        

        return ETrue;

        }

    return EFalse;

    }

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

// 

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

//

TBool WlanDot11State::AreSupportedRatesMet(

    WlanContextImpl& aCtxImpl, 

    TBool aCheckAlsoExtendedRates )

    {   

    OsTracePrint( KWarningLevel, 

        (TUint8*)("UMAC: WlanDot11State::AreSupportedRatesMet") );

    // make sure these critters are zeroed at the beginning

    aCtxImpl.GetMinBasicRate() = 0;

    aCtxImpl.GetMaxBasicRate() = 0;

    aCtxImpl.ClearBasicRateSet();

    // clear our existing supported rates IE

    aCtxImpl.GetOurSupportedRatesIE().Clear();

    // ... and our existing extended supported rates IE

    aCtxImpl.GetOurExtendedSupportedRatesIE().Clear();

    TUint32 tx_rates( 0 );

    TUint8 nwRate( 0 );

    // go through all supported rate elements in the supported rates IE 

    // ( max 8 ).

    // Remenber that basic rates are also always part of supported rates 

    // when building supported rates bitmask

    for ( TUint32 outer_idx = 0 

        // loop until element count in the IE is reached

        ; ( outer_idx != aCtxImpl.GetApSupportedRatesIE().GetElementLength() )

        // OR maximum length allowed for the IE is reached

        // 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 have allocated enough space for all 802.11b/g rates in this

        // IE and hence the following constant in the loop end condition

        && outer_idx < KMaxNumberOfDot11bAndgRates

        ; ++outer_idx )

        {

        nwRate = (aCtxImpl.GetApSupportedRatesIE())[outer_idx];

        if ( !ProcessSingleSupportedRateElement( aCtxImpl, nwRate, tx_rates ) )

            {

            // unknown supported rates element encountered

            if ( nwRate & KBasicRateMask )

                {

                // it is part of BSS Basic Rate Set 

                if ( aCtxImpl.BssMembershipFeatureSupported( nwRate ) )

                    {

                    // it is a WLAN feature which we support, 

                    // so we can continue. No action required here

                    }

                 else

                    {

                    // we can't cope with it and shall abort

                    OsTracePrint( KWarningLevel, (TUint8*)

                        ("UMAC: WlanDot11State::AreSupportedRatesMet: network has unsupported mandatory rate/feature -> abort") );

                    OsTracePrint( KWarningLevel, (TUint8*)

                        ("UMAC: WlanDot11State::AreSupportedRatesMet: rate: 0x%02x"), 

                        nwRate);                    

                    return EFalse;

                    }

                }

            else

                {

                // unknown element is not part of BSS Basic Rate Set

                // we can cope with that 

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("UMAC: WlanDot11State::AreSupportedRatesMet: init network connect") );

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("UMAC: WlanDot11State::AreSupportedRatesMet: network has unsupported supported rate -> continue") );

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("UMAC: WlanDot11State::AreSupportedRatesMet: rate: 0x%02x"), 

                    nwRate);

                }

            }

        } // end outer for

    if ( aCheckAlsoExtendedRates )

        {

        // go through all supported rate elements in the extended supported 

        // rates IE ( max 255 ).

        // Remember that basic rates are also always part of supported rates 

        // when building supported rates bitmask

        for ( TUint32 outer_idx = 0; 

              // loop until max element count in the IE is reached

              ( outer_idx != aCtxImpl.GetApExtendedSupportedRatesIE().GetElementLength() )

              // OR maximum length allowed for the IE is reached

              && outer_idx < KMaxNumberOfExtendedRates; 

              ++outer_idx )

            {

            nwRate = (aCtxImpl.GetApExtendedSupportedRatesIE())[outer_idx];        

            if ( !ProcessSingleSupportedRateElement( 

                    aCtxImpl, 

                    nwRate, 

                    tx_rates ) )

                {

                // unknown supported rates element encountered

                if ( nwRate & KBasicRateMask )

                    {

                    // it is part of BSS Basic Rate Set 

                    if ( aCtxImpl.BssMembershipFeatureSupported( nwRate ) )

                        {

                        // it is a WLAN feature which we support, 

                        // so we can continue. No action required here

                        }

                     else

                        {

                        // we can't cope with it and shall abort

                        OsTracePrint( KWarningLevel, (TUint8*)

                            ("UMAC: WlanDot11State::AreSupportedRatesMet: network has unsupported mandatory rate/feature -> abort") );