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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// L2CAP Host resolver.

// Implements Inquiry and Name lookup

// 

//

#include "hostresolver.h"

#include <bluetooth/logger.h>

#include <bluetooth/hci/event.h>

#include <bluetooth/hci/hciutil.h>

#include <bluetooth/hci/hciconsts.h>

#include <bluetooth/hci/inquirycommand.h>

#include <bluetooth/hci/inquirycancelcommand.h>

#include <bluetooth/hci/writeinquirymodecommand.h>

#include <bluetooth/hci/writeextendedinquiryresponsecommand.h>

#include <bluetooth/hci/readextendedinquiryresponsecommand.h>

#include <bluetooth/hci/remotenamerequestcommand.h>

#include <bluetooth/hci/remotenamereqcompleteevent.h>

#include <bluetooth/hci/remotenamerequestcancelcommand.h>

#include <bluetooth/hci/remotehostsupportedfeaturesnotificationevent.h>

#include <bluetooth/hci/readlocalnamecommand.h>

// Command Events

#include <bluetooth/hci/inquiryresultevent.h>

#include <bluetooth/hci/inquiryresultwithrssievent.h>

#include <bluetooth/hci/extendedinquiryresultevent.h>

// Command Complete Events

#include <bluetooth/hci/readlocalnamecompleteevent.h>

#include <bluetooth/hci/commandcompleteevent.h>

#include <bluetooth/hci/commandstatusevent.h>

#include <e32std.h>

#include <s32mem.h>

#include <bt_sock.h>

#include <utf.h>

#include "debug.h"

#include "linkutil.h"

#include "physicallinksmanager.h"	// to get baseband freed up for inquiries

#include "BTSec.h"

//Diagnostic string for security check failures, in builds without platsec

//diagnostics this will be NULL.

const char* const KBT_HOSTRESOLVER_NAME_DIAG = __PLATSEC_DIAGNOSTIC_STRING("Bluetooth Host Resolver");

const static TUint KHostResDontBlock = 4;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_HOSTRESOLVER);

#endif

//

//	BT Inquiry Result record.

//

CBTInqResultRecord::CBTInqResultRecord(const TBTDevAddr& aAddr)

	: iCodec(iEntry.iExtendedInquiryResponse)

	{

	LOG_FUNC

	iEntry.iBdaddr = aAddr;

	// Default to page scan repetition mode R2 as recommended by Bray to give best

	// chance of success for host resolver needs.

	// Also allow other default values to be entered here

	iEntry.iPageScanRepetitionMode = KDefaultBluetoothPageScanRepMode;

	iEntry.iPageScanMode = KDefaultBluetoothPageScanMode;

	iEntry.iClockOffset = KDefaultBluetoothClockOffset;

	iEntry.iCoD = KDefaultBluetoothClassOfDevice;

	if(aAddr!=TBTDevAddr())

		{

		iJuiceFromHCIMask = EBluetoothAddr;

		}

	//else 0 cos 'C' class

	SetNameValid(EFalse);

	}

CBTInqResultRecord::~CBTInqResultRecord()

	{

	LOG_FUNC

	iIACs.Close();

	}

inline void CBTInqResultRecord::Open()

/**

	Some reference is now pointing at us.

	Inc the ref count.

**/

	{

	LOG_FUNC

	++iRefCount;

	}

void CBTInqResultRecord::Close()

/**

	Reference closing.

	Auto delete if this was the last reference pointing to us.

**/

	{

	LOG_FUNC

	--iRefCount;

	if (iRefCount <= 0)

		delete this;

	}

TInquiryLogEntry& CBTInqResultRecord::LogEntry()

/**

	The inquiry result.

	This is stored as it was returned from the HCI.

	The host resolver will convert it into an InquirySockAddr

	when a client actually wants to retreve it.

**/

	{

	LOG_FUNC

	return iEntry;

	}

inline void CBTInqResultRecord::SetName(const TDesC8& aName)

	{

	LOG_FUNC

	iName = aName;

	}

inline const TDesC8& CBTInqResultRecord::Name() const

/**

	The UTF name of the remote device.

	This is stored as it comes in off the wire, the host resolver

	converts to Unicode if & when a client actually requires it.

**/

	{

	LOG_FUNC

	return iName;

	}

inline TInt CBTInqResultRecord::IncFlushes()

/**

	Age the result record

	Returns it's new age.

**/

	{

	LOG_FUNC

	return ++iFlushes;

	}

inline TBool CBTInqResultRecord::IsNameValid() const

	{

	LOG_FUNC

	return iNameLookupResultCode == KErrNone;

	}

inline void CBTInqResultRecord::SetNameValid(TBool aBool)

	{

	LOG_FUNC

	if(aBool)

		iNameLookupResultCode = KErrNone;

	else

		iNameLookupResultCode = 1;

	}

void CBTInqResultRecord::SetNameLookupResultCode(TInt aResultCode)

	{// Only record error, if we don't have a valid name already

	LOG_FUNC

	if(!IsNameValid())

		iNameLookupResultCode = aResultCode;

	}

inline TBool CBTInqResultRecord::IsNameRequestPending() const

	{

	LOG_FUNC

	return iNameStatus & ENamePending;

	}

inline void CBTInqResultRecord::SetNamePending(TBool aBool)

	{

	LOG_FUNC

	if(aBool)

		iNameStatus |= ENamePending;

	else

		iNameStatus &= ~ENamePending;

	}

inline TBool CBTInqResultRecord::IsNameRefreshRequested() const

	{

	LOG_FUNC

	return iNameStatus & ENameRefreshRequested;

	}

inline void CBTInqResultRecord::SetNameRefreshRequested(TBool aBool)

	{

	LOG_FUNC

	if(aBool)

		iNameStatus |= ENameRefreshRequested;

	else

		iNameStatus &= ~ENameRefreshRequested;

	}

inline TBool CBTInqResultRecord::IsNameComplete() const

	{

	LOG_FUNC

	return iNameStatus & ENameComplete;

	}

inline void CBTInqResultRecord::SetNameComplete(TBool aBool)

	{

	LOG_FUNC

	if(aBool)

		iNameStatus |= ENameComplete;

	else

		iNameStatus &= ~ENameComplete;

	}

inline TBool CBTInqResultRecord::IsExplicitNameRequest() const

	{

	LOG_FUNC

	return iNameStatus & ENameExplicitRequest;

	}

inline void CBTInqResultRecord::SetExplicitNameRequest(TBool aBool)

	{

	LOG_FUNC

	if(aBool)

		iNameStatus |= ENameExplicitRequest;

	else

		iNameStatus &= ~ENameExplicitRequest;

	}

inline TBool CBTInqResultRecord::HaveNameLookupResult() const

	{

	LOG_FUNC

	return iNameLookupResultCode <= KErrNone;

	}

inline TInt CBTInqResultRecord::NameLookupResultCode() const

	{// Only valid if HaveNameLookupResult == ETrue

	LOG_FUNC

	__ASSERT_DEBUG(HaveNameLookupResult(), Panic(EBTNameLookupResultNotFound));

	return iNameLookupResultCode;

	}

inline TInt CBTInqResultRecord::NameLookupAttempts() const

	{

	LOG_FUNC

	return iNameLookupAttempts;

	}

void CBTInqResultRecord::GetInquirySockAddr(TInquirySockAddr& aAddr)

/**

	Read this result record out into a TInquirySockAddr.

**/

	{

	LOG_FUNC

	aAddr.SetBTAddr(LogEntry().iBdaddr);

	TBTDeviceClass cod(LogEntry().iCoD);

	aAddr.SetMajorServiceClass(cod.MajorServiceClass());

	aAddr.SetMajorClassOfDevice(cod.MajorDeviceClass());

	aAddr.SetMinorClassOfDevice(cod.MinorDeviceClass());

	TUint8 resultFlags = 0;

	if(iJuiceFromHCIMask & EBluetoothRssi)

		{

		TInquiryLogEntry* logEntry = &(LogEntry());

		resultFlags |= TInquirySockAddr::ERssiValid;

		aAddr.SetRssi(static_cast<TInquiryLogEntryWithRssi*>(logEntry)->iRssi.RSSI());

		}

	aAddr.SetResultFlags(resultFlags);

	}

TInt CBTInqResultRecord::GetEir(TNameRecord& aNameRec, TBool aIgnoreCachedName)

	{

	// Reformat the EIR (i.e. remove 0s from EIR) for the constructor

	LOG_FUNC

	TInt error = KErrNone;

	aNameRec.iName.Zero();

	iCodec.Set(aNameRec);

	if(IsEirPresent())

		{

		TInquiryLogEntry* logEntry = &(LogEntry());

		iCodec.Copy(static_cast<TInquiryLogEntryWithEir*>(logEntry)->iExtendedInquiryResponse);

		}

	// replace device name in eir with iName if there is a complete name present

	if(IsNameValid() && IsNameComplete() && !aIgnoreCachedName)

		{

		iCodec.SetDeviceName(iName, ETrue);

		}

	return error;

	}

TInt CBTInqResultRecord::GetName(TNameRecord& aNameRec)

	{

	LOG_FUNC

	TInt err = KErrNotFound;

	if(HaveNameLookupResult())

		{

		err = CnvUtfConverter::ConvertToUnicodeFromUtf8(aNameRec.iName, iName);

		if (err >= KErrNone)

			{

			err = KErrNone;

			if(!IsNameComplete())

				{

				aNameRec.iFlags |= TNameRecord::EPartial;

				}

			else

				{

				aNameRec.iFlags &= ~(TNameRecord::EPartial);

				}

			}

		}

	else

		{

		err = KErrNone; // just following the old way of working.

		aNameRec.iName.Zero();

		}

	return err;

	}

TInt CBTInqResultRecord::AddIAC(TUint aIAC)

/**

	Adds IAC into list of those this device has responded to

	@return KErrNone	IAC added without any bother

	@return KErrAlreadyExists	IAC already in list

**/

	{

	LOG_FUNC

	return iIACs.InsertInOrder(aIAC);

	}

inline TBool CBTInqResultRecord::HasRespondedToIAC(TUint aIAC)

	{

	LOG_FUNC

	return (iIACs.FindInOrder(aIAC) >= 0);

	}

inline TInt CBTInqResultRecord::NumberOfIACsRespondedTo()

	{

	LOG_FUNC

	return iIACs.Count();

	}

inline void CBTInqResultRecord::ClearIACs()

	{

	LOG_FUNC

	iIACs.Reset();

	}

//

//	Inquiry result reference.

//

CBTInqResultRef::CBTInqResultRef(CBTInqResultRef& aRef)

	: iRecord(aRef.iRecord)

	{

	LOG_FUNC

	iRecord.Open();

	}

CBTInqResultRef::~CBTInqResultRef()

	{

	LOG_FUNC

	iRecord.Close();

	iLink.Deque();

	}

CBTInqResultRef::CBTInqResultRef(CBTInqResultRecord& aRec)

	: iRecord(aRec)

	{

	LOG_FUNC

	iRecord.Open();

	}

inline CBTInqResultRecord& CBTInqResultRef::Result() const

	{

	LOG_FUNC

	return iRecord;

	}

//

//	BT Inquiry Result Set.

//

CBTInqResultSet::CBTInqResultSet()

	: iResultRefs(_FOFF(CBTInqResultRef, iLink)),

	iNextRefIter(iResultRefs)

	{

	LOG_FUNC

	}

CBTInqResultSet::~CBTInqResultSet()

	{

	LOG_FUNC

	Reset();

	}

void CBTInqResultSet::Reset()

	{

	LOG_FUNC

	while (!iResultRefs.IsEmpty())

		delete iResultRefs.First();

	ReturnToFirstResult();

	}

CBTInqResultRef* CBTInqResultSet::Add(CBTInqResultRecord& aRec)

	{

	LOG_FUNC

	CBTInqResultRef* ref = new CBTInqResultRef(aRec);

	if (!ref)

		{

		return 0;

		}

	iResultRefs.AddLast(*ref);

	if (!iNextRefIter)

		{

		iNextRefIter.SetToLast();

		}

	return ref;

	}

CBTInqResultRef* CBTInqResultSet::FindEntry(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	TResultQueIter iter(iResultRefs);

	while (iter)

		{

		CBTInqResultRef* ref = iter++;

		if (ref->Result().LogEntry().iBdaddr == aAddr)

			{

			return ref;

			}

		}

	return 0;

	}

CBTInqResultRef* CBTInqResultSet::NextResult()

	{

	LOG_FUNC

	return iCurrentResult = (iNextRefIter++);

	}

inline CBTInqResultRef* CBTInqResultSet::CurrentResult()

	{

	LOG_FUNC

	return iCurrentResult;

	}

void CBTInqResultSet::ReturnToFirstResult()

	{

	LOG_FUNC

	iNextRefIter.SetToFirst();

	iCurrentResult = 0;

	}

inline TBool CBTInqResultSet::IsEmpty()

	{

	LOG_FUNC

	return iResultRefs.IsEmpty();

	}

void CBTInqResultSet::MoveToback(CBTInqResultRef& aRef)

	{

	LOG_FUNC

	if(iNextRefIter == &aRef)

		NextResult();

	aRef.iLink.Deque();

	iResultRefs.AddLast(aRef);

	if (!iNextRefIter)

		{

		iNextRefIter.SetToLast();

		}

	}

//

//	BT Host resolver.

//

CBTHostResolver::CBTHostResolver(CBTInquiryMgr& aInquiryMgr)

	: iInquiryMgr(aInquiryMgr), 

	iRequestState(EIdle),

	iInquiryStatus(EInquiryReady)

	{

	LOG_FUNC

#ifdef _DEBUG

	iInquiryMgr.IncrementHRCount();

#endif

	}

CBTHostResolver::~CBTHostResolver()

	{

	LOG_FUNC

	iLink.Deque();

	iInquiryMgr.DeletingHostResolver();

#ifdef _DEBUG

	iInquiryMgr.DecrementHRCount();

#endif

	}

void CBTHostResolver::GetByName(TNameRecord& /*aName*/)

	{

	LOG_FUNC

	iNotify->QueryComplete(KErrNotSupported);

	}

void CBTHostResolver::GetByAddress(TNameRecord& aName)

	{

	LOG_FUNC

	__ASSERT_DEBUG(iRequestState == EIdle, Panic(EHostResolverTwoRequests));

	iNameRecord = &aName;

	iNameRecord->iName.Zero();

	iSockAddr = TInquirySockAddr::Cast(aName.iAddr);