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

// This implements the CLinkMgrProtocol object that is the contact point from

// BT PRT to the LinkMgr stack

// At present this class also remembers the configuration of the controller

// -- no particular reason - could be encapsulated in a class that the facade

// knows about.

// 

//

#include <bt_sock.h>

#include <bluetooth/logger.h>

#include "debug.h"

#include <utf.h>

#include <bluetooth/hci/hciframe.h>

#include <bluetooth/aclsockaddr.h>

#include "linkmgr.h"

#include "hcifacade.h"

#include "bt.h"

#include "hostresolver.h"

#include "linkmuxer.h"

#include "physicallinksmanager.h"

#include "linkconsts.h"

#include "eirmanserver.h"

#include "eirmanager.h"

#include "eirpublisherlocalname.h"

#include "eirpublishertxpowerlevel.h"

#include "bredrcontrollerconfiguration.h"

#include "ProxySAP.h"

#include "SCOSAP.h"

#include "ACLSAP.h"

#include "VendorSAP.h"

#include "vendorspecific.h"

#include "Subscribers.h"

#include "BTSec.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

#ifdef _DEBUG

PANICCATEGORY("linkmgr");

#endif

const TInt KLengthOfDeviceClass = 11;			// 11 bits in the device class portion of the CoD

const TInt KStartingOffsetOfDeviceClass = 2;	// 2 LSB bits for format type

const TUint32 KDeviceClassReset = 0;			// used to reset persistent data

// Constant which can be ANDed with a complete CoD bitmask to extract the device class portion.

const TInt KDeviceClassBitMask = ((1 << KLengthOfDeviceClass) - 1) << KStartingOffsetOfDeviceClass;

enum TLinkMgrPanic

	{

	ELinkMgrProtocolOpenedAfterClose,

	ELinkMgrProtocolBadAFHHostChannelClassification,

	EUnknownFatalError,

	ELocalDeviceBadHandle,

	ERegistrySessionClosedTooManyTimes,

	ERegistrySessionDeletedWhenOpen,

	};

void Panic(TLinkMgrPanic aPanic)

// Panic L2CAP due to stack bug.

	{

	LOG_STATIC_FUNC

	_LIT(KL2CAPPanicName, "BTLinkMgr");

	User::Panic(KL2CAPPanicName, aPanic);

	}

// Construction & Initialisation

CLinkMgrProtocol::CLinkMgrProtocol(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

: CBluetoothProtocolBase(aSecMan, aControlPlane, aCodMan)

, iDebugModeDefinitionResult(KErrGeneral)

	{

	LOG_FUNC

	TCallBack cb(TryToClose, this);

	iIdleTimerEntry.Set(cb);

	}

CLinkMgrProtocol::~CLinkMgrProtocol()

/**

	Delete all our stuff

**/

	{

	LOG_FUNC

	RemoveIdleTimerEntry();

	// Delete setter P&S values

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetScanningStatus);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetLimitedDiscoverableStatus);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetDeviceClass);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetAFHHostChannelClassification);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetAFHChannelAssessmentMode);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetDeviceName);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetAcceptPairedOnlyMode);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetPageScanParameters);

	// Delete standard P&S values (possibly trying to delete already deleted shared set+get values)

	iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetLocalDeviceAddress);

	iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetPHYCount);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetConnectingStatus);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetScanningStatus);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetLimitedDiscoverableStatus);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetDeviceClass);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetDeviceName);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetAcceptPairedOnlyMode);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothHostResolverActive);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothSetSimplePairingDebugMode);

	iProperty.Delete(KPropertyUidBluetoothCategory,	KPropertyKeyBluetoothGetPageScanParameters);

	delete iPhysicalLinksMgr;

	delete iInquiryMgr;

	delete iEirManServer;

	delete iACLStateFactory;

	delete iSCOStateFactory;

	SecMan().ClearHCICommandQueue(); // clears up the commands

	SecMan().ClearLinksMgrProtocol();

	SecMan().ClearPhysicalLinksMgr();

	delete iLinkMuxer;

	delete iHCIFacade;

	delete iRegistryUpdater;

	DeletePublications();

	iSubscribers.ResetAndDestroy();

	iLocalDevice.Close();

	delete iRegSess;

	}

CLinkMgrProtocol* CLinkMgrProtocol::NewL(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

	{

	LOG_STATIC_FUNC

	CLinkMgrProtocol* i=new (ELeave) CLinkMgrProtocol(aSecMan, aControlPlane, aCodMan);

	return i;

	}

void CLinkMgrProtocol::InitL(TDesC& /*aTag*/)

/**

	Pre-binding initialise.

	Allocate any objects we need here.

	ESOCK ensures that this function will only be called once per

	object of this class, regardless of how long it hangs around.

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iClosePending, Panic(ELinkMgrProtocolOpenedAfterClose));

	__ASSERT_DEBUG(!iIdleEntryQueued, Panic(ELinkMgrProtocolOpenedAfterClose));

	__ASSERT_DEBUG(!iHCIFacade, Panic(ELinkMgrProtocolOpenedAfterClose));

	// Get the local device settings from persistent store

	// By keeping a session open for the lifetime of this protocol

	// we prevent RegServ being created during connection time.

	LOG(_L("LinkMgr : Initialising RegistryServer"));

	iRegSess = CRegistrySession::NewL(*this);

	TInt err = iLocalDevice.Open(iRegSess->RegServ());

	if (err ==KErrNone)

		{

		// read local device settings (e.g page scan\inquiry scan) from registry

		err = iLocalDevice.Get(iLocalDeviceSettings);	// ignore error - can continue

		__ASSERT_DEBUG(err==KErrNone, Panic(EUnknownFatalError));		

		//

		// Mask off the service class bits from the CoD -- we're not interested in the

		// registry's values for anything other than the device class part.

		// There's a nice terminology overload here, as the 'Class of Device' contains

		// both a device class and a service class.  It might have been nice if the

		// getter and setter methods were 'ClassOfDevice', but even that wouldn't help

		// much...

		//

		iLocalDeviceSettings.SetDeviceClass(iLocalDeviceSettings.DeviceClass() & KDeviceClassBitMask);

		//NB - no (ELeave) here - in OOM we'd rather continue and not update the registry

		//than Leave.  All calls to methods are guarded by "if (iRegistryUpdater)"

		iRegistryUpdater = new CRegistryUpdater(iLocalDevice, iLocalDeviceSettings);

		}

	LOG(_L("LinkMgr : Creating HCIFacade (and HCI)"));

	iHCIFacade = CHCIFacade::NewL(*this); 	// Create HCI/HCIFacade first

	iPhysicalLinksMgr = CPhysicalLinksManager::NewL(*this, *iHCIFacade, *iRegSess, SecMan(), CodMan());

	iPhysicalLinksMgr->SetAcceptPairedOnlyMode(iLocalDeviceSettings.AcceptPairedOnlyMode()); // Tell the physical links manager the persisted value for the accept paired only mode

	iHCIFacade->SetPhysicalLinksMgr(*iPhysicalLinksMgr); 	// Tell HCIFacade of ConnMgr

	SecMan().SetPhysicalLinksMgr(*iPhysicalLinksMgr);

	SecMan().SetLinksMgrProtocol(*this);

	SecMan().SetHCICommandQueue(iHCIFacade->CommandQController());

	LOG(_L("LinkMgr : Initialising Link Muxer"));

	iLinkMuxer=CLinkMuxer::NewL(*this, *iHCIFacade);

	iHCIFacade->SetLinkMuxer(*iLinkMuxer);

	iACLStateFactory = CACLLinkStateFactory::NewL();

	iSCOStateFactory = CSyncLinkStateFactory::NewL();

	LOG(_L("LinkMgr : Initialising EirManServer"));

	iEirManServer = CEirManServer::NewL(iHCIFacade->CommandQController(), *this);

	LOG(_L("LinkMgr : Initialising InquiryMgr"));

	iInquiryMgr = CBTInquiryMgr::NewL(*this);

	iInquiryMgr->SetHCICommandQueue(iHCIFacade->CommandQController());

	LOG(_L("LinkMgr : Configuring HCIFacade)"));

	iHCIFacade->InitL(iLocalDeviceSettings);// passes ownership of device

	// Inquiry and page scan is read from BT Registry and set it to P&S

	// As there is no listening socket, they are set to OFF on HW yet!

	// P&S value is taken to account as soon we open the first listening socket!

	DefinePublications(iLocalDeviceSettings.ScanEnable());

	// set up subscribers

	CSubscriber* subscriber;

	subscriber = CDiscoverabilitySubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CLimitedSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CDeviceClassSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CAFHHostChannelClassificationSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CDeviceNameSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CRegistryRemoteTableSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CAcceptPairedOnlySubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	subscriber = CAFHChannelAssessmentModeSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	if(iDebugModeDefinitionResult == KErrNone)

		{

		// Only subscribe on debug mode if we have managed to successfully define

		// the key ourselves (this is because it needs to be protected with the very 

		// strong CommDD capability).

		subscriber = CDebugModeSubscriber::NewL(*this);

		CleanupStack::PushL(subscriber);

		User::LeaveIfError(iSubscribers.Append(subscriber));

		CleanupStack::Pop(subscriber);

		}

	subscriber = CPageScanParametersSubscriber::NewL(*this);

	CleanupStack::PushL(subscriber);

	User::LeaveIfError(iSubscribers.Append(subscriber));

	CleanupStack::Pop(subscriber);

	// set CoD - leave if goes wrong, user's device will be "unknown" otherwise

	// NB - In future we should tie this to the SDP Server...(or someother higher API...)

	if (iLocalDeviceSettings.DeviceClass() && iLocalDeviceSettings.IsValidDeviceClass())

	// Some phones never set their CoD in s/w, we don't want to blat

	// over their h/w settings

		{

		iPendingLocalDeviceSettings.SetDeviceClass(iLocalDeviceSettings.DeviceClass()); //we expect this after power on

		}

	CodMan().Initialise();	// Cod Service Manager can now get a valid CoD

	if(iLocalDeviceSettings.AFHChannelAssessmentMode() == EFalse)

	// If this feature is supported it will start off switched on

		{

		SetAFHChannelAssessmentModeL(iLocalDeviceSettings.AFHChannelAssessmentMode());

		}

	//Attempt to make sure that controller has the same value as the registry

	//and that the P&S key 'KPropertyKeyBluetoothGetLimitedDiscoverableStatus'

	//is, as a consequence, 'Set' appropriately (when the associated controller 

	//event arrives).

	DoSetLimitedDiscoverableL(iLocalDeviceSettings.LimitedDiscoverable());

	LOG(_L("LinkMgr : Initialising BR/EDR Controller Configuration"));

	iBrEdrControllerConfiguration = CBrEdrControllerConfiguration::NewL(iHCIFacade->CommandQController(), *this);

	LOG(_L("LinkMgr : Initialising complete"));

	}

void CLinkMgrProtocol::DefinePublications(THCIScanEnable aHCIScanEnable)

	{

	LOG_FUNC

	// 6 properties for setting.

	// Its possible that these are re-defined below, but we are discarding any KErrAlreadyExists.

	// As the setters require more capabilities we ensure that they get defined first.

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetScanningStatus,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	// Even if we initialise KPropertyKeyBluetoothSetScanningStatus to Inquiry & 

	// Page scanning enabled, it's not turned on at this point. Only when first

	// listening socket is opened, this value will control the inquiry scan & page scan

	(void)(iProperty.Set(KPropertyUidBluetoothCategory,

						 KPropertyKeyBluetoothSetScanningStatus,

						 aHCIScanEnable));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetLimitedDiscoverableStatus,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetDeviceClass,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetAFHHostChannelClassification,

							RProperty::EByteArray,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetAFHChannelAssessmentMode,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetDeviceName,

							RProperty::EText,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetAcceptPairedOnlyMode,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	iDebugModeDefinitionResult = (iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetSimplePairingDebugMode,

							RProperty::EInt,

							KLOCAL_SERVICES,

							KCOMMDD

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothSetPageScanParameters,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void) RProperty::Set(KPropertyUidBluetoothCategory,

						  KPropertyKeyBluetoothSetPageScanParameters,

						  EStandardPageScanParameters);

	// Original Get P&S value definitions.

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetLocalDeviceAddress,

							RProperty::EByteArray,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetPHYCount,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetConnectingStatus,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetScanningStatus,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetLimitedDiscoverableStatus,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetDeviceClass,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetDeviceName,

							RProperty::EText,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetAcceptPairedOnlyMode,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

 	(void) (iProperty.Define(KPropertyUidBluetoothCategory,

 							KPropertyKeyBluetoothHostResolverActive,

 							RProperty::EInt,

 							KLOCAL_SERVICES,

 						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

 							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetSimplePairingDebugMode,

							RProperty::EInt,

							KLOCAL_SERVICES,

						   	KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void)(iProperty.Define(KPropertyUidBluetoothCategory,

							KPropertyKeyBluetoothGetPageScanParameters,

							RProperty::EInt,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL,

							KLOCAL_SERVICES_AND_NETWORK_CONTROL

							));

	(void) RProperty::Set(KPropertyUidBluetoothCategory,

						  KPropertyKeyBluetoothGetPageScanParameters,

						  EStandardPageScanParameters);

	}

void CLinkMgrProtocol::DeletePublications()

	{

	LOG_FUNC

	//we own them, so they'll get deleted

	iProperty.Close();

	}

void CLinkMgrProtocol::StartL()

/**

	Binding complete.

	Startup call from esock.  Do nothing

	If HCI needs any start-up, do it here.

**/

	{

	LOG_FUNC

	}

// From higher protocol

void CLinkMgrProtocol::BindL(CProtocolBase* protocol, TUint /* id*/)

	{

	LOG_FUNC

	TServerProtocolDesc prtDesc;

	protocol->Identify(&prtDesc);

#ifdef TCI

	if(prtDesc.iAddrFamily!=KBTAddrFamily || prtDesc.iProtocol!=KTCIL2CAP)

#else

	if(prtDesc.iAddrFamily!=KBTAddrFamily || prtDesc.iProtocol!=KL2CAP)

#endif

		{

		User::Leave(KErrBtEskError);

		}

	// Store this for error propogation

	//