/*

* Copyright (c) 2005-2007 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 WlanDot11OpenAuthPending class

*

*/

/*

* %version: 23 %

*/

#include "config.h"

#include "UmacDot11OpenAuthPending.h"

#include "UmacContextImpl.h"

#ifndef NDEBUG 

const TInt8 WlanDot11OpenAuthPending::iName[] = "dot11-openauthpending";

#endif // !NDEBUG 

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

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

// 

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

//

#ifndef NDEBUG 

const TInt8* WlanDot11OpenAuthPending::GetStateName( 

    TUint8& aLength ) const

    {

    aLength = sizeof( iName );

    return iName;

    }

#endif

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

// Handler for state entry event.

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

//

void WlanDot11OpenAuthPending::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:

            // do all the synchronous 

            // composite state entry actions

            StateEntryActions( aCtxImpl );

            // continue with the state traversal

            Fsm( aCtxImpl, ECONTINUE );

            break;

        case ETXAUTHFRAME:

            // send the authenticate frame

            if ( !SendAuthSeqNbr1Frame( aCtxImpl ) )

                {

                // tx of dot11-authenticate 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 ECONTINUEDOT11TRAVERSE:

            ContinueDot11StateTraversal( aCtxImpl );

            break;

        case EWAIT4AUTHRESPONSE:

            // start a timer to wait for the response frame

            StartAuthenticationFrameResponseTimer( aCtxImpl );

            break;

        case EWAIT4PUSHPACKET:

            // nothing to do here than wait 

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for rx authentication response event.

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

//

void WlanDot11OpenAuthPending::OnRxAuthResponseEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EWAIT4AUTHRESPONSE:

            ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

            break;

        default:

            // this means that we have recieved a valid dot11 

            // authenticate 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 authenticate 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*)("UMAC: state:"));

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif 

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// set appropriate used algorithm number to authenticate request frame

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

//

void WlanDot11OpenAuthPending::OnSetAlgorithmNumber( 

    WlanContextImpl& aCtxImpl )

    {

    if ( aCtxImpl.HtSupportedByNw() )

        {

        aCtxImpl.GetHtAuthenticationFrame().SetAlgorithmNmbr( 

            aCtxImpl.AuthenticationAlgorithmNumber() );

        }

    else

        {

        aCtxImpl.GetAuthenticationFrame().SetAlgorithmNmbr( 

            aCtxImpl.AuthenticationAlgorithmNumber() );

        }

    }

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

// If we land here it means that we have received a frame of somekind

// with a status success

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

//

void WlanDot11OpenAuthPending::OnReceiveFrameSuccess(

    WlanContextImpl& aCtxImpl,

    const void* aFrame,

    TUint16 /*aLength*/,

    WHA::TRcpi /*aRcpi*/,

    TUint32 aFlags,

    TUint8* /*aBuffer*/ )

    {

    // parse frame in order to determine is it what we want

    const SManagementFrameHeader* frame_hdr 

        = static_cast<const SManagementFrameHeader*>(aFrame);

    TBool type_match( EFalse );

    if ( // can we accept this frame 

         // is this a management type + authentication subtype frame 

         IsRequestedFrameType( 

             frame_hdr->iFrameControl.iType,

             E802Dot11FrameTypeAuthentication, type_match )

         // AND our MAC address is DA

         && (frame_hdr->iDA == aCtxImpl.iWlanMib.dot11StationId)

         // AND we are in correct state

         && ( iState == EWAIT4AUTHRESPONSE )

        )

        {

        // cancel authentication frame response timer

        aCtxImpl.CancelTimer(); 

        iFlags |= KAuthReceived;

        // we have got a hit...let's proceed

        // store the used authentication algorithm number

        // for later use

        const TUint16 used_auth_algorithm = 

            aCtxImpl.AuthenticationAlgorithmNumber();

        // validate the authentication frame

        if ( ResolveAuthMessage( 

                aCtxImpl, 

                used_auth_algorithm, 

                aFrame, 

                aFlags ) )

            {

            // authentication success 

            OsTracePrint( KUmacAuth, (TUint8*)

                ("UMAC: dot11-openauthpending * authentication success") );

            // mark it also

            iFlags |= KAuthSuccess;

            }

        else

            {

            // authentication response message was NOT ok

            //   lets's see why that's the case 

            const SAuthenticationFixedFields* auth_fields 

                = reinterpret_cast<const SAuthenticationFixedFields*>

                  (reinterpret_cast<const TUint8*>(aFrame) + 

                   sizeof( SManagementFrameHeader ));

            TInt completion_code( KErrGeneral );

            if ( // is open mode authentication

                ( auth_fields->AlgorithmNumber() == used_auth_algorithm )

                // AND is authentication transaction sequence number expected

                && ( auth_fields->SequenceNumber() 

                == aCtxImpl.GetAuthSeqNmbrExpected())

                )

                {

                OsTracePrint( KWarningLevel | KUmacAuth, (TUint8*)

                    ("UMAC: dot11-openauthpending authentication denied") );

                OsTracePrint( KWarningLevel | KUmacAuth, (TUint8*)

                    ("UMAC: status code from frame: %d"), 

                    auth_fields->StatusCode() );

                if ( auth_fields->StatusCode() == E802Dot11StatusSuccess )

                    {

                    // catch a internal programming error

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

                        (TUint8*)(WLAN_FILE), __LINE__ );

                    }

                // status code was something else than status success

                completion_code = auth_fields->StatusCode();

                }

            else

                {

                // a malformed message, but it is a failure in any case

                OsTracePrint( KWarningLevel | KUmacAuth, (TUint8*)

                    ("UMAC: dot11-openauthpending authentication failure") );

                OsTracePrint( KWarningLevel | KUmacAuth, (TUint8*)

                    ("UMAC: auth message not valid") );

                }

            // set the completion code value returned to user mode

            // as the dot11idle state does the OID completion in this case

            aCtxImpl.iStates.iIdleState.Set( completion_code );

            }

        }

    else    // can we accept this frame

        {

        // not a valid type of frame 

        // or we are not in correct state 

        // so we shall discard it's processing

        }

    if ( iFlags & KAuthReceived )

        {

        // authentication response was received

        // either success or failure

        // we don't really care in this state

        Fsm( aCtxImpl, ERXAUTHRESPONSE );

        }

    }