// 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:

// This does the main work on behalf of the subsessions of liasing with DBMS

// 

//

#include "BTRegistryDB.h"

#include "btmanserverutil.h"

#include <utf.h>

#include <bluetooth/logger.h>

#include <bafl/sysutil.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_REGISTRY);

#endif

#ifdef _DEBUG

PANICCATEGORY("btregdb");

#endif

void Panic(TBTRegistryDBPanic aPanic)

	{

	LOG_STATIC_FUNC

	_LIT(KRegistryDBPanicName, "BT RegistryDB Panic");

	User::Panic(KRegistryDBPanicName, aPanic);

	}

//

CBTRegistry::CBTRegistry()

	{

	LOG_FUNC

	}

CBTRegistry::~CBTRegistry()

	{

	LOG_FUNC

	iDB.Close();

	iDBMSServer.Close();

	}

CBTRegistry* CBTRegistry::NewL()

	{

	LOG_STATIC_FUNC

	CBTRegistry* self = new (ELeave) CBTRegistry;

	CleanupStack::PushL(self);

	self->ConstructL();

#ifdef _DEBUG

	CleanupStack::Check(self);

#endif

	CleanupStack::Pop();

	return self;

	}

void CBTRegistry::ConstructL()

	{

	LOG_FUNC

	// we use a DBMS Server session as multiple clients may

	// be updating their views concurrently.  Without this

	// DBMS would (rightly) panic a rowset already in update

	User::LeaveIfError(iDBMSServer.Connect());

	OpenRegistryL();

	}

void CBTRegistry::OpenRegistryL()

/**

	Open the Registry DB.

	If it doesn't exist, attempt to create the necessary path,file and DB

**/

	{

	LOG_FUNC

	const static TInt KMaxTries=4;

	TInt err;

	TInt loopCount=0;

	//	In secure EKA2 DBMS land, registry DB is created in DBMS data cage

	do

		{

		err=iDB.Open(iDBMSServer, TBTRegistryDatabaseSecure()(), KBTRegistryDatabaseSecurePolicy());

		if(err == KErrNotFound)

			{

			CreateRegistryL();

			}

		else if (err != KErrNone)

			{

			// If we get here the BT registry file must be corrupt. 

			// Delete the file and go round the while loop once more.

			DeleteCorruptRegistryL();

			}

		else

			{

			TRAP(err,ValidateMetaTableL()); // make sure it's ok version etc.

			if(err==KErrNone)

				{

				TRAP(err,ValidatePersistTableL()); // make sure it's been properly written to

				}

			if (err!=KErrNone)

				{

				// Either the Meta Table validate failed or the Persist Table validate failed.

				// Delete the file and go round the while loop once more.

				DeleteCorruptRegistryL();

				}

			}	

		loopCount++;

		} while (err!=KErrNone && loopCount<KMaxTries);

	if(err != KErrNone)

		{

		User::Leave(KErrAbort);		// give up gracefully

		}

	// Purge any SSP debug link keys left over from a previous SSP debug session

	PurgeDebugLinkKeysL();

	(void)iDB.Compact();	// compact now

	// ready!

	}

RDbTable* CBTRegistry::OpenTableL(const TDesC& aTable)

/**

	Find tables of a given name

	@param	aTable	Name of table to open

	@return table and ownership

**/

	{

	LOG_FUNC

	RDbTable* table = new (ELeave) RDbTable;

	CleanupCloseDeletePushL(table);

	TInt err;

	err = table->Open(iDB, aTable);

	User::LeaveIfError(err);

	CleanupStack::Pop(); // table

	return table;

	}

RDbTable* CBTRegistry::OpenPersistTableL()

/**

	Find the persist table (local device settings)

	and return it and ownership

	@return ownership of table

**/

	{

	LOG_FUNC

	return OpenTableL(KPersistTable);

	}

RDbTable* CBTRegistry::OpenDeviceTableL()

/**

	Find the remote device table

	@return table and ownership

**/

	{

	LOG_FUNC

	return OpenTableL(KDeviceTable);

	}

RDbTable* CBTRegistry::OpenCSYTableL()

/**

	Find the CSY table

	@return table and ownership

**/

	{

	LOG_FUNC

	return OpenTableL(KCSYTable);

	}

void CBTRegistry::ValidateMetaTableL()

/**

	Go to Meta table and check version numbers etc

**/

	{

	LOG_FUNC

	RDbTable* table = OpenTableL(KMetaTable);

	CleanupCloseDeletePushL(table);

	// get the processSID

	TBool success = table->FirstL();

	if (!success)

		{

		LOG(_L("BT Registry DB Meta Table CORRUPT!"));

		User::Leave(KErrEof);

		}

	table->GetL();

	//put version checking in when we think about backup server

	TUint major = table->ColUint32(ColumnNoL(KMetaColName_VersionMajor, *table));

	TUint minor = table->ColUint32(ColumnNoL(KMetaColName_VersionMinor, *table));

	LOG(_L("CBTRegistry opened registry DB Meta Table"));

	LOG1(_L("\tMajorVersion: %d"), major); 

	LOG1(_L("\tMinorVersion: %d"), minor); 

	if(KRegistryDBVersionMajor != major || 

			KRegistryDBVersionMinor != minor)

		{

		User::Leave(KErrCorrupt);

		}

	CleanupStack::PopAndDestroy(table);

	}

void CBTRegistry::ValidatePersistTableL()

/**

	Go to Persist table and check local device values

**/

	{

	LOG_FUNC

	RDbTable* table = OpenTableL(KPersistTable);

	CleanupCloseDeletePushL(table);

	// get the processSID

	TBool success = table->FirstL();

	if (!success)

		{

		LOG(_L("BT Registry DB Local Device Table (Persist Table) CORRUPT!"));

		User::Leave(KErrEof);

		}

	table->GetL();

#ifdef _DEBUG

	// check the Local device configuration (aka Stack Persistance data)

	TPtrC8 addrBuf(table->ColDes8(ColumnNoL(KColName_DeviceAddress, *table)));

	TUint32 CoD = table->ColUint32(ColumnNoL(KPersistColName_CoD, *table));

	TUint8 scanEnable = table->ColUint8(ColumnNoL(KPersistColName_ScanEnable, *table));

	TPtrC8 name = table->ColDes8(ColumnNoL(KPersistColName_LocalName, *table));

	TUint8 powerSettings = table->ColUint8(ColumnNoL(KPersistColName_PowerSettings, *table));

	TUint8 limDisc = table->ColUint8(ColumnNoL(KPersistColName_LimitedDiscoverable, *table));

	TBool afhChannelAssessmentMode = table->ColUint8(ColumnNoL(KPersistColName_AFHChannelAssessmentMode, *table));

	TBool acceptPairedOnlyMode = table->ColUint8(ColumnNoL(KPersistColName_AcceptPairedOnlyMode, *table));

	LOG(_L("CBTRegistry opened registry DB Persist Table"));

	LOG6(_L("\tDevice Address (zero is acceptable): %02x%02x %02x%02x%02x%02x"),

			addrBuf[0],

			addrBuf[1],

			addrBuf[2],

			addrBuf[3],

			addrBuf[4],

			addrBuf[5]

			);

	LOG1(_L("\tCoD: 0x%02x"),CoD);

	LOG1(_L("\tScan Enable: 0x%02x"),scanEnable);

	LOG1(_L8("\tLocal Name: \"%S\""),&name); //name is an 8 bit string

	LOG1(_L("\tPower Settings: 0x%02x"),powerSettings);

	LOG1(_L("\tLimited Discoverable: 0x%02x"),limDisc);

	LOG1(_L("\tAFHChannelAssessmentMode: %d"),afhChannelAssessmentMode);

	LOG1(_L("\tAcceptPairedOnlyMode: %d"),acceptPairedOnlyMode);

#endif

	CleanupStack::PopAndDestroy(table);

	}

void CBTRegistry::CreateRegistryL()

/**

	Creates the Database and Tables we need

**/

	{

	LOG_FUNC

	//	In secure DBMS land, the BT Manager DB is created in DBMS's data cage.

	TInt err = iDB.Create(iDBMSServer, TBTRegistryDatabaseSecure()(), KBTRegistryDatabaseSecurePolicy()); // This leaves iDB in an open state.

	User::LeaveIfError(err);

	SetupDefaultRegistryL();

	// close the database

	iDB.Close();	

	LOG(_L("BT Registry DB Created successfully"));

	}

void CBTRegistry::PurgeDebugLinkKeysL()

/**

 	Remove (if present) any SSP debug link keys that may have been created by a previous SSP debug session.

**/

	{

	LOG_FUNC

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.MatchLinkKeyTypeL(ELinkKeyDebug);

	//We dont use the bookmark here, so employ a dummy bookmark.

	TDbBookmark dummy;

	RDbView* view = OpenViewL(query, dummy);

	CleanupCloseDeletePushL(view);

	if (!view->IsEmptyL())

		{

		// Debug link keys found in registry, unpair these.

		UnpairViewL(*view);

		}

	CleanupStack::PopAndDestroy(2, &query);	// view and query

	}

void CBTRegistry::CreatePersistTableL()

/**

	Create the table with all that is necessary for storing local device details

**/

	{

	LOG_FUNC

	CDbColSet* theColumns = CDbColSet::NewLC();

	// add in the columns for the Local device configuration (aka Stack Persistance data)

	theColumns->AddL(TDbCol(KColName_DeviceAddress,						EDbColText8));	// Binary not allowed in SQL

	theColumns->AddL(TDbCol(KPersistColName_CoD,						EDbColUint32));

	theColumns->AddL(TDbCol(KPersistColName_ScanEnable,					EDbColUint8));

	// specify the maximum local name length to be KMaxBluetoothNameLen

	theColumns->AddL(TDbCol(KPersistColName_LocalName,					EDbColText8, KMaxBluetoothNameLen));

	theColumns->AddL(TDbCol(KPersistColName_PowerSettings,				EDbColUint8));

	theColumns->AddL(TDbCol(KPersistColName_LimitedDiscoverable,		EDbColBit));

	theColumns->AddL(TDbCol(KPersistColName_AFHChannelAssessmentMode,	EDbColBit));

	theColumns->AddL(TDbCol(KPersistColName_AcceptPairedOnlyMode,		EDbColBit));

	User::LeaveIfError(iDB.CreateTable(KPersistTable, *theColumns));

	CleanupStack::PopAndDestroy(theColumns);

	}

void CBTRegistry::CreateDeviceTableL()

/**

	Create the table with all that is necessary to store details about remote devices

	To provide better CoD searching than the underlying SQL supports

	this table uses >1 column for device class of remote device

	This also allows for future versions of the CoD field in the BT Spec

**/

	{

	LOG_FUNC

	CDbColSet* theColumns = CDbColSet::NewLC();

	theColumns->AddL(TDbCol(KColName_ProcessSID,			EDbColUint32));	//SID of process adding record

	theColumns->AddL(TDbCol(KColName_DeviceAddress,			EDbColText8));	// Binary not allowed in SQL

	theColumns->AddL(TDbCol(KDeviceColName_CoD_MajorDev,	EDbColUint32));

	theColumns->AddL(TDbCol(KDeviceColName_CoD_MinorDev,	EDbColUint32));

	theColumns->AddL(TDbCol(KDeviceColName_CoD_Service,		EDbColUint32));

	theColumns->AddL(TDbCol(KDeviceColName_BluetoothName,	EDbColText8, KMaxBluetoothNameLen));	// keep UTF8

	theColumns->AddL(TDbCol(KDeviceColName_FriendlyName,	EDbColText16, KMaxBluetoothNameLen));	// possible UNICODE?

	theColumns->AddL(TDbCol(KDeviceColName_LinkKey,			EDbColText8));	// Binary not allowed in SQL

	theColumns->AddL(TDbCol(KDeviceColName_PassKey,			EDbColText8));	// Binary not allowed in SQL	

	theColumns->AddL(TDbCol(KDeviceColName_PageScanMode,	EDbColUint8));

	theColumns->AddL(TDbCol(KDeviceColName_PageScanRepMode,	EDbColUint8));

	theColumns->AddL(TDbCol(KDeviceColName_PageScanPeriodMode,	EDbColUint8));

	theColumns->AddL(TDbCol(KDeviceColName_LastSeen,		EDbColInt64));

	theColumns->AddL(TDbCol(KDeviceColName_LastUsed,		EDbColInt64));

	theColumns->AddL(TDbCol(KDeviceColName_GlobalSecSecurity,	EDbColUint8));

	theColumns->AddL(TDbCol(KDeviceColName_GlobalSecPasskeyLen,	EDbColUint32));

	theColumns->AddL(TDbCol(KDeviceColName_LinkKeyType,		EDbColUint8));

	theColumns->AddL(TDbCol(KDeviceColName_UiCookie,		EDbColText8)); // Can only simulate "bit-masked" searching in SQL if stored as text

	User::LeaveIfError(iDB.CreateTable(KDeviceTable, *theColumns));

	CleanupStack::PopAndDestroy(theColumns);

	}

void CBTRegistry::CreateMetaTableL()

/**

	Stores useful information about the database

	Version - useful for attempting to see if we can restore an old db

	Originating process

**/

	{

	LOG_FUNC

	CDbColSet* theColumns = CDbColSet::NewLC();

	theColumns->AddL(TDbCol(KMetaColName_VersionMajor,	EDbColUint32));

	theColumns->AddL(TDbCol(KMetaColName_VersionMinor,	EDbColUint32));

	theColumns->AddL(TDbCol(KColName_ProcessSID,		EDbColUint32));	//SID of process adding record

	User::LeaveIfError(iDB.CreateTable(KMetaTable, *theColumns));

	CleanupStack::PopAndDestroy(theColumns);

	SetMetaDataL();

	}

void CBTRegistry::CreateCSYTableL()

/**

	Create the table with all that is necessary to store details about virtual serial ports

**/

	{

	LOG_FUNC

	CDbColSet* theColumns = CDbColSet::NewLC();

	theColumns->AddL(TDbCol(KColName_ProcessSID,		EDbColUint32));	//SID of process adding record

	theColumns->AddL(TDbCol(KBTCOMMColName_Port,		EDbColUint32));	

	theColumns->AddL(TDbCol(KColName_DeviceAddress,		EDbColText8));	//Device address

	theColumns->AddL(TDbCol(KBTCOMMColName_ServiceUUID,	EDbColText8));	//SDP UUID - 16bytes

	theColumns->AddL(TDbCol(KBTCOMMColName_Security,	EDbColUint8));	//Security

	theColumns->AddL(TDbCol(KBTCOMMColName_ServiceName,	EDbColText));	//ServiceName

	User::LeaveIfError(iDB.CreateTable(KCSYTable, *theColumns));

	CleanupStack::PopAndDestroy(theColumns);

	}

TDbColNo CBTRegistry::ColumnNoL(const TDesC& aColName, const RDbRowSet& aRowSet)

/**

Looks up column names and returns the column number

	@param	aColName the name of the column

	@param	aRowSet	the rowset in which to find the column

	@return the column number with aColName

**/

	{

	LOG_FUNC

	// get the schema from the table - we own this

#ifdef _DEBUG

	CDbColSet* schema = NULL;

	TRAPD(err, schema = aRowSet.ColSetL());

	if(err == KErrNoMemory)

		{

		User::Leave(err);

		}

	//This __ASSERT_DEBUG is here to catch any 'Leaves'

	//in RDbRowSet::ColSetL other than that\those using

	//KErrNoMemory.

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

#else

	CDbColSet* schema = aRowSet.ColSetL(); // no need to push onto cleanup

#endif

	// get the column number, based on name

	TDbColNo column = schema->ColNo(aColName);

	delete schema;

	return column;

	}

TBool CBTRegistry::DevicePresentL(const TBTDevAddr& aAddress)

/**

	Checks to see if a device is present in the Registry

	@param	aAddress	The key to finding a device

	@return True if Device is present, false if not

**/

	{

	LOG_FUNC

	// form an SQL query for the device with address aAddress

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.FindDeviceL(aAddress);

	TDbBookmark dummy;

	RDbView* view = NULL;

	// open the view with that SQL query

	view = OpenViewL(query, dummy);	// uses a private view...

	CleanupCloseDeletePushL(view);

	TInt count = view->CountL();

	__ASSERT_ALWAYS(count <= 1, Panic(ETooManyRemoteDeviceEntries));

	CleanupStack::PopAndDestroy(2, &query); // view and query

	return (count!=0);

	}

void CBTRegistry::CreateDeviceL(const CBTDevice& aDetails, TBool aStoreUiCookie, const TSecureId& aClientSID)

/**

	Add a new record into the DB

	@param	aDetails	The new device details to add

	@param	aClientUid	The ID of the process adding the new record

	@leave	KErrCorrupt if device to add is not valid

	@leave	KErrAlreadyExists if device to add is already present

**/

	{

	LOG_FUNC

	if (!aDetails.IsValidBDAddr())

		{

		User::Leave(KErrCorrupt);

		}

	if (DevicePresentL(aDetails.BDAddr()))

		{

		User::Leave(KErrAlreadyExists);

		}

	RDbTable* table = OpenDeviceTableL();

	CleanupCloseDeletePushL(table);

	table->InsertL();

	table->SetColL(ColumnNoL(KColName_DeviceAddress, *table), aDetails.BDAddr().Des());

	table->SetColL(ColumnNoL(KColName_ProcessSID, *table), aClientSID);

	// got some initial details; stick them in now...

	SetDeviceL(*table, aDetails, !aStoreUiCookie);	// does the remaining columns

	CleanupStack::PopAndDestroy(table);

	}

void CBTRegistry::UnpairL(RDbRowSet& aRowSet)

/**

	Unpairs a set of devices

	@pre	A rowset constraining the view to a single device

	@param	aRowSet	The set of records to unpair

	@see    DBMS for leave codes

**/

	{

	LOG_FUNC

	aRowSet.UpdateL();

	aRowSet.SetColNullL(ColumnNoL(KDeviceColName_LinkKey, aRowSet));

	aRowSet.SetColNullL(ColumnNoL(KDeviceColName_PassKey, aRowSet));

	aRowSet.SetColNullL(ColumnNoL(KDeviceColName_LinkKeyType, aRowSet));