diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanldd/wlan_common/umac_common/src/UmacDot11OpenAuthPending.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanldd/wlan_common/umac_common/src/UmacDot11OpenAuthPending.cpp Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,263 @@ +/* +* 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(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 + (reinterpret_cast(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 ); + } + }