1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <bluetooth/logger.h>

    17 

    18 #include "secman.h"

    19 #include "secevent.h"

    20 #include "btaccessrequesterstatemachine.h"

    21 

    22 #ifdef __FLOG_ACTIVE

    23 _LIT8(KLogComponent, LOG_COMPONENT_SECMAN);

    24 #endif

    25 

    26 

    27 void Panic(TBTFlyStateMachinePanic aPanic)

    28 	{

    29 	User::Panic(KBTFlyStateStateMachine, aPanic);

    30 	}

    31 

    32 

    33 // This is the separation between the action and the constructors of the states.

    34 

    35 CBTAccessRequesterStateFactory* CBTAccessRequesterStateFactory::NewL()

    36 	{

    37 	LOG_STATIC_FUNC

    38 	CBTAccessRequesterStateFactory* self = CBTAccessRequesterStateFactory::NewLC();

    39 	CleanupStack::Pop(self);

    40 	return self;

    41 	}

    42 

    43 CBTAccessRequesterStateFactory* CBTAccessRequesterStateFactory::NewLC()

    44 	{

    45 	LOG_STATIC_FUNC

    46 	CBTAccessRequesterStateFactory* self = new(ELeave) CBTAccessRequesterStateFactory();

    47 	CleanupStack::PushL(self);

    48 	self->ConstructL();

    49 	return self;

    50 	}

    51 

    52 

    53 CBTAccessRequesterStateFactory::~CBTAccessRequesterStateFactory()

    54 	{

    55 	LOG_FUNC

    56 	iStateActions.ResetAndDestroy();

    57 	}

    58 

    59 CBTAccessRequesterStateFactory::CBTAccessRequesterStateFactory()

    60 	{

    61 	LOG_FUNC

    62 	}

    63 

    64 void CBTAccessRequesterStateFactory::ConstructL()

    65 	{

    66 	LOG_FUNC

    67 

    68 	for(TInt i=EBTUninitialised;i<EBTMaximumStateNumber;i++)

    69 		{

    70 		CBTBaseStateAction* ptr = GetStateL(static_cast<TBTAccessRequesterState>(i));

    71 		CleanupStack::PushL(ptr);

    72 		iStateActions.AppendL(ptr);

    73 		CleanupStack::Pop();

    74 		}

    75 	}

    76 

    77 

    78 

    79 TInt CBTAccessRequesterStateFactory::ProcessRequesterState(TBTAccessRequesterState aState, CBTAccessRequester& aRequester, TBTSecEvent& aEvent)

    80 	{

    81 	LOG_FUNC

    82 

    83 	TInt ret = KErrNotFound;

    84 

    85 	TBTAccessRequesterState nextState = iStateActions[aState]->GetNextState(aEvent.Event());

    86 	if(nextState != EBTUnknownState)

    87 		{

    88 		LOG(_L8("\tState transition FOUND!"));

    89 		// We should ensure that at each iteration through the state machine the requirements

    90 		// are up-to-date. This is needed as the physical link may have changed

    91 		// some internal state e.g. as a result of the Registry having been modified.

    92 		ret = EBTSecManAccessDenied;

    93 		if(!aRequester.RequirementsDenied())

    94 			{

    95 			ret = KErrNone;

    96 			if(nextState != EBTNopState)

    97 				{

    98 				aRequester.SetCurrentState(nextState);

    99 				iStateActions[nextState]->ExecuteAction(aRequester, aEvent);

   100 				}

   101 			}

   102 		}

   103 

   104 	return ret;

   105 	}

   106 

   107 CBTBaseStateAction* CBTAccessRequesterStateFactory::GetStateL(TBTAccessRequesterState aState)

   108 	{

   109 	LOG_FUNC

   110 

   111 	LOG1(_L8("\taState = %d"),aState);

   112 	CBTBaseStateAction* ptr = NULL;

   113 	switch(aState)

   114 		{

   115 	case EBTUninitialised:

   116 		ptr = CBTUninitialisedState::NewL(aState);

   117 		break;

   118 

   119 	case EBTReady:

   120 		ptr = CBTReadyState::NewL(aState);

   121 		break;

   122 

   123 	case EBTWaiting:

   124 		ptr = CBTWaitingState::NewL(aState);

   125 		break;

   126 

   127 	case EBTPhysicalLinkUp:

   128 		ptr = CBTPhysicalLinkUpState::NewL(aState);

   129 		break;

   130 

   131 	case EBTAuthenticationRequested:

   132 		ptr = CBTAuthenticationRequestedState::NewL(aState);

   133 		break;

   134 

   135 	case EBTRequestAuthentication:

   136 		ptr = CBTRequestAuthenticationState::NewL(aState);

   137 		break;

   138 

   139 	case EBTAuthenticationComplete:

   140 		ptr = CBTAuthenticationCompleteState::NewL(aState);

   141 		break;

   142 

   143 	case EBTEncryptionChangePending:

   144 		ptr = CBTEncryptionChangePendingState::NewL(aState);

   145 		break;

   146 

   147 	case EBTEncryptionChangeComplete:

   148 		ptr = CBTEncryptionChangeCompleteState::NewL(aState);

   149 		break;

   150 

   151 	case EBTAuthorisationRequested:

   152 		ptr = CBTAuthorisationRequestedState::NewL(aState);

   153 		break;

   154 

   155 	case EBTRequestAuthorisation:

   156 		ptr = CBTRequestAuthorisationState::NewL(aState);

   157 		break;

   158 

   159 	case EBTAuthorisationComplete:

   160 		ptr = CBTAuthorisationCompleteState::NewL(aState);

   161 		break;

   162 

   163 	// Simple Pairing actions

   164 	case EBTIOCapsResponse:

   165 		ptr = CBTIOCapsResponseState::NewL(aState);

   166 		break;

   167 

   168 	case EBTIOCapsRequested:

   169 		ptr = CBTIOCapsRequestedState::NewL(aState);

   170 		break;

   171 

   172 	case EBTUserConfirmation:

   173 		ptr = CBTUserConfirmationState::NewL(aState);

   174 		break;

   175 

   176 	case EBTPasskeyEntry:

   177 		ptr = CBTPasskeyEntryState::NewL(aState);

   178 		break;

   179 

   180 	case EBTRemoteOOBDataRequest:

   181 		ptr = CBTRemoteOOBDataRequestState::NewL(aState);

   182 		break;

   183 

   184 	case EBTSimplePairingPending:

   185 		ptr = CBTSimplePairingPendingState::NewL(aState);

   186 		break;

   187 

   188 	case EBTPrefetchZombie:

   189 		ptr = CBTPrefetchZombieState::NewL(aState);

   190 		break;

   191 

   192 	default:

   193 		__ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyUnknowState));

   194 		break;

   195 		}//end switch

   196 

   197 	return ptr;

   198 	}

   199 

   200 

   201 /*********************** SECOND GENERATION CODE ************/

   202 

   203 /**

   204 class CBTBaseStateAction

   205 */

   206 CBTBaseStateAction* CBTBaseStateAction::NewL(TBTAccessRequesterState aState)

   207 	{

   208 	LOG_STATIC_FUNC

   209 	CBTBaseStateAction* self = CBTBaseStateAction::NewLC(aState);

   210 	CleanupStack::Pop();	//self

   211 	return self;

   212 	}

   213 

   214 CBTBaseStateAction* CBTBaseStateAction::NewLC(TBTAccessRequesterState aState)

   215 	{

   216 	LOG_STATIC_FUNC

   217 	CBTBaseStateAction* self = new(ELeave) CBTBaseStateAction(aState);

   218 	CleanupStack::PushL(self);

   219 	return self;

   220 	}

   221 CBTBaseStateAction::CBTBaseStateAction(TBTAccessRequesterState aState)

   222 : iState(aState)

   223 	{

   224 	LOG_FUNC

   225 	}

   226 

   227 

   228 CBTBaseStateAction::~CBTBaseStateAction()

   229 	{

   230 	LOG_FUNC

   231 	}

   232 

   233 /* virtual */void CBTBaseStateAction::ExecuteAction(CBTAccessRequester& /*aRequester*/,TBTSecEvent& /*aEvent*/)

   234 	{

   235 	LOG_FUNC

   236 	}

   237 

   238 /* virtual */TBTAccessRequesterState CBTBaseStateAction::GetNextState(TInt /*aEventId*/)

   239 	{

   240 	LOG_FUNC

   241 	return EBTUnknownState;

   242 	}

   243 

   244 

   245 // CBTUninitialisedState

   246 CBTUninitialisedState* CBTUninitialisedState::NewL(TBTAccessRequesterState aState)

   247 	{

   248 	LOG_STATIC_FUNC

   249 	CBTUninitialisedState* self = CBTUninitialisedState::NewLC(aState);

   250 	CleanupStack::Pop();	//self

   251 	return self;

   252 	}

   253 

   254 CBTUninitialisedState* CBTUninitialisedState::NewLC(TBTAccessRequesterState aState)

   255 	{

   256 	LOG_STATIC_FUNC

   257 	CBTUninitialisedState* self = new(ELeave) CBTUninitialisedState(aState);

   258 	CleanupStack::PushL(self);

   259 	return self;

   260 	}

   261 

   262 CBTUninitialisedState::~CBTUninitialisedState()

   263 	{

   264 	LOG_FUNC

   265 	}

   266 

   267 void CBTUninitialisedState::ExecuteAction(CBTAccessRequester& /*aRequester*/,TBTSecEvent& /*aEvent*/)

   268 	{

   269 	LOG_FUNC

   270 	//this should never be called

   271 	__ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyMismatchExecuteActionState));

   272 	}

   273 

   274 TBTAccessRequesterState CBTUninitialisedState::GetNextState(TInt aEventId)

   275 	{

   276 	LOG_FUNC

   277 	TBTAccessRequesterState state = EBTUnknownState;

   278 	switch(aEventId)

   279 		{

   280 	case TBTSecEvent::EStart:

   281 		state = EBTWaiting;

   282 		break;

   283 	case TBTSecEvent::EPhysicalLinkUp:

   284 		state = EBTPhysicalLinkUp;

   285 		break;

   286 	case TBTSecEvent::EPhysicalLinkDown:

   287 		state = EBTPrefetchZombie;

   288 		break;

   289 		}

   290 	return state;

   291 	}

   292 

   293 

   294 /**

   295 class CBTWaitingState

   296 */

   297 CBTWaitingState* CBTWaitingState::NewL(TBTAccessRequesterState aState)

   298 	{

   299 	LOG_STATIC_FUNC

   300 	CBTWaitingState* self = CBTWaitingState::NewLC(aState);

   301 	CleanupStack::Pop();	//self

   302 	return self;

   303 	}

   304 

   305 CBTWaitingState* CBTWaitingState::NewLC(TBTAccessRequesterState aState)

   306 	{

   307 	LOG_STATIC_FUNC

   308 	CBTWaitingState* self = new(ELeave) CBTWaitingState(aState);

   309 	CleanupStack::PushL(self);

   310 	return self;

   311 	}

   312 

   313 CBTWaitingState::~CBTWaitingState()

   314 	{

   315 	LOG_FUNC

   316 	}

   317 

   318 void CBTWaitingState::ExecuteAction(CBTAccessRequester& /*aRequester*/, TBTSecEvent& /*aEvent*/)

   319 	{

   320 	LOG_FUNC

   321 	// Nothing to do except wait for the next even.

   322 	}

   323 

   324 TBTAccessRequesterState CBTWaitingState::GetNextState(TInt aEventId)

   325 	{

   326 	LOG_FUNC

   327 	TBTAccessRequesterState state = EBTUnknownState;

   328 	switch(aEventId)

   329 		{

   330 	case TBTSecEvent::EPhysicalLinkUp:

   331 		state = EBTReady;

   332 		break;

   333 	case TBTSecEvent::EPhysicalLinkDown:

   334 		state = EBTPrefetchZombie;

   335 		break;

   336 	//Handle the Encryption change event

   337 	case TBTSecEvent::EEncryptionChangeComplete:

   338 		state = EBTNopState;

   339 		break;

   340 		}

   341 	return state;

   342 	}

   343 

   344 

   345 /**

   346 class CBTPhysicalLinkUpState

   347 */

   348 CBTPhysicalLinkUpState* CBTPhysicalLinkUpState::NewL(TBTAccessRequesterState aState)

   349 	{

   350 	LOG_STATIC_FUNC

   351 	CBTPhysicalLinkUpState* self = CBTPhysicalLinkUpState::NewLC(aState);

   352 	CleanupStack::Pop();	//self

   353 	return self;

   354 	}

   355 

   356 CBTPhysicalLinkUpState* CBTPhysicalLinkUpState::NewLC(TBTAccessRequesterState aState)

   357 	{

   358 	LOG_STATIC_FUNC

   359 	CBTPhysicalLinkUpState* self = new(ELeave) CBTPhysicalLinkUpState(aState);

   360 	CleanupStack::PushL(self);

   361 	return self;

   362 	}

   363 

   364 CBTPhysicalLinkUpState::~CBTPhysicalLinkUpState()

   365 	{

   366 	LOG_FUNC

   367 	}

   368 

   369 void CBTPhysicalLinkUpState::ExecuteAction(CBTAccessRequester& /*aRequester*/, TBTSecEvent& /*aEvent*/)

   370 	{

   371 	LOG_FUNC

   372 	// Nothing to do

   373 	}

   374 

   375 TBTAccessRequesterState CBTPhysicalLinkUpState::GetNextState(TInt aEventId)

   376 	{

   377 	LOG_FUNC

   378 	// This state the access requester is waiting to start - any other events

   379 	// are ignored for the moment.

   380 	TBTAccessRequesterState state = EBTPhysicalLinkUp;

   381 	switch(aEventId)

   382 		{

   383 	case TBTSecEvent::EStart:

   384 		state = EBTReady;

   385 		break;

   386 	case TBTSecEvent::EEncryptionChangeComplete:

   387 		state = EBTNopState;

   388 		break;

   389 	case TBTSecEvent::EPhysicalLinkDown:

   390 		state = EBTPrefetchZombie;

   391 		break;

   392 		}

   393 	return state;

   394 	}

   395 

   396 

   397 /**

   398 class CBTReadyState

   399 */

   400 CBTReadyState* CBTReadyState::NewL(TBTAccessRequesterState aState)

   401 	{

   402 	LOG_STATIC_FUNC

   403 	CBTReadyState* self = CBTReadyState::NewLC(aState);

   404 	CleanupStack::Pop();	//self

   405 	return self;

   406 	}

   407 

   408 CBTReadyState* CBTReadyState::NewLC(TBTAccessRequesterState aState)

   409 	{

   410 	LOG_STATIC_FUNC

   411 	CBTReadyState* self = new(ELeave) CBTReadyState(aState);

   412 	CleanupStack::PushL(self);

   413 	return self;

   414 	}

   415 

   416 CBTReadyState::~CBTReadyState()

   417 	{

   418 	LOG_FUNC

   419 	}

   420 

   421 void CBTReadyState::ExecuteAction(CBTAccessRequester& aRequester, TBTSecEvent& aEvent)

   422 	{

   423 	LOG_FUNC

   424 	aRequester.Ready(aEvent);

   425 	}

   426 

   427 TBTAccessRequesterState CBTReadyState::GetNextState(TInt aEventId)

   428 	{

   429 	LOG_FUNC

   430 	TBTAccessRequesterState state = EBTUnknownState;

   431 	switch(aEventId)

   432 		{

   433 	case TBTSecEvent::ERequestAuthentication:

   434 		state = EBTRequestAuthentication;

   435 		break;

   436 

   437 	case TBTSecEvent::EAuthenticationComplete:

   438 		state = EBTAuthenticationComplete;

   439 		break;

   440 

   441 	case TBTSecEvent::EAuthenticationRequested:

   442 		state = EBTAuthenticationRequested;

   443 		break;

   444 		

   445 	case TBTSecEvent::EEncryptionChangeComplete:

   446 		state = EBTNopState;

   447 		break;

   448 

   449 	case TBTSecEvent::EPhysicalLinkDown:

   450 		state = EBTPrefetchZombie;

   451 		break;

   452 		}

   453 	return state;

   454 	}

   455 

   456 

   457 

   458 /**

   459 class CBTAuthenticationRequestedState

   460 */

   461 CBTAuthenticationRequestedState* CBTAuthenticationRequestedState::NewL(TBTAccessRequesterState aState)

   462 	{

   463 	LOG_STATIC_FUNC

   464 	CBTAuthenticationRequestedState* self = CBTAuthenticationRequestedState::NewLC(aState);

   465 	CleanupStack::Pop();	//self

   466 	return self;

   467 	}

   468 

   469 CBTAuthenticationRequestedState* CBTAuthenticationRequestedState::NewLC(TBTAccessRequesterState aState)

   470 	{

   471 	LOG_STATIC_FUNC

   472 	CBTAuthenticationRequestedState* self = new(ELeave) CBTAuthenticationRequestedState(aState);

   473 	CleanupStack::PushL(self);

   474 	return self;

   475 	}

   476 

   477 CBTAuthenticationRequestedState::~CBTAuthenticationRequestedState()

   478 	{

   479 	LOG_FUNC

   480 	}

   481 

   482 /* virtual */void CBTAuthenticationRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   483 	{

   484 	LOG_FUNC

   485 	aRequester.AuthenticationRequested(aEvent);

   486 	}

   487 

   488 /* virtual */TBTAccessRequesterState CBTAuthenticationRequestedState::GetNextState(TInt aEventId)

   489 	{

   490 	LOG_FUNC

   491 	TBTAccessRequesterState state = EBTUnknownState;

   492 

   493 	switch(aEventId)

   494 		{

   495 	case TBTSecEvent::EAuthenticationComplete:

   496 		state = EBTAuthenticationComplete;

   497 		break;

   498 

   499 	case TBTSecEvent::EIOCapsResponse:

   500 		state = EBTIOCapsResponse;

   501 		break;

   502 

   503 	case TBTSecEvent::EIOCapsRequested:

   504 		state = EBTIOCapsRequested;

   505 		break;

   506 		

   507 	case TBTSecEvent::EEncryptionChangeComplete:

   508 		state = EBTNopState;

   509 		break;

   510 

   511 	case TBTSecEvent::EPhysicalLinkDown:

   512 		state = EBTPrefetchZombie;

   513 		break;

   514 		}

   515 	return state;

   516 	}

   517 

   518 

   519 /**

   520 class CBTRequestAuthenticationState

   521 */

   522 CBTRequestAuthenticationState* CBTRequestAuthenticationState::NewL(TBTAccessRequesterState aState)

   523 	{

   524 	LOG_STATIC_FUNC

   525 	CBTRequestAuthenticationState* self = CBTRequestAuthenticationState::NewLC(aState);

   526 	CleanupStack::Pop();	//self

   527 	return self;

   528 	}

   529 

   530 CBTRequestAuthenticationState* CBTRequestAuthenticationState::NewLC(TBTAccessRequesterState aState)

   531 	{

   532 	LOG_STATIC_FUNC

   533 	CBTRequestAuthenticationState* self = new(ELeave) CBTRequestAuthenticationState(aState);

   534 	CleanupStack::PushL(self);

   535 	return self;

   536 	}

   537 

   538 CBTRequestAuthenticationState::~CBTRequestAuthenticationState()

   539 	{

   540 	LOG_FUNC

   541 	}

   542 

   543 /* virtual */void CBTRequestAuthenticationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   544 	{

   545 	LOG_FUNC

   546 	aRequester.RequestAuthentication(aEvent);

   547 	}

   548 

   549 /* virtual */TBTAccessRequesterState CBTRequestAuthenticationState::GetNextState(TInt aEventId)

   550 	{

   551 	LOG_FUNC

   552 	TBTAccessRequesterState state = EBTUnknownState;

   553 

   554 	switch(aEventId)

   555 		{

   556 	case TBTSecEvent::EAuthenticationComplete:

   557 		state = EBTAuthenticationComplete;

   558 		break;

   559 

   560 	case TBTSecEvent::EIOCapsResponse:

   561 		state = EBTIOCapsResponse;

   562 		break;

   563 

   564 	case TBTSecEvent::EIOCapsRequested:

   565 		state = EBTIOCapsRequested;

   566 		break;

   567 		

   568 	case TBTSecEvent::EEncryptionChangeComplete:

   569 		state = EBTNopState;

   570 		break;

   571 

   572 	case TBTSecEvent::EPhysicalLinkDown:

   573 		state = EBTPrefetchZombie;

   574 		break;

   575 		}

   576 	return state;

   577 	}

   578 

   579 

   580 /**

   581 class CBTAuthenticationCompleteState

   582 */

   583 CBTAuthenticationCompleteState* CBTAuthenticationCompleteState::NewL(TBTAccessRequesterState aState)

   584 	{

   585 	LOG_STATIC_FUNC

   586 	CBTAuthenticationCompleteState* self = CBTAuthenticationCompleteState::NewLC(aState);

   587 	CleanupStack::Pop(self);

   588 	return self;

   589 	}

   590 

   591 CBTAuthenticationCompleteState* CBTAuthenticationCompleteState::NewLC(TBTAccessRequesterState aState)

   592 	{

   593 	LOG_STATIC_FUNC

   594 	CBTAuthenticationCompleteState* self = new(ELeave) CBTAuthenticationCompleteState(aState);

   595 	CleanupStack::PushL(self);

   596 	return self;

   597 	}

   598 

   599 CBTAuthenticationCompleteState::~CBTAuthenticationCompleteState()

   600 	{

   601 	LOG_FUNC

   602 	}

   603 

   604 /* virtual */void CBTAuthenticationCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   605 	{

   606 	LOG_FUNC

   607 	aRequester.AuthenticationComplete(aEvent);

   608 	}

   609 

   610 /* virtual */TBTAccessRequesterState CBTAuthenticationCompleteState::GetNextState(TInt aEventId)

   611 	{

   612 	LOG_FUNC

   613 	TBTAccessRequesterState state = EBTUnknownState;

   614 

   615 	switch(aEventId)

   616 		{

   617 	case TBTSecEvent::ERequestEncryptionChange: //fall through

   618 	case TBTSecEvent::EEncryptionChangeRequested:

   619 		state = EBTEncryptionChangePending;

   620 		break;

   621 	

   622 	case TBTSecEvent::ERequestAuthentication: // for re-issue

   623 		state = EBTRequestAuthentication;

   624 		break;

   625 	case TBTSecEvent::EAuthenticationRequested: // maybe

   626 		state = EBTAuthenticationRequested;

   627 		break;

   628 

   629 	case TBTSecEvent::EPhysicalLinkDown:

   630 		state = EBTPrefetchZombie;

   631 		break;

   632 		}

   633 	return state;

   634 	}

   635 

   636 

   637 /**

   638 class CBTEncryptionChangePendingState

   639 */

   640 CBTEncryptionChangePendingState* CBTEncryptionChangePendingState::NewL(TBTAccessRequesterState aState)

   641 	{

   642 	LOG_STATIC_FUNC

   643 	CBTEncryptionChangePendingState* self = CBTEncryptionChangePendingState::NewLC(aState);

   644 	CleanupStack::Pop();	//self

   645 	return self;

   646 	}

   647 

   648 CBTEncryptionChangePendingState* CBTEncryptionChangePendingState::NewLC(TBTAccessRequesterState aState)

   649 	{

   650 	LOG_STATIC_FUNC

   651 	CBTEncryptionChangePendingState* self = new(ELeave) CBTEncryptionChangePendingState(aState);

   652 	CleanupStack::PushL(self);

   653 	return self;

   654 	}

   655 

   656 CBTEncryptionChangePendingState::~CBTEncryptionChangePendingState()

   657 	{

   658 	LOG_FUNC

   659 	}

   660 

   661 /* virtual */void CBTEncryptionChangePendingState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   662 	{

   663 	LOG_FUNC

   664 	aRequester.EncryptionChangePending(aEvent);

   665 	}

   666 

   667 /* virtual */TBTAccessRequesterState CBTEncryptionChangePendingState::GetNextState(TInt aEventId)

   668 	{

   669 	LOG_FUNC

   670 	TBTAccessRequesterState state = EBTUnknownState;

   671 

   672 	switch(aEventId)

   673 		{

   674 	case TBTSecEvent::EEncryptionChangeComplete:

   675 		state = EBTEncryptionChangeComplete;

   676 		break;

   677 		}

   678 	return state;

   679 	}

   680 

   681 

   682 /**

   683 class CBTEncryptionChangeCompleteState

   684 */

   685 CBTEncryptionChangeCompleteState* CBTEncryptionChangeCompleteState::NewL(TBTAccessRequesterState aState)

   686 	{

   687 	LOG_STATIC_FUNC

   688 	CBTEncryptionChangeCompleteState* self = CBTEncryptionChangeCompleteState::NewLC(aState);

   689 	CleanupStack::Pop();	//self

   690 	return self;

   691 	}

   692 

   693 CBTEncryptionChangeCompleteState* CBTEncryptionChangeCompleteState::NewLC(TBTAccessRequesterState aState)

   694 	{

   695 	LOG_STATIC_FUNC

   696 	CBTEncryptionChangeCompleteState* self = new(ELeave) CBTEncryptionChangeCompleteState(aState);

   697 	CleanupStack::PushL(self);

   698 	return self;

   699 	}

   700 

   701 CBTEncryptionChangeCompleteState::~CBTEncryptionChangeCompleteState()

   702 	{

   703 	LOG_FUNC

   704 	}

   705 

   706 /* virtual */void CBTEncryptionChangeCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   707 	{

   708 	LOG_FUNC

   709 	aRequester.EncryptionChangeComplete(aEvent);

   710 	}

   711 

   712 /* virtual */TBTAccessRequesterState CBTEncryptionChangeCompleteState::GetNextState(TInt aEventId)

   713 	{

   714 	LOG_FUNC

   715 	TBTAccessRequesterState state = EBTUnknownState;

   716 

   717 	switch(aEventId)

   718 		{

   719 	case TBTSecEvent::ERequestEncryptionChange:

   720 		state = EBTEncryptionChangePending;

   721 		break;

   722 

   723 	case TBTSecEvent::ERequestAuthorisation:

   724 		state = EBTRequestAuthorisation;

   725 		break;

   726 		}

   727 	return state;

   728 	}

   729 

   730 

   731 /**

   732 class CBTAuthorisationRequestedState

   733 */

   734 CBTAuthorisationRequestedState* CBTAuthorisationRequestedState::NewL(TBTAccessRequesterState aState)

   735 	{

   736 	LOG_STATIC_FUNC

   737 	CBTAuthorisationRequestedState* self = CBTAuthorisationRequestedState::NewLC(aState);

   738 	CleanupStack::Pop();	//self

   739 	return self;

   740 	}

   741 

   742 CBTAuthorisationRequestedState* CBTAuthorisationRequestedState::NewLC(TBTAccessRequesterState aState)

   743 	{

   744 	LOG_STATIC_FUNC

   745 	CBTAuthorisationRequestedState* self = new(ELeave) CBTAuthorisationRequestedState(aState);

   746 	CleanupStack::PushL(self);

   747 	return self;

   748 	}

   749 

   750 CBTAuthorisationRequestedState::~CBTAuthorisationRequestedState()

   751 	{

   752 	LOG_FUNC

   753 	}

   754 

   755 /* virtual */void CBTAuthorisationRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   756 	{

   757 	LOG_FUNC

   758 	aRequester.AuthorisationRequested(aEvent);

   759 	}

   760 

   761 /* virtual */TBTAccessRequesterState CBTAuthorisationRequestedState::GetNextState(TInt aEventId)

   762 	{

   763 	LOG_FUNC

   764 	TBTAccessRequesterState state = EBTUnknownState;

   765 

   766 	switch(aEventId)

   767 		{

   768 	case TBTSecEvent::EAuthorisationComplete:

   769 		state = EBTAuthorisationComplete;

   770 		break;

   771 	case TBTSecEvent::EEncryptionChangeComplete:

   772 		state = EBTNopState;

   773 		break;

   774 		}

   775 	return state;

   776 	}

   777 

   778 

   779 /**

   780 class CBTRequestAuthorisationState

   781 */

   782 CBTRequestAuthorisationState* CBTRequestAuthorisationState::NewL(TBTAccessRequesterState aState)

   783 	{

   784 	LOG_STATIC_FUNC

   785 	CBTRequestAuthorisationState* self = CBTRequestAuthorisationState::NewLC(aState);

   786 	CleanupStack::Pop();	//self

   787 	return self;

   788 	}

   789 

   790 CBTRequestAuthorisationState* CBTRequestAuthorisationState::NewLC(TBTAccessRequesterState aState)

   791 	{

   792 	LOG_STATIC_FUNC

   793 	CBTRequestAuthorisationState* self = new(ELeave) CBTRequestAuthorisationState(aState);

   794 	CleanupStack::PushL(self);

   795 	return self;

   796 	}

   797 

   798 CBTRequestAuthorisationState::~CBTRequestAuthorisationState()

   799 	{

   800 	LOG_FUNC

   801 	}

   802 

   803 /* virtual */void CBTRequestAuthorisationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   804 	{

   805 	LOG_FUNC

   806 	aRequester.RequestAuthorisation(aEvent);

   807 	}

   808 

   809 /* virtual */TBTAccessRequesterState CBTRequestAuthorisationState::GetNextState(TInt aEventId)

   810 	{

   811 	LOG_FUNC

   812 	TBTAccessRequesterState state = EBTUnknownState;

   813 

   814 	switch(aEventId)

   815 		{

   816 	case TBTSecEvent::EAuthorisationRequested:

   817 		state = EBTAuthorisationRequested;

   818 		break;

   819 		

   820 	case TBTSecEvent::EAuthorisationComplete:

   821 		state = EBTAuthorisationComplete;

   822 		break;

   823 		

   824 	case TBTSecEvent::EEncryptionChangeComplete:

   825 		state = EBTNopState;

   826 		break;

   827 		}

   828 	return state;

   829 	}

   830 

   831 

   832 /**

   833 class CBTAuthorisationCompleteState

   834 */

   835 CBTAuthorisationCompleteState* CBTAuthorisationCompleteState::NewL(TBTAccessRequesterState aState)

   836 	{

   837 	LOG_STATIC_FUNC

   838 	CBTAuthorisationCompleteState* self = CBTAuthorisationCompleteState::NewLC(aState);

   839 	CleanupStack::Pop();	//self

   840 	return self;

   841 	}

   842 

   843 CBTAuthorisationCompleteState* CBTAuthorisationCompleteState::NewLC(TBTAccessRequesterState aState)

   844 	{

   845 	LOG_STATIC_FUNC

   846 	CBTAuthorisationCompleteState* self = new(ELeave) CBTAuthorisationCompleteState(aState);

   847 	CleanupStack::PushL(self);

   848 	return self;

   849 	}

   850 

   851 CBTAuthorisationCompleteState::~CBTAuthorisationCompleteState()

   852 	{

   853 	LOG_FUNC

   854 	}

   855 

   856 /* virtual */void CBTAuthorisationCompleteState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   857 	{

   858 	LOG_FUNC

   859 	aRequester.AuthorisationComplete(aEvent);

   860 	}

   861 

   862 /* virtual */TBTAccessRequesterState CBTAuthorisationCompleteState::GetNextState(TInt /*aEventId*/)

   863 	{

   864 	LOG_FUNC

   865 	__ASSERT_ALWAYS(0, User::Panic(KBTFlyStateStateMachine,EBTFlyUnknowNextState));

   866 	return EBTUnknownState;

   867 	}

   868 

   869 

   870 /**

   871 class CBTIOCapsResponseState

   872 */

   873 CBTIOCapsResponseState* CBTIOCapsResponseState::NewL(TBTAccessRequesterState aState)

   874 	{

   875 	LOG_STATIC_FUNC

   876 	CBTIOCapsResponseState* self = CBTIOCapsResponseState::NewLC(aState);

   877 	CleanupStack::Pop();	//self

   878 	return self;

   879 	}

   880 

   881 CBTIOCapsResponseState* CBTIOCapsResponseState::NewLC(TBTAccessRequesterState aState)

   882 	{

   883 	LOG_STATIC_FUNC

   884 	CBTIOCapsResponseState* self = new(ELeave) CBTIOCapsResponseState(aState);

   885 	CleanupStack::PushL(self);

   886 	return self;

   887 	}

   888 

   889 CBTIOCapsResponseState::~CBTIOCapsResponseState()

   890 	{

   891 	LOG_FUNC

   892 	}

   893 

   894 /* virtual */void CBTIOCapsResponseState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   895 	{

   896 	LOG_FUNC

   897 	aRequester.IOCapsResponse(aEvent);

   898 	}

   899 

   900 /* virtual */TBTAccessRequesterState CBTIOCapsResponseState::GetNextState(TInt aEventId)

   901 	{

   902 	LOG_FUNC

   903 	TBTAccessRequesterState state = EBTUnknownState;

   904 

   905 	switch(aEventId)

   906 		{

   907 	case TBTSecEvent::EAuthenticationComplete:

   908 		state = EBTAuthenticationComplete;

   909 		break;

   910 

   911 	case TBTSecEvent::EIOCapsRequested:

   912 		state = EBTIOCapsRequested;

   913 		break;

   914 

   915 	case TBTSecEvent::EUserConfirmationRequested:

   916 		state = EBTUserConfirmation;

   917 		break;

   918 

   919 	case TBTSecEvent::EPasskeyNotfication:

   920 		state = EBTPasskeyEntry;

   921 		break;

   922 

   923 	case TBTSecEvent::ERemoteOOBDataRequested:

   924 		state = EBTRemoteOOBDataRequest;

   925 		break;

   926 		

   927 	case TBTSecEvent::EEncryptionChangeComplete:

   928 		state = EBTNopState;

   929 		break;

   930 		}

   931 	return state;

   932 	}

   933 

   934 

   935 /**

   936 class CBTIOCapsRequestedState

   937 */

   938 CBTIOCapsRequestedState* CBTIOCapsRequestedState::NewL(TBTAccessRequesterState aState)

   939 	{

   940 	LOG_STATIC_FUNC

   941 	CBTIOCapsRequestedState* self = CBTIOCapsRequestedState::NewLC(aState);

   942 	CleanupStack::Pop();	//self

   943 	return self;

   944 	}

   945 

   946 CBTIOCapsRequestedState* CBTIOCapsRequestedState::NewLC(TBTAccessRequesterState aState)

   947 	{

   948 	LOG_STATIC_FUNC

   949 	CBTIOCapsRequestedState* self = new(ELeave) CBTIOCapsRequestedState(aState);

   950 	CleanupStack::PushL(self);

   951 	return self;

   952 	}

   953 

   954 CBTIOCapsRequestedState::~CBTIOCapsRequestedState()

   955 	{

   956 	LOG_FUNC

   957 	}

   958 

   959 /* virtual */void CBTIOCapsRequestedState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

   960 	{

   961 	LOG_FUNC

   962 	aRequester.IOCapsRequested(aEvent);

   963 	}

   964 

   965 /* virtual */TBTAccessRequesterState CBTIOCapsRequestedState::GetNextState(TInt aEventId)

   966 	{

   967 	LOG_FUNC

   968 	TBTAccessRequesterState state = EBTUnknownState;

   969 

   970 	switch(aEventId)

   971 		{

   972 	case TBTSecEvent::EAuthenticationComplete:

   973 		state = EBTAuthenticationComplete;

   974 		break;

   975 

   976 	case TBTSecEvent::EIOCapsResponse:

   977 		state = EBTIOCapsResponse;

   978 		break;

   979 

   980 	case TBTSecEvent::EUserConfirmationRequested:

   981 		state = EBTUserConfirmation;

   982 		break;

   983 

   984 	case TBTSecEvent::EPasskeyNotfication:

   985 		state = EBTPasskeyEntry;

   986 		break;

   987 

   988 	case TBTSecEvent::ERemoteOOBDataRequested:

   989 		state = EBTRemoteOOBDataRequest;

   990 		break;

   991 		

   992 	case TBTSecEvent::EEncryptionChangeComplete:

   993 		state = EBTNopState;

   994 		break;

   995 		}

   996 	return state;

   997 	}

   998 

   999 

  1000 /**

  1001 class CBTUserConfirmationState

  1002 */

  1003 CBTUserConfirmationState* CBTUserConfirmationState::NewL(TBTAccessRequesterState aState)

  1004 	{

  1005 	LOG_STATIC_FUNC

  1006 	CBTUserConfirmationState* self = CBTUserConfirmationState::NewLC(aState);

  1007 	CleanupStack::Pop();	//self

  1008 	return self;

  1009 	}

  1010 

  1011 CBTUserConfirmationState* CBTUserConfirmationState::NewLC(TBTAccessRequesterState aState)

  1012 	{

  1013 	LOG_STATIC_FUNC

  1014 	CBTUserConfirmationState* self = new(ELeave) CBTUserConfirmationState(aState);

  1015 	CleanupStack::PushL(self);

  1016 	return self;

  1017 	}

  1018 

  1019 CBTUserConfirmationState::~CBTUserConfirmationState()

  1020 	{

  1021 	LOG_FUNC

  1022 	}

  1023 

  1024 /* virtual */void CBTUserConfirmationState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

  1025 	{

  1026 	LOG_FUNC

  1027 	aRequester.UserConfirmation(aEvent);

  1028 	}

  1029 

  1030 /* virtual */TBTAccessRequesterState CBTUserConfirmationState::GetNextState(TInt aEventId)

  1031 	{

  1032 	LOG_FUNC

  1033 	TBTAccessRequesterState state = EBTUnknownState;

  1034 

  1035 	switch(aEventId)

  1036 		{

  1037 	case TBTSecEvent::EUserConfirmationRequestComplete:

  1038 		state = EBTSimplePairingPending;

  1039 		break;

  1040 

  1041 	case TBTSecEvent::EAuthenticationComplete:

  1042 		state = EBTAuthenticationComplete;

  1043 		break;

  1044 		

  1045 	case TBTSecEvent::EEncryptionChangeComplete:

  1046 		state = EBTNopState;

  1047 		break;

  1048 		}

  1049 	return state;

  1050 	}

  1051 

  1052 

  1053 /**

  1054 class CBTPasskeyEntryState

  1055 */

  1056 CBTPasskeyEntryState* CBTPasskeyEntryState::NewL(TBTAccessRequesterState aState)

  1057 	{

  1058 	LOG_STATIC_FUNC

  1059 	CBTPasskeyEntryState* self = CBTPasskeyEntryState::NewLC(aState);

  1060 	CleanupStack::Pop();	//self

  1061 	return self;

  1062 	}

  1063 

  1064 CBTPasskeyEntryState* CBTPasskeyEntryState::NewLC(TBTAccessRequesterState aState)

  1065 	{

  1066 	LOG_STATIC_FUNC

  1067 	CBTPasskeyEntryState* self = new(ELeave) CBTPasskeyEntryState(aState);

  1068 	CleanupStack::PushL(self);

  1069 	return self;

  1070 	}

  1071 

  1072 CBTPasskeyEntryState::~CBTPasskeyEntryState()

  1073 	{

  1074 	LOG_FUNC

  1075 	}

  1076 

  1077 /* virtual */void CBTPasskeyEntryState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

  1078 	{

  1079 	LOG_FUNC

  1080 	aRequester.PasskeyEntry(aEvent);

  1081 	}

  1082 

  1083 /* virtual */TBTAccessRequesterState CBTPasskeyEntryState::GetNextState(TInt aEventId)

  1084 	{

  1085 	LOG_FUNC

  1086 	TBTAccessRequesterState state = EBTUnknownState;

  1087 

  1088 	switch(aEventId)

  1089 		{

  1090 	case TBTSecEvent::EKeypressEntry:

  1091 		state = EBTPasskeyEntry;

  1092 		break;

  1093 

  1094 	case TBTSecEvent::EAuthenticationComplete:

  1095 		state = EBTAuthenticationComplete;

  1096 		break;

  1097 

  1098 	case TBTSecEvent::EKeypressComplete:

  1099 		state = EBTSimplePairingPending;

  1100 		break;

  1101 		

  1102 	case TBTSecEvent::EEncryptionChangeComplete:

  1103 		state = EBTNopState;

  1104 		break;

  1105 		}

  1106 	return state;

  1107 	}

  1108 

  1109 

  1110 /**

  1111 class CBTRemoteOOBDataRequestState

  1112 */

  1113 CBTRemoteOOBDataRequestState* CBTRemoteOOBDataRequestState::NewL(TBTAccessRequesterState aState)

  1114 	{

  1115 	LOG_STATIC_FUNC

  1116 	CBTRemoteOOBDataRequestState* self = CBTRemoteOOBDataRequestState::NewLC(aState);

  1117 	CleanupStack::Pop();	//self

  1118 	return self;

  1119 	}

  1120 

  1121 CBTRemoteOOBDataRequestState* CBTRemoteOOBDataRequestState::NewLC(TBTAccessRequesterState aState)

  1122 	{

  1123 	LOG_STATIC_FUNC

  1124 	CBTRemoteOOBDataRequestState* self = new(ELeave) CBTRemoteOOBDataRequestState(aState);

  1125 	CleanupStack::PushL(self);

  1126 	return self;

  1127 	}

  1128 

  1129 CBTRemoteOOBDataRequestState::~CBTRemoteOOBDataRequestState()

  1130 	{

  1131 	LOG_FUNC

  1132 	}

  1133 

  1134 /* virtual */void CBTRemoteOOBDataRequestState::ExecuteAction(CBTAccessRequester& aRequester,TBTSecEvent& aEvent)

  1135 	{