diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/secman/btaccessrequesterstatemachine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btstack/secman/btaccessrequesterstatemachine.cpp Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,1251 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// + +#include + +#include "secman.h" +#include "secevent.h" +#include "btaccessrequesterstatemachine.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, LOG_COMPONENT_SECMAN); +#endif + + +void Panic(TBTFlyStateMachinePanic aPanic) + { + User::Panic(KBTFlyStateStateMachine, aPanic); + } + + +// This is the separation between the action and the constructors of the states. + +CBTAccessRequesterStateFactory* CBTAccessRequesterStateFactory::NewL() + { + LOG_STATIC_FUNC + CBTAccessRequesterStateFactory* self = CBTAccessRequesterStateFactory::NewLC(); + CleanupStack::Pop(self); + return self; + } + +CBTAccessRequesterStateFactory* CBTAccessRequesterStateFactory::NewLC() + { + LOG_STATIC_FUNC + CBTAccessRequesterStateFactory* self = new(ELeave) CBTAccessRequesterStateFactory(); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + + +CBTAccessRequesterStateFactory::~CBTAccessRequesterStateFactory() + { + LOG_FUNC + iStateActions.ResetAndDestroy(); + } + +CBTAccessRequesterStateFactory::CBTAccessRequesterStateFactory() + { + LOG_FUNC + } + +void CBTAccessRequesterStateFactory::ConstructL() + { + LOG_FUNC + + for(TInt i=EBTUninitialised;i(i)); + CleanupStack::PushL(ptr); + iStateActions.AppendL(ptr); + CleanupStack::Pop(); + } + } + + + +TInt CBTAccessRequesterStateFactory::ProcessRequesterState(TBTAccessRequesterState aState, CBTAccessRequester& aRequester, TBTSecEvent& aEvent) + { + LOG_FUNC + + TInt ret = KErrNotFound; + + TBTAccessRequesterState nextState = iStateActions[aState]->GetNextState(aEvent.Event()); + if(nextState != EBTUnknownState) + { + LOG(_L8("\tState transition FOUND!")); + // We should ensure that at each iteration through the state machine the requirements + // are up-to-date. This is needed as the physical link may have changed + // some internal state e.g. as a result of the Registry having been modified. + ret = EBTSecManAccessDenied; + if(!aRequester.RequirementsDenied()) + { + ret = KErrNone; + if(nextState != EBTNopState) + { + aRequester.SetCurrentState(nextState); + iStateActions[nextState]->ExecuteAction(aRequester, aEvent); + } + } + } + + return ret; + } + +CBTBaseStateAction* CBTAccessRequesterStateFactory::GetStateL(TBTAccessRequesterState aState) + { + LOG_FUNC + + LOG1(_L8("\taState = %d"),aState); + CBTBaseStateAction* ptr = NULL; + switch(aState) + { + case EBTUninitialised: + ptr = CBTUninitialisedState::NewL(aState); + break; + + case EBTReady: + ptr = CBTReadyState::NewL(aState); + break; + + case EBTWaiting: + ptr = CBTWaitingState::NewL(aState); + break; + + case EBTPhysicalLinkUp: + ptr = CBTPhysicalLinkUpState::NewL(aState); + break; + + case EBTAuthenticationRequested: + ptr = CBTAuthenticationRequestedState::NewL(aState); + break; + + case EBTRequestAuthentication: + ptr = CBTRequestAuthenticationState::NewL(aState); + break; + + case EBTAuthenticationComplete: + ptr = CBTAuthenticationCompleteState::NewL(aState); + break; + + case EBTEncryptionChangePending: + ptr = CBTEncryptionChangePendingState::NewL(aState); + break; + + case EBTEncryptionChangeComplete: + ptr = CBTEncryptionChangeCompleteState::NewL(aState); + break; + + case EBTAuthorisationRequested: + ptr = CBTAuthorisationRequestedState::NewL(aState); + break; + + case EBTRequestAuthorisation: + ptr = CBTRequestAuthorisationState::NewL(aState); + break; + + case EBTAuthorisationComplete: + ptr = CBTAuthorisationCompleteState::NewL(aState); + break; + + // Simple Pairing actions + case EBTIOCapsResponse: + ptr = CBTIOCapsResponseState::NewL(aState); + break; + + case EBTIOCapsRequested: + ptr = CBTIOCapsRequestedState::NewL(aState); + break; + + case EBTUserConfirmation: + ptr = CBTUserConfirmationState::NewL(aState); + break; + + case EBTPasskeyEntry: + ptr = CBTPasskeyEntryState::NewL(aState); + break; + + case EBTRemoteOOBDataRequest: + ptr = CBTRemoteOOBDataRequestState::NewL(aState); + break; + + case EBTSimplePairingPending: + ptr = CBTSimplePairingPendingState::NewL(aState); + break; + + case EBTPrefetchZombie: + ptr = CBTPrefetchZombieState::NewL(aState); + break; + + default: + __ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyUnknowState)); + break; + }//end switch + + return ptr; + } + + +/*********************** SECOND GENERATION CODE ************/ + +/** +class CBTBaseStateAction +*/ +CBTBaseStateAction* CBTBaseStateAction::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTBaseStateAction* self = CBTBaseStateAction::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTBaseStateAction* CBTBaseStateAction::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTBaseStateAction* self = new(ELeave) CBTBaseStateAction(aState); + CleanupStack::PushL(self); + return self; + } +CBTBaseStateAction::CBTBaseStateAction(TBTAccessRequesterState aState) +: iState(aState) + { + LOG_FUNC + } + + +CBTBaseStateAction::~CBTBaseStateAction() + { + LOG_FUNC + } + +/* virtual */void CBTBaseStateAction::ExecuteAction(CBTAccessRequester& /*aRequester*/,TBTSecEvent& /*aEvent*/) + { + LOG_FUNC + } + +/* virtual */TBTAccessRequesterState CBTBaseStateAction::GetNextState(TInt /*aEventId*/) + { + LOG_FUNC + return EBTUnknownState; + } + + +// CBTUninitialisedState +CBTUninitialisedState* CBTUninitialisedState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTUninitialisedState* self = CBTUninitialisedState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTUninitialisedState* CBTUninitialisedState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTUninitialisedState* self = new(ELeave) CBTUninitialisedState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTUninitialisedState::~CBTUninitialisedState() + { + LOG_FUNC + } + +void CBTUninitialisedState::ExecuteAction(CBTAccessRequester& /*aRequester*/,TBTSecEvent& /*aEvent*/) + { + LOG_FUNC + //this should never be called + __ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyMismatchExecuteActionState)); + } + +TBTAccessRequesterState CBTUninitialisedState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + switch(aEventId) + { + case TBTSecEvent::EStart: + state = EBTWaiting; + break; + case TBTSecEvent::EPhysicalLinkUp: + state = EBTPhysicalLinkUp; + break; + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + +/** +class CBTWaitingState +*/ +CBTWaitingState* CBTWaitingState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTWaitingState* self = CBTWaitingState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTWaitingState* CBTWaitingState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTWaitingState* self = new(ELeave) CBTWaitingState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTWaitingState::~CBTWaitingState() + { + LOG_FUNC + } + +void CBTWaitingState::ExecuteAction(CBTAccessRequester& /*aRequester*/, TBTSecEvent& /*aEvent*/) + { + LOG_FUNC + // Nothing to do except wait for the next even. + } + +TBTAccessRequesterState CBTWaitingState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + switch(aEventId) + { + case TBTSecEvent::EPhysicalLinkUp: + state = EBTReady; + break; + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + //Handle the Encryption change event + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTPhysicalLinkUpState +*/ +CBTPhysicalLinkUpState* CBTPhysicalLinkUpState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPhysicalLinkUpState* self = CBTPhysicalLinkUpState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTPhysicalLinkUpState* CBTPhysicalLinkUpState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPhysicalLinkUpState* self = new(ELeave) CBTPhysicalLinkUpState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTPhysicalLinkUpState::~CBTPhysicalLinkUpState() + { + LOG_FUNC + } + +void CBTPhysicalLinkUpState::ExecuteAction(CBTAccessRequester& /*aRequester*/, TBTSecEvent& /*aEvent*/) + { + LOG_FUNC + // Nothing to do + } + +TBTAccessRequesterState CBTPhysicalLinkUpState::GetNextState(TInt aEventId) + { + LOG_FUNC + // This state the access requester is waiting to start - any other events + // are ignored for the moment. + TBTAccessRequesterState state = EBTPhysicalLinkUp; + switch(aEventId) + { + case TBTSecEvent::EStart: + state = EBTReady; + break; + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + +/** +class CBTReadyState +*/ +CBTReadyState* CBTReadyState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTReadyState* self = CBTReadyState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTReadyState* CBTReadyState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTReadyState* self = new(ELeave) CBTReadyState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTReadyState::~CBTReadyState() + { + LOG_FUNC + } + +void CBTReadyState::ExecuteAction(CBTAccessRequester& aRequester, TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.Ready(aEvent); + } + +TBTAccessRequesterState CBTReadyState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + switch(aEventId) + { + case TBTSecEvent::ERequestAuthentication: + state = EBTRequestAuthentication; + break; + + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EAuthenticationRequested: + state = EBTAuthenticationRequested; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + + +/** +class CBTAuthenticationRequestedState +*/ +CBTAuthenticationRequestedState* CBTAuthenticationRequestedState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthenticationRequestedState* self = CBTAuthenticationRequestedState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTAuthenticationRequestedState* CBTAuthenticationRequestedState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthenticationRequestedState* self = new(ELeave) CBTAuthenticationRequestedState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTAuthenticationRequestedState::~CBTAuthenticationRequestedState() + { + LOG_FUNC + } + +/* virtual */void CBTAuthenticationRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.AuthenticationRequested(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTAuthenticationRequestedState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EIOCapsResponse: + state = EBTIOCapsResponse; + break; + + case TBTSecEvent::EIOCapsRequested: + state = EBTIOCapsRequested; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + +/** +class CBTRequestAuthenticationState +*/ +CBTRequestAuthenticationState* CBTRequestAuthenticationState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRequestAuthenticationState* self = CBTRequestAuthenticationState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTRequestAuthenticationState* CBTRequestAuthenticationState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRequestAuthenticationState* self = new(ELeave) CBTRequestAuthenticationState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTRequestAuthenticationState::~CBTRequestAuthenticationState() + { + LOG_FUNC + } + +/* virtual */void CBTRequestAuthenticationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.RequestAuthentication(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTRequestAuthenticationState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EIOCapsResponse: + state = EBTIOCapsResponse; + break; + + case TBTSecEvent::EIOCapsRequested: + state = EBTIOCapsRequested; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + +/** +class CBTAuthenticationCompleteState +*/ +CBTAuthenticationCompleteState* CBTAuthenticationCompleteState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthenticationCompleteState* self = CBTAuthenticationCompleteState::NewLC(aState); + CleanupStack::Pop(self); + return self; + } + +CBTAuthenticationCompleteState* CBTAuthenticationCompleteState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthenticationCompleteState* self = new(ELeave) CBTAuthenticationCompleteState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTAuthenticationCompleteState::~CBTAuthenticationCompleteState() + { + LOG_FUNC + } + +/* virtual */void CBTAuthenticationCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.AuthenticationComplete(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTAuthenticationCompleteState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::ERequestEncryptionChange: //fall through + case TBTSecEvent::EEncryptionChangeRequested: + state = EBTEncryptionChangePending; + break; + + case TBTSecEvent::ERequestAuthentication: // for re-issue + state = EBTRequestAuthentication; + break; + case TBTSecEvent::EAuthenticationRequested: // maybe + state = EBTAuthenticationRequested; + break; + + case TBTSecEvent::EPhysicalLinkDown: + state = EBTPrefetchZombie; + break; + } + return state; + } + + +/** +class CBTEncryptionChangePendingState +*/ +CBTEncryptionChangePendingState* CBTEncryptionChangePendingState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTEncryptionChangePendingState* self = CBTEncryptionChangePendingState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTEncryptionChangePendingState* CBTEncryptionChangePendingState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTEncryptionChangePendingState* self = new(ELeave) CBTEncryptionChangePendingState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTEncryptionChangePendingState::~CBTEncryptionChangePendingState() + { + LOG_FUNC + } + +/* virtual */void CBTEncryptionChangePendingState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.EncryptionChangePending(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTEncryptionChangePendingState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTEncryptionChangeComplete; + break; + } + return state; + } + + +/** +class CBTEncryptionChangeCompleteState +*/ +CBTEncryptionChangeCompleteState* CBTEncryptionChangeCompleteState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTEncryptionChangeCompleteState* self = CBTEncryptionChangeCompleteState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTEncryptionChangeCompleteState* CBTEncryptionChangeCompleteState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTEncryptionChangeCompleteState* self = new(ELeave) CBTEncryptionChangeCompleteState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTEncryptionChangeCompleteState::~CBTEncryptionChangeCompleteState() + { + LOG_FUNC + } + +/* virtual */void CBTEncryptionChangeCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.EncryptionChangeComplete(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTEncryptionChangeCompleteState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::ERequestEncryptionChange: + state = EBTEncryptionChangePending; + break; + + case TBTSecEvent::ERequestAuthorisation: + state = EBTRequestAuthorisation; + break; + } + return state; + } + + +/** +class CBTAuthorisationRequestedState +*/ +CBTAuthorisationRequestedState* CBTAuthorisationRequestedState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthorisationRequestedState* self = CBTAuthorisationRequestedState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTAuthorisationRequestedState* CBTAuthorisationRequestedState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthorisationRequestedState* self = new(ELeave) CBTAuthorisationRequestedState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTAuthorisationRequestedState::~CBTAuthorisationRequestedState() + { + LOG_FUNC + } + +/* virtual */void CBTAuthorisationRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.AuthorisationRequested(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTAuthorisationRequestedState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthorisationComplete: + state = EBTAuthorisationComplete; + break; + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTRequestAuthorisationState +*/ +CBTRequestAuthorisationState* CBTRequestAuthorisationState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRequestAuthorisationState* self = CBTRequestAuthorisationState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTRequestAuthorisationState* CBTRequestAuthorisationState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRequestAuthorisationState* self = new(ELeave) CBTRequestAuthorisationState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTRequestAuthorisationState::~CBTRequestAuthorisationState() + { + LOG_FUNC + } + +/* virtual */void CBTRequestAuthorisationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.RequestAuthorisation(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTRequestAuthorisationState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthorisationRequested: + state = EBTAuthorisationRequested; + break; + + case TBTSecEvent::EAuthorisationComplete: + state = EBTAuthorisationComplete; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTAuthorisationCompleteState +*/ +CBTAuthorisationCompleteState* CBTAuthorisationCompleteState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthorisationCompleteState* self = CBTAuthorisationCompleteState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTAuthorisationCompleteState* CBTAuthorisationCompleteState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTAuthorisationCompleteState* self = new(ELeave) CBTAuthorisationCompleteState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTAuthorisationCompleteState::~CBTAuthorisationCompleteState() + { + LOG_FUNC + } + +/* virtual */void CBTAuthorisationCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.AuthorisationComplete(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTAuthorisationCompleteState::GetNextState(TInt /*aEventId*/) + { + LOG_FUNC + __ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyUnknowNextState)); + return EBTUnknownState; + } + + +/** +class CBTIOCapsResponseState +*/ +CBTIOCapsResponseState* CBTIOCapsResponseState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTIOCapsResponseState* self = CBTIOCapsResponseState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTIOCapsResponseState* CBTIOCapsResponseState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTIOCapsResponseState* self = new(ELeave) CBTIOCapsResponseState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTIOCapsResponseState::~CBTIOCapsResponseState() + { + LOG_FUNC + } + +/* virtual */void CBTIOCapsResponseState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.IOCapsResponse(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTIOCapsResponseState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EIOCapsRequested: + state = EBTIOCapsRequested; + break; + + case TBTSecEvent::EUserConfirmationRequested: + state = EBTUserConfirmation; + break; + + case TBTSecEvent::EPasskeyNotfication: + state = EBTPasskeyEntry; + break; + + case TBTSecEvent::ERemoteOOBDataRequested: + state = EBTRemoteOOBDataRequest; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTIOCapsRequestedState +*/ +CBTIOCapsRequestedState* CBTIOCapsRequestedState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTIOCapsRequestedState* self = CBTIOCapsRequestedState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTIOCapsRequestedState* CBTIOCapsRequestedState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTIOCapsRequestedState* self = new(ELeave) CBTIOCapsRequestedState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTIOCapsRequestedState::~CBTIOCapsRequestedState() + { + LOG_FUNC + } + +/* virtual */void CBTIOCapsRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.IOCapsRequested(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTIOCapsRequestedState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EIOCapsResponse: + state = EBTIOCapsResponse; + break; + + case TBTSecEvent::EUserConfirmationRequested: + state = EBTUserConfirmation; + break; + + case TBTSecEvent::EPasskeyNotfication: + state = EBTPasskeyEntry; + break; + + case TBTSecEvent::ERemoteOOBDataRequested: + state = EBTRemoteOOBDataRequest; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTUserConfirmationState +*/ +CBTUserConfirmationState* CBTUserConfirmationState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTUserConfirmationState* self = CBTUserConfirmationState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTUserConfirmationState* CBTUserConfirmationState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTUserConfirmationState* self = new(ELeave) CBTUserConfirmationState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTUserConfirmationState::~CBTUserConfirmationState() + { + LOG_FUNC + } + +/* virtual */void CBTUserConfirmationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.UserConfirmation(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTUserConfirmationState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EUserConfirmationRequestComplete: + state = EBTSimplePairingPending; + break; + + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTPasskeyEntryState +*/ +CBTPasskeyEntryState* CBTPasskeyEntryState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPasskeyEntryState* self = CBTPasskeyEntryState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTPasskeyEntryState* CBTPasskeyEntryState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPasskeyEntryState* self = new(ELeave) CBTPasskeyEntryState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTPasskeyEntryState::~CBTPasskeyEntryState() + { + LOG_FUNC + } + +/* virtual */void CBTPasskeyEntryState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.PasskeyEntry(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTPasskeyEntryState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EKeypressEntry: + state = EBTPasskeyEntry; + break; + + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::EKeypressComplete: + state = EBTSimplePairingPending; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTRemoteOOBDataRequestState +*/ +CBTRemoteOOBDataRequestState* CBTRemoteOOBDataRequestState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRemoteOOBDataRequestState* self = CBTRemoteOOBDataRequestState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTRemoteOOBDataRequestState* CBTRemoteOOBDataRequestState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTRemoteOOBDataRequestState* self = new(ELeave) CBTRemoteOOBDataRequestState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTRemoteOOBDataRequestState::~CBTRemoteOOBDataRequestState() + { + LOG_FUNC + } + +/* virtual */void CBTRemoteOOBDataRequestState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.RemoteOOBDataRequest(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTRemoteOOBDataRequestState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + + case TBTSecEvent::ERemoteOOBDataRequestComplete: + state = EBTSimplePairingPending; + break; + + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTSimplePairingPendingState +*/ +CBTSimplePairingPendingState* CBTSimplePairingPendingState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTSimplePairingPendingState* self = CBTSimplePairingPendingState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTSimplePairingPendingState* CBTSimplePairingPendingState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTSimplePairingPendingState* self = new(ELeave) CBTSimplePairingPendingState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTSimplePairingPendingState::~CBTSimplePairingPendingState() + { + LOG_FUNC + } + +/* virtual */void CBTSimplePairingPendingState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent) + { + LOG_FUNC + aRequester.SimplePairingPending(aEvent); + } + +/* virtual */TBTAccessRequesterState CBTSimplePairingPendingState::GetNextState(TInt aEventId) + { + LOG_FUNC + TBTAccessRequesterState state = EBTUnknownState; + + switch(aEventId) + { + case TBTSecEvent::EKeypressEntry: + // Although display is finished - keypresses can be received still (as + // authentication may still be in progress.) + state = EBTPasskeyEntry; + break; + case TBTSecEvent::EAuthenticationComplete: + state = EBTAuthenticationComplete; + break; + case TBTSecEvent::EEncryptionChangeComplete: + state = EBTNopState; + break; + } + return state; + } + + +/** +class CBTPrefetchZombieState +*/ +CBTPrefetchZombieState* CBTPrefetchZombieState::NewL(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPrefetchZombieState* self = CBTPrefetchZombieState::NewLC(aState); + CleanupStack::Pop(); //self + return self; + } + +CBTPrefetchZombieState* CBTPrefetchZombieState::NewLC(TBTAccessRequesterState aState) + { + LOG_STATIC_FUNC + CBTPrefetchZombieState* self = new(ELeave) CBTPrefetchZombieState(aState); + CleanupStack::PushL(self); + return self; + } + +CBTPrefetchZombieState::~CBTPrefetchZombieState() + { + LOG_FUNC + } + +void CBTPrefetchZombieState::ExecuteAction(CBTAccessRequester& /*aRequester*/, TBTSecEvent& /*aEvent*/) + { + LOG_FUNC + // Do nothing this state swallows all events as the requester is a member of the living dead. + } + +TBTAccessRequesterState CBTPrefetchZombieState::GetNextState(TInt /*aEventId*/) + { + LOG_FUNC + // Once dead, remain dead + return EBTPrefetchZombie; + }