/*

* Copyright (c) 2005-2008 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 WlanDot11IbssScanningMode class.

*

*/

/*

* %version: 17 %

*/

#include "config.h"

#include "umacdot11ibssscanningmode.h"

#include "umacscanfsmcntx.h"

#include "UmacContextImpl.h"

#include "UmacWsaWriteMib.h"

#include "UmacWsaScan.h"

#include "umacwhastopscan.h"

#include "umacwhatodot11typeconverter.h"

#ifndef NDEBUG

const TInt8 WlanDot11IbssScanningMode::iName[] = "dot11-ibssscanningmode";

const TUint8 WlanDot11IbssScanningMode::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"EEXECUTESCANFSM"},

        {"ECONTINUEDOT11TRAVERSE"}

    };

const TUint8 WlanDot11IbssScanningMode::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, 

        {"ETXCOMPLETE"},

        {"ESTARTSCANNINGMODE"},

        {"ESCANMODERUNNING"},

        {"ESTOPSCANNINGMODE"},

        {"ESCANNINGMODEEXIT"},

        {"EABORT"}

    };

#endif

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

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

// 

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

//

WlanDot11IbssScanningMode::~WlanDot11IbssScanningMode() 

    {

    iCtxImpl = NULL;

    iSSID = NULL;

    iChannels = NULL;

    iPimpl = NULL;

    }

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

// 

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

//

void WlanDot11IbssScanningMode::Set( 

    WlanContextImpl& aCtxImpl )

    {

    iCtxImpl = &aCtxImpl;

    }

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

// 

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

//

void WlanDot11IbssScanningMode::Set( 

    WlanContextImpl& /*aCtxImpl*/,

    TScanMode aMode,                    

    const TSSID& aSSID,                 

    TUint32 aScanRate,                    

    SChannels& aChannels,

    TUint32 aMinChannelTime,            

    TUint32 aMaxChannelTime,

    TBool aSplitScan )    

    {

    // we can store pointers as oid parameters are guaranteed to be valid 

    // to the point the corresponding completion method is called

    iMode = aMode;

    iSSID = &aSSID;

    iScanRate = aScanRate;

    iChannels = &aChannels;

    iMinChannelTime = aMinChannelTime;            

    iMaxChannelTime = aMaxChannelTime;

    iSplitScan = aSplitScan;

    }

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

// The internal state transition method.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

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

// The event dispatcher method.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

    OsTracePrint( KScan, 

        (TUint8*)("UMAC * dot11-ibssscanningmode * FSM EVENT") );

#ifndef NDEBUG

    OsTracePrint( KScan, (TUint8*)("event:"));

    OsTracePrint( KScan, iEventName[aEvent] );

    OsTracePrint( KScan, (TUint8*)("state:"));

    OsTracePrint( KScan, iStateName[iState] );

#endif

    switch ( aEvent )

        {

        case ESTATEENTRY:

            OnStateEntryEvent( aCtxImpl );

            break;

        case ETXCOMPLETE:

            OnTxCompleteEvent( aCtxImpl );

            break;

        case ESTARTSCANNINGMODE:

            OnStartScanningModeEvent( aCtxImpl );

            break;

        case ESCANMODERUNNING:

            OnScanModeRunningEvent( aCtxImpl );

            break;

        case ESTOPSCANNINGMODE:

            OnStopScanningModeEvent( aCtxImpl );

            break;

        case ESCANNINGMODEEXIT:

            OnScanningModeExitEvent( aCtxImpl );

            break;

        case EABORT:

            OnAbortEvent( aCtxImpl );

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

            OsTracePrint( KErrorLevel, (TUint8*)("event:"));

            OsTracePrint( KErrorLevel, iEventName[aEvent] );                

#endif

            OsAssert( (TUint8*)("* UMAC * panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:

            iPimpl = static_cast<WlanScanFsmCntx*>

                (os_alloc( sizeof(WlanScanFsmCntx) ));

            if ( iPimpl )

                {

                // allocation success

                new (iPimpl) WlanScanFsmCntx( *this );

                // start fsm traversal

                ChangeInternalState( aCtxImpl, EEXECUTESCANFSM );                

                }

            else

                {

                // allocation failure

                Fsm( aCtxImpl, EABORT );

                }

            break;

        case EEXECUTESCANFSM:

            ExecuteScanFsm( aCtxImpl );

            break;

        case ECONTINUEDOT11TRAVERSE:

            ContinueDot11StateTraversal( aCtxImpl );

            break;

        default:

            // cath internal FSM programming error

#ifndef NDEBUG

            OsTracePrint( KErrorLevel, (TUint8*)("state:"));

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

            OsAssert( (TUint8*)("* UMAC * panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnTxCompleteEvent( 

    WlanContextImpl& /*aCtxImpl*/ ) const

    {

    switch ( iState )

        {

        case EEXECUTESCANFSM:

            // we are running the scan fsm 

            // and we have nothing to do here

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

            OsTracePrint( KErrorLevel, (TUint8*)("state:"));

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

            OsAssert( (TUint8*)("* UMAC * panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnStartScanningModeEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // start the scanning mode

    // convert scan parameters to WHA types

    // Note that we need to deallocate the memory from whaChannels

    // - which is allocated in ConvertToWhaTypes() - when we are done

    WHA::SSSID* wha_ssid = 

        static_cast<WHA::SSSID*>(os_alloc( sizeof(WHA::SSSID) )); 

    if ( !wha_ssid )

        {

        // memory allocation failue; that's fatal

        Fsm( aCtxImpl, EABORT );

        return;

        }

    WHA::SChannels* wha_channels( NULL );

    TUint8 wha_channelcount( 0 );

    if ( !(WlanWhaToDot11TypeConverter::ConvertToWhaTypes(       

        aCtxImpl, 

        iSSID, 

        *wha_ssid, 

        iChannels, 

        iMinChannelTime,

        iMaxChannelTime,

        wha_channels, 

        wha_channelcount )) )

        {

        // memory allocation failue; that's fatal

        os_free( wha_ssid );

        Fsm( aCtxImpl, EABORT );

        }

    else

        {

        // start the scanning process

        const TUint8 KNbrOfProbeReqsPerCh = 2;

        const TUint8 KNoProbeReqs = 0;        

        const TUint8 KNbrOfSsids = 1;

        const TUint8 KNoSsids = 0;

        // 1st set the context

        aCtxImpl.WsaScan().Set( 

            aCtxImpl,

            iScanRate,

            iChannels->iBand,

            wha_channelcount,

            wha_channels,

            WHA::EFgScan,

            (iMode == EActiveScan) ? KNbrOfProbeReqsPerCh : KNoProbeReqs,

            iSplitScan,

            wha_ssid->iSSIDLength ? KNbrOfSsids : KNoSsids,

            wha_ssid );

        // change global state: entry procedure triggers action

        ChangeState( aCtxImpl, 

            *this,              // prev state

            aCtxImpl.WsaScan()  // next state

            );

        // as the parameters have been supplied we can now deallocate

        os_free( wha_ssid );

        os_free( wha_channels );                                    

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnScanModeRunningEvent( 

    WlanContextImpl& aCtxImpl ) const

    {

    // complete the scan request

    OsTracePrint( KScan, (TUint8*)

        ("UMAC: WlanDot11IbssScanningMode::OnScanModeRunningEvent: Complete scan request") );

    OnOidComplete( aCtxImpl );            

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnStopScanningModeEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,                  // prev state

        aCtxImpl.WhaStopScan()  // next state

        );

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IbssScanningMode::OnScanningModeExitEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // scanning mode has stopped and so can we

    // inform the mgmt client about scan completion

    OsTracePrint( KScan, (TUint8*)

        ("UMAC: WlanDot11IbssScanningMode::OnScanningModeExitEvent: Send scan complete indication"));

    OnInDicationEvent( aCtxImpl, EScanCompleted );

    // continue with the dot11 state traversal

    ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

    }

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

// simulate macnotresponding error

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

//

void WlanDot11IbssScanningMode::OnAbortEvent( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KWarningLevel, 

        (TUint8*)("UMAC * dot11-ibssscanningmode * abort") );

    DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

    }

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

// 

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

//

void WlanDot11IbssScanningMode::ExecuteScanFsm( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    // start scan fsm

    iPimpl->Current().StartScanningMode( *iPimpl );

    }

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

// 

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

//

void WlanDot11IbssScanningMode::ContinueDot11StateTraversal( 

    WlanContextImpl& aCtxImpl )

    {

    // return back     

    ChangeState( aCtxImpl, 

        *this,                              // prev state

        aCtxImpl.iStates.iIbssNormalMode    // next state

        );

    }

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

// Handler for WHA command response event.

// It is guaranteed by the global protocol fsm framework that no WHA command is 

// pending when this method is entered

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

//

void WlanDot11IbssScanningMode::OnWhaCommandResponse( 

    WlanContextImpl& aCtxImpl, 

    WHA::TCommandId aCommandId, 

    WHA::TStatus aStatus,

    const WHA::UCommandResponseParams& aCommandResponseParams,

    TUint32 aAct )

    {

    if ( aCommandId == WHA::EScanCommandResponse )

        {

        OsTracePrint( KScan, (TUint8*)("UMAC * OnScanningModeStarted"));

        // morph event to the scan fsm

        iPimpl->Current().OnScanningModeStarted( *iPimpl );

        }

    else if ( aCommandId == WHA::EStopScanResponse )

        {

        // complete the stop scan request

        OsTracePrint( KScan, (TUint8*)

            ("UMAC: WlanDot11IbssScanningMode::OnWhaCommandResponse: complete stop scan request"));        

        OnOidComplete( aCtxImpl );

        }

    else

        {

        // this is a response to a command that was not generated 

        // by this dot11 state object

        // so let's forward it to the default handler 

        WlanDot11State::OnWhaCommandResponse(

            aCtxImpl, 

            aCommandId, 

            aStatus,

            aCommandResponseParams,

            aAct );

        }

    }

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

// Handler for WHA command completion event.

// It is guaranteed by the global protocol fsm framework that no WHA command is 

// pending when this method is entered

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

//

TBool WlanDot11IbssScanningMode::CommandComplete( 

    WlanContextImpl& /*aCtxImpl*/, 

    WHA::TCompleteCommandId aCompleteCommandId, 

    WHA::TStatus /*aStatus*/,

    const WHA::UCommandCompletionParams& /*aCommandCompletionParams*/ )

    {

    if ( aCompleteCommandId != WHA::EScanComplete )

        {

        // implementation error as this can be the only one

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

        }

    OsTracePrint( KScan, (TUint8*)("UMAC * OnScanningModeStopped"));

    // morph event to scan fsm

    iPimpl->Current().OnScanningModeStopped( *iPimpl );

    // as scanning mode has ended we will change dot11 state.

    // Signal it to caller

    return ETrue;

    }

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

// 

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

//

TAny* WlanDot11IbssScanningMode::RequestForBuffer( 

    WlanContextImpl& aCtxImpl, 

    TUint16 aLength )

    {

    return aCtxImpl.GetRxBuffer( aLength );

    }

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

// 

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

//

void WlanDot11IbssScanningMode::OnBeaconFrameRx( 

    WlanContextImpl& aCtxImpl,

    const TAny* aFrame,

    const TUint32 aLength,

    WHA::TRcpi aRcpi,

    TUint8* aBuffer )

    {

    // as we have a beacon frame 

    // we will pass it to the client of the mgmt interface

    XferDot11FrameToMgmtClient( aCtxImpl, aFrame, aLength, aRcpi, aBuffer );

    }

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

// 

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

//

void WlanDot11IbssScanningMode::OnProbeResponseFrameRx( 

    WlanContextImpl& aCtxImpl,

    const TAny* aFrame,

    const TUint32 aLength,

    WHA::TRcpi aRcpi,

    TUint8* aBuffer )

    {

    // as we have a probe response frame

    // we will pass it to the client of the mgmt interface

    XferDot11FrameToMgmtClient( aCtxImpl, aFrame, aLength, aRcpi, aBuffer );

    }

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

// 

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

//