1 // Copyright (c) 2005-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 //

    15 

    16 #include "SqlSrvFileData.h"		//TSqlSrvFileData

    17 #include "SqlSrvMain.h"			//CSqlServer

    18 #include "SqlSrvAuthorizer.h"	//MSqlPolicyInspector

    19 #include "SqlSrvDatabase.h"

    20 #include "SqlSrvStatement.h"

    21 #include "SqlUtil.h"			//Panic codes, Sql2OsErrCode()

    22 #include "SqlSrvUtil.h"			//Global server functions

    23 #include "SqlCompact.h"

    24 #include "SqlSrvResourceProfiler.h"

    25 

    26 //

    27 // The following macro disables the creation/loading of the settings table.

    28 // It is for internal testing purposes only!

    29 // 

    30 //    __SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__

    31 // 

    32 // This means that the database index will always be rebuilt when loaded by 

    33 // by the server regardless of the current system collation/locale in use. 

    34 // The benefit of enabling this macro is that a client can send PRAGMA 

    35 // commands to the SQL server before any tables have been explicity created in 

    36 // a NON-SECURE database (secure databases still automatically get a security 

    37 // policy table).

    38 //

    39 // The macro is applied inside:  

    40 //		CSqlSrvDatabase::StoreSettingsL

    41 // 		CSqlSrvDatabase::ProcessSettingsL

    42 // 

    43 // We should inform the user at compile-time if this macro has been enabled:

    44 #if defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)

    45 #pragma message(">>> WARNING: Use of SYMBIAN_SETTINGS table has been disabled <<<")

    46 #endif

    47 

    48 

    49 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    50 /////////////////////////////        Local const data   ///////////////////////////////////////////////////////

    51 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    52 

    53 const char* KErrMsg1 = "Missing ESCAPE expression";

    54 const char* KErrMsg2 = "ESCAPE expression must be a single character";

    55 

    56 ////////////////////////////////////////////////////////

    57 //Attach/detach SQL statements (zero-terminated strings)

    58 _LIT(KAttachDb, "ATTACH DATABASE :FileName AS :DbName\x0");

    59 _LIT(KDetachDb, "DETACH DATABASE :DbName\x0");

    60 ////////////////////////////////////////////////////////

    61 // Pragma SQL statements. The database names in all statements are quoted to avoid the "sql injection" threat.

    62 // (At the moment there is no way to pass an invalid database name for these statements, because the database has to be attached

    63 //  first and a parameter binding is used there. So, the quoting is just for safety and against changes in the future)

    64 _LIT(KCacheSizePragma,	"PRAGMA \"%S\".cache_size=%d\x0");

    65 _LIT(KPageSizePragma,	"PRAGMA \"%S\".page_size=%d\x0");

    66 _LIT(KAutoVacuumPragma,	"PRAGMA \"%S\".auto_vacuum=%d\x0");

    67 //_LIT(KPersist, "persist");

    68 //_LIT(KPersistentJournalPragma, "PRAGMA \"%S\".journal_mode=%S\x0");

    69 ////////////////////////////////////////////////////////

    70 //"LIKE" - user defined function name

    71 _LIT8(KStrLikeFuncName,  "LIKE\x0");

    72 

    73 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    74 /////////////////////////////        Local functions    ///////////////////////////////////////////////////////

    75 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    76 

    77 //Local function, used for comparing TSqlAttachDbPair objects.

    78 //(TSqlAttachDbPair structure represents type of the objects, members

    79 // of the map used for keeping the information regarding attached databases)

    80 //

    81 //Note that iKey members of aLeft and aRight function parameters are expected to be 

    82 //UTF8 encoded, zero-terminated strings.

    83 //

    84 //The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or

    85 //aRight argument is NULL.

    86 static TInt Compare(const TSqlAttachDbPair& aLeft, const TSqlAttachDbPair& aRight)

    87 	{

    88 	__SQLASSERT(aLeft.iKey != NULL && aRight.iKey != NULL, ESqlPanicInternalError);

    89 	return ::CompareNoCase8(TPtrC8(aLeft.iKey), TPtrC8(aRight.iKey));

    90 	}

    91 

    92 //Local function, used for comparing TSqlCompactDbPair objects.

    93 //(TSqlCompactDbPair structure represents type of the objects, members

    94 // of the map used for keeping the information regarding compacted databases)

    95 //

    96 //Note that iKey members of aLeft and aRight function parameters are expected to be 

    97 //UTF16 encoded strings.

    98 //

    99 //The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or

   100 //aRight argument is NULL.

   101 static TInt Compare2(const TSqlCompactDbPair& aLeft, const TSqlCompactDbPair& aRight)

   102 	{

   103 	__SQLASSERT(aLeft.iKey != NULL && aRight.iKey != NULL, ESqlPanicInternalError);

   104 	return ::CompareNoCase(*aLeft.iKey, *aRight.iKey);

   105 	}

   106 

   107 //Creates/opens database file (database file name in aFileData parameter) and initializes aDbHandle parameter.

   108 //The database will be created either with UTF-16 or UTF-8 encoding, depending on the 

   109 //TSqlSrvFileData::IsUTF16() property.

   110 static void CreateDbHandleL(const TSqlSrvFileData& aFileData, sqlite3*& aDbHandle)

   111 	{

   112 	if(aFileData.ConfigParams().iDbEncoding == TSqlSrvConfigParams::EEncUtf8)

   113 		{

   114 		TBuf8<KMaxFileName + 1> fileNameZ;

   115 		if(!::UTF16ZToUTF8Z(aFileData.FileNameZ(), fileNameZ))

   116 			{

   117 			__SQLLEAVE(KErrGeneral);	

   118 			}

   119 		__SQLLEAVE_IF_ERROR(::CreateDbHandle8(fileNameZ, aDbHandle));

   120 		}

   121 	else

   122 		{

   123 		__SQLLEAVE_IF_ERROR(::CreateDbHandle16(aFileData.FileNameZ(), aDbHandle));

   124 		}

   125 	}

   126 	

   127 //LoadAttachedDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the 

   128 //security policies read from the attached database file, which name is in aFileData parameter.

   129 //The created database security policy object is placed in the cleanup stack.

   130 //The caller is responsible for the destruction of the created and returned security policy object.

   131 //This function is used to read the security policies of attached databases.

   132 static CSqlSecurityPolicy* LoadAttachedDbSecurityPolicyLC(const TSqlSrvFileData& aFileData)

   133 	{

   134 	//Create new database security policy object and initialize it with a default security policy

   135 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);

   136 	CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);

   137 	//This is an attached  database and has to be opened

   138 	sqlite3* dbHandle = NULL;

   139 	CreateDbHandleL(aFileData, dbHandle);

   140 	CleanupStack::PushL(TCleanupItem(&CloseDbCleanup, dbHandle));

   141 	//Read the security policies.

   142 	TSqlDbSysSettings dbSysSettings(dbHandle);

   143 	dbSysSettings.LoadSecurityPolicyL(*dbPolicy);

   144 	CleanupStack::PopAndDestroy();//TCleanupItem(&CloseDbCleanup, dbHandle)

   145 	return dbPolicy;

   146 	}

   147 

   148 //LoadDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the 

   149 //security policies read from the database file.

   150 //The created database security policy object is placed in the cleanup stack.

   151 //The caller is responsible for destroying the returned database security policy object.

   152 //The function is used to read the security policy of the main database.

   153 static CSqlSecurityPolicy* LoadDbSecurityPolicyLC(sqlite3* aDbHandle)

   154 	{

   155 	__SQLASSERT(aDbHandle != NULL, ESqlPanicBadArgument);

   156 	//Create new database security policy object and initialize it with a default security policy

   157 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);

   158 	CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);

   159 	//Read the security policies.

   160 	TSqlDbSysSettings dbSysSettings(aDbHandle);

   161 	dbSysSettings.LoadSecurityPolicyL(*dbPolicy);

   162 	return dbPolicy;

   163 	}

   164 

   165 //CreateStrCopyLC() makes a copy of aSrc string and places it in the cleanup stack.

   166 //aSrc is expected to be UTF8 encoded, zero terminated string.

   167 //The function panics in _DEBUG mode if aSrc is NULL.

   168 static TUint8* CreateStrCopyLC(const TUint8* aSrc)

   169 	{

   170 	__SQLASSERT(aSrc != NULL, ESqlPanicBadArgument);

   171 	TInt len = User::StringLength(aSrc) + 1;

   172 	TUint8* copy = new (ELeave) TUint8[len];

   173 	Mem::Copy(copy, aSrc, len);

   174 	CleanupStack::PushL(copy);

   175 	return copy;

   176 	}

   177 

   178 //EnableAuthorizer() function is used to reenable the authorizer callback

   179 //during the stack cleanup.

   180 static void EnableAuthorizer(void* aAuthorizerDisabled)

   181 	{

   182 	__SQLASSERT(aAuthorizerDisabled != NULL, ESqlPanicBadArgument);

   183 	TBool* authorizerDisabled = static_cast <TBool*> (aAuthorizerDisabled);

   184 	*authorizerDisabled = EFalse;

   185 	}

   186 

   187 //Used by DbFileCleanup()

   188 NONSHARABLE_STRUCT(TDbFileCleanup)

   189 	{

   190 	TDbFileCleanup(const TSqlSrvFileData& aSqlSrvFileData, sqlite3*& aDbHandle) :

   191 		iSqlSrvFileData(aSqlSrvFileData),

   192 		iDbHandle(aDbHandle)

   193 		{

   194 		//aDbHandle can be NULL (it is a reference to a pointer and the pointer can be initialized later)

   195 		}

   196 	void Cleanup()

   197 		{

   198 		::CloseDbHandle(iDbHandle);//This operation also deletes the journal file

   199 		iDbHandle = NULL;

   200 		(void)iSqlSrvFileData.Fs().Delete(iSqlSrvFileData.FileName());

   201 		}

   202 private:

   203 	const TSqlSrvFileData&	iSqlSrvFileData;

   204 	sqlite3*& 				iDbHandle;

   205 	};

   206 

   207 //DbFileCleanup() is used to close and delete the database file during the stack cleanup, if

   208 //CSqlSrvDatabase's ConstructL() method(s) leave (when creating a new database file).

   209 static void DbFileCleanup(void* aDbFileCleanup)

   210 	{

   211 	__SQLASSERT(aDbFileCleanup != NULL, ESqlPanicBadArgument);

   212 	TDbFileCleanup* dbFileCleanup = static_cast <TDbFileCleanup*> (aDbFileCleanup);

   213 	dbFileCleanup->Cleanup();

   214 	}

   215 

   216 //Executes "PRAGMA" SQL statement + INTEGER value.

   217 //Pragma parameters:

   218 // aValue - integer pragma value to be set;

   219 // aPragma - pragma statement, the format is: ""PRAGMA <database name>.<parameter name>=%d\x0""

   220 // aDbName - "main" or the attached database name

   221 //This function is used for setting "cache_size", "page_size", "auto_vacuum" pragmas.

   222 //During the call the authorizer will be disabled.

   223 static TInt ExecPragma(sqlite3* aDbHandle, TBool& aAuthorizerDisabled, const TDesC& aPragma, TInt aValue, const TDesC& aDbName = KMainDb16)

   224 	{

   225 	__SQLASSERT(aDbHandle != NULL, ESqlPanicBadArgument);

   226 	TBuf<KMaxFileName + 64> pragmaSql;//(KMaxFileName + 64) characters buffer length is enough for the longest possible PRAGMA statement

   227 	pragmaSql.Format(aPragma, &aDbName, aValue);

   228 	TBool authorizerDisabledState = aAuthorizerDisabled;

   229 	aAuthorizerDisabled	= ETrue;

   230 	TInt err = DbExecStmt16(aDbHandle, pragmaSql);

   231 	aAuthorizerDisabled = authorizerDisabledState;

   232 	return err;

   233 	}

   234 

   235 //////////////////////////////////////////////////////////////////////////////////////////////////////

   236 /////////////////////////////   CSqlSrvDatabase class    /////////////////////////////////////////////

   237 //////////////////////////////////////////////////////////////////////////////////////////////////////

   238 

   239 

   240 

   241 /////////////////////////////   Object creation methods  /////////////////////////////////////////////

   242 

   243 /**

   244 Creates new CSqlSrvDatabase instance which creates and manages new secure SQL database.

   245 

   246 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   247      			 file session reference and some other database file related properties.

   248 				 The format of the name must be:

   249 				 \<drive\>:\<[SID]database file name excluding the path\>.

   250 				 "[SID]" refers to SID of the application which creates the database.

   251 @param aSecurityPolicy The database security policies container. 

   252 					   CSqlSrvDatabase instance stores the pointer in the security policy map,

   253 					   if it does not exist there already. The security policies map is owned by the CSqlServer class.

   254 

   255 @return A pointer to the created CSqlSrvDatabase instance.

   256 

   257 @see CSqlServer

   258 @see TSqlSrvFileData

   259 @see MSqlPolicyInspector

   260 @see RSqlSecurityMap

   261 @see CSqlSecurityPolicy

   262 

   263 @leave KErrNoMemory, an out of memory condition has occurred;

   264 	   KErrArgument, if a system table name found in the security policies (aSecurityPolicy);

   265 	   KErrAlreadyExists, the file already exists;

   266        KErrNotReady, the drive does not exist or is not ready;

   267        KErrInUse, the file is already open;

   268        KErrPermissionDenied, the client application does not satisfy the relevant database security policies.

   269                       Note that the function may also leave with some other database specific 

   270                       errors categorised as ESqlDbError, and other system-wide error codes.

   271                       

   272 @panic SqlDb 4 In _DEBUG mode if aFileData does not refer to a secure database file name.

   273 @panic SqlDb 4 In _DEBUG mode if aSecurityPolicy is NULL.

   274 */

   275 CSqlSrvDatabase* CSqlSrvDatabase::CreateSecureL(const TSqlSrvFileData& aFileData, CSqlSecurityPolicy* aSecurityPolicy)

   276 	{

   277 	__SQLASSERT(aFileData.IsSecureFileNameFmt(), ESqlPanicBadArgument);

   278 	__SQLASSERT(aSecurityPolicy != NULL, ESqlPanicBadArgument);

   279 	if(!::SqlServer().SecurityInspector().Check(aSecurityPolicy->DbPolicy(RSqlSecurityPolicy::ESchemaPolicy)))

   280 		{

   281 		//The caller has no "SCHEMA" policy. Then the client is not given a permission to create the database.

   282 		//Delete aSecurityPolicy since no database object is going to be created and the security policy object 

   283 		//won't be put in the security policies map.

   284 		delete aSecurityPolicy;

   285 		__SQLLEAVE(KErrPermissionDenied);

   286 		}

   287 	//What does happen with aSecurityPolicy instance?

   288 	// If the database is created successfully, then a lookup will be made in the security policies map.

   289 	// (the security policies map contains reference counted security policies)

   290 	//    If the same security policy already exists in the map, then aSecurityPolicy will be deleted.

   291 	//                                          The reference counter of the found policy will be incremented.

   292 	//    If aSecurityPolicy is not in the map, then it will be put in the map and removed

   293 	//                                          from the map when CSqlSrvDatabase object is destroyed.

   294 	//											(the "remove" operation decrements the security policy counter

   295 	//											and destroys the policy if it reaches 0)

   296 	//

   297 	//The security policy map pair is:

   298 	//{secure_db_name, reference_counted db_security_policy}

   299 	//The security policy is reference counted, because the same database can be shared between one or more

   300 	//connections (clients), in which case only a single, reference counted instance of the database security

   301 	//policy is kept in the map.

   302 	CleanupStack::PushL(aSecurityPolicy);

   303 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

   304 	CleanupStack::Pop(aSecurityPolicy);

   305 	CleanupStack::PushL(self);

   306 	self->ConstructCreateSecureL(aFileData, aSecurityPolicy);

   307 	CleanupStack::Pop(self);

   308 	return self;

   309 	}

   310 

   311 /**

   312 Creates new CSqlSrvDatabase instance which creates and manages new SQL database.

   313 

   314 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   315      			 file session reference and some other database file related properties.

   316 

   317 @return A pointer to the created CSqlSrvDatabase instance.

   318 

   319 @see CSqlServer

   320 @see TSqlSrvFileData

   321 @see MSqlPolicyInspector

   322 @see RSqlSecurityMap

   323 @see CSqlSecurityPolicy

   324 

   325 @leave KErrNoMemory, an out of memory condition has occurred;

   326 	   KErrArgument, the file name is a name of a secure database;

   327 	   KErrAlreadyExists, the file already exists;

   328        KErrNotReady, the drive does not exist or is not ready;

   329        KErrInUse, the file is already open;

   330        KErrArgument, the file name refers to a secure database, but aSecurityPolicy is NULL;

   331                       Note that the function may also leave with some other database specific 

   332                       errors categorised as ESqlDbError, and other system-wide error codes.

   333 

   334 @panic SqlDb 4 In _DEBUG mode if aFileData refers to a secure database file name.

   335 */

   336 CSqlSrvDatabase* CSqlSrvDatabase::CreateL(const TSqlSrvFileData& aFileData)

   337 	{

   338 	__SQLASSERT(!aFileData.IsSecureFileNameFmt(), ESqlPanicBadArgument);

   339 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

   340 	CleanupStack::PushL(self);

   341 	self->ConstructCreateL(aFileData);

   342 	CleanupStack::Pop(self);

   343 	return self;

   344 	}

   345 

   346 /**

   347 Creates new CSqlSrvDatabase instance which opens and manages an existing SQL database.

   348 

   349 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   350      			 file session reference and some other database file related properties.

   351 				 If this is a secure database, then the format of the name must be:

   352 				 \<drive\>:\<[SID]database file name excluding the path\>.

   353 				 If this is a non-secure database, then the file name has to be the full database file name.

   354 				 "[SID]" refers to SID of the application which created the database.

   355 				 If this is application's private database, then the format of aFileData is as it is described

   356 				 in TSqlSrvFileData::SetFromHandleL() comments.

   357 

   358 @return A pointer to the created CSqlSrvDatabase instance.

   359 

   360 @leave KErrNoMemory, an out of memory condition has occurred;

   361        KErrNotReady, the drive does not exist or is not ready;

   362        KErrNotFound, the database file does not exist;

   363        KErrInUse, the file is already open;

   364        KErrPermissionDenied, the client application does not satisfy the relevant database security policies.

   365                       Note that the function may also leave with some other database specific 

   366                       errors categorised as ESqlDbError, and other system-wide error codes.

   367 

   368 @see CSqlServer

   369 @see TSqlSrvFileData

   370 @see MSqlPolicyInspector

   371 @see RSqlSecurityMap

   372 @see CSqlSecurityPolicy

   373 @see TSqlSrvFileData::SetFromHandleL()

   374 */

   375 CSqlSrvDatabase* CSqlSrvDatabase::OpenL(const TSqlSrvFileData& aFileData)

   376 	{

   377 	CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();

   378 	CleanupStack::PushL(self);

   379 	aFileData.IsSecureFileNameFmt() ? self->ConstructOpenSecureL(aFileData) : self->ConstructOpenL(aFileData);

   380 	CleanupStack::Pop(self);

   381 	return self;

   382 	}

   383 

   384 /**

   385 Cleans up the allocated for the database connection memory and other resources.

   386 */

   387 CSqlSrvDatabase::~CSqlSrvDatabase()

   388 	{

   389     SQLPROFILER_DB_CLOSE((TUint)iDbHandle);

   390 	TSqlCompactDbMapIterator compactDbIt(iCompactDbMap);

   391 	TSqlCompactDbPair compactDbPair;

   392 	while(compactDbIt.Next(compactDbPair))

   393 		{

   394 		::SqlServer().Compactor().ReleaseEntry(*compactDbPair.iData);

   395 		}

   396 	iCompactDbMap.Close();

   397 	//If iSecureDbName is not NULL, the current CSqlSrvDatabase object operates on a secure database.

   398 	//The database security policy has to be removed from the security policy map.

   399 	//(The "remove" operation actually decrements the security policy reference counter and destroys the policy

   400 	//when the counter reaches 0. The counter value may be greater than 1 if the database is shared between

   401 	//more than one connection)

   402 	if(iSecureDbName)

   403 		{

   404 		::SqlServer().SecurityMap().Remove(iSecureDbName);

   405 		//The security policy map owns iSecureDbName and iSecurityPolicy and is responsible for 

   406 		//iSecureDbName and iSecurityPolicy destruction.

   407 		}

   408 	iAttachDbMap.Close();

   409 	::CloseDbHandle(iDbHandle);

   410 	}

   411 

   412 /**

   413 Initializes CSqlSrvDatabase data memebers with their default values.

   414 

   415 

   416 @see MSqlPolicyInspector

   417 @see RSqlSecurityMap

   418 @see CSqlServer

   419 */

   420 CSqlSrvDatabase::CSqlSrvDatabase() :

   421 	iAttachDbMap(TSqlAttachDbLinearOrder(&Compare), TSqlAttachDbDestructor()),

   422 	iCompactDbMap(TSqlCompactDbLinearOrder(&Compare2), TSqlCompactDbDestructor())

   423 	{

   424 	}

   425 	

   426 /**

   427 Creates a new SQL database file and executes config pragmas.

   428 This function is part of CSqlSrvDatabase instance initialization.

   429 If the function leaves and the error is not KErrAlreadyExists, the database file will be deleted.

   430 

   431 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   432      			 file session reference and some other database file related properties.

   433 				 If this is a secure database, then the format of the name must be:

   434 				 \<drive\>:\<[SID]database file name excluding the path\>.

   435 				 If this is a non-secure database, then the file name has to be the full database file name.

   436 				 "[SID]" refers to SID of the application which creates the database.

   437 

   438 @see TSqlSrvFileData

   439 

   440 @leave KErrNoMemory, an out of memory condition has occurred;

   441        KErrAlreadyExists, the file already exists.

   442                       Note that the function may also leave with some other database specific 

   443                       errors categorised as ESqlDbError, and other system-wide error codes.

   444 */

   445 void CSqlSrvDatabase::CreateNewDbFileL(const TSqlSrvFileData& aFileData)

   446 	{

   447 	if(::FileExists(aFileData.Fs(), aFileData.FileName()))

   448 		{

   449 		__SQLLEAVE(KErrAlreadyExists);	

   450 		}		

   451 	TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);

   452 	CleanupStack::PushL(TCleanupItem(&DbFileCleanup, &dbFileCleanup));

   453 	::CreateDbHandleL(aFileData, iDbHandle);

   454 	SetConfigL(aFileData.ConfigParams(), ETrue);

   455 	CleanupStack::Pop();//DbFileCleanup

   456 	}

   457 	

   458 /**

   459 Opens an existing SQL database file and executes config pragmas.

   460 

   461 This function is part of CSqlSrvDatabase instance initialization.

   462 

   463 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   464      			 file session reference and some other database file related properties.

   465 				 If this is a secure database, then the format of the name must be:

   466 				 \<drive\>:\<[SID]database file name excluding the path\>.

   467 				 If this is a non-secure database, then the file name has to be the full database file name.

   468 				 "[SID]" refers to SID of the application which creates the database.

   469 				 If this is application's private database, then the format of aFileData is as it is described

   470 				 in TSqlSrvFileData::SetFromHandleL() comments.

   471 				

   472 @leave KErrNoMemory, an out of memory condition has occurred;

   473        KErrNotFound, SQL database file not found.

   474                       Note that the function may also leave with some other database specific 

   475                       errors categorised as ESqlDbError, and other system-wide error codes.

   476 

   477 @see TSqlSrvFileData

   478 @see TSqlSrvFileData::SetFromHandleL()

   479 */

   480 void CSqlSrvDatabase::OpenExistingDbFileL(const TSqlSrvFileData& aFileData)

   481 	{

   482 	if(!aFileData.ContainHandles())

   483 		{//This check is valid only if the database is outside application's private data cage

   484 		if(!::FileExists(aFileData.Fs(), aFileData.FileName()))

   485 			{

   486 			__SQLLEAVE(KErrNotFound);	

   487 			}

   488 		}

   489 	::CreateDbHandleL(aFileData, iDbHandle);

   490 	//this is an existing database, only the cache size can be changed, the page size is persistent database property.

   491 	//But for private databases, opened on the client side - the page size can be set (for the "create database" operations).

   492 	SetConfigL(aFileData.ConfigParams(), aFileData.ContainHandles());

   493 	}

   494 	

   495 /**

   496 Installs an authorizer callback function.

   497 

   498 The callback function is invoked by the SQL parser at SQL statement compile time for each attempt 

   499 to access a column of a table in the database and is used to assert the calling application's rights to

   500 perform specific SQL operation.

   501 

   502 This function is part of CSqlSrvDatabase instance initialization.

   503 

   504 @leave The function may leave with some database specific errors categorised as ESqlDbError.

   505 */

   506 void CSqlSrvDatabase::InstallAuthorizerL()

   507 	{

   508 	//Install the authorizer just once. "Install authorizer" may be expensive and dangerous operation because 

   509 	//it will expire the already prepared statements.

   510 	if(!iAuthorizerInstalled)

   511 		{

   512 		(void)sqlite3SymbianLastOsError();//clear last OS error

   513 		TInt err = sqlite3_set_authorizer(iDbHandle, &CSqlSrvDatabase::AuthorizeCallback, this);

   514 		__SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));

   515 		}

   516 	iAuthorizerInstalled = ETrue;

   517 	}

   518 

   519 #ifdef SYMBIAN_USE_SQLITE_VERSION_3_6_4

   520 extern "C" int sqlite3RegisterInternalUtf8Like(sqlite3 *db);

   521 #endif

   522 /**

   523 Installs user-defined functions. At the moment there is only one: LIKE.

   524 

   525 Replacing the LIKE operator default implementation with user defined LIKE functions.

   526 The default implementation need a replacement because it does not work correctly with UTF16 encoded strings.

   527 */

   528 void CSqlSrvDatabase::InstallUDFsL()

   529 	{

   530 	//Registering user defined LIKE function with 2 parameters for UTF16 encoding

   531 	TInt err = sqlite3_create_function(iDbHandle, reinterpret_cast <const char*> (KStrLikeFuncName().Ptr()),

   532 									   2/*arg*/, SQLITE_UTF16, this /*user data*/, 

   533 									   &CSqlSrvDatabase::LikeSqlFunc, NULL/*xStep*/, NULL/*xFinal*/);

   534 	__SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));

   535 	//Registering user defined LIKE function with 3 parameters for UTF16 encoding 

   536 	err = sqlite3_create_function(iDbHandle, reinterpret_cast <const char*> (KStrLikeFuncName().Ptr()),

   537 								  3/*arg*/, SQLITE_UTF16, this/*user data*/, 

   538 								  &CSqlSrvDatabase::LikeSqlFunc, NULL/*xStep*/, NULL/*xFinal*/);

   539 	__SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));

   540 	

   541 #ifdef SYMBIAN_USE_SQLITE_VERSION_3_6_4

   542 	//Registering user defined LIKE function with 2 and 3 parameters for UTF8 encoding

   543 	//Once registered, these will be treated as built-in functions 

   544 	err = sqlite3RegisterInternalUtf8Like(iDbHandle);

   545 	__SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));

   546 #endif

   547 	}

   548 

   549 /**

   550 Constructs a key for searching in the security policies map.

   551 

   552 The key is UTF8 encoded, zero-terminated string.

   553 

   554 Every time when CSqlSrvDatabase instance creates, opens or attaches a secure database, it updates

   555 the contents of the security policies map (RSqlSecurityMap class), which is a single instance owned 

   556 by the CSqlServer class.

   557 

   558 @param aDbFileName Full secure database file name, from which the security policies map key 

   559 				   will be constructed.

   560 

   561 @return A const pointer to the constructed security map key. No memory is allocated for the key.

   562 

   563 @leave KErrGeneral the UTF16 to UTF8 conversion of aDbFileName parameter failed.

   564 

   565 @see RSqlSecurityMap

   566 @see CSqlServer

   567 */

   568 const TUint8* CSqlSrvDatabase::SecurityMapKeyL(const TDesC& aDbFileName)

   569 	{

   570 	//Form the map item key - the secure database name

   571 	TParsePtrC parse(aDbFileName);//this call may panic if aDbFileName cannot be parsed. But aDbFileName was preprocessed by TSqlSrvFileData::Set

   572 	TFileName secureDbName;

   573 	secureDbName.Copy(parse.Drive());

   574 	secureDbName.Append(parse.NameAndExt());

   575 	secureDbName.Append(TChar(0));

   576 	TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));

   577 	if(!::UTF16ZToUTF8Z(secureDbName, ptr))

   578 		{

   579 		__SQLLEAVE(KErrGeneral);			

   580 		}

   581 	return iFileNameBuf;

   582 	}

   583 

   584 /**

   585 Attaches a secure or non-secure database to the current database connection.

   586 

   587 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   588      			 file session reference and some other database file related properties.

   589 				 If this is a secure database, then the format of the name must be:

   590 				 \<drive\>:\<[SID]database file name excluding the path\>.

   591 				 If this is a non-secure database, then the file name has to be the full database file name.

   592 				 "[SID]" refers to SID of the application which creates the database.

   593 @param aDbName Database name. It must be unique (per database connection). This is the name which can

   594                be used for accessing tables in the attached database. The syntax is "database-name.table-name".

   595 

   596 @leave KErrNotFound, the database file which has to be attached does not exist.

   597        KErrPermissionDenied, the client application does not satisfy the relevant security policies of

   598        				  the attached database.

   599                       Note that the function may also leave with some other database specific 

   600                       errors categorised as ESqlDbError, and other system-wide error codes.

   601 

   602 @see TSqlSrvFileData

   603 */

   604 void CSqlSrvDatabase::AttachDbL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)

   605 	{

   606 	if(!aFileData.ContainHandles())

   607 		{//This check is valid only if the database is outside application's private data cage

   608 		if(!::FileExists(aFileData.Fs(), aFileData.FileName()))

   609 			{

   610 			__SQLLEAVE(KErrNotFound);	

   611 			}

   612 		}

   613 	if(!aFileData.IsSecureFileNameFmt())		

   614 		{//A non-secure database to be attached -  execute the "ATTACH DB" SQL statement and initialize the attached database.

   615 		InitAttachedDbL(aFileData, aDbName);

   616 		}

   617 	else

   618 		{//A secure database has to be attached. This is a complex operation and if it fails, proper cleanup

   619 		 //has to be performed. "state" variable keeps the state, after which the "attach db" operation failed.

   620 		 //There are three things needed to be done when atatching a secure database:

   621 		 // 1. Executing the "ATTACH DB" SQL statement and initializing the attached database

   622 		 // 2. Updating the security policy map

   623 		 // 3. Updating the {db name, logical db name} map

   624 		 //The additional map (3) is needed because when the authorizer callback is called by SQLITE, the callback

   625 		 //is given the logical database name, if that's an operation on an attached database. Since the security 

   626 		 //policy map uses the database name as a key, the map (3) is used to find what is the physical database 

   627 		 //name, which the logical database name points to.

   628 		 //

   629 		 //There is an additional step (0), which may happen when a secure database is attached to a 

   630 		 //non-secure database. But this step does not require a cleanup.

   631 		CSqlSrvDatabase::TAttachState state = CSqlSrvDatabase::EAStNone;

   632 		const TUint8* securityMapKey = NULL;

   633 		TRAPD(err, DoAttachSecureDbL(state, aFileData, aDbName, securityMapKey));

   634 		if(err != KErrNone)

   635 			{

   636 			//Cleanup

   637 			if(state > CSqlSrvDatabase::EAStNone)

   638 				{

   639 				(void)FinalizeAttachedDb(aDbName);

   640 				if(state > CSqlSrvDatabase::EAStDbAttached)

   641 					{

   642 					::SqlServer().SecurityMap().Remove(securityMapKey);

   643 					}

   644 				}

   645 			__SQLLEAVE(err);

   646 			}

   647 		}

   648 	}

   649 

   650 /**

   651 Attaches a secure database to the existing connection.

   652 

   653 The function also updates the following maps:

   654 - Security policies map (CSqlServer::iSecurityMap), where a reference counted copy of database security policies

   655   is kept for each created/opened/attached database during the life time of the SQL server;

   656 - Attached secure databases map (CSqlSrvDatabase::iAttachDbMap), where an information is kept what SQL database

   657   file name corresponds to a specific attached database name. This information is used by the authorizer callback

   658   function in order to find what database security policies have to be asserted when a SQL operation is issued

   659   for a particular attached database (the attached database name is identified always by its name, not the file name);

   660 

   661 @param aState Output parameter - the attach progress state, used by the calling function to perform correctly 

   662 			  the cleanup, if the attach operation fails.

   663 			  It may have the following values set:

   664 			  - CSqlSrvDatabase::EAStNone - no resources need to be freed;

   665 			  - CSqlSrvDatabase::EAStDbAttached - the function was able to execute the "ATTACH DATABASE"

   666 			      SQL statement before an error occured. The calling function has to execute "DETACH DATABASE"

   667 			      SQL statement to detach the database;

   668 			  - CSqlSrvDatabase::EAStSecurityMapUpdated - the function was able to update the security policies

   669 			      map (CSqlServer::iSecurityMap) before an error occured. The calling function has to remove

   670 			      the attached database security policies from the map and detach the database.

   671 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

   672      			 file session reference and some other database file related properties.

   673 				 The secure database name format must be:

   674 				 \<drive\>:\<[SID]database file name excluding the path\>.

   675 				 "[SID]" refers to SID of the application which creates the database.

   676 @param aDbName Database name. It must be unique (per database connection). This is the name which can

   677                be used for accessing tables in the attached database. The syntax is "database-name.table-name".

   678 @param aMapKey Output parameter, UTF8 encoded, zero-terminated string, which can be used for searching 

   679 			   of the attached database security policies in the security policies map (CSqlServer::iSecurityMap). 

   680 			   No memory is allocated for the key.

   681 

   682 @see RSqlSecurityMap

   683 @see RSqlAttachDbMap

   684 @see CSqlServer

   685 @see TSqlSrvFileData

   686 @see CSqlSrvDatabase

   687 

   688 @leave KErrNoMemory, an out of memory condition has occurred;

   689        KErrPermissionDenied, the client application does not satisfy the relevant security policies of

   690        				  the attached database.

   691                       Note that the function may also leave with some other database specific 

   692                       errors categorised as ESqlDbError, and other system-wide error codes.

   693 */

   694 void CSqlSrvDatabase::DoAttachSecureDbL(CSqlSrvDatabase::TAttachState& aState, 

   695 										const TSqlSrvFileData& aFileData, 

   696 										const TDesC& aDbName, const TUint8*& aMapKey)

   697 	{

   698 	//Step 1: Attach the database and initialize the attached database

   699 	InitAttachedDbL(aFileData, aDbName);

   700 	aState = CSqlSrvDatabase::EAStDbAttached;

   701 	//Step 2: Load the database security policy and update the security map

   702 	const CSqlSecurityPolicy* securityPolicy = NULL;

   703 	UpdateSecurityMapL(ETrue, aFileData, aMapKey, securityPolicy);

   704 	aState = CSqlSrvDatabase::EAStSecurityMapUpdated;

   705 	//Check that the caller has at least one of {Schema, Read, Write} policies.

   706 	BasicSecurityPolicyCheckL(*securityPolicy);

   707 	//Step 3: Update the attached databases map

   708 	InsertInAttachDbMapL(aFileData.FileName(), aDbName);

   709 	}

   710 	

   711 /**

   712 Detaches a database from the current database connection.

   713 

   714 The function also will search the security policies map (CSqlServer::iSecurityMap) and the attached databases

   715 map (CSqlSrvDatabase::iAttachDbMap) for entries which correspond to the database ,

   716 which is about to be detached, and will remove the entries.

   717 

   718 @param aDbName Attached database name. It must be unique (per database connection).

   719 

   720 @leave The function may leave with some database specific errors categorised as ESqlDbError, 

   721 	   and other system-wide error codes.

   722 	   

   723 @see CSqlSrvDatabase::DoAttachSecureDbL()

   724 @see RSqlSecurityMap

   725 @see RSqlAttachDbMap

   726 @see CSqlServer

   727 @see CSqlSrvDatabase

   728 */

   729 void CSqlSrvDatabase::DetachDbL(const TDesC& aDbName)

   730 	{

   731 	TInt err = FinalizeAttachedDb(aDbName);

   732 	if(err == KErrNone)

   733 		{

   734 		TRAP(err, RemoveFromMapsL(aDbName));//ignore the error

   735 		}

   736 	else

   737 		{

   738 		__SQLLEAVE(err);

   739 		}

   740 	}

   741 

   742 /**

   743 Calculates and returns the database size. 

   744 

   745 @param aDbName Attached database name or KNullDesC for the main database

   746 

   747 @leave The function may leave with some database specific errors categorised as ESqlDbError, 

   748 	   and other system-wide error codes.

   749 

   750 @return Database size in bytes.

   751 */

   752 TInt64 CSqlSrvDatabase::SizeL(const TDesC& aDbName)

   753 	{

   754 	iAuthorizerDisabled	= ETrue;

   755 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   756 	TInt pageCount = 0;

   757 	__SQLLEAVE_IF_ERROR(::DbPageCount(iDbHandle, aDbName, pageCount));

   758 	__SQLASSERT(pageCount >= 0, ESqlPanicInternalError);

   759 	CleanupStack::PopAndDestroy();

   760 	return (TInt64)pageCount * PageSizeL(aDbName);

   761 	}

   762 

   763 /**

   764 Retrieves the database free space. 

   765 

   766 @param aDbName Attached database name or KNullDesC for the main database

   767 

   768 @return Database free space in bytes.

   769 

   770 @leave The function may leave with some database specific errors categorised as ESqlDbError, 

   771 	   and other system-wide error codes.

   772 */

   773 TInt64 CSqlSrvDatabase::FreeSpaceL(const TDesC& aDbName)

   774 	{

   775 	iAuthorizerDisabled	= ETrue;

   776 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   777 	TInt freePageCount = 0;

   778 	__SQLLEAVE_IF_ERROR(::DbFreePageCount(iDbHandle, aDbName, freePageCount));

   779 	CleanupStack::PopAndDestroy();

   780 	__SQLASSERT(freePageCount >= 0, ESqlPanicInternalError);

   781 	return (TInt64)freePageCount * PageSizeL(aDbName);

   782 	}

   783 

   784 /**

   785 Collects information regarding the current cache size, page, size, encoding, etc. and puts the values

   786 in the aDest output string.

   787 

   788 @param aDest Output parameter, where the result values will be stored. The string format is: "<val1>;<val2>...;".

   789 

   790 @leave The function may leave with some database specific errors categorised as ESqlDbError, 

   791 	   and other system-wide error codes.

   792 */

   793 void CSqlSrvDatabase::QueryConfigL(TDes8& aDest)

   794 	{

   795 	iAuthorizerDisabled	= ETrue;

   796 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   797 

   798 	TInt cacheSize = 0;

   799 	__SQLLEAVE_IF_ERROR(::DbCacheSize(iDbHandle, KNullDesC, cacheSize));

   800 	

   801 	TInt pageSize = 0;

   802 	__SQLLEAVE_IF_ERROR(::DbPageSize(iDbHandle, KNullDesC, pageSize));

   803 

   804 	TBuf8<16> encoding;

   805 	__SQLLEAVE_IF_ERROR(::DbEncoding(iDbHandle, KNullDesC, encoding));

   806 

   807 	TInt defaultSoftHeapLimit = TSqlSrvConfigParams::KDefaultSoftHeapLimitKb;

   808 

   809 	TInt vacuum = 0;

   810 	__SQLLEAVE_IF_ERROR(::DbVacuumMode(iDbHandle, KNullDesC, vacuum));

   811 

   812 	aDest.AppendNum(cacheSize);	

   813 	_LIT8(KSemiColon, ";");

   814 	aDest.Append(KSemiColon);	

   815 	aDest.AppendNum(pageSize);	

   816 	aDest.Append(KSemiColon);	

   817 	aDest.Append(encoding);	

   818 	aDest.Append(KSemiColon);	

   819 	aDest.AppendNum(defaultSoftHeapLimit);	

   820 	aDest.Append(KSemiColon);	

   821 	aDest.AppendNum(vacuum);	

   822 	aDest.Append(KSemiColon);	

   823 	

   824 	CleanupStack::PopAndDestroy();

   825 	}

   826 

   827 /**

   828 Compacts the database free space. 

   829 

   830 @param aSize The requested database space to be compacted, in bytes.

   831 			 If aSize value is RSqlDatabase::EMaxCompaction, then all free pages will be removed.

   832 			 Note that the requested space to be compacted will be rounded up to the nearest page count,

   833 			 e.g. request for removing 1 byte will remove one free page from the database file. 

   834 

   835 @param aDbName Attached database name or KNullDesC for the main database

   836 

   837 @return The size of the removed free space

   838 

   839 @leave The function may leave with some database specific errors categorised as ESqlDbError, 

   840 	   and other system-wide error codes.

   841 */

   842 TInt CSqlSrvDatabase::CompactL(TInt aSize, const TDesC& aDbName)

   843 	{

   844 	__SQLASSERT(aSize > 0 || aSize == RSqlDatabase::EMaxCompaction, ESqlPanicBadArgument);

   845 	TInt pageSize = PageSizeL(aDbName);//PageSizeL() will disable/enable the authorizer

   846 	TInt pageCount = KMaxTInt;

   847 	if(aSize > 0)

   848 		{//64-bit calculations to avoid the overflow in case if (aSize + pageSize) >= KMaxTInt.

   849 		pageCount = (TInt64)((TInt64)aSize + pageSize - 1) / pageSize;

   850 		}

   851 	if(pageCount > 0)

   852 		{

   853 		iAuthorizerDisabled	= ETrue;

   854 		CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   855 		__SQLLEAVE_IF_ERROR(::DbCompact(iDbHandle, aDbName, pageCount, pageCount));

   856 		CleanupStack::PopAndDestroy();

   857 		}

   858 	return pageCount * pageSize;

   859 	}

   860 

   861 /**

   862 This structure is used in case if the InitAttachedDbL() execution fails and the 

   863 executed operations ("attach database", "init compact") have to be reverted calling

   864 FinalizeAttachedDb().

   865 

   866 @see CSqlSrvDatabase::InitAttachedDbL

   867 @see CSqlSrvDatabase::FinalizeAttachedDb

   868 @see CSqlSrvDatabase::AttachCleanup

   869 

   870 @internalComponent

   871 */

   872 NONSHARABLE_STRUCT(TAttachCleanup)

   873 	{

   874 	inline TAttachCleanup(CSqlSrvDatabase& aSelf, const TDesC& aDbName) :

   875 		iSelf(aSelf),

   876 		iDbName(aDbName)

   877 		{

   878 		}

   879 	CSqlSrvDatabase& iSelf;

   880 	const TDesC& iDbName;

   881 	};

   882 

   883 /**

   884 Cleanup function. Calls FinalizeAttachedDb() if InitAttachedDbL() has failed.

   885 

   886 @param aCleanup A pointer to a TAttachCleanup object that contains the needed for the cleanup information.

   887 

   888 @see TAttachCleanup

   889 

   890 @internalComponent

   891 */

   892 void CSqlSrvDatabase::AttachCleanup(void* aCleanup)

   893 	{

   894 	TAttachCleanup* cleanup = reinterpret_cast <TAttachCleanup*> (aCleanup);

   895 	__SQLASSERT(cleanup != NULL, ESqlPanicBadArgument);

   896 	if(cleanup)

   897 		{

   898 		(void)cleanup->iSelf.FinalizeAttachedDb(cleanup->iDbName);

   899 		}

   900 	}

   901 

   902 /**

   903 Forms and executes "ATTACH DATABASE" SQL statement.

   904 If the database is not read-only:

   905  - Makes the attached database journal file persistent.

   906  - Initializes the attached database compaction mode.

   907  - The attached database will be reindexed if the default collation has been changed.

   908 

   909 @param aFileData Attached database file data

   910 @param aDbName Attached database name. It must be unique (per database connection).

   911 

   912 @leave KErrNoMemory, an out of memory condition has occurred;

   913                       Note that the function may also leave with some other database specific 

   914                       errors categorised as ESqlDbError, and other system-wide error codes.

   915                       

   916 @see InitCompactionL

   917 @see ProcessSettingsL

   918 */

   919 void CSqlSrvDatabase::InitAttachedDbL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)

   920 	{

   921 	TPtrC dbFileName = aFileData.FileName();

   922 	TBool readOnlyDbFile = aFileData.IsReadOnly();

   923 	

   924 	InstallAuthorizerL();

   925 	iAuthorizerDisabled	= ETrue;

   926 	CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   927 	sqlite3_stmt* stmtHandle = StmtPrepare16L(iDbHandle, KAttachDb);

   928 	TInt err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 1, dbFileName.Ptr(), dbFileName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());

   929 	if(err == KErrNone)

   930 		{

   931 		err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 2, aDbName.Ptr(), aDbName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());

   932 		if(err == KErrNone)

   933 			{

   934 			err = StmtExec(stmtHandle);

   935 			}

   936 		}

   937 	TInt err2 = ::FinalizeStmtHandle(stmtHandle);

   938 	CleanupStack::PopAndDestroy();//TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled)

   939 	if(err == KErrNone && err2 != KErrNone)

   940 		{//::FinalizeStmtHandle() has failed

   941 		err = err2;

   942 		}

   943 	__SQLLEAVE_IF_ERROR(err);

   944 	

   945 	TAttachCleanup attachCleanup(*this, aDbName);

   946 	CleanupStack::PushL(TCleanupItem(&CSqlSrvDatabase::AttachCleanup, &attachCleanup));

   947 	

   948 	SetConfigL(aFileData.ConfigParams(), EFalse, aDbName);

   949 	

   950 	if(!readOnlyDbFile)

   951 		{

   952 		iAuthorizerDisabled	= ETrue;

   953 		CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));

   954 		ProcessSettingsL(aFileData, aDbName);

   955 		CleanupStack::PopAndDestroy();//TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled)

   956 		}

   957 	

   958 	CleanupStack::Pop();//TCleanupItem(&CSqlSrvDatabase::AttachCleanup, &attachCleanup)

   959 	}

   960 

   961 /**

   962 Forms and executes "DETACH DATABASE" SQL statement.

   963 If the database was scheduled for background compacting, the related database entry will be removed from

   964 the vaccum db map.

   965 

   966 @param aDbName Attached database name. It must be unique (per database connection).

   967 

   968 @return KErrNone, Operation completed successfully;

   969 		KErrNoMemory, an out of memory condition has occurred.

   970                       Note that the function may also return some other database specific 

   971                       errors categorised as ESqlDbError, and other system-wide error codes.

   972 */

   973 TInt CSqlSrvDatabase::FinalizeAttachedDb(const TDesC& aDbName)

   974 	{

   975 	ReleaseCompactEntry(aDbName);

   976 	iAuthorizerDisabled	= ETrue;

   977 	sqlite3_stmt* stmtHandle = NULL;

   978 	TRAPD(err, stmtHandle = StmtPrepare16L(iDbHandle, KDetachDb));

   979 	if(err == KErrNone)

   980 		{

   981 		err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 1, aDbName.Ptr(), aDbName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());

   982 		if(err == KErrNone)

   983 			{

   984 			err = StmtExec(stmtHandle);

   985 			}

   986 		}

   987 	TInt err2 = ::FinalizeStmtHandle(stmtHandle);

   988 	if(err == KErrNone && err2 != KErrNone)

   989 		{//::FinalizeStmtHandle() has failed

   990 		err = err2;

   991 		}

   992 	iAuthorizerDisabled	= EFalse;

   993 	return err;

   994 	}

   995 

   996 /**

   997 Updates the security policies map (CSqlServer::iSecurityMap).

   998 

   999 Inserts a new item in the security map, or if such item already exists there - its reference counter will

  1000 be incremented.

  1001 The method guarantees that either the security map will be updated, or the method leaves and the security

  1002 policies map stays unchanged.

  1003 

  1004 @param aAttachedDb True if the currently processed database is an attached database, false if it is the main db.

  1005 @param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a

  1006      			 file session reference and some other database file related properties.

  1007 				 The secure database name format must be:

  1008 				 \<drive\>:\<[SID]database file name excluding the path\>.

  1009 				 "[SID]" refers to SID of the application which creates the database.

  1010 @param aMapKey Output parameter. UTF8 encoded, zero-terminated string. On function exit cannot be NULL. 

  1011                It will be set to point to the security policies map key. No memory is allocated for the key.

  1012 @param aSecurityPolicy Output parameter. On function exit cannot be NULL. It will be set to point to the security policies.

  1013 

  1014 @leave KErrNoMemory, an out of memory condition has occurred;

  1015                       Note that the function may also leave with some other database specific 

  1016                       errors categorised as ESqlDbError, and other system-wide error codes.

  1017 

  1018 @see RSqlSecurityMap

  1019 @see CSqlServer

  1020 @see TSqlSrvFileData

  1021 @see CSqlSecurityPolicy

  1022 */

  1023 void CSqlSrvDatabase::UpdateSecurityMapL(TBool aAttachedDb, const TSqlSrvFileData& aFileData, 

  1024 										 const TUint8*& aMapKey, const CSqlSecurityPolicy*& aSecurityPolicy)

  1025 	{

  1026 	//Check if a copy of the database security policies is already in the security map.

  1027 	aMapKey = SecurityMapKeyL(aFileData.FileName());

  1028 	TSqlSecurityPair* pair = ::SqlServer().SecurityMap().Entry(aMapKey);

  1029 	if(pair)

  1030 		{

  1031 		//Yes, it is in the map. Increment the reference counter.

  1032 		//(It will be decremented when detaching the database).

  1033 		pair->iRefCounter.Increment();

  1034 		aMapKey = pair->iKey;

  1035 		aSecurityPolicy = pair->iData;

  1036 		}

  1037 	else

  1038 		{

  1039 		//No, it is not in the map. Read the security policies from the security policies tables and 

  1040 		//insert a new item in the map.

  1041 		__SQLASSERT(aMapKey != NULL, ESqlPanicInternalError);

  1042 		aMapKey = ::CreateStrCopyLC(aMapKey);

  1043 		CSqlSecurityPolicy* securityPolicy = aAttachedDb ? ::LoadAttachedDbSecurityPolicyLC(aFileData) :

  1044 		                                                   ::LoadDbSecurityPolicyLC(iDbHandle);

  1045 		__SQLLEAVE_IF_ERROR(::SqlServer().SecurityMap().Insert(aMapKey, securityPolicy));

  1046 		CleanupStack::Pop(2);//iSecurityMap owns aMapKey and securityPolicy objects

  1047 		aSecurityPolicy = securityPolicy;

  1048 		}

  1049 	__SQLASSERT(aMapKey != NULL, ESqlPanicInternalError);

  1050 	__SQLASSERT(aSecurityPolicy != NULL, ESqlPanicInternalError);

  1051 	}

  1052 

  1053 /**

  1054 Removes attached secure database entries from the maps.

  1055 

  1056 The function will search the security policies map (CSqlServer::iSecurityMap) and the attached databases

  1057 map (CSqlSrvDatabase::iAttachDbMap) for entries which correspond to the database with aDbName name,

  1058 and will remove the entries.

  1059 

  1060 The sequence of the performed by the function operations is:

  1061 1. Looks for a map item which key is aDbName in iAttachDbMap map.

  1062 2. If such pair exists, the data part of the pair is used as a key in iSecurityMap map.

  1063 3. Remove the iSecurityMap map item pointed by the data part of the found pair.

  1064 4. Remove the iAttachDbMap map item pointed by aDbName.

  1065 

  1066 @param aDbName Attached database name. It must be unique (per database connection).

  1067 

  1068 @leave KErrGeneral It is not possible to convert aDbName parameter to UTF8 encoded string.

  1069 

  1070 @see CSqlSrvDatabase::DoAttachDbL()

  1071 @see CSqlSrvDatabase::DoAttachSecureDbL()

  1072 @see RSqlSecurityMap

  1073 @see RSqlAttachDbMap

  1074 @see CSqlServer

  1075 @see CSqlSrvDatabase

  1076 */

  1077 void CSqlSrvDatabase::RemoveFromMapsL(const TDesC& aDbName)

  1078 	{

  1079 	TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));

  1080 	if(!::UTF16ToUTF8Z(aDbName, ptr))

  1081 		{

  1082 		__SQLLEAVE(KErrGeneral);	

  1083 		}

  1084 	TSqlAttachDbPair* attachDbPair = iAttachDbMap.Entry(iFileNameBuf);

  1085 	if(attachDbPair)

  1086 		{//aDbName refers to attached secure database

  1087 		::SqlServer().SecurityMap().Remove(attachDbPair->iData);

  1088 		iAttachDbMap.Remove(iFileNameBuf);

  1089 		}

  1090 	}

  1091 

  1092 /**

  1093 Inserts a new entry in the attached databases map (CSqlSrvDatabase::iAttachDbMap).

  1094 

  1095 The method guarantees that either a new [logical db name, secure db name] pair will be inserted in

  1096 iAttachDbMap or the method fails and the content of iAttachDbMap remains unchanged.

  1097 

  1098 @param aDbFileName Database file name, including the path.

  1099 @param aDbName Database name.

  1100 

  1101 @leave KErrNoMemory, an out of memory condition has occurred;

  1102 	   KErrGeneral, it is not possible to convert the function parameters to UTF8 encoded strings.

  1103 

  1104 @see RSqlAttachDbMap

  1105 @see CSqlSrvDatabase

  1106 */

  1107 void CSqlSrvDatabase::InsertInAttachDbMapL(const TDesC& aDbFileName, const TDesC& aDbName)

  1108 	{

  1109 	//Convert aDbName to UTF8, zero-terminated name

  1110 	TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));

  1111 	if(!::UTF16ToUTF8Z(aDbName, ptr))

  1112 		{

  1113 		__SQLLEAVE(KErrGeneral);	

  1114 		}

  1115 	const TUint8* mapKey = ::CreateStrCopyLC(iFileNameBuf);

  1116 	const TUint8* mapData = SecurityMapKeyL(aDbFileName);

  1117 	mapData = ::CreateStrCopyLC(mapData);

  1118 	__SQLLEAVE_IF_ERROR(iAttachDbMap.Insert(mapKey, mapData));

  1119 	CleanupStack::Pop(2);//iAttachDbMap owns mapKey amd mapData.

  1120 	}

  1121 

  1122 /**

  1123 Processes the database settings that are currently stored in the settings table.

  1124 Makes the journal file persistent.

  1125 Initializes the database compaction mode.

  1126 Based on the current settings the database may be configured to become 'up-to-date'.

  1127 This configuration may include reindexing the database if the collation dll has

  1128 changed and/or executing database configuration file operations.

  1129 

  1130 @param aFileData The file data object,

  1131 @param aDbName Logical database name: "main" for the main database or attached database name,

  1132 				        

  1133 @leave The function may leave with system-wide error codes or SQL errors of ESqlDbError type

  1134