FCL/sf/os/bt: comparison bluetooth/btstack/linkmgr/hostresolver.cpp

equal deleted inserted replaced

-:14e279d2bbb7
+:22de2e391156
 	{
 	LOG_FUNC
 	__ASSERT_DEBUG(iRequestState == EIdle, Panic(EHostResolverTwoRequests));
 	iNameRecord = &aName;
 	iNameRecord->iName.Zero();
-	TInquirySockAddr& sa = TInquirySockAddr::Cast(aName.iAddr);
+	iSockAddr = TInquirySockAddr::Cast(aName.iAddr);
-	LOG1(_L("Host Resolver\tAction = %d"),sa.Action());
+	LOG1(_L("Host Resolver\tAction = %d"),iSockAddr.Action());
-	if(sa.Action() & KHostResCache)
+	if(iSockAddr.Action() & KHostResCache)
 		//Complete immediately with info if available!
 		{
 		TInt err = KErrNotFound;
-		CBTInqResultRef* ref = iInquiryMgr.FindExistingCacheEntry(sa.BTAddr());
+		CBTInqResultRef* ref = iInquiryMgr.FindExistingCacheEntry(iSockAddr.BTAddr());
 		if (ref)
 			{// Got a result to send up
 			CBTInqResultRecord& rec = ref->Result();
-			rec.GetInquirySockAddr(sa); //Put BT address, CoD etc into 'aName'
+			rec.GetInquirySockAddr(TInquirySockAddr::Cast(aName.iAddr)); //Put BT address, CoD etc into 'aName'
 			// Check whether client wants EIRs instead of names
-			if(sa.Action() & KHostResEir)
+			if(iSockAddr.Action() & KHostResEir)
 				{
 				// Client knows about EIR, we'll fill the TNameRecord with EIR
 				err = rec.GetEir(aName, EFalse);
 				}
 			else
 		iNotify->QueryComplete(err);
 		return;
 		}
 	// Must request at least one of inquiry or name lookup
-	if (!(sa.Action() & (KHostResInquiry | KHostResName)))
+	if (!(iSockAddr.Action() & (KHostResInquiry | KHostResName)))
 		{
 		iRequestState = EError;
 		CompleteRequest(KErrArgument);
 		return;
 		}
 		iRequestState = EError;
 		CompleteRequest(KErrHardwareNotAvailable);
 		return;
 		}
-	iNameLookupMode = (sa.Action()) & KHostResName ? EDoGetNames : EDontGetNames;
+	iNameLookupMode = (iSockAddr.Action()) & KHostResName ? EDoGetNames : EDontGetNames;
-	TBool ignoreCache = (sa.Action() & KHostResIgnoreCache) ? ETrue : EFalse;
+	TBool ignoreCache = (iSockAddr.Action() & KHostResIgnoreCache) ? ETrue : EFalse;
-	if (sa.Action() & KHostResInquiry)
+	if (iSockAddr.Action() & KHostResInquiry)
 		{
 		// We only support GIAC and LIAC
-		if (sa.IAC() != KLIAC && sa.IAC() != KGIAC)
+		if (iSockAddr.IAC() != KLIAC && iSockAddr.IAC() != KGIAC)
 			{
 			iRequestState = EError;
 			CompleteRequest(KErrNotSupported);
 			return;
 			}
-		sa.SetBTAddr(TBTDevAddr());
+		iSockAddr.SetBTAddr(TBTDevAddr());
 		iRequestState = EInquiry;
 		if (iInquiryStatus == EInquiryReady)
 			{// Need to start the inquiry process
 			iInquiryStatus = EInquiring;
 			// We set this before calling StartInquiry, as StartInquiry can call InquiryComplete synchronously.
 			iResults.Reset();
-			iInquiryMgr.StartInquiry(*this, sa.IAC(), ignoreCache);
+			iInquiryMgr.StartInquiry(*this, iSockAddr.IAC(), ignoreCache);
 			}
 		}
 	else // Not an inquiry - just a name lookup
 		{
 		// Just name lookup -- add it to the result set, and request a lookup of it
 		iResults.Reset();
-		CBTInqResultRef* ref = iInquiryMgr.AddEntryToCache(sa.BTAddr());
+		CBTInqResultRef* ref = iInquiryMgr.AddEntryToCache(iSockAddr.BTAddr());
 		if(ref)
 			{// This ref is in cache -- need to make our own ref
 			ref = iResults.Add(ref->Result());
 			}
 		if (!ref)
 			CompleteRequest(KErrNoMemory);
 			return;
 			}
 		iResults.NextResult(); // Move iter onto first (only) result
 		iRequestState = ENameLookup;
-		iInquiryMgr.LookupName(*this, sa.BTAddr(), ignoreCache, ETrue);
+		iInquiryMgr.LookupName(*this, iSockAddr.BTAddr(), ignoreCache, ETrue);
 		}
 	TryToCompleteRequest();
 	}
 TInt CBTHostResolver::SetOption(TUint /*aLevel*/, TUint /*aName*/, const TDesC8& /*aOption*/)
 	// Check if we've already seen this result
 	CBTInqResultRef* ref = iResults.FindEntry(aResult.LogEntry().iBdaddr);
 	if (ref)
 		return;
-	TInquirySockAddr& sa = TInquirySockAddr::Cast(iNameRecord->iAddr);
+	if(!aResult.HasRespondedToIAC(iSockAddr.IAC()))
-	if(!aResult.HasRespondedToIAC(sa.IAC()))
 		return; // It's never responded to our IAC, so ignore it
 	ref = iResults.Add(aResult);
 	if (!ref)
 		{
 		}
 	if(iNameLookupMode == EDoGetNames)
 		{
 		// Find out whether cache was supposed to be ignored from TNameRecord that was passed into GetByAddress() previously
-		TBool ignoreCache = (sa.Action() & KHostResIgnoreCache) ? ETrue : EFalse;
+		TBool ignoreCache = (iSockAddr.Action() & KHostResIgnoreCache) ? ETrue : EFalse;
 		// Handle a "special" case: Cache is to be ignored, but we got the _complete_ name during the inquiry process inside an EIR
 		// (which doesn't count as cached data, since it's freshly arrived from the radio). In this case we don't really want to
 		// launch a remote name request
 		if(ignoreCache && ref->Result().IsEirPresent() && ref->Result().Codec().IsDataTypePresent(EEirLocalNameComplete))
 			{
 	}
 TUint CBTHostResolver::GetIAC() const
 	{
 	LOG_FUNC
-	if (!iNameRecord)
+	TUint ret = 0;
-		{
+	if (iInquiryStatus == EInquiring)
-		return 0;		// avoid dereferencing a null ptr
+		{
+		ret = iSockAddr.IAC(); // Only return IAC if an inquiry is requested
 		}
-	TInquirySockAddr& sa = TInquirySockAddr::Cast(iNameRecord->iAddr);
+	return ret;
-	return sa.IAC();
 	}
 TInt CBTHostResolver::SecurityCheck(MProvdSecurityChecker *aSecurityChecker)
 	{
 	LOG_FUNC
 	Must only break out (i.e. return) if the request is completed, or
 	non-blocking mode requested
 **/
 	{
 	LOG_FUNC
-	TInquirySockAddr& sa = TInquirySockAddr::Cast(iNameRecord->iAddr);
+	if ((iSockAddr.Action() & KHostResInquiry) && iRequestState == EInquiry)
-	if ((sa.Action() & KHostResInquiry) && iRequestState == EInquiry)
 		{
 		CBTInqResultRef* refNextRes = iResults.NextResult();
 		if (refNextRes)
 			{// Got a result to send up
 			if (iNameLookupMode == EDoGetNames)
 				{// Need to get the name of this baby...
 				iRequestState = ENameLookup;
 				}
 			else
 				{//Complete!
-				refNextRes->Result().GetInquirySockAddr(sa);
+				refNextRes->Result().GetInquirySockAddr(TInquirySockAddr::Cast(iNameRecord->iAddr));
 				// If EIR was requested and we got one, stick it in the name field
 				TInt err = KErrNone;
-				if(sa.Action() & KHostResEir)
+				if(iSockAddr.Action() & KHostResEir)
 					{
-					err = refNextRes->Result().GetEir(*iNameRecord, (sa.Action() & KHostResIgnoreCache) && !(sa.Action() & KHostResName));
+					err = refNextRes->Result().GetEir(*iNameRecord, (iSockAddr.Action() & KHostResIgnoreCache) && !(iSockAddr.Action() & KHostResName));
 					}
 				else
 					{
 					err = refNextRes->Result().GetName(*iNameRecord);
 					}
 				}
 			return;
 			}
 		}
-	if ((sa.Action() & KHostResName) && iRequestState == ENameLookup)
+	if ((iSockAddr.Action() & KHostResName) && iRequestState == ENameLookup)
 		{
 		CBTInqResultRef* refNextRes = iResults.CurrentResult();
 		if(!refNextRes)
 			{// Can't get the name... no result to lookup
 			CompleteRequest(KErrHostResNoMoreResults);
 		do
 			{
 			CBTInqResultRecord& rec = refNextRes->Result();
 			if(rec.HaveNameLookupResult() && !rec.IsNameRequestPending() && rec.IsNameComplete())
 				{// Got a name! Complete the request
-				rec.GetInquirySockAddr(sa);
+				rec.GetInquirySockAddr(TInquirySockAddr::Cast(iNameRecord->iAddr));
 				TInt err = rec.NameLookupResultCode();
 				if (err == KErrNone)
 					{// Copy & convert the UTF-8 name over into the result record.
-					if(sa.Action() & KHostResEir)
+					if(iSockAddr.Action() & KHostResEir)
 						{
 						err = rec.GetEir(*iNameRecord, EFalse);
 						}
 					else
 						{
 				if (err != KErrNone)
 					{
 					iNameRecord->iName.Zero();
 					}
 				// Name lookup complete (poss. with errors)
-				if(sa.Action() & KHostResInquiry)
+				if(iSockAddr.Action() & KHostResInquiry)
 					{// Ignore name failures if we're also doing inquiry
 					CompleteRequest(KErrNone);
 					}
 				else
 					{// Report any error encountered (or none)
 		}
 	else if(iRequestState==EError)
 		{
 		CompleteRequest(KErrHardwareNotAvailable);
 		}
-	if(sa.Action() & KHostResDontBlock)
+	if(iSockAddr.Action() & KHostResDontBlock)
 		{// Complete any outstanding non-blocking operation
 		CompleteRequest(KErrWouldBlock);
 		}
 	}
 	}
 void CBTInquiryMgr::DeletingHostResolver()
 	{
 	LOG_FUNC
-	// A host resolver is being deleted - we need to check if any other host resolvers want inquiry results from the current IAC.
+	// A host resolver is being deleted - we need to check if we need to change IAC.
-	if(!iRequestedInquiryIAC)
+	// If no host resolver is requesting an inquiry, just let the inquiry run to fill up the cache
-		{
+	TUint requestedIAC = RequestedInquiryIAC();
-		 //No 'current' IAC exists
+	if (iHWState == EInquiry && requestedIAC != 0 && iCurrentInquiryIAC != requestedIAC)
-		 return;
+		{
-		}
+		TInt err = CancelHardwareInquiry();
-	TDblQueIter<CBTHostResolver> iter(iHRs);
+		if(err==KErrNone)
-	TBool iacFound=EFalse;
+			{
-	while (iter)
+			SetHWState(ECancellingForNewIAC);
-		{
+			iFlusher->Cancel();     // Stop watchdog, start flusher.
-		if ((iter++)->GetIAC() == iRequestedInquiryIAC)
+			}
-			{
+		}
-			iacFound = ETrue;
+	}
-			}
-		}
+TUint CBTInquiryMgr::RequestedInquiryIAC()
-	if (!iacFound)
+{
-		{
+TUint ret = 0;
-		iRequestedInquiryIAC = 0;
+TDblQueIter<CBTHostResolver> iter(iHRs);
-		}
+CBTHostResolver* hostRes = NULL;
-	}
+while ((hostRes = iter++) != NULL)
+{
+	// Only overwrite the requested IAC if:
+	// - We haven't found a host resolver requesting an IAC yet, or
+	// - This host resolver requests LIAC, which we prioritise over GIAC
+if (ret == 0 || hostRes->GetIAC() == KLIAC)
+{
+ret = hostRes->GetIAC();
+}
+}
+return ret;
+}
 void CBTInquiryMgr::InquiryResult(TInt aErr,const TInquiryLogEntry& aEntry)
 /**
 	Single Inquiry result received.
 	Called via HCI for each incoming inquiry result. Need to demultiplex these
 					have been generated. We don't use this info atm, though.
 **/
 	{
 	LOG_FUNC
 	SetCacheAge(iCurrentInquiryIAC, 0);
-	TUint iacToComplete = iRequestedInquiryIAC;
+	TUint iacToComplete = iCurrentInquiryIAC;
-	iRequestedInquiryIAC = 0;
+	iCurrentInquiryIAC = 0;
 	iFlusher->Cancel(); // Stop watchdog, start flusher
 	SetHWState(EIdle);
 	// don't publish status here, might be doing a name lookup
 	EnableFlusher();
 			}
 		hr++;
 		}
 	// Only queue the inquiry if we have completed all the name requests from this one.
 	// Otherwise, it will be issued after all the remote name requests have completed.
-	if (iQueuedInquiryIAC != 0 && iPendingNameRequests == 0)
+	if (RequestedInquiryIAC() != 0 && iPendingNameRequests == 0)
 		{
-		iRequestedInquiryIAC = iQueuedInquiryIAC;
-		iQueuedInquiryIAC = 0;
 		DoInquiry();
 		}
 	}
 /**
 			}
 		}
 	// In case we're now free, do inquiry
 	LOG(_L("CBTInquiryMgr::HandleRemoteNameResult asking for another inquiry"));
-	if (iPendingNameRequests == 0 && iRequestedInquiryIAC == 0) // If we've completed the current inquiry, see if we've got another one queued.
-		{
-		iRequestedInquiryIAC = iQueuedInquiryIAC;
-		iQueuedInquiryIAC = 0;
-		}
 	DoInquiry();
 	}
 const TDesC8* CBTInquiryMgr::DeviceNameFromCache(const TBTDevAddr& aAddr)
 /**
 		LOG(_L("CBTInquiryMgr::StartInquiry giving result from cache"));
 		aResolver.InquiryComplete(KErrNone);
 		return;
 		}
-	if (iRequestedInquiryIAC || iQueuedInquiryIAC)
+	if (iCurrentInquiryIAC)
 		{
-		LOG(_L("CBTInquiryMgr::StartInquiry iRequestedInquiryIAC"));
+		LOG(_L("CBTInquiryMgr::StartInquiry"));
-		if(iRequestedInquiryIAC == aIAC)
+if (aIgnoreCache && (aIAC == iCurrentInquiryIAC || aIAC == KGIAC))
-			{
+{
-			// an Inquiry is ongoing, return any results already found during the
+// an Inquiry is ongoing, return any results already found during the
-			// current Inquiry if not already done so as part of the complete cache
+// current Inquiry if not already done so as part of the complete cache
-			if (aIgnoreCache)
+iCurrentResults.ReturnToFirstResult();
-				{
+while (CBTInqResultRef* ref = iCurrentResults.NextResult())
-				iCurrentResults.ReturnToFirstResult();
+{
-				while (CBTInqResultRef* ref = iCurrentResults.NextResult())
+if (ref->Result().iFoundDuringCurrentInquiry)
-					{
+{
-					if (ref->Result().iFoundDuringCurrentInquiry)
+aResolver.InquiryResult(ref->Result());
-						{
+}
-						aResolver.InquiryResult(ref->Result());
+}
-						}
+}
-					}
+		if(iCurrentInquiryIAC == aIAC)
-				}
+			{
 			// the current Inquiry will just continue
 			return;
 			}
-		if (aIAC == KGIAC)
+		if(iHWState == EInquiry && RequestedInquiryIAC() != iCurrentInquiryIAC)
 			{
-			// If the current IAC is GIAC, and the requested inquiry IAC isn't, it must be LIAC
+			// The requested IAC (which prioritises LIAC) is different to the current IAC, so cancel to change the IAC
-			__ASSERT_DEBUG(iRequestedInquiryIAC == KLIAC, Panic(EBTUnexpectedIAC));
-			// Queue a general inquiry for when the current limited inquiry has finished
-			iQueuedInquiryIAC = aIAC;
-			return;
-			}
-		else if(iHWState == EInquiry)
-			{
-			// The host resolver should only allow through GIAC and LIAC, and we handle GIAC above
-			__ASSERT_DEBUG(aIAC == KLIAC, Panic(EBTUnexpectedIAC));
-			// We favour a Limited inqiury, so interrupt the current general inquiry
 			TInt err = CancelHardwareInquiry();
 			if(err!=KErrNone)
 				{
 				LOG(_L("CBTInquiryMgr::StartInquiry cancel didn't work"));
 				aResolver.InquiryComplete(err); // cancel went wrong
 				return;
 				}
-			// Queue a general inquiry for when the limited inquiry is complete
-			iRequestedInquiryIAC = KLIAC;
-			iQueuedInquiryIAC = KGIAC;
 			SetHWState(ECancellingForNewIAC);
 			iFlusher->Cancel(); 	// Stop watchdog, start flusher.
 			return;
 			}
-		else
+		}
-			{
-			// The host resolver should only allow through GIAC and LIAC, and we handle GIAC above
-			__ASSERT_DEBUG(aIAC == KLIAC, Panic(EBTUnexpectedIAC));
-			iRequestedInquiryIAC = KLIAC;
-			iQueuedInquiryIAC = KGIAC;
-			}
-		}
-	iRequestedInquiryIAC = aIAC;
 	iInquiryInteruptions = 0;
 	DoInquiry();
 	}
 	Only starts it if there isn't already one going.
 **/
 	{
 	LOG_FUNC
-	if(iRequestedInquiryIAC == 0 || iHWState != EIdle || iHRs.IsEmpty())
+	if(RequestedInquiryIAC() == 0 || iHWState != EIdle || iHRs.IsEmpty())
 		{
 #ifdef _DEBUG
-		LOG3(_L("Not starting inquiry. iRequestedInquiryIAC == %d, iHWState == %d, iHostResolverCount == %d"), iRequestedInquiryIAC, iHWState, iNumHRs);
+		LOG3(_L("Not starting inquiry. RequestedInquiryIAC == %d, iHWState == %d, iHostResolverCount == %d"), RequestedInquiryIAC(), iHWState, iNumHRs);
 		if (iHRs.IsEmpty())
 			{
 			LOG(_L("No HRs interested in results - Stopping discovery"));
 			}
 #endif
 		if (iHWState == EIdle)
 			{
 			LOG(_L("CBTInquiryMgr::DoInquiry PublishStatus Idle"));
 			PublishStatus();// make sure the status says we're idle
+			}
+		if (RequestedInquiryIAC() == 0)
+			{
+			iCurrentInquiryIAC = 0;
 			}
 		return;
 		}
 	// If pending on name lookup, we'll do it when that finishes
 		}
 	else
 		{
 		// Couldn't start inquiry.
 		// Make sure the request is completed.
-		iRequestedInquiryIAC = 0;
+		iCurrentInquiryIAC = 0;
 		InquiryComplete(err, 0);
 		LOG(_L("CBTInquiryMgr::DoInquiry PublishState Idle couldn't start inquiry"));
 		PublishStatus();
 		return;
 		}
 	}
 TInt CBTInquiryMgr::StartHardwareInquiry()
 	{
 	LOG_FUNC
-	iCurrentInquiryIAC = iRequestedInquiryIAC;
+	iCurrentInquiryIAC = RequestedInquiryIAC();
 	// attempt to free up baseband space for best performance discovery
 	iLinkMgrProtocol.PhysicalLinksMgr().RequireSlotSpace(); // will *eventually* put connections in hold - we dont wait though
 	TRAPD(err, StartInquiryL(iCurrentInquiryIAC, KInquiryLength, KInquiryMaxResults));
 	return err;
 	while(CBTInqResultRef *ref = iCurrentResults.NextResult())
 		{
 		CBTInqResultRecord& rec = ref->Result();
 		if(rec.IsNameRequestPending())
 			{
-			if(!iRequestedInquiryIAC ||
+			if(RequestedInquiryIAC() == 0 || rec.NameLookupAttempts() < KMaxNameLookupAttemptsDuringInquiry)
-			   rec.NameLookupAttempts() < KMaxNameLookupAttemptsDuringInquiry)
 				{
 				// We want the first record for the current IAC or a record for an explicit name request.
 				// Failing that, we'll just have the first record
 				if (rec.HasRespondedToIAC(iCurrentInquiryIAC) || rec.IsExplicitNameRequest())
 					{

changeset 48	22de2e391156
parent 34	9d84592f5036
child 51	20ac952a623c