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 // This does the main work on behalf of the subsessions of liasing with DBMS

    15 // 

    16 //

    17 

    18 #include "BTRegistryDB.h"

    19 #include "btmanserverutil.h"

    20 #include <utf.h>

    21 #include <bluetooth/logger.h>

    22 #include <bafl/sysutil.h>

    23 

    24 #ifdef __FLOG_ACTIVE

    25 _LIT8(KLogComponent, LOG_COMPONENT_BT_REGISTRY);

    26 #endif

    27 

    28 #ifdef _DEBUG

    29 PANICCATEGORY("btregdb");

    30 #endif

    31 

    32 

    33 void Panic(TBTRegistryDBPanic aPanic)

    34 	{

    35 	LOG_STATIC_FUNC

    36 	_LIT(KRegistryDBPanicName, "BT RegistryDB Panic");

    37 	User::Panic(KRegistryDBPanicName, aPanic);

    38 	}

    39 //

    40 

    41 CBTRegistry::CBTRegistry()

    42 	{

    43 	LOG_FUNC

    44 	}

    45 

    46 CBTRegistry::~CBTRegistry()

    47 	{

    48 	LOG_FUNC

    49 	iDB.Close();

    50 	iDBMSServer.Close();

    51 	}

    52 

    53 CBTRegistry* CBTRegistry::NewL()

    54 	{

    55 	LOG_STATIC_FUNC

    56 	CBTRegistry* self = new (ELeave) CBTRegistry;

    57 	CleanupStack::PushL(self);

    58 	self->ConstructL();

    59 #ifdef _DEBUG

    60 	CleanupStack::Check(self);

    61 #endif

    62 	CleanupStack::Pop();

    63 	return self;

    64 	}

    65 

    66 void CBTRegistry::ConstructL()

    67 	{

    68 	LOG_FUNC

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

    70 	// be updating their views concurrently.  Without this

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

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

    73 	OpenRegistryL();

    74 	}

    75 

    76 void CBTRegistry::OpenRegistryL()

    77 /**

    78 	Open the Registry DB.

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

    80 **/

    81 	{

    82 	LOG_FUNC

    83 	const static TInt KMaxTries=4;

    84 	TInt err;

    85 	TInt loopCount=0;

    86 	

    87 

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

    89 	do

    90 		{

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

    92 			

    93 		if(err == KErrNotFound)

    94 			{

    95 			CreateRegistryL();

    96 			}

    97 		else if (err != KErrNone)

    98 			{

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

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

   101 			DeleteCorruptRegistryL();

   102 			}

   103 		else

   104 			{

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

   106 			if(err==KErrNone)

   107 				{

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

   109 				}

   110 			if (err!=KErrNone)

   111 				{

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

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

   114 				DeleteCorruptRegistryL();

   115 				}

   116 			}	

   117 		loopCount++;

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

   119 

   120 	if(err != KErrNone)

   121 		{

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

   123 		}

   124 

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

   126 	PurgeDebugLinkKeysL();

   127 

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

   129 	// ready!

   130 	}

   131 

   132 

   133 

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

   135 /**

   136 	Find tables of a given name

   137 	@param	aTable	Name of table to open

   138 	@return table and ownership

   139 **/

   140 	{

   141 	LOG_FUNC

   142 	RDbTable* table = new (ELeave) RDbTable;

   143 	CleanupCloseDeletePushL(table);

   144 

   145 	TInt err;

   146 

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

   148 	User::LeaveIfError(err);

   149 

   150 	CleanupStack::Pop(); // table

   151 

   152 	return table;

   153 	}

   154 

   155 RDbTable* CBTRegistry::OpenPersistTableL()

   156 /**

   157 	Find the persist table (local device settings)

   158 	and return it and ownership

   159 

   160 	@return ownership of table

   161 **/

   162 	{

   163 	LOG_FUNC

   164 	return OpenTableL(KPersistTable);

   165 	}

   166 

   167 RDbTable* CBTRegistry::OpenDeviceTableL()

   168 /**

   169 	Find the remote device table

   170 	@return table and ownership

   171 **/

   172 	{

   173 	LOG_FUNC

   174 	return OpenTableL(KDeviceTable);

   175 	}

   176 

   177 RDbTable* CBTRegistry::OpenCSYTableL()

   178 /**

   179 	Find the CSY table

   180 	@return table and ownership

   181 **/

   182 	{

   183 	LOG_FUNC

   184 	return OpenTableL(KCSYTable);

   185 	}

   186 

   187 void CBTRegistry::ValidateMetaTableL()

   188 /**

   189 	Go to Meta table and check version numbers etc

   190 **/

   191 	{

   192 	LOG_FUNC

   193 	RDbTable* table = OpenTableL(KMetaTable);

   194 	CleanupCloseDeletePushL(table);

   195 

   196 	// get the processSID

   197 	TBool success = table->FirstL();

   198 	if (!success)

   199 		{

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

   201 		User::Leave(KErrEof);

   202 		}

   203 

   204 	table->GetL();

   205 	

   206 

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

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

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

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

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

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

   213 

   214 	if(KRegistryDBVersionMajor != major || 

   215 			KRegistryDBVersionMinor != minor)

   216 		{

   217 		User::Leave(KErrCorrupt);

   218 		}

   219 

   220 	CleanupStack::PopAndDestroy(table);

   221 	}

   222 

   223 void CBTRegistry::ValidatePersistTableL()

   224 /**

   225 	Go to Persist table and check local device values

   226 **/

   227 	{

   228 	LOG_FUNC

   229 	RDbTable* table = OpenTableL(KPersistTable);

   230 	CleanupCloseDeletePushL(table);

   231 

   232 	// get the processSID

   233 	TBool success = table->FirstL();

   234 	if (!success)

   235 		{

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

   237 		User::Leave(KErrEof);

   238 		}

   239 		

   240 	table->GetL();

   241 	

   242 #ifdef _DEBUG

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

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

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

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

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

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

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

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

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

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

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

   254 			addrBuf[0],

   255 			addrBuf[1],

   256 			addrBuf[2],

   257 			addrBuf[3],

   258 			addrBuf[4],

   259 			addrBuf[5]

   260 			);

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

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

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

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

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

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

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

   268 #endif

   269 

   270 	CleanupStack::PopAndDestroy(table);

   271 	}

   272 

   273 void CBTRegistry::CreateRegistryL()

   274 /**

   275 	Creates the Database and Tables we need

   276 **/

   277 	{

   278 	LOG_FUNC

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

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

   281 

   282 

   283 	User::LeaveIfError(err);

   284 	

   285 	SetupDefaultRegistryL();

   286 	

   287 	// close the database

   288 	iDB.Close();	

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

   290 	}

   291 

   292 void CBTRegistry::PurgeDebugLinkKeysL()

   293 /**

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

   295 **/

   296 	{

   297 	LOG_FUNC

   298 	RBTDbQuery query;

   299 	CleanupClosePushL(query);

   300 	query.MatchLinkKeyTypeL(ELinkKeyDebug);

   301 

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

   303 	TDbBookmark dummy;

   304 	RDbView* view = OpenViewL(query, dummy);

   305 	CleanupCloseDeletePushL(view);

   306 

   307 	if (!view->IsEmptyL())

   308 		{

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

   310 		UnpairViewL(*view);

   311 		}

   312 	

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

   314 	}

   315 

   316 

   317 void CBTRegistry::CreatePersistTableL()

   318 /**

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

   320 **/

   321 	{

   322 	LOG_FUNC

   323 	CDbColSet* theColumns = CDbColSet::NewLC();

   324 

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

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

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

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

   329 	// specify the maximum local name length to be KMaxBluetoothNameLen

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

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

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

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

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

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

   336 

   337 	CleanupStack::PopAndDestroy(theColumns);

   338 	}

   339 

   340 void CBTRegistry::CreateDeviceTableL()

   341 /**

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

   343 	

   344 	To provide better CoD searching than the underlying SQL supports

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

   346 	

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

   348 **/

   349 	{

   350 	LOG_FUNC

   351 	CDbColSet* theColumns = CDbColSet::NewLC();

   352 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   371 

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

   373 

   374 	CleanupStack::PopAndDestroy(theColumns);

   375 	}

   376 

   377 void CBTRegistry::CreateMetaTableL()

   378 /**

   379 	Stores useful information about the database

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

   381 	Originating process

   382 **/

   383 	{

   384 	LOG_FUNC

   385 	CDbColSet* theColumns = CDbColSet::NewLC();

   386 

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

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

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

   390 

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

   392 

   393 	CleanupStack::PopAndDestroy(theColumns);

   394 

   395 	SetMetaDataL();

   396 	}

   397 

   398 void CBTRegistry::CreateCSYTableL()

   399 /**

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

   401 **/

   402 	{

   403 	LOG_FUNC

   404 	CDbColSet* theColumns = CDbColSet::NewLC();

   405 

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

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

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

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

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

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

   412 

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

   414 

   415 	CleanupStack::PopAndDestroy(theColumns);

   416 	}

   417 

   418 

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

   420 /**

   421 Looks up column names and returns the column number

   422 

   423 	@param	aColName the name of the column

   424 	@param	aRowSet	the rowset in which to find the column

   425 	@return the column number with aColName

   426 **/

   427 	{

   428 	LOG_FUNC

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

   430 #ifdef _DEBUG

   431 	CDbColSet* schema = NULL;

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

   433 	if(err == KErrNoMemory)

   434 		{

   435 		User::Leave(err);

   436 		}

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

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

   439 	//KErrNoMemory.

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

   441 #else

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

   443 #endif

   444 	// get the column number, based on name

   445 	TDbColNo column = schema->ColNo(aColName);

   446 	delete schema;

   447 	return column;

   448 	}

   449 

   450 

   451 

   452 TBool CBTRegistry::DevicePresentL(const TBTDevAddr& aAddress)

   453 /**

   454 	Checks to see if a device is present in the Registry

   455 	@param	aAddress	The key to finding a device

   456 	@return True if Device is present, false if not

   457 **/

   458 	{

   459 	LOG_FUNC

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

   461 	RBTDbQuery query;

   462 	CleanupClosePushL(query);

   463 	query.FindDeviceL(aAddress);

   464 

   465 	TDbBookmark dummy;

   466 	RDbView* view = NULL;

   467 

   468 	// open the view with that SQL query

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

   470 	CleanupCloseDeletePushL(view);

   471 

   472 	TInt count = view->CountL();

   473 	

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

   475 

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

   477 	return (count!=0);

   478 	}

   479 

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

   481 /**

   482 	Add a new record into the DB

   483 

   484 	@param	aDetails	The new device details to add

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

   486 	@leave	KErrCorrupt if device to add is not valid

   487 	@leave	KErrAlreadyExists if device to add is already present

   488 **/

   489 	{

   490 	LOG_FUNC

   491 	if (!aDetails.IsValidBDAddr())

   492 		{

   493 		User::Leave(KErrCorrupt);

   494 		}

   495 

   496 	if (DevicePresentL(aDetails.BDAddr()))

   497 		{

   498 		User::Leave(KErrAlreadyExists);

   499 		}

   500 

   501 	RDbTable* table = OpenDeviceTableL();

   502 	CleanupCloseDeletePushL(table);

   503 

   504 	table->InsertL();

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

   506 

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

   508 

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

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

   511 	CleanupStack::PopAndDestroy(table);

   512 	}

   513 

   514 void CBTRegistry::UnpairL(RDbRowSet& aRowSet)

   515 /**

   516 	Unpairs a set of devices

   517 

   518 	@pre	A rowset constraining the view to a single device

   519 	@param	aRowSet	The set of records to unpair

   520 	@see    DBMS for leave codes

   521 **/

   522 	{

   523 	LOG_FUNC

   524 	aRowSet.UpdateL();

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

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

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

   528 	

   529 	CleanPutL(aRowSet);

   530 	}

   531 

   532 void CBTRegistry::UnpairViewL(RDbRowSet& aRowSet)

   533 /**

   534 	Unpairs all sets of devices in the supplied rowset

   535 

   536 	@pre	A rowset constraining the view 

   537 	@param	aRowSet	The set of records to unpair

   538 	@see    DBMS for leave codes

   539 **/

   540 	{

   541 	LOG_FUNC

   542 	aRowSet.FirstL();

   543 	TInt c = aRowSet.CountL();

   544 	for (TInt i=0; i<c; i++)

   545 		{

   546 		UnpairL(aRowSet);

   547 		aRowSet.NextL();

   548 		}

   549 	}

   550 

   551 void CBTRegistry::UpdateDeviceL(RDbRowSet& aRowSet, const CBTDevice& aDetails)

   552 /**

   553 	Given a rowset (from a previous find) and

   554 	mark the rowset for update, and make the changes

   555 

   556 	@param	aRowSet	The set of rows to update - typically one row...

   557 **/

   558 	{

   559 	LOG_FUNC

   560 	aRowSet.UpdateL();

   561 	SetDeviceL(aRowSet, aDetails);

   562 	}

   563 

   564 void CBTRegistry::UpdateNameL(const TBTDevAddr& aAddress,

   565 							  const TDesC8& aName,

   566 							  TBTManServerRequest aRequest)

   567 /**

   568 	Update the name of a device - either friendly or Bluetooth name

   569 

   570 	@param	aAddress    The device to update

   571 	@param  aName	    The new name

   572 	@param  aRequest	Determines the type of name to change

   573 

   574 	Could change this so subsession opens the rowset and just gives that to this

   575 **/

   576 	{

   577 	LOG_FUNC

   578 	// Find the row

   579 	RBTDbQuery deviceQuery;

   580 	CleanupClosePushL(deviceQuery);

   581 	deviceQuery.FindDeviceL(aAddress);

   582 

   583 	TDbBookmark dummy;

   584 

   585 	RDbView* view = OpenViewL(deviceQuery, dummy);

   586 	CleanupCloseDeletePushL(view);

   587 

   588 	view->UpdateL();

   589 

   590 	switch (aRequest)

   591 		{

   592 	case EBTRegistryModifyFriendlyName:

   593 		{

   594 		TBuf<KMaxFriendlyNameLen> temp;

   595 		User::LeaveIfError(CnvUtfConverter::ConvertToUnicodeFromUtf8(temp,aName));

   596 		view->SetColL(ColumnNoL(KDeviceColName_FriendlyName, *view), temp);

   597 		break;

   598 		}

   599 

   600 	case EBTRegistryModifyBluetoothName:

   601 		{

   602 		view->SetColL(ColumnNoL(KDeviceColName_BluetoothName, *view), aName);

   603 		break;

   604 		}

   605 	default:

   606 		Panic(EBadNameToUpdate);

   607 		}

   608 	CleanPutL(*view);

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

   610 	}

   611 

   612 void CBTRegistry::UpdateLocalDeviceL(const TBTLocalDevice& aLocalDevice)

   613 /**

   614 	@param	aLocalDevice The new settings

   615 **/

   616 	{

   617 	LOG_FUNC

   618 	// obliterate what's there

   619 	RDbTable* table = OpenPersistTableL();

   620 	CleanupCloseDeletePushL(table);	

   621 

   622 	TInt count = table->CountL();

   623 	__ASSERT_DEBUG(count <=1, Panic(ETooManyLocalDeviceEntries));

   624 	if (!count)

   625 		{

   626 		// we need to insert the one and only row as this is a fresh table

   627 		table->InsertL();

   628 		}

   629 	else

   630 		{

   631 		// go to the only row

   632 		TBool success = table->FirstL();

   633 		if (!success)

   634 			{

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

   636 			User::Leave(KErrEof);

   637 			}

   638 

   639 		table->UpdateL();

   640 		}

   641 

   642 	if (aLocalDevice.IsValidAddress())

   643 		table->SetColL(ColumnNoL(KColName_DeviceAddress, *table),

   644 					aLocalDevice.Address().Des());

   645 

   646 	if (aLocalDevice.IsValidDeviceClass())

   647 		table->SetColL(ColumnNoL(KPersistColName_CoD, *table),

   648 					static_cast<TUint>(aLocalDevice.DeviceClass()));

   649 

   650 	if (aLocalDevice.IsValidDeviceName())

   651 		table->SetColL(ColumnNoL(KPersistColName_LocalName, *table),

   652 					aLocalDevice.DeviceName());

   653 

   654 	if (aLocalDevice.IsValidScanEnable())

   655 		table->SetColL(ColumnNoL(KPersistColName_ScanEnable, *table),

   656 					static_cast<TUint>(aLocalDevice.ScanEnable()));

   657 

   658 	if (aLocalDevice.IsValidPowerSetting())

   659 		table->SetColL(ColumnNoL(KPersistColName_PowerSettings, *table),

   660 					static_cast<TUint>(aLocalDevice.PowerSetting()));

   661 

   662 	if (aLocalDevice.IsValidAFHChannelAssessmentMode())

   663 		table->SetColL(ColumnNoL(KPersistColName_AFHChannelAssessmentMode, *table),

   664 					static_cast<TBool>(aLocalDevice.AFHChannelAssessmentMode()));

   665 

   666 	if (aLocalDevice.IsValidLimitedDiscoverable())

   667 		table->SetColL(ColumnNoL(KPersistColName_LimitedDiscoverable, *table),

   668 					static_cast<TBool>(aLocalDevice.LimitedDiscoverable()));

   669 

   670 	if (aLocalDevice.IsValidAcceptPairedOnlyMode())

   671 		table->SetColL(ColumnNoL(KPersistColName_AcceptPairedOnlyMode, *table),

   672 					static_cast<TBool>(aLocalDevice.AcceptPairedOnlyMode()));

   673 

   674 	CleanPutL(*table);

   675 	CleanupStack::PopAndDestroy(table);

   676 	}

   677 

   678 void CBTRegistry::SetMetaDataL()

   679 /**

   680 	Set the values for the MetaData Table

   681 **/

   682 	{

   683 	LOG_FUNC

   684 	// put defaults in

   685 	RDbTable* table = OpenTableL(KMetaTable);

   686 	CleanupCloseDeletePushL(table);

   687 	

   688 #ifdef _DEBUG

   689 	TInt c=0;

   690 	TRAP_IGNORE(c=table->CountL());

   691 	__ASSERT_DEBUG(c==0, Panic(EMetaTableBroken));

   692 #endif

   693 

   694 	table->InsertL();

   695 

   696 	table->SetColL(ColumnNoL(KColName_ProcessSID, *table), RProcess().SecureId());

   697 

   698 	table->SetColL(ColumnNoL(KMetaColName_VersionMajor, *table), KRegistryDBVersionMajor);

   699 	table->SetColL(ColumnNoL(KMetaColName_VersionMinor, *table), KRegistryDBVersionMinor);

   700 

   701 	CleanPutL(*table);

   702 	CleanupStack::PopAndDestroy(table);

   703 	}

   704 

   705 void CBTRegistry::SetDeviceL(RDbRowSet& aRowSet, const CBTDevice& aDetails, TBool aIgnoreUiCookie)

   706 /**

   707 	Set the values for the device record if the Details are valid

   708 

   709 	@param	aRowSet		The rowset to adjust...typically one row

   710 	@param 	aDetails	The new details

   711 **/

   712 	{

   713 	LOG_FUNC

   714 	if (aDetails.AsNamelessDevice().IsValidPageScanMode())

   715 		{

   716 		aRowSet.SetColL(ColumnNoL(KDeviceColName_PageScanMode, aRowSet), static_cast<TUint>(aDetails.AsNamelessDevice().PageScanMode()));

   717 		}

   718 	if (aDetails.AsNamelessDevice().IsValidPageScanRepMode())

   719 		{

   720 		aRowSet.SetColL(ColumnNoL(KDeviceColName_PageScanRepMode, aRowSet), static_cast<TUint>(aDetails.AsNamelessDevice().PageScanRepMode()));

   721 		}

   722 	if (aDetails.AsNamelessDevice().IsValidPageScanPeriodMode())

   723 		{

   724 		aRowSet.SetColL(ColumnNoL(KDeviceColName_PageScanPeriodMode, aRowSet), static_cast<TUint>(aDetails.AsNamelessDevice().PageScanPeriodMode()));

   725 		}

   726 	if (aDetails.IsValidDeviceClass())

   727 		{

   728 		const TBTDeviceClass& cod = aDetails.DeviceClass();

   729 		

   730 		aRowSet.SetColL(ColumnNoL(KDeviceColName_CoD_MajorDev, aRowSet), static_cast<TUint>(cod.MajorDeviceClass()));

   731 		aRowSet.SetColL(ColumnNoL(KDeviceColName_CoD_MinorDev, aRowSet), static_cast<TUint>(cod.MinorDeviceClass()));

   732 		aRowSet.SetColL(ColumnNoL(KDeviceColName_CoD_Service, aRowSet), static_cast<TUint>(cod.MajorServiceClass()));

   733 		}

   734 	if (aDetails.IsValidDeviceName())

   735 		{

   736 		aRowSet.SetColL(ColumnNoL(KDeviceColName_BluetoothName, aRowSet), aDetails.DeviceName());

   737 		}

   738 	if (aDetails.IsValidFriendlyName())

   739 		{

   740 		aRowSet.SetColL(ColumnNoL(KDeviceColName_FriendlyName, aRowSet), aDetails.FriendlyName());

   741 		}

   742 	if (aDetails.IsValidUsed())

   743 		{

   744 		aRowSet.SetColL(ColumnNoL(KDeviceColName_LastUsed, aRowSet), aDetails.Used().Int64());

   745 		}

   746 	if (aDetails.IsValidSeen())

   747 		{

   748 		aRowSet.SetColL(ColumnNoL(KDeviceColName_LastSeen, aRowSet), aDetails.Seen().Int64());

   749 		}

   750 	if (aDetails.IsValidGlobalSecurity())

   751 		{

   752 		aRowSet.SetColL(ColumnNoL(KDeviceColName_GlobalSecSecurity, aRowSet), static_cast<TUint>(aDetails.GlobalSecurity().SecurityValue()));

   753 		aRowSet.SetColL(ColumnNoL(KDeviceColName_GlobalSecPasskeyLen, aRowSet), static_cast<TUint>(aDetails.GlobalSecurity().PasskeyMinLength()));

   754 		}

   755 	if (aDetails.IsValidLinkKey())

   756 		{

   757 		aRowSet.SetColL(ColumnNoL(KDeviceColName_LinkKey, aRowSet), aDetails.LinkKey());

   758 		aRowSet.SetColL(ColumnNoL(KDeviceColName_LinkKeyType, aRowSet), aDetails.LinkKeyType());

   759 		}

   760 	else

   761 		{

   762 		LOG(_L("Sec\tNot setting link key"))

   763 		}

   764 	if (aDetails.IsValidPassKey())

   765 		{

   766 		aRowSet.SetColL(ColumnNoL(KDeviceColName_PassKey, aRowSet), aDetails.PassKey());

   767 		}

   768 	if (aDetails.IsValidUiCookie() && !aIgnoreUiCookie)

   769 		{

   770 		static const TUint8 KCookieBinaryRepresentationWidth = 32; // 32bits encoded as binary string.

   771 		TBuf8<KCookieBinaryRepresentationWidth> textCookieValue;

   772 		textCookieValue.NumFixedWidth(aDetails.UiCookie(), EBinary, KCookieBinaryRepresentationWidth);

   773 		aRowSet.SetColL(ColumnNoL(KDeviceColName_UiCookie, aRowSet), textCookieValue);

   774 		}

   775 	

   776 	CleanPutL(aRowSet);

   777 	}

   778 

   779 void CBTRegistry::CleanPutL(RDbRowSet& aRowSet)

   780 /**

   781 	Try to put the changes into a RowSet

   782 	If this fails cancel the update and reset

   783 	Then re-leave

   784 **/

   785 	{

   786 	LOG_FUNC

   787 	TRAPD(dbResult, aRowSet.PutL());

   788 

   789 	if (dbResult!=KErrNone)

   790 		{

   791 		aRowSet.Cancel();

   792 		aRowSet.Reset();

   793 		User::Leave(KErrCorrupt); // this will complete the client message

   794 		}

   795 	}

   796 

   797 RDbView* CBTRegistry::OpenDeviceL(const TBTDevAddr& aAddr, TDbBookmark& aBookmark)

   798 /**

   799 	Open a view onto a given record in the Registry

   800 	@return a bookmark to the entry should the caller want it

   801 **/

   802 	{

   803 	LOG_FUNC

   804 	RBTDbQuery query;

   805 	CleanupClosePushL(query);

   806 	query.FindDeviceL(aAddr);

   807 

   808 	// open the device

   809 	RDbView* view = NULL;

   810 	view = OpenViewL(query, aBookmark);

   811 

   812 	CleanupCloseDeletePushL(view);

   813 

   814 #ifdef _DEBUG

   815 	TInt c=0;

   816 	TRAP_IGNORE(c=view->CountL());

   817 	__ASSERT_DEBUG(c<=1, Panic(ETooManyRemoteDeviceEntries));

   818 #endif

   819 

   820 	CleanupStack::Pop(view); // view (pass ownership)

   821 	CleanupStack::PopAndDestroy(&query); // query

   822 	return view;

   823 	}

   824 

   825 RDbView* CBTRegistry::OpenViewL(const TDesC& aSQLQuery, TDbBookmark& aBookmark)

   826 /**

   827 	Returns a view resulting from the execution of the aSQLQuery

   828 	Update aBookmark to be the beginning of the view

   829 **/

   830 	{

   831 	LOG_FUNC

   832 	RDbView* view = new (ELeave) RDbView;

   833 	CleanupCloseDeletePushL(view);	

   834 

   835 	// open the view based on the SQL query

   836 	User::LeaveIfError(view->Prepare(iDB, aSQLQuery));

   837 	// could separate this into separate Evaluates, but expected to be smallish DB

   838 	User::LeaveIfError(view->EvaluateAll());

   839 

   840 	// move to first row, and bookmark it

   841 	view->FirstL();

   842 	aBookmark = view->Bookmark();	// set bookmark in case user would like it

   843 

   844 	CleanupStack::Pop(view);

   845 	return view;	// returns ownership

   846 	}

   847 

   848 RDbView* CBTRegistry::OpenViewL(const RBTDbQuery& aQuery, TDbBookmark& aBookmark)

   849 /**

   850 	Overload allowing just a RBTDbQuery to be executed - hides the SQL query

   851 **/

   852 	{

   853 	LOG_FUNC

   854 	return OpenViewL(aQuery.QueryBuf(), aBookmark);

   855 	}

   856 

   857 void CBTRegistry::IncrementRowL(RDbRowSet& aRowSet, TDbBookmark& aBookmark)

   858 /**

   859 	Move to the next row in a RowSet and return a bookmark should the caller be interested

   860 **/

   861 	{

   862 	LOG_FUNC

   863 	aRowSet.NextL();	// move onto next row for next get

   864 	aBookmark = aRowSet.Bookmark();

   865 	}

   866 

   867 void CBTRegistry::GetRowL(RDbRowSet& aRowSet, const TDbBookmark& aBookmark)

   868 /**

   869 	Mark the rowset for reading

   870 **/

   871 	{

   872 	LOG_FUNC

   873 	if (!aRowSet.AtEnd())

   874 		{

   875 		aRowSet.GotoL(aBookmark);

   876 		aRowSet.GetL();		// get the row (which is a remote device on this table)

   877 		}

   878 	else

   879 		{

   880 		User::Leave(KErrEof);

   881 		}

   882 	}

   883 

   884 

   885 void CBTRegistry::GetNamelessDetailsL(TBTNamelessDevice& aDevice, 

   886 									  RDbRowSet& aRowSet, 

   887 									  TBool includeKeys)

   888 /**

   889 	Gets the next device (row) out of a rowset and puts them in a CBTDevice

   890 	The CBTDevice and its ownership is returned to the caller

   891 **/

   892 	{

   893 	LOG_FUNC

   894 	__ASSERT_DEBUG(!aRowSet.IsColNull(ColumnNoL(KColName_DeviceAddress, aRowSet)), Panic(ECorruptDeviceEntry));

   895 

   896 	TPtrC8 addrBuf(aRowSet.ColDes8(ColumnNoL(KColName_DeviceAddress, aRowSet)));

   897 	aDevice.SetAddress(static_cast<TBTDevAddr>(addrBuf));

   898 

   899 	TDbColNo column;

   900 

   901 	column = ColumnNoL(KDeviceColName_PageScanMode, aRowSet);

   902 	if (!aRowSet.IsColNull(column))

   903 		{

   904 		aDevice.SetPageScanMode(aRowSet.ColUint8(column));

   905 		}

   906 

   907 	column = ColumnNoL(KDeviceColName_PageScanPeriodMode, aRowSet);

   908 	if (!aRowSet.IsColNull(column))

   909 		{

   910 		aDevice.SetPageScanPeriodMode(aRowSet.ColUint8(column));

   911 		}

   912 

   913 	column = ColumnNoL(KDeviceColName_PageScanRepMode, aRowSet);

   914 	if (!aRowSet.IsColNull(column))

   915 		{

   916 		aDevice.SetPageScanRepMode(aRowSet.ColUint8(column));

   917 		}

   918 

   919 /*	column = ColumnNoL(KDeviceColName_CoD, aRowSet);

   920 	if (!aRowSet.IsColNull(column))

   921 		{

   922 		aDevice.SetDeviceClass(aRowSet.ColUint32(column));

   923 		}

   924 */

   925 	// all CoD columns must be set - just test one

   926 	column = ColumnNoL(KDeviceColName_CoD_MajorDev, aRowSet);

   927 	if (!aRowSet.IsColNull(column))

   928 		{

   929 		TUint majorDeviceClass = aRowSet.ColUint(column);

   930 

   931 		column = ColumnNoL(KDeviceColName_CoD_MinorDev, aRowSet);

   932 		TUint minorDeviceClass = aRowSet.ColUint(column);

   933 

   934 		column = ColumnNoL(KDeviceColName_CoD_Service, aRowSet);

   935 		TUint serviceClass = aRowSet.ColUint(column);

   936 		

   937 		aDevice.SetDeviceClass(TBTDeviceClass(static_cast<TUint16>(serviceClass),

   938 											  static_cast<TUint8>(majorDeviceClass),

   939 											  static_cast<TUint8>(minorDeviceClass)));

   940 		

   941 		}

   942 	

   943 	column = ColumnNoL(KDeviceColName_GlobalSecSecurity, aRowSet);

   944 	if (!aRowSet.IsColNull(column))

   945 		{

   946 		TBTDeviceSecurity devSec;

   947 		devSec.SetSecurityValue(aRowSet.ColUint8(column));

   948 		column = ColumnNoL(KDeviceColName_GlobalSecPasskeyLen, aRowSet);

   949 		devSec.SetPasskeyMinLength(aRowSet.ColUint32(column));

   950 				

   951 		aDevice.SetGlobalSecurity(devSec);

   952 		}

   953 

   954 	column = ColumnNoL(KDeviceColName_LinkKey, aRowSet);

   955 	TDbColNo typeColumn = ColumnNoL(KDeviceColName_LinkKeyType, aRowSet);

   956 

   957 	if (!aRowSet.IsColNull(column))

   958 		{

   959 		if(includeKeys)

   960 			{

   961 			TBTLinkKey linkKey;

   962 			linkKey.Copy(aRowSet.ColDes8(column));

   963 			aDevice.SetLinkKey(linkKey, static_cast<TBTLinkKeyType>(aRowSet.ColUint8(typeColumn)));

   964 			}

   965 		else

   966 			{

   967 			LOG(_L("Device paired but lack of capability to retrieve link key"));

   968 			aDevice.SetPaired(static_cast<TBTLinkKeyType>(aRowSet.ColUint8(typeColumn)));

   969 			}

   970 		}

   971 	else

   972 		{

   973 		LOG(_L("Sec\tDevice has NULL LinkKey column => Unpaired"))

   974 		}

   975 

   976 	column = ColumnNoL(KDeviceColName_PassKey, aRowSet);

   977 

   978 	if (!aRowSet.IsColNull(column))

   979 		{

   980 		if(includeKeys)

   981 			{

   982 			TBTPinCode passKey;

   983 			passKey.Copy(aRowSet.ColDes8(column));

   984 			aDevice.SetPassKey(passKey);

   985 			}

   986 		else

   987 			{

   988 			LOG(_L("Device has PIN code but lack of capability to retrieve PIN code"));

   989 			}

   990 		}

   991 	else

   992 		{

   993 		LOG(_L("Sec\tDevice has NULL PinCode column"))

   994 		}

   995 		

   996 	column = ColumnNoL(KDeviceColName_LastSeen, aRowSet);

   997 	if (!aRowSet.IsColNull(column))

   998 		{

   999 		aDevice.SetSeen(TTime(aRowSet.ColInt64(column)));

  1000 		}

  1001 

  1002 	column = ColumnNoL(KDeviceColName_LastUsed, aRowSet);

  1003 	if (!aRowSet.IsColNull(column))

  1004 		{

  1005 		aDevice.SetUsed(TTime(aRowSet.ColInt64(column)));

  1006 		}

  1007 	

  1008 	column = ColumnNoL(KDeviceColName_UiCookie, aRowSet);

  1009 	if (!aRowSet.IsColNull(column))

  1010 		{

  1011 		TPtrC8 cookieBuf(aRowSet.ColDes8(column));

  1012 		TLex8 lexer(cookieBuf);

  1013 		TUint32 cookieValue = 0;

  1014 		TInt err = lexer.Val(cookieValue, EBinary);

  1015 		if(err != KErrNone)

  1016 			{

  1017 			// discard the specific lexer errors, the fundemental issue

  1018 			// is that the device entry is corrupted in someway.

  1019 			User::Leave(KErrCorrupt);

  1020 			}

  1021 		aDevice.SetUiCookie(cookieValue);

  1022 		}

  1023 	}

  1024 

  1025 const TBTNamelessDevice* CBTRegistry::GetNextNamelessDeviceLC(RDbRowSet& aRowSet, 

  1026 															  TDbBookmark& aBookmark, 

  1027 															  TBool includeKeys)

  1028 /**

  1029 	Get the next row from the rowset; building and return TBTNamelessDevice via heap

  1030 **/

  1031 	{

  1032 	LOG_FUNC

  1033 	GetRowL(aRowSet, aBookmark);

  1034 	// there is a row to get, instantiate an object to receive details

  1035 	TBTNamelessDevice* device = new(ELeave) TBTNamelessDevice; // for passing ownership

  1036 	CleanupStack::PushL(device);

  1037 	GetNamelessDetailsL(*device, aRowSet, includeKeys);

  1038 	IncrementRowL(aRowSet, aBookmark);

  1039 	return device;

  1040 	}

  1041 

  1042 CBTDevice* CBTRegistry::GetNextDeviceL(RDbRowSet& aRowSet, 

  1043 											 TDbBookmark& aBookmark, 

  1044 											 TBool includeLinkKey)

  1045 /**

  1046 	Get the next row from the rowset; building and return CBTDevice via heap

  1047 **/

  1048 	{

  1049 	LOG_FUNC

  1050 	GetRowL(aRowSet, aBookmark);

  1051 	// there is a row to get, so instantiate an object to receive details

  1052 	CBTDevice* device = CBTDevice::NewLC();

  1053 	GetNamelessDetailsL(device->AsNamelessDevice(), aRowSet, includeLinkKey);

  1054 

  1055 	TDbColNo column = ColumnNoL(KDeviceColName_BluetoothName, aRowSet);

  1056 	if (!aRowSet.IsColNull(column))

  1057 		{

  1058 		device->SetDeviceNameL(aRowSet.ColDes8(column));

  1059 		}

  1060 

  1061 	column = ColumnNoL(KDeviceColName_FriendlyName, aRowSet);

  1062 	if (!aRowSet.IsColNull(column))

  1063 		{

  1064 		TBuf<KMaxFriendlyNameLen> unicodeBuf;

  1065 		unicodeBuf.Copy(aRowSet.ColDes(column));

  1066 		device->SetFriendlyNameL(unicodeBuf);

  1067 		}

  1068 	IncrementRowL(aRowSet, aBookmark);

  1069 	CleanupStack::Pop(device);

  1070 	return device;

  1071 	}

  1072 

  1073 const TUid CBTRegistry::CreatingProcessUidL(RDbRowSet& aRowSet)

  1074 /**

  1075 	@return	Value read from DB of the process that created a rowset

  1076 **/

  1077 	{

  1078 	LOG_FUNC

  1079 #ifdef _DEBUG

  1080 	TInt c=0;

  1081 	TRAP_IGNORE(c=aRowSet.CountL());

  1082 	__ASSERT_DEBUG(c==1, Panic(ETooManyRemoteDeviceEntries));

  1083 #endif

  1084 

  1085 	aRowSet.GetL();	// this makes the semantics of this function a bit odd...it leaves the rowset open for read

  1086 	TInt val = aRowSet.ColUint32(ColumnNoL(KColName_ProcessSID, aRowSet));

  1087 	return TUid::Uid(val);

  1088 	}

  1089 

  1090 

  1091 void CBTRegistry::DeleteViewL(RDbRowSet& aRowSet, TBool aDeleteAll, const TSecureId& aSecureId)

  1092 /**

  1093 	Delete all the rows in the set whose originating Id is the same as 

  1094 	aSecureId

  1095 	

  1096 	@param aRowSet The rowset whose records are to be deleted

  1097 	@param aDeleteAll If set to ETrue, all rows are deleted. If EFalse, only those

  1098 	rows whose SID value is same as aSecureId will be deleted.

  1099 	@param aSecureId The SID of the calling process.

  1100 **/

  1101 	{

  1102 	LOG_FUNC

  1103 	aRowSet.FirstL();

  1104 	TInt c = aRowSet.CountL();

  1105 	

  1106 	if(	c == 0 )

  1107 		{

  1108 		//	No rows, nothing to do

  1109 		return;

  1110 		}

  1111 		

  1112 	TDbColNo secureIdColNo=ColumnNoL(KColName_ProcessSID, aRowSet);

  1113 	//	There should always be a ProcessSID column present in the view

  1114 	__ASSERT_ALWAYS(secureIdColNo != KDbNullColNo, Panic(EColumnNotFound));

  1115 	

  1116 	for (TInt i=0; i<c; i++)

  1117 		{

  1118 		//	Retrieve the current row ready to be accessed

  1119 		aRowSet.GetL();

  1120 		if( aDeleteAll || (aRowSet.ColUint32(secureIdColNo) == aSecureId) )

  1121 			{

  1122 			aRowSet.DeleteL();

  1123 			}

  1124 		//	Regardless of the DeleteL or no DeleteL, the cursor remains

  1125 		//	in the same location, so we always need to call NextL.

  1126 		aRowSet.NextL();

  1127 		}

  1128 	// better try to compact now to avoid ballooning

  1129 	(void)iDB.Compact();

  1130 	}

  1131 

  1132 

  1133 TBTLocalDevice* CBTRegistry::GetLocalDeviceLC()

  1134 /**