/*

* 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:   Implementation of the WlanDot11AssociationPending class

*

*/

/*

* %version: 45 %

*/

#include "config.h"

#include "UmacDot11AssociationPending.h"

#include "UmacContextImpl.h"

#include "umacelementlocator.h"

#include "umacwhaconfigureac.h"

#include "802dot11DefaultValues.h"

#ifndef NDEBUG

const TInt8 WlanDot11AssociationPending::iName[] = "dot11-associationpending";

const TUint8 WlanDot11AssociationPending::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"ETXASSOCREQFRAME"}, 

        {"EWAIT4ASSOCRESPONSE"},

        {"ECONFIGUREAC"},

        {"EWAIT4PUSHPACKET"},

        {"ECONTINUEDOT11TRAVERSE"}

    };

const TUint8 WlanDot11AssociationPending::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, 

        {"ERXASSOCRESPONSE"},

        {"ETX_ASSOCFRAME_XFER"},

        {"ETXCOMPLETE"},

        {"ETIMEOUT"},

        {"ETX_SCHEDULER_FULL"},

        {"EPUSHPACKET"}

    };

#endif 

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

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

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

//

void WlanDot11AssociationPending::Entry( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacProtocolState | KUmacAssoc, 

        (TUint8*)("UMAC: WlanDot11AssociationPending::Entry()"));

    if ( aCtxImpl.WsaCmdActive() )

        {

        // sanity checking code

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

        }

    // no need to do event dispatching as this

    // thing is triggered by the user and

    // is executed synchronously as we only do OID completion

    // at the end of authenticate + association process

    if ( iState == EINIT )

        {

        // this is the start of the the FSM actions

        Fsm( aCtxImpl, ESTATEENTRY );

        }

    else

        {

        // this is NOT the start of the the FSM actions

        // note that we send the ETXCOMPLETE event as the states

        // that wait for it are the only ones that can be interrupted

        // as they are asynchronous operations by nature

        // and wait for corresponding WHA completion method

        Fsm( aCtxImpl, ETXCOMPLETE );        

        }

    }

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

// 

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

//

void WlanDot11AssociationPending::Exit( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    // reset our local FSM for the next time...

    iState = EINIT;

    }

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

// 

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

//

void WlanDot11AssociationPending::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

    OsTracePrint( KUmacAssoc, 

        (TUint8*)("UMAC: WlanDot11AssociationPending::Fsm(): FSM EVENT") );

#ifndef NDEBUG

    OsTracePrint( KUmacAssoc, (TUint8*)("UMAC: event:"));

    OsTracePrint( KUmacAssoc, iEventName[aEvent] );

    OsTracePrint( KUmacAssoc, (TUint8*)("UMAC: state:"));

    OsTracePrint( KUmacAssoc, iStateName[iState] );

#endif

    switch ( aEvent )

        {

        case ESTATEENTRY:

            OnStateEntryEvent( aCtxImpl );

            break;

        case ETX_ASSOCFRAME_XFER:

            OnTxAssocFrameXferEvent( aCtxImpl );

            break;

        case ERXASSOCRESPONSE:

            OnRxAssociationResponseEvent( aCtxImpl );

            break;

        case ETXCOMPLETE:

            OnTxCompleteEvent( aCtxImpl );

            break;

        case ETIMEOUT:

            OnTimeoutEvent( aCtxImpl );

            break;

        case ETX_SCHEDULER_FULL:

            OnTxSchedulerFullEvent( aCtxImpl );

            break;

        case EPUSHPACKET:

            OnPushPacketEvent( aCtxImpl );

            break;

        default:

            // cath internal FSM programming error

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

            break;

        }

    }

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

// Handler for state entry event.

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

//

void WlanDot11AssociationPending::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( 

        KUmacAssoc, 

        (TUint8*)("UMAC: WlanDot11AssociationPending::OnStateEntryEvent()"));

    switch ( iState )

        {

        case EINIT:

            iFlags = 0;

            ChangeInternalState( aCtxImpl, ETXASSOCREQFRAME );            

            break;

        case ETXASSOCREQFRAME:

            // send the associate frame

            if ( !SendAssociationRequest( aCtxImpl ) )

                {

                // tx of dot11-associate frame failed  

                // because packet scheduler was full

                // or because we didn't get a Tx buffer

                // so we enter to a wait state

                Fsm( aCtxImpl, ETX_SCHEDULER_FULL );

                }            

            break;

        case EWAIT4ASSOCRESPONSE:

            // start a timer to wait for the response frame

            StartAssociationFrameResponseTimer( aCtxImpl );

            break;

        case ECONFIGUREAC:

            ConfigureAc( aCtxImpl );

            break;

        case ECONTINUEDOT11TRAVERSE:

            ContinueDot11StateTraversal( aCtxImpl );

            break;

        case EWAIT4PUSHPACKET:

            // nothing to do here than wait 

            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 association response timeout event.

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

//

void WlanDot11AssociationPending::OnTimeoutEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // set completion code

    // as dot11idle state does the OID completion

    aCtxImpl.iStates.iIdleState.Set( KErrTimedOut );

    ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

    }

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

// Handler for associate request frame 

// has been xferred to the WLAN device event

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

//

void WlanDot11AssociationPending::OnTxAssocFrameXferEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // change state

    ChangeInternalState( aCtxImpl, EWAIT4ASSOCRESPONSE );

    }

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

// Handler for rx association response event.

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

//

void WlanDot11AssociationPending::OnRxAssociationResponseEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EWAIT4ASSOCRESPONSE:

            if ( iFlags & KConfigureAc )

                {

                ChangeInternalState( aCtxImpl, ECONFIGUREAC );                                

                }

            else

                {

                ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );                

                }

            break;

        default:

            // this means that we have recieved a valid dot11 

            // associate response frame that we are waiting for

            // but we are not internally in such a state

            // only feasible situation for this is that 

            // someone  has skipped a call to the packet xfer method

            // that informs of associate request frame 

            // xfer to the WLAN device.

            // other case is that our fsm is totally messed up

            // so we catch this

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// 

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

//

void WlanDot11AssociationPending::OnTxCompleteEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case ECONFIGUREAC:

            // continue state traversal

            ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( KErrorLevel, (TUint8*)("UMAC: state: %d"), iState);        

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

            break;

        }

    }

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

// Handler for scheduler full event upon trying to tx dot11-associate frame

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

//

void WlanDot11AssociationPending::OnTxSchedulerFullEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // change state

    OsTracePrint( KWarningLevel | KUmacAssoc, (TUint8*)

        ("UMAC: packet scheduler full during association process") );

    ChangeInternalState( aCtxImpl, EWAIT4PUSHPACKET );

    }

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

// Handler for push packet to packet scheduler possible event

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

//

void WlanDot11AssociationPending::OnPushPacketEvent( 

    WlanContextImpl& aCtxImpl )

    {

    if ( iState == EWAIT4PUSHPACKET )

        {

        ChangeInternalState( aCtxImpl, ETXASSOCREQFRAME );

        }

    }

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

// 

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

//

void WlanDot11AssociationPending::ContinueDot11StateTraversal( 

    WlanContextImpl& aCtxImpl )

    {

    if ( iFlags & KAssocSuccess )

        {

        // traverse to next dot11state

        ChangeState( aCtxImpl,

            *this,                                      // prev state   

            aCtxImpl.iStates.iInfrastructureModeInit    // next state

            );

        }

    else

        {

        // proceed back to idle

        //

        ChangeState( aCtxImpl, 

            *this,                          // prev state

            aCtxImpl.iStates.iIdleState     // next state

            );

        }

    }

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

// 

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

//

void WlanDot11AssociationPending::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    OsTracePrint( KUmacAssoc, (TUint8*)

        ("UMAC: WlanDot11AssociationPending::ChangeInternalState(): old state:"));

#ifndef NDEBUG

    OsTracePrint( KUmacAssoc, iStateName[iState] );

    OsTracePrint( KUmacAssoc, (TUint8*)("new state:"));

    OsTracePrint( KUmacAssoc, iStateName[aNewState] );

#endif 

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

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

// 

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

//

#ifndef NDEBUG 

const TInt8* WlanDot11AssociationPending::GetStateName( 

    TUint8& aLength ) const

    {

    aLength = sizeof( iName );

    return iName;

    }

#endif 

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

// 

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

//

TBool WlanDot11AssociationPending::SendAssociationRequest( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacAssoc, (TUint8*)

        ("UMAC: WlanDot11AssociationPending::SendAssociationRequest"));

    TBool status ( EFalse );

    TUint8* startOfFrame ( NULL );

    const TUint32 length_of_frame 

        = ConstructAssociationRequestFrame( aCtxImpl, startOfFrame );

    if ( length_of_frame )

        {

        // frame is ready for delivery in the tx buffer

        // send association request message to the AP

        const WHA::TQueueId queue_id 

            = QueueId( aCtxImpl, startOfFrame );

        // push the frame to packet scheduler for transmission

        status = aCtxImpl.PushPacketToPacketScheduler(

                    startOfFrame,

                    length_of_frame,

                    queue_id,

                    E802Dot11FrameTypeAssociationReq,

                    NULL,

                    EFalse,

                    EFalse,

                    ETrue );

        if ( !status )

            {

            // as we came here we did get an internal Tx buffer for the frame

            // but packet push to scheduler failed. In this case we need cancel

            // the internal Tx buffer reservation as we will request it again

            // when the Packet Scheduler is again ready for packet push

            aCtxImpl.MarkInternalTxBufFree();

            }

        }

    else

        {

        // frame not ready for delivery. EFalse will be returned

        }

    return status;

    }

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

// 

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

//

TUint WlanDot11AssociationPending::ConstructAssociationRequestFrame( 

    WlanContextImpl& aCtxImpl,

    TUint8*& aStartOfFrame )

    {

    OsTracePrint( KUmacAssoc, (TUint8*)

        ("UMAC: WlanDot11AssociationPending::ConstructAssociationRequestFrame") );

    TUint32 lengthOfFrame ( 0 );

    // client doesn't have to take care of the tx buffer header space

    // as the method below does that by itself

    aStartOfFrame = aCtxImpl.TxBuffer( ETrue );

    if ( aStartOfFrame )

        {

        // construct association request frame

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

        // in the initialization phase of the state machine

        // Also capabilty information field is already set to frame template 

        // in AreNetworkRequirementsMet() method

        TUint8* buffer_ptr = aStartOfFrame;

        if ( aCtxImpl.HtSupportedByNw() && aCtxImpl.QosEnabled() )

            {

            // set the BSSID field     

            (aCtxImpl.GetHtAssociationRequestFrame()).iHeader.iBSSID = 

                aCtxImpl.GetBssId();

            // set the DA field 

            (aCtxImpl.GetHtAssociationRequestFrame()).iHeader.iDA = 

                aCtxImpl.GetBssId();

            // set listen interval (in units of beacon interval)

            (aCtxImpl.GetHtAssociationRequestFrame()).iFixedFields.iListenInterval 

                = KDot11ListenIntervalInMs / aCtxImpl.NetworkBeaconInterval();

            // copy frame to tx-buffer to correct offset

            os_memcpy( 

                buffer_ptr,

                &(aCtxImpl.GetHtAssociationRequestFrame()), 

                sizeof( SHtAssociationRequestFrame ) );

            buffer_ptr += sizeof( SHtAssociationRequestFrame );            

            }

        else

            {

            // set the BSSID field     

            (aCtxImpl.GetAssociationRequestFrame()).iHeader.iBSSID = 

                aCtxImpl.GetBssId();

            // set the DA field 

            (aCtxImpl.GetAssociationRequestFrame()).iHeader.iDA = 

                aCtxImpl.GetBssId();

            // set listen interval (in units of beacon interval)

            (aCtxImpl.GetAssociationRequestFrame()).iFixedFields.iListenInterval 

                = KDot11ListenIntervalInMs / aCtxImpl.NetworkBeaconInterval();

            // copy frame to tx-buffer to correct offset

            os_memcpy( 

                buffer_ptr,

                &(aCtxImpl.GetAssociationRequestFrame()), 

                sizeof( SAssociationRequestFrame ) );

            buffer_ptr += sizeof( SAssociationRequestFrame );

            }

        // set SSID IE

        SSsIdIE ssid_ie( (aCtxImpl.GetSsId()).ssid, 

            (aCtxImpl.GetSsId()).ssidLength );

        const TUint8 ssidIeLength( ssid_ie.GetIeLength() );

        os_memcpy(

            buffer_ptr, 

            &ssid_ie, 

            ssidIeLength );

        buffer_ptr += ssidIeLength;

        // set supported rates IE

        const TUint8 supportedRatesIeLength( 

            aCtxImpl.GetOurSupportedRatesIE().GetIeLength() );

        os_memcpy( 

            buffer_ptr, 

            &(aCtxImpl.GetOurSupportedRatesIE()), 

            supportedRatesIeLength );

        buffer_ptr += supportedRatesIeLength;

        if ( aCtxImpl.HtSupportedByNw() )

            {

            // set HT capabilities element

            const TUint8 htCapabilitiesIeLength( 

                aCtxImpl.GetOurHtCapabilitiesIe().GetIeLength() );

            os_memcpy( 

                buffer_ptr,