1 // Copyright (c) 1999-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 

    17 #include <bluetooth/logger.h>

    18 

    19 #include <bluetooth/hci/hciutil.h>

    20 

    21 #include "secman.h"

    22 #include "secevent.h"

    23 #include "hostresolver.h"

    24 #include "pairingserver.h"

    25 #include "oobdata.h"

    26 #include "simplepairingresult.h"

    27 #include "btaccessrequesterstatemachine.h"

    28 

    29 #ifdef BT_LINKMGR_V2

    30 #include "physicallinks.h"

    31 #include "physicallinksmanager.h"

    32 #else

    33 #include "PhysicalLinks.h"

    34 #include "PhysicalLinksManager.h"

    35 #endif

    36 

    37 

    38 #ifdef __FLOG_ACTIVE

    39 _LIT8(KLogComponent, LOG_COMPONENT_SECMAN);

    40 #endif

    41 

    42 #ifdef _DEBUG

    43 PANICCATEGORY("secman");

    44 #endif

    45 

    46 static const TInt KBTSecManAccessRequesterArrayGranularity = 4;

    47 static const TInt KBTSecManNotifierRequesterArrayGranularity = 4;

    48 

    49 

    50 //------------------------------------------------------------------------//

    51 //class CBTSecMan

    52 //------------------------------------------------------------------------//

    53 

    54 CBTSecMan* CBTSecMan::NewL()

    55 	{

    56 	LOG_STATIC_FUNC

    57 	CBTSecMan* self = CBTSecMan::NewLC();

    58 	CleanupStack::Pop(self);

    59 	return self;

    60 	}

    61 

    62 CBTSecMan* CBTSecMan::NewLC()

    63 	{

    64 	LOG_STATIC_FUNC

    65 	CBTSecMan* self = new(ELeave) CBTSecMan();

    66 	CleanupStack::PushL(self);

    67 	self->ConstructL();

    68 	return self;

    69 	}

    70 

    71 CBTSecMan::CBTSecMan()

    72 	: iAccessRequesters(KBTSecManAccessRequesterArrayGranularity)

    73 	, iPendingAccessRequesters(KBTSecManAccessRequesterArrayGranularity)

    74 	, iNotifierRequesters(KBTSecManNotifierRequesterArrayGranularity)

    75 	, iLocalSimplePairingMode(EFalse)

    76 	, iDebugMode (EFalse)

    77 	{

    78 	LOG_FUNC

    79 	}

    80 

    81 void CBTSecMan::ConstructL()

    82 	{

    83 	LOG_FUNC

    84 	iStateMachine = CBTAccessRequesterStateFactory::NewL();

    85 	iCommandController = CSecManCommandController::NewL(*this);

    86 	

    87 	iOobDataManager = COobDataManager::NewL(*this);

    88 	iSimplePairingResultList = CSimplePairingResultList::NewL();

    89 	iAuthenticationResultList = CAuthenticationResultList::NewL();

    90 	iPairingServer = CPairingServer::NewL(*iOobDataManager, *iSimplePairingResultList, *iAuthenticationResultList);

    91 	}

    92 

    93 void CBTSecMan::SetLocalSimplePairingMode(TBool aEnabled)

    94 	{

    95 	LOG_FUNC

    96 	iLocalSimplePairingMode=aEnabled;

    97 	}

    98 

    99 TBool CBTSecMan::LocalSimplePairingMode() const

   100 	{

   101 	LOG_FUNC

   102 	return iLocalSimplePairingMode;

   103 	}

   104 

   105 void CBTSecMan::SimplePairingSupportDetermined(const TBTDevAddr& aBDAddr)

   106 	{

   107 	LOG_FUNC

   108 

   109 	// Pending requesters must be notified first than the active requester. 

   110 	// Otherwise it wouldn't work properly and pending requesters would not be notified at all.

   111 	for (TInt i=0; i<iPendingAccessRequesters.Count(); i++)

   112 		{

   113 		CBTAccessRequester* requester = iPendingAccessRequesters[i];

   114 		if (requester->DeviceAddress() == aBDAddr && requester->BasebandConnected())

   115 			{

   116 			TBTSecEvent event(TBTSecEvent::EPhysicalLinkUp);

   117 			requester->SendEvent(event);

   118 			}	

   119 		}

   120 

   121 	CBTAccessRequester* requester = this->FindActiveAccessRequester(aBDAddr);

   122 	// There should only be one active access requester

   123 	if (requester && requester->BasebandConnected())

   124 		{

   125 		TBTSecEvent event(TBTSecEvent::EPhysicalLinkUp);

   126 		requester->SendEvent(event);

   127 		}

   128 	}

   129 

   130 void CBTSecMan::SetPhysicalLinksMgr(const CPhysicalLinksManager& aConnectionsMgr)

   131 	{

   132 	LOG_FUNC

   133 	iPhysicalLinksManager = &const_cast<CPhysicalLinksManager&>(aConnectionsMgr);

   134 	iPairingServer->SetPhysicalLinksManager(*iPhysicalLinksManager);

   135 	}

   136 

   137 void CBTSecMan::ClearPhysicalLinksMgr()

   138 	{

   139 	LOG_FUNC

   140 	iPhysicalLinksManager = NULL;

   141 	iPairingServer->ClearPhysicalLinkMgr();

   142 	}

   143 

   144 // Passes a reference to the LinksMgrProtocol ultimately to the PairingServer 

   145 void CBTSecMan::SetLinksMgrProtocol(CLinkMgrProtocol& aLinkMgrProtocol)

   146 	{

   147 	LOG_FUNC

   148 	iPairingServer->SetLinksMgrProtocol(aLinkMgrProtocol);

   149 	}

   150 

   151 void CBTSecMan::ClearLinksMgrProtocol()

   152 	{

   153 	LOG_FUNC

   154 	iPairingServer->ClearLinksMgrProtocol();

   155 	}

   156 

   157 void CBTSecMan::SetHCICommandQueue(MHCICommandQueue& aCommandQueue)

   158 	{

   159 	LOG_FUNC

   160 	iCommandController->SetHCICommandQueue(aCommandQueue);

   161 	iOobDataManager->SetHCICommandQueue(aCommandQueue);

   162 	}

   163 

   164 void CBTSecMan::ClearHCICommandQueue()

   165 	{

   166 	LOG_FUNC

   167 	iCommandController->ClearHCICommandQueue();

   168 	iOobDataManager->ClearHCICommandQueue();

   169 	}

   170 

   171 CPhysicalLinksManager& CBTSecMan::ConnectionsManager() const

   172 	{

   173 	LOG_FUNC

   174 	__ASSERT_ALWAYS(iPhysicalLinksManager, PANIC(KBTSecPanic,EBTSecNullPhysicalLinksManager));

   175 	return *iPhysicalLinksManager;

   176 	}

   177 

   178 COobDataManager& CBTSecMan::OobDataManager() const

   179 	{

   180 	LOG_FUNC

   181 	return *iOobDataManager;

   182 	}

   183 

   184 TBool CBTSecMan::DebugMode() const

   185 	{

   186 	LOG_FUNC

   187 	return iDebugMode;

   188 	}

   189 

   190 void CBTSecMan::SetDebugMode(TBool aOn)

   191 	{

   192 	LOG_FUNC

   193 	// SecMan owns the policy about simple pairing debug mode - here we only allow it to be 

   194 	// turned on.  So ignore any "off" requests.  (Stack must be unloaded for debug mode to be

   195 	// turned off).

   196 	if(aOn && !iDebugMode)

   197 		{

   198 		// First try to set debug mode. If we fail to send the command then we will just be

   199 		// stuck in non-debug mode...

   200 		static const TUint8 KSimplePairingDebugModeEnabled = 0x01;

   201 		TRAP_IGNORE(iCommandController->WriteSimplePairingDebugModeL(KSimplePairingDebugModeEnabled));

   202 		}

   203 	}

   204 

   205 void CBTSecMan::ClearDebugMode()

   206 	{

   207 	LOG_FUNC

   208 	// Used to clear debug mode when the stack is reset

   209 	iDebugMode = EFalse;

   210 	ConnectionsManager().SimplePairingDebugModeChanged(EFalse);

   211 	}

   212 

   213 void CBTSecMan::DebugModeChanged(TBool aOn)

   214 	{

   215 	__ASSERT_DEBUG(aOn, PANIC(KBTSecPanic, EBTSecDebugModeTurnedOff));

   216 	iDebugMode = aOn;

   217 	ConnectionsManager().SimplePairingDebugModeChanged(aOn);

   218 	}

   219 

   220 CBTSecMan::~CBTSecMan()

   221 	{

   222 	LOG_FUNC

   223 	

   224 	iAccessRequesters.ResetAndDestroy();

   225 	iAccessRequesters.Close();

   226 

   227 	iPendingAccessRequesters.ResetAndDestroy();

   228 	iPendingAccessRequesters.Close();

   229 	

   230 	iNotifierRequesters.ResetAndDestroy();

   231 	iNotifierRequesters.Close();

   232 	

   233 	delete iStateMachine;

   234 	delete iCommandController;

   235 	delete iPairingServer;

   236 	delete iOobDataManager;

   237 	delete iSimplePairingResultList;

   238 	delete iAuthenticationResultList;

   239 	}

   240 

   241 CBTAccessRequester* CBTSecMan::FindActiveAccessRequester(const TBTDevAddr& aAddr) const

   242 	{

   243 	LOG_FUNC

   244 	CBTAccessRequester* ret = NULL;

   245 	TInt ix = iAccessRequesters.Find(aAddr, CompareAccessRequesterByBDAddr);

   246 	if(ix >= 0)

   247 		{

   248 		ret = iAccessRequesters[ix];

   249 		}

   250 	return ret;

   251 	}

   252 

   253 TBool CBTSecMan::CompareAccessRequesterByBDAddr(const TBTDevAddr* aKey, const CBTAccessRequester& aAccessRequester)

   254 	{

   255 	LOG_STATIC_FUNC

   256 	return (!aKey || (*aKey) == aAccessRequester.DeviceAddress());

   257 	}

   258 

   259 TBool CBTSecMan::CompareAccessRequesterByRequester(const MAccessRequestResponseHandler* aKey, const CBTAccessRequester& aAccessRequester)

   260 	{

   261 	LOG_STATIC_FUNC

   262 	return aKey == &aAccessRequester.ServiceRequester();

   263 	}

   264 

   265 void CBTSecMan::AccessRequestL(const TBTServiceSecurity& aSecurity,

   266 							   const TBTServiceSecurityPerDevice* const aOverride,

   267 							   const TBTDevAddr& aBDAddr,

   268 							   TAccessType aAccessType,

   269 							   MAccessRequestResponseHandler& aRequester)

   270 /**

   271 Handle an access request...

   272 Create a new CBTAccessRequester object to handle the request.

   273 **/

   274 	{

   275 	LOG_FUNC

   276 

   277 #ifdef _DEBUG

   278 	// Check that a service isn't queuing multiple access requesters.

   279 	TInt ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   280 	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecServiceTryingToQueueMultipleAccessRequesters));

   281 	ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   282 	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecServiceTryingToQueueMultipleAccessRequesters));

   283 #endif // _DEBUG

   284 

   285 	// find the baseband this SAP is running on

   286 	CPhysicalLink& con = *iPhysicalLinksManager->FindPhysicalLink(aBDAddr);

   287 	CBTAccessRequester* p = CBTAccessRequester::NewLC(con, aSecurity,

   288 													  aOverride,

   289 													  aRequester,

   290 													  aAccessType,

   291 													  *this);

   292 	

   293 	CBTAccessRequester* requester = FindActiveAccessRequester(aBDAddr);

   294 	if(requester)

   295 		{

   296 		User::LeaveIfError(iPendingAccessRequesters.Append(p));

   297 		CleanupStack::Pop(p); //clean up of p now handled by iPendingAccessRequesters

   298 		}

   299 	else

   300 		{

   301 		User::LeaveIfError(iAccessRequesters.Append(p));

   302 		CleanupStack::Pop(p); //clean up of p now handled by iAccessRequesters

   303 		// Try to start- it may not happen (depends on if device retrieved from registry)

   304 		p->Start();

   305 		}

   306 	

   307 	}

   308 

   309 void CBTSecMan::CancelRequest(MAccessRequestResponseHandler& aRequester)

   310 	{

   311 	LOG_FUNC

   312 	// search through access requesters to find correct one

   313 	LOG1(_L8("\tCBTSecMan::CancelRequest from SAP 0x%08x"), &aRequester)

   314 

   315 	CBTAccessRequester* request = NULL;

   316 	

   317 	TInt ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   318 	if(ix >= 0)

   319 		{

   320 		request = iAccessRequesters[ix];

   321 		}

   322 	else

   323 		{

   324 		ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   325 		if(ix >= 0)

   326 			{

   327 			request = iPendingAccessRequesters[ix];

   328 			}

   329 		}

   330 	

   331 	if(request)

   332 		{

   333 		static_cast<void>(FinishAccessRequest(request)); // don't need to call back to requester...

   334 		}

   335 	

   336 #ifdef _DEBUG

   337 	// Do a sanity test to check that there aren't multiple access requesters per service

   338 	ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   339 	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecMultipleActiveAccessRequestersForService));

   340 	ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

   341 	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecMultiplePendingAccessRequestersForService));

   342 #endif // _DEBUG

   343 	}

   344 

   345 void CBTSecMan::GetPassKeyLengthAndOriginator(const TBTDevAddr& aAddr, TUint& aPasskeyMinLength,

   346 											  TBool& aLocallyInitiatedAuthentication,

   347 											  TBool& aStrongKeyRequired)

   348 

   349 /**

   350 If authorisation request was initiated locally it will return true and will

   351 return the passkey minimal length requred by user

   352 **/

   353 	{

   354 	LOG_FUNC

   355 	TUint tmpPasskeyLength = 0;

   356 	TBluetoothMitmProtection mitmReqs = EMitmNotRequired;

   357 	TBool locallyInitiated = EFalse;

   358 	TInt count = iAccessRequesters.Count();

   359 	aStrongKeyRequired = EFalse;

   360 

   361 	// find all pending AccessRequesters for given BTAddr and find maximum of PasskeyMinLength

   362 	if(count != 0)

   363 		{

   364 		for (TInt i=0; i<count;i++)

   365 			{

   366 			CBTAccessRequester* requester = iAccessRequesters[i];

   367 			if (requester->IsAuthenticationReqPending(aAddr, tmpPasskeyLength, mitmReqs))

   368 				{

   369 				locallyInitiated = ETrue;

   370 				if (aPasskeyMinLength < tmpPasskeyLength)

   371 					{

   372 					aPasskeyMinLength = tmpPasskeyLength;

   373 					}

   374 				if(mitmReqs == EMitmRequired)

   375 					{

   376 					aStrongKeyRequired = ETrue;

   377 					}

   378 				}

   379 			}

   380 		}

   381 	aLocallyInitiatedAuthentication = locallyInitiated;

   382 	}

   383 

   384 

   385 

   386 TBool CBTSecMan::IsDedicatedBondingAttempted(const TBTDevAddr& aAddr)

   387 	{

   388 	LOG_FUNC

   389 

   390 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   391 

   392 	if(requester && (requester->AccessType() == EDedicatedBonding) )

   393 		{

   394 		return ETrue;

   395 		}

   396 	else

   397 		{

   398 		return EFalse;

   399 		}

   400 	}

   401 

   402 TBool CBTSecMan::IsOutboundAccessRequest(const TBTDevAddr& aAddr)

   403 	{

   404 	LOG_FUNC

   405 	// For now the only outbound access request is for dedicated bonding

   406 	// attempts (so we share the code).

   407 	return IsDedicatedBondingAttempted(aAddr);

   408 	}

   409 

   410 

   411 void CBTSecMan::AuthenticationInProgress()

   412 /**

   413 When authentication request was sent to HW, HCI will notify SecMan

   414 **/

   415 	{

   416 	LOG_FUNC

   417 	// find first pending AccessRequesters and set AuthenticationInProgress flag

   418 	for (TInt i=0; i<iAccessRequesters.Count(); i++)

   419 		{

   420 		CBTAccessRequester* requester = iAccessRequesters[i];

   421 

   422 		if (requester->AuthenticationRequired() && !requester->AuthenticationInProgress())

   423 			{

   424 			TBTSecEvent event(TBTSecEvent::EAuthenticationRequested);

   425 			requester->SendEvent(event);

   426 			break;

   427 			}

   428 		}

   429 	}

   430 

   431 void CBTSecMan::IOCapabilityRequestFromRemote(const TBTDevAddr& aAddr)

   432 	{

   433 	LOG_FUNC

   434 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   435 	if(requester)

   436 		{

   437 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   438 		TBTSecEvent event(TBTSecEvent::EIOCapsRequested);

   439 		requester->SendEvent(event);

   440 		}

   441 	else

   442 		{

   443 		LOG(_L8("\tCBTAccessRequester NOT FOUND!\n"));

   444 		CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   445 		__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing)); // If we've got an IO Capability Response we should have a link

   446 

   447 		if(link->IsPairable())

   448 			{

   449 			link->SetAuthenticationPending(ESimplePairingPending);

   450 			THCIOobDataPresence oobPresence = EOOBDataNotPresent;

   451 			if (link->HasRemoteOobData())

   452 				{

   453 				oobPresence = EOOBDataPresent;

   454 				}

   455 			THCIAuthenticationRequirement authReq = link->AuthenticationRequirement();

   456 			if(ConnectionsManager().IsAcceptPairedOnlyMode())

   457 				{

   458 				// in paired only mode, only MITM pairings are acceptable.

   459 				switch(authReq)

   460 					{

   461 				case EMitmNotReqNoBonding:

   462 				case EMitmReqNoBonding:

   463 					authReq = EMitmReqNoBonding;

   464 					break;

   465 				case EMitmNotReqDedicatedBonding:

   466 				case EMitmReqDedicatedBonding:

   467 					authReq = EMitmReqDedicatedBonding;

   468 					break;

   469 				case EMitmNotReqGeneralBonding:

   470 				case EMitmReqGeneralBonding:

   471 					authReq = EMitmReqGeneralBonding;

   472 					break;

   473 	            default:

   474 	                PANIC(KBTSecPanic, EBTSecUnexpectedIoCapability);

   475 	                break;

   476 					}

   477 				link->SetLocalMITM(ETrue);

   478 				}

   479 			else

   480 				{

   481 				link->SetLocalMITM(EFalse);

   482 				}

   483 		

   484 			TRAP_IGNORE(iCommandController->IOCapabilityRequestReplyL(aAddr, EIOCapsDisplayYesNo, oobPresence, authReq));

   485 			}

   486 		else

   487 			{

   488 			TRAP_IGNORE(iCommandController->IOCapabilityRequestNegativeReplyL(aAddr, EPairingNotAllowed));

   489 			}

   490 		}

   491 	}

   492 

   493 

   494 void CBTSecMan::IOCapabilityAskForResponse(const TBTDevAddr& aAddr,

   495 										THCIIoCapability aIOCapability,

   496 										THCIOobDataPresence aOOBDataPresent,

   497 										THCIAuthenticationRequirement aAuthenticationRequirements)

   498 	{

   499 	LOG_FUNC

   500 	

   501 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   502 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing)); // If we've got an IO Capability Response we should have a link

   503 	link->IOCapabilityAskForResponse(aIOCapability, aOOBDataPresent, aAuthenticationRequirements);

   504 	

   505 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   506 	if(requester)

   507 		{

   508 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   509 		TBTSecEventIoCapabilityResponse event(aIOCapability, aOOBDataPresent, aAuthenticationRequirements);

   510 		requester->SendEvent(event);

   511 		}

   512 	}

   513 

   514 void CBTSecMan::RemoteOOBDataRequest(const TBTDevAddr& aAddr)

   515 	{

   516 	LOG_FUNC

   517 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   518 	if(requester)

   519 		{

   520 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   521 		TBTSecEvent event(TBTSecEvent::ERemoteOOBDataRequested);

   522 		requester->SendEvent(event);

   523 		}

   524 

   525 	TBluetoothSimplePairingHash hashC;

   526 	TBluetoothSimplePairingRandomizer randomizerR;

   527 	if(OobDataManager().GetRemoteOobData(aAddr, hashC, randomizerR))

   528 		{

   529 		TRAP_IGNORE(iCommandController->RemoteOOBDataRequestReplyL(aAddr, hashC, randomizerR));

   530 		}

   531 	else

   532 		{

   533 		TRAP_IGNORE(iCommandController->RemoteOOBDataRequestNegativeReplyL(aAddr));

   534 		}

   535 	}

   536 

   537 void CBTSecMan::RemoteOOBDataRequestComplete(const TBTDevAddr& aAddr)

   538 	{

   539 	LOG_FUNC

   540 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   541 	if(requester)

   542 		{

   543 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   544 		TBTSecEvent event(TBTSecEvent::ERemoteOOBDataRequestComplete);

   545 		requester->SendEvent(event);

   546 		}

   547 	}

   548 

   549 void CBTSecMan::UserConfirmationRequest(const TBTDevAddr& aAddr, TUint32 aNumericValue)

   550 	{

   551 	LOG_FUNC

   552 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   553 	if(requester)

   554 		{

   555 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   556 		TBTSecEventUserConfirmationRequest event(aNumericValue);

   557 		requester->SendEvent(event);

   558 		}

   559 

   560 	if(requester != FindActiveAccessRequester(aAddr))

   561 		{

   562 		// The previous requester has been completed so move on.

   563 		TRAP_IGNORE(iCommandController->UserConfirmationRequestNegativeReplyL(aAddr));

   564 		return; // No passkey or comparison dialogs; disconnect instead

   565 		}

   566 

   567 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   568 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   569 	__ASSERT_DEBUG(!link->InstanceNumericComparator(), PANIC(KBTSecPanic, EBTSecConnectionNumericComparisonTwice));

   570 	if(link->InstanceNumericComparator())

   571 		{

   572 		return;

   573 		}

   574 

   575 	if(link->AuthWithMITM())

   576 		{

   577 		TBool locallyInitiated; //Authentication

   578 		TBool strongKeyRequired;

   579 		TUint minPasskeyLength=0;

   580 

   581 		GetPassKeyLengthAndOriginator(aAddr, minPasskeyLength, locallyInitiated, strongKeyRequired);

   582 		TRAPD(err,link->NewNumericComparatorL(aAddr, *this, aNumericValue, locallyInitiated));

   583 		if(err)

   584 			{

   585 			if(requester)

   586 				{

   587 				requester->CompleteRequest(EBTSecManAccessDenied);

   588 				}

   589 			else

   590 				{

   591 				TRAP_IGNORE(iCommandController->UserConfirmationRequestNegativeReplyL(aAddr));

   592 				return;// No passkey or comparison dialogs; disconnect instead

   593 				}

   594 			}

   595 		}

   596 	else

   597 		{

   598 		// Just Work...

   599 		if(requester)

   600 			{

   601 			LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   602 			TBTSecEventUserConfirmationComplete event(ETrue);

   603 			requester->SendEvent(event);

   604 			}

   605 

   606 		// note: -- check errors here

   607 		TRAP_IGNORE(iCommandController->UserConfirmationRequestReplyL(aAddr));

   608 		}

   609 	}

   610 

   611 void CBTSecMan::UserConfirmationComplete(const TBTDevAddr& aAddr, TBool aResult, TInt aError)

   612 	{

   613 	LOG_FUNC

   614 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   615 	if (requester)

   616 		{

   617 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   618 		if (aError == KErrNone)

   619 			{

   620 			TBTSecEventUserConfirmationComplete event(aResult);

   621 			requester->SendEvent(event);

   622 			}

   623 		else

   624 			{

   625 			TBTSecEventUserConfirmationComplete event(EFalse);  // Failed, so send EFalse

   626 			requester->SendEvent(event);

   627 			}

   628 		}

   629 

   630 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   631 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   632 

   633 	if (aError!=KErrNone)

   634 		{

   635 		// there was an error somewhere a long the way so respond negatively

   636 		// note: -- check errors here

   637 		TRAP_IGNORE(iCommandController->UserConfirmationRequestNegativeReplyL(aAddr));

   638 		}

   639 	else

   640 		{

   641 		// got a result

   642 		if(aResult)

   643 			{

   644 			link->PinRequestSent();

   645 			// note: -- check errors here

   646 			TRAP_IGNORE(iCommandController->UserConfirmationRequestReplyL(aAddr));

   647 			}

   648 		else

   649 			{

   650 			// note: -- check errors here

   651 			TRAP_IGNORE(iCommandController->UserConfirmationRequestNegativeReplyL(aAddr));

   652 			}

   653 		}

   654 	link->DeleteNumericComparator();

   655 	}

   656 

   657 void CBTSecMan::PasskeyNotification(const TBTDevAddr& aAddr, TUint32 aPasskey)

   658 	{

   659 	LOG_FUNC

   660 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   661 	if (requester)

   662 		{

   663 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   664 		TBTSecEventPasskeyNotification event(aPasskey);

   665 		requester->SendEvent(event);

   666 		}

   667 

   668 	if(requester != FindActiveAccessRequester(aAddr))

   669 		{

   670 		// the previous requester has been completed so move on.

   671 		return;

   672 		}

   673 

   674 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   675 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   676 

   677 	__ASSERT_DEBUG(!link->InstancePasskeyEntry(), PANIC(KBTSecPanic, EBTSecConnectionPasskeyNotificationTwice));

   678 

   679 	if(link->InstancePasskeyEntry())

   680 		{

   681 		return;

   682 		}

   683 

   684 	TBool locallyInitiated; //Authentication

   685 	TBool strongKeyRequired;

   686 	TUint minPasskeyLength=0;

   687 

   688 	GetPassKeyLengthAndOriginator(aAddr, minPasskeyLength, locallyInitiated, strongKeyRequired);

   689 	TRAPD(err, link->NewPasskeyEntryL(aAddr, *this,aPasskey, locallyInitiated));

   690 	if(err != KErrNone)

   691 		{

   692 		if(requester)

   693 			{

   694 			requester->CompleteRequest(EBTSecManAccessDenied);

   695 			}

   696 		}

   697 	}

   698 

   699 void CBTSecMan::KeypressNotification(const TBTDevAddr& aAddr, TUint8 aNotificationType)

   700 	{

   701 	LOG_FUNC

   702 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   703 	if (requester)

   704 		{

   705 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   706 		TBTSecEventKeypressEntry event(aNotificationType);

   707 		requester->SendEvent(event);

   708 		}

   709 

   710 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   711 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   712 

   713 	if (link->InstancePasskeyEntry())

   714 		{

   715 		THCIPasskeyEntryNotificationType keyType = static_cast<THCIPasskeyEntryNotificationType>(aNotificationType);

   716 		link->PasskeyEntryKeyPressed(keyType);

   717 		}

   718 	}

   719 

   720 void CBTSecMan::PasskeyNotificationComplete(const TBTDevAddr& aAddr, TInt aError)

   721 	{

   722 	LOG_FUNC

   723 	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

   724 	if (requester)

   725 		{

   726 		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

   727 		TBTSecEvent event(TBTSecEvent::EKeypressComplete, aError);

   728 		requester->SendEvent(event);

   729 		}

   730 

   731 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   732 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   733 	link->DeletePasskeyEntry();

   734 	}

   735 

   736 void CBTSecMan::AccessRequestComplete(CBTAccessRequester* aAccessRequester, TInt aResult)

   737 /**

   738 The access request has been fully completed.

   739 Delete the CBTAccessRequester that was handling the request.

   740 **/

   741 	{

   742 	LOG_FUNC

   743 	MAccessRequestResponseHandler& service = FinishAccessRequest(aAccessRequester);

   744 	// now tell the service

   745 	service.AccessRequestComplete(aResult);

   746 	}

   747 	

   748 MAccessRequestResponseHandler& CBTSecMan::FinishAccessRequest(CBTAccessRequester* aAccessRequester)

   749 	{

   750 	LOG_FUNC

   751 	TBTDevAddr addr = aAccessRequester->DeviceAddress();

   752 

   753 	// find the originating service *now*

   754 	MAccessRequestResponseHandler& service = const_cast<MAccessRequestResponseHandler&>

   755 											(aAccessRequester->ServiceRequester());

   756 

   757 	CBTAccessRequester* newRequester = NULL;

   758 	// Determine if this is an active access requester.

   759 	TInt ix = iAccessRequesters.Find(aAccessRequester);

   760 	if(ix >= 0)

   761 		{

   762 		// We need to replace this requester with a new one.

   763 		// Find the new access requester

   764 		ix = iPendingAccessRequesters.Find(addr, CompareAccessRequesterByBDAddr);

   765 		if(ix >= 0)

   766 			{

   767 			newRequester = iPendingAccessRequesters[ix];

   768 			iPendingAccessRequesters.Remove(ix);

   769 			iPendingAccessRequesters.GranularCompress();

   770 			}

   771 		// Remove bindings for the completed access requester (and substitute with new one if neccessary)

   772 		ix = iAccessRequesters.Find(aAccessRequester);

   773 		__ASSERT_DEBUG(ix >= 0, PANIC(KBTSecPanic, EBTSecAccessRequesterCompletedWhenNotActive));

   774 		if(newRequester)

   775 			{

   776 			iAccessRequesters[ix] = newRequester;

   777 			}

   778 		else

   779 			{

   780 			iAccessRequesters.Remove(ix);

   781 			}

   782 		}

   783 	else

   784 		{

   785 		// This must be a pending requester - in which case we just complete it.

   786 		__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecAccessRequesterShouldHaveNotBeenFound));

   787 		ix = iPendingAccessRequesters.Find(aAccessRequester);

   788 		__ASSERT_DEBUG(ix >= 0, PANIC(KBTSecPanic, EBTSecAccessRequesterShouldHaveBeenFound));

   789 		iPendingAccessRequesters.Remove(ix);

   790 		iPendingAccessRequesters.GranularCompress();

   791 		}

   792 

   793 	// Cleanup the access requester

   794 	delete aAccessRequester, aAccessRequester = NULL;

   795 

   796 	// Start the new requester if there is one.

   797 	if(newRequester)

   798 		{

   799 		newRequester->Start();

   800 		}

   801 	

   802 	return service;

   803 	}

   804 

   805 void CBTSecMan::SimplePairingComplete(const TBTDevAddr& aAddr, THCIErrorCode aError)

   806 	{

   807 	LOG_FUNC

   808 	TInt err = CHciUtil::SymbianErrorCode(aError);

   809 

   810 	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

   811 	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing));

   812 

   813 	if (link->InstancePasskeyEntry() && link->IsPasskeyEntryActive())

   814 		{

   815 		link->CancelPasskeyEntry();

   816 		PasskeyNotificationComplete(aAddr, err);

   817 		}

   818 	if (link->InstanceNumericComparator() && link->IsNumericComparatorActive())

   819 		{

   820 		link->CancelNumericComparator();

   821 		UserConfirmationComplete(aAddr, EFalse, err);

   822 		}

   823 

   824 	iPhysicalLinksManager->SimplePairingComplete(aAddr, aError);

   825 

   826  	// Add result to list (always with HCI error code).

   827  	// Pairing results will be added only if pairing that involved numeric Comparison or passkey entry.

   828  	// It should not be added if the pairing completed using Just Works

   829  	if(link->AuthWithMITM())

   830  		{

   831  		iSimplePairingResultList->NewResult(aAddr, (KHCIErrorBase - aError));

   832  		}

   833 	}

   834 

   835 void CBTSecMan::AuthenticationComplete(const TBTDevAddr& aAddr, THCIErrorCode aError)

   836 	{

   837 	LOG_FUNC

   838 	iAuthenticationResultList->NewResult(aAddr, (KHCIErrorBase - aError));

   839 	}

   840 

   841 void CBTSecMan::AddNotifierRequestToQueL(CSecNotifierRequester& aRequest)

   842 /**

   843 Add notifier request to front of queue.  If there are no other requests already in the queue,

   844 initiate this request.

   845 **/

   846 	{

   847 	LOG_FUNC

   848 	TInt count = iNotifierRequesters.Count();

   849 	User::LeaveIfError(iNotifierRequesters.Insert(&aRequest,0));	//add to front of queue since requests are taken from the back

   850 	if(count == 0)	// ok since count was calculated before we inserted the new element

   851 		{

   852 		iActiveNotifierRequester = &aRequest;

   853 		aRequest.DoRequest();

   854 		}

   855 	else

   856 		{

   857 		LOG(_L8("\tSecman: Request queued, should start later..."));

   858 		}

   859 	}

   860 

   861 void CBTSecMan::RemoveNotifierRequestFromQue(CSecNotifierRequester& aRequest)

   862 /**

   863 Remove the request from the queue.  If aRequest is the currently active request then we can activate

   864 the next one in the queue.  Otherwise, aRequest is being deleted prematurely and we must simply

   865 remove it from the array.

   866 **/

   867 	{

   868 	LOG_FUNC

   869 	TInt count = iNotifierRequesters.Count();

   870 	TInt found = 0;

   871 	for (TInt i=(count-1); i>=0; i--)

   872 		{

   873 		if (iNotifierRequesters[i] == &aRequest)

   874 			{

   875 			found++;

   876 			iNotifierRequesters.Remove(i);

   877 			}

   878 		}

   879 	__ASSERT_DEBUG(found, PANIC(KBTSecPanic, EBTSecBadNotifierArray));

   880 

   881 	if(&aRequest == iActiveNotifierRequester)

   882 		{

   883 		//start the next request if there is one...

   884 		count = iNotifierRequesters.Count();

   885 		if (count > 0)

   886 			{

   887 			LOG(_L8("\tCBTSecMan - auto-starting next notifier request from queue"));

   888 			iActiveNotifierRequester = iNotifierRequesters[count-1];

   889 			iActiveNotifierRequester->DoRequest();

   890 			}

   891 		else

   892 			{

   893 			iActiveNotifierRequester = NULL;

   894 			}

   895 		}

   896 	}

   897 

   898 CBTAccessRequesterStateFactory* CBTSecMan::StateMachine()

   899 	{

   900 	LOG_FUNC

   901 	return iStateMachine;

   902 	}

   903 

   904 CSecNotifierRequester::CSecNotifierRequester(CBTSecMan& aSecMan)

   905 	: CActive(EPriorityStandard)

   906 	, iInquiryMgr(aSecMan.ConnectionsManager().LinkManagerProtocol().InquiryMgr())

   907 	, iSecMgr(aSecMan)

   908 	{

   909 	LOG_FUNC

   910 	}

   911 

   912 void CSecNotifierRequester::ConstructL(const TBTDevAddr& aAddr)

   913 	{

   914 	LOG_FUNC

   915 	LEAVEIFERRORL(iNotifier.Connect());

   916 

   917 	// find the name at this stage for this device - may not be there yet

   918 	iDeviceName = iInquiryMgr.DeviceNameFromCache(aAddr);

   919 

   920 	if (!iDeviceName || iDeviceName->Length() ==0)

   921 		{

   922 		// cache didn't have name - so we'll ask for it as a HR action

   923 		TRAP_IGNORE(iHR = iInquiryMgr.NewHostResolverL());

   924 		iHRNameRecord = new TNameRecord;

   925 

   926 		// ignore error - only an optimisation - don't want to leave if there's

   927 		// a problem doing this optimisation

   928 		if (iHR && iHRNameRecord)

   929 			{

   930 			iHR->SetNotify(this);

   931 

   932 			TInquirySockAddr i;

   933 			i.SetAction(KHostResName);

   934 			i.SetBTAddr(aAddr);

   935 			iHRNameRecord->iAddr = i;

   936 			iHR->GetByAddress(*iHRNameRecord);

   937 			}

   938 		}

   939 

   940 	iDevAddr = aAddr;

   941 

   942 	iSecMgr.AddNotifierRequestToQueL(*this);

   943 	iIsAddedToNotifierQue = ETrue;

   944 	}

   945 

   946 void CSecNotifierRequester::RemoveMyselfFromQue()

   947 	{

   948 	LOG_FUNC

   949 	iSecMgr.RemoveNotifierRequestFromQue(*this);

   950 	}

   951 

   952 CSecNotifierRequester::~CSecNotifierRequester()

   953 	{

   954 	LOG_FUNC

   955 	Cancel();

   956 

   957 	//remove ourself from the notifier que if we're still on it.

   958 	if (iIsAddedToNotifierQue)

   959 		{

   960 		RemoveMyselfFromQue();

   961 		iIsAddedToNotifierQue = EFalse;

   962 		}

   963 

   964 	delete iHR;

   965 	delete iHRNameRecord;

   966 

   967 	iNotifier.Close();

   968 	}

   969 

   970 void CSecNotifierRequester::QueryComplete(TInt aErr)

   971 	{

   972 	LOG_FUNC

   973 	if (aErr==KErrNone && iHRNameRecord)

   974 		{

   975 		// now have device name - update notifiers

   976 		// we do have a copy of the name - but it is now wide :-|

   977 		// and also we have iDeviceName that is still NULL, so best bet is

   978 		// to just set our pointer and use the cache one (which we *know* is there!)

   979 		TBTDevAddr a = TBTSockAddr::Cast(iHRNameRecord->iAddr).BTAddr();

   980 		iDeviceName = iInquiryMgr.DeviceNameFromCache(a);

   981 		DoUpdateNotifier();

   982 		}

   983 

   984 	delete iHRNameRecord;

   985 	iHRNameRecord = NULL;

   986 	}

   987 

   988 void CSecNotifierRequester::HandleTimeout()

   989 	{

   990 	LOG_FUNC

   991 	// A timer user should implement this function

   992 	__ASSERT_DEBUG(EFalse, PANIC(KBTSecPanic, EBTSecNotifierRequesterUsingTimerWithoutHandling));

   993 	}

   994 

   995 

   996 

   997 CSecNotifierRequesterTimer* CSecNotifierRequesterTimer::NewL(CSecNotifierRequester& aObserver)

   998 	{

   999 	LOG_STATIC_FUNC

  1000 	CSecNotifierRequesterTimer* self = new(ELeave) CSecNotifierRequesterTimer(aObserver);

  1001 	CleanupStack::PushL(self);

  1002 	self->ConstructL();

  1003 	CleanupStack::Pop(self);

  1004 	return self;

  1005 	}

  1006 

  1007 CSecNotifierRequesterTimer::CSecNotifierRequesterTimer(CSecNotifierRequester& aObserver)

  1008 	: CTimer(EPriorityStandard)

  1009 	, iObserver(aObserver)

  1010 	{

  1011 	LOG_FUNC

  1012 	CActiveScheduler::Add(this);

  1013 	}

  1014 

  1015 CSecNotifierRequesterTimer::~CSecNotifierRequesterTimer()

  1016 	{

  1017 	LOG_FUNC

  1018 	Cancel();

  1019 	}

  1020 

  1021 void CSecNotifierRequesterTimer::Start(TTimeIntervalMicroSeconds32 aTimeout)

  1022 	{

  1023 	LOG_FUNC

  1024 	After(aTimeout);

  1025 	}

  1026 

  1027 void CSecNotifierRequesterTimer::ConstructL()

  1028 	{

  1029 	LOG_FUNC

  1030 	CTimer::ConstructL();

  1031 	}

  1032 

  1033 void CSecNotifierRequesterTimer::RunL()

  1034 	{

  1035 	LOG_FUNC

  1036 	iObserver.HandleTimeout();

  1037 	}

  1038 

  1039 

  1040 //------------------------------------------------------------------------//

  1041 //class CBTPinRequester

  1042 //------------------------------------------------------------------------//

  1043 

  1044 

  1045 CBTPinRequester* CBTPinRequester::NewL(const TBTDevAddr& aAddr,

  1046 									   MPINCodeResponseHandler& aRequester,

  1047 									   CBTSecMan& aSecMan,

  1048 									   TUint aPasskeyMinLength,

  1049 									   TBool aInternallyInitiated,

  1050 									   TBool aStrongKeyRequired,

  1051 									   TUint aRecommendedPasskeyMinLength)

  1052 	{

  1053 	LOG_STATIC_FUNC

  1054 	CBTPinRequester* s = CBTPinRequester::NewLC(aAddr, aRequester, aSecMan,

  1055 	                                            aPasskeyMinLength, aInternallyInitiated, aStrongKeyRequired, aRecommendedPasskeyMinLength);

  1056 	CleanupStack::Pop(s);

  1057 	return s;

  1058 	}

  1059 

  1060 CBTPinRequester* CBTPinRequester::NewLC(const TBTDevAddr& aAddr,

  1061 										MPINCodeResponseHandler& aRequester,

  1062 										CBTSecMan& aSecMan,

  1063 										TUint aPasskeyMinLength,

  1064 										TBool aInternallyInitiated,

  1065 										TBool aStrongKeyRequired,

  1066 										TUint aRecommendedPasskeyMinLength)

  1067 	{

  1068 	LOG_STATIC_FUNC

  1069 	CBTPinRequester* s = new(ELeave) CBTPinRequester(aRequester, aSecMan,

  1070 	                                                 aPasskeyMinLength, aInternallyInitiated, aStrongKeyRequired, aRecommendedPasskeyMinLength);

  1071 	CleanupStack::PushL(s);

  1072 	s->ConstructL(aAddr);

  1073 	return s;

  1074 	}

  1075 

  1076 CBTPinRequester::CBTPinRequester(MPINCodeResponseHandler& aHandler,

  1077 								 CBTSecMan& aSecMan,

  1078 								 TUint aPasskeyMinLength,

  1079 								 TBool aInternallyInitiated,

  1080 								 TBool aStrongKeyRequired,

  1081 								 TUint aRecommendedPasskeyMinLength)

  1082 	: CSecNotifierRequester(aSecMan)

  1083 	, iHandler(&aHandler)

  1084 	, iSecMan(aSecMan)

  1085 	, iPasskeyMinLength(aPasskeyMinLength)

  1086 	, iInternallyInitiated(aInternallyInitiated)

  1087 	, iStrongKeyRequired(aStrongKeyRequired)

  1088 	, iRecommendedPasskeyMinLength(aRecommendedPasskeyMinLength)

  1089 	{

  1090 	LOG_FUNC

  1091 	CActiveScheduler::Add(this);

  1092 	}

  1093 

  1094 void CBTPinRequester::ConstructL(const TBTDevAddr& aAddr)

  1095 	{

  1096 	LOG_FUNC

  1097 	iTimer = CSecNotifierRequesterTimer::NewL(*this);

  1098 	CSecNotifierRequester::ConstructL(aAddr);

  1099 	}

  1100 

  1101 CBTPinRequester::~CBTPinRequester()

  1102 	{

  1103 	LOG_FUNC

  1104 	delete iTimer;

  1105 	Cancel();

  1106 	CBase::Delete(iUpdateNotifier.iNameUpdater); // Delete through the CBase virtual destructor.

  1107 	}

  1108 

  1109 

  1110 void CBTPinRequester::UpdateHandler(MPINCodeResponseHandler& aNewHandler)

  1111 	{

  1112 	LOG_FUNC

  1113 	iHandler = &aNewHandler;

  1114 	}

  1115 

  1116 

  1117 void CBTPinRequester::DoUpdateNotifier()

  1118 	{

  1119 	LOG_FUNC

  1120  	if(IsActive())

  1121  		{

  1122  		switch(iNotifierType)

  1123 	 		{

  1124 	 	case ESspAwareNotifier:

  1125 	 		UpdateSspAwareNotifier();

  1126 	 		break;

  1127 	 	case ELegacyNotifier:

  1128 	 		UpdateLegacyNotifier();

  1129 	 		break;

  1130 	 	default:

  1131 			DEBUG_PANIC_LINENUM

  1132 	 		break;

  1133 	 		}

  1134 		}