1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvDatabase.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1706 @@
1.4 +// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "SqlSrvFileData.h" //TSqlSrvFileData
1.20 +#include "SqlSrvMain.h" //CSqlServer
1.21 +#include "SqlSrvAuthorizer.h" //MSqlPolicyInspector
1.22 +#include "SqlSrvDatabase.h"
1.23 +#include "SqlSrvStatement.h"
1.24 +#include "SqlUtil.h" //Panic codes, Sql2OsErrCode()
1.25 +#include "SqlSrvUtil.h" //Global server functions
1.26 +#include "SqlCompact.h"
1.27 +#include "SqlSrvResourceProfiler.h"
1.28 +#include "OstTraceDefinitions.h"
1.29 +#ifdef OST_TRACE_COMPILER_IN_USE
1.30 +#include "SqlSrvDatabaseTraces.h"
1.31 +#endif
1.32 +#include "SqlTraceDef.h"
1.33 +
1.34 +//
1.35 +// The following macro disables the creation/loading of the settings table.
1.36 +// It is for internal testing purposes only!
1.37 +//
1.38 +// __SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__
1.39 +//
1.40 +// This means that the database index will always be rebuilt when loaded by
1.41 +// by the server regardless of the current system collation/locale in use.
1.42 +// The benefit of enabling this macro is that a client can send PRAGMA
1.43 +// commands to the SQL server before any tables have been explicity created in
1.44 +// a NON-SECURE database (secure databases still automatically get a security
1.45 +// policy table).
1.46 +//
1.47 +// The macro is applied inside:
1.48 +// CSqlSrvDatabase::StoreSettingsL
1.49 +// CSqlSrvDatabase::ProcessSettingsL
1.50 +//
1.51 +// We should inform the user at compile-time if this macro has been enabled:
1.52 +#if defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
1.53 +#pragma message(">>> WARNING: Use of SYMBIAN_SETTINGS table has been disabled <<<")
1.54 +#endif
1.55 +
1.56 +
1.57 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.58 +///////////////////////////// Local const data ///////////////////////////////////////////////////////
1.59 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.60 +
1.61 +const char* KErrMsg1 = "Missing ESCAPE expression";
1.62 +const char* KErrMsg2 = "ESCAPE expression must be a single character";
1.63 +
1.64 +////////////////////////////////////////////////////////
1.65 +//Attach/detach SQL statements (zero-terminated strings)
1.66 +_LIT(KAttachDb, "ATTACH DATABASE :FileName AS :DbName\x0");
1.67 +_LIT(KDetachDb, "DETACH DATABASE :DbName\x0");
1.68 +////////////////////////////////////////////////////////
1.69 +// Pragma SQL statements. The database names in all statements are quoted to avoid the "sql injection" threat.
1.70 +// (At the moment there is no way to pass an invalid database name for these statements, because the database has to be attached
1.71 +// first and a parameter binding is used there. So, the quoting is just for safety and against changes in the future)
1.72 +_LIT(KCacheSizePragma, "PRAGMA \"%S\".cache_size=%d\x0");
1.73 +_LIT(KPageSizePragma, "PRAGMA \"%S\".page_size=%d\x0");
1.74 +_LIT(KAutoVacuumPragma, "PRAGMA \"%S\".auto_vacuum=%d\x0");
1.75 +//_LIT(KPersist, "persist");
1.76 +//_LIT(KPersistentJournalPragma, "PRAGMA \"%S\".journal_mode=%S\x0");
1.77 +_LIT(KJournalSizeLimitPragma, "PRAGMA \"%S\".journal_size_limit=%d\x0");
1.78 +////////////////////////////////////////////////////////
1.79 +//"LIKE" - user defined function name
1.80 +_LIT8(KStrLikeFuncName, "LIKE\x0");
1.81 +
1.82 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.83 +///////////////////////////// Local functions ///////////////////////////////////////////////////////
1.84 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.85 +
1.86 +//Local function, used for comparing TSqlAttachDbPair objects.
1.87 +//(TSqlAttachDbPair structure represents type of the objects, members
1.88 +// of the map used for keeping the information regarding attached databases)
1.89 +//
1.90 +//Note that iKey members of aLeft and aRight function parameters are expected to be
1.91 +//UTF8 encoded, zero-terminated strings.
1.92 +//
1.93 +//The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or
1.94 +//aRight argument is NULL.
1.95 +static TInt Compare(const TSqlAttachDbPair& aLeft, const TSqlAttachDbPair& aRight)
1.96 + {
1.97 + __ASSERT_DEBUG(aLeft.iKey != NULL && aRight.iKey != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.98 + return ::CompareNoCase8(TPtrC8(aLeft.iKey), TPtrC8(aRight.iKey));
1.99 + }
1.100 +
1.101 +//Local function, used for comparing TSqlCompactDbPair objects.
1.102 +//(TSqlCompactDbPair structure represents type of the objects, members
1.103 +// of the map used for keeping the information regarding compacted databases)
1.104 +//
1.105 +//Note that iKey members of aLeft and aRight function parameters are expected to be
1.106 +//UTF16 encoded strings.
1.107 +//
1.108 +//The function will panic with panic code 7 in _DEBUG mode if iKey member of aLeft or
1.109 +//aRight argument is NULL.
1.110 +static TInt Compare2(const TSqlCompactDbPair& aLeft, const TSqlCompactDbPair& aRight)
1.111 + {
1.112 + __ASSERT_DEBUG(aLeft.iKey != NULL && aRight.iKey != NULL, __SQLPANIC2(ESqlPanicInternalError));
1.113 + return ::CompareNoCase(*aLeft.iKey, *aRight.iKey);
1.114 + }
1.115 +
1.116 +//Creates/opens database file (database file name in aFileData parameter) and initializes aDbHandle parameter.
1.117 +//The database will be created either with UTF-16 or UTF-8 encoding, depending on the
1.118 +//TSqlSrvFileData::IsUTF16() property.
1.119 +static void CreateDbHandleL(const TSqlSrvFileData& aFileData, sqlite3*& aDbHandle)
1.120 + {
1.121 + if(aFileData.ConfigParams().iDbEncoding == TSqlSrvConfigParams::EEncUtf8)
1.122 + {
1.123 + TBuf8<KMaxFileName + 1> fileNameZ;
1.124 + if(!::UTF16ZToUTF8Z(aFileData.FileNameZ(), fileNameZ))
1.125 + {
1.126 + __SQLLEAVE2(KErrGeneral);
1.127 + }
1.128 + __SQLLEAVE_IF_ERROR2(::CreateDbHandle8(fileNameZ, aDbHandle));
1.129 + }
1.130 + else
1.131 + {
1.132 + __SQLLEAVE_IF_ERROR2(::CreateDbHandle16(aFileData.FileNameZ(), aDbHandle));
1.133 + }
1.134 + }
1.135 +
1.136 +//LoadAttachedDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the
1.137 +//security policies read from the attached database file, which name is in aFileData parameter.
1.138 +//The created database security policy object is placed in the cleanup stack.
1.139 +//The caller is responsible for the destruction of the created and returned security policy object.
1.140 +//This function is used to read the security policies of attached databases.
1.141 +static CSqlSecurityPolicy* LoadAttachedDbSecurityPolicyLC(const TSqlSrvFileData& aFileData)
1.142 + {
1.143 + //Create new database security policy object and initialize it with a default security policy
1.144 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);
1.145 + CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);
1.146 + //This is an attached database and has to be opened
1.147 + sqlite3* dbHandle = NULL;
1.148 + CreateDbHandleL(aFileData, dbHandle);
1.149 + CleanupStack::PushL(TCleanupItem(&CloseDbCleanup, dbHandle));
1.150 + //Read the security policies.
1.151 + TSqlDbSysSettings dbSysSettings(dbHandle);
1.152 + dbSysSettings.LoadSecurityPolicyL(*dbPolicy);
1.153 + CleanupStack::PopAndDestroy();//TCleanupItem(&CloseDbCleanup, dbHandle)
1.154 + return dbPolicy;
1.155 + }
1.156 +
1.157 +//LoadDbSecurityPolicyLC() creates a new CSqlSecurityPolicy object and initializes it with the
1.158 +//security policies read from the database file.
1.159 +//The created database security policy object is placed in the cleanup stack.
1.160 +//The caller is responsible for destroying the returned database security policy object.
1.161 +//The function is used to read the security policy of the main database.
1.162 +static CSqlSecurityPolicy* LoadDbSecurityPolicyLC(sqlite3* aDbHandle)
1.163 + {
1.164 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.165 + //Create new database security policy object and initialize it with a default security policy
1.166 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);
1.167 + CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);
1.168 + //Read the security policies.
1.169 + TSqlDbSysSettings dbSysSettings(aDbHandle);
1.170 + dbSysSettings.LoadSecurityPolicyL(*dbPolicy);
1.171 + return dbPolicy;
1.172 + }
1.173 +
1.174 +//CreateStrCopyLC() makes a copy of aSrc string and places it in the cleanup stack.
1.175 +//aSrc is expected to be UTF8 encoded, zero terminated string.
1.176 +//The function panics in _DEBUG mode if aSrc is NULL.
1.177 +static TUint8* CreateStrCopyLC(const TUint8* aSrc)
1.178 + {
1.179 + __ASSERT_DEBUG(aSrc != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.180 + TInt len = User::StringLength(aSrc) + 1;
1.181 + TUint8* copy = new (ELeave) TUint8[len];
1.182 + Mem::Copy(copy, aSrc, len);
1.183 + CleanupStack::PushL(copy);
1.184 + return copy;
1.185 + }
1.186 +
1.187 +//EnableAuthorizer() function is used to reenable the authorizer callback
1.188 +//during the stack cleanup.
1.189 +static void EnableAuthorizer(void* aAuthorizerDisabled)
1.190 + {
1.191 + __ASSERT_DEBUG(aAuthorizerDisabled != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.192 + TBool* authorizerDisabled = static_cast <TBool*> (aAuthorizerDisabled);
1.193 + *authorizerDisabled = EFalse;
1.194 + }
1.195 +
1.196 +//Used by DbFileCleanup()
1.197 +NONSHARABLE_STRUCT(TDbFileCleanup)
1.198 + {
1.199 + TDbFileCleanup(const TSqlSrvFileData& aSqlSrvFileData, sqlite3*& aDbHandle) :
1.200 + iSqlSrvFileData(aSqlSrvFileData),
1.201 + iDbHandle(aDbHandle)
1.202 + {
1.203 + //aDbHandle can be NULL (it is a reference to a pointer and the pointer can be initialized later)
1.204 + }
1.205 + void Cleanup()
1.206 + {
1.207 + ::CloseDbHandle(iDbHandle);//This operation also deletes the journal file
1.208 + iDbHandle = NULL;
1.209 + (void)iSqlSrvFileData.Fs().Delete(iSqlSrvFileData.FileName());
1.210 + }
1.211 +private:
1.212 + const TSqlSrvFileData& iSqlSrvFileData;
1.213 + sqlite3*& iDbHandle;
1.214 + };
1.215 +
1.216 +//DbFileCleanup() is used to close and delete the database file during the stack cleanup, if
1.217 +//CSqlSrvDatabase's ConstructL() method(s) leave (when creating a new database file).
1.218 +static void DbFileCleanup(void* aDbFileCleanup)
1.219 + {
1.220 + __ASSERT_DEBUG(aDbFileCleanup != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.221 + TDbFileCleanup* dbFileCleanup = static_cast <TDbFileCleanup*> (aDbFileCleanup);
1.222 + dbFileCleanup->Cleanup();
1.223 + }
1.224 +
1.225 +//Executes "PRAGMA" SQL statement + INTEGER value.
1.226 +//Pragma parameters:
1.227 +// aValue - integer pragma value to be set;
1.228 +// aPragma - pragma statement, the format is: ""PRAGMA <database name>.<parameter name>=%d\x0""
1.229 +// aDbName - "main" or the attached database name
1.230 +//This function is used for setting "cache_size", "page_size", "auto_vacuum" pragmas.
1.231 +//During the call the authorizer will be disabled.
1.232 +static TInt ExecPragma(sqlite3* aDbHandle, TBool& aAuthorizerDisabled, const TDesC& aPragma, TInt aValue, const TDesC& aDbName = KMainDb16)
1.233 + {
1.234 + __SQLTRACE_INTERNALSEXPR(TPtrC pragmaprnptr(aPragma.Left(aPragma.Length() - 1)));
1.235 + SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, EXECPRAGMA_ENTRY, "Entry;0;ExecPragma;sqlite3*=0x%X;aPragma=%S;aValue=%d;aDbName=%S", (TUint)aDbHandle, __SQLPRNSTR(pragmaprnptr), aValue, __SQLPRNSTR(aDbName)));
1.236 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.237 + TBuf<KMaxFileName + 64> pragmaSql;//(KMaxFileName + 64) characters buffer length is enough for the longest possible PRAGMA statement
1.238 + pragmaSql.Format(aPragma, &aDbName, aValue);
1.239 + TBool authorizerDisabledState = aAuthorizerDisabled;
1.240 + aAuthorizerDisabled = ETrue;
1.241 + TInt err = DbExecStmt16(aDbHandle, pragmaSql);
1.242 + aAuthorizerDisabled = authorizerDisabledState;
1.243 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, EXECPRAGMA_EXIT, "Exit;0;ExecPragma;sqlite3*=0x%X;err=%d", (TUint)aDbHandle, err));
1.244 + return err;
1.245 + }
1.246 +
1.247 +//The journal size limit is set to be at lest 16 pages and no less than 64 Kb.
1.248 +static void SetJournalSizeLimitL(sqlite3* aDbHandle, TBool& aAuthorizerDisabled, TInt aPageSize, const TDesC& aDbName = KMainDb16)
1.249 + {
1.250 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.251 + if(aPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet)
1.252 + {
1.253 + __SQLLEAVE_IF_ERROR2(DbPageSize(aDbHandle, aDbName, aPageSize));
1.254 + }
1.255 + const TInt KPageMultiplier = 16;
1.256 + const TInt KDefaultJournalSizeLimit = 64 * 1024;
1.257 + const TInt KMaxJournalSizeLimit = 512 * 1024;
1.258 + const TInt KJournalSizeLimit = Min((aPageSize * KPageMultiplier), KMaxJournalSizeLimit);
1.259 + if(KJournalSizeLimit > KDefaultJournalSizeLimit)
1.260 + {
1.261 + __SQLLEAVE_IF_ERROR2(::ExecPragma(aDbHandle, aAuthorizerDisabled, KJournalSizeLimitPragma, KJournalSizeLimit));
1.262 + }
1.263 + }
1.264 +
1.265 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.266 +///////////////////////////// CSqlSrvDatabase class /////////////////////////////////////////////
1.267 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.268 +
1.269 +
1.270 +
1.271 +///////////////////////////// Object creation methods /////////////////////////////////////////////
1.272 +
1.273 +/**
1.274 +Creates new CSqlSrvDatabase instance which creates and manages new secure SQL database.
1.275 +
1.276 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.277 + file session reference and some other database file related properties.
1.278 + The format of the name must be:
1.279 + \<drive\>:\<[SID]database file name excluding the path\>.
1.280 + "[SID]" refers to SID of the application which creates the database.
1.281 +@param aSecurityPolicy The database security policies container.
1.282 + CSqlSrvDatabase instance stores the pointer in the security policy map,
1.283 + if it does not exist there already. The security policies map is owned by the CSqlServer class.
1.284 +
1.285 +@return A pointer to the created CSqlSrvDatabase instance.
1.286 +
1.287 +@see CSqlServer
1.288 +@see TSqlSrvFileData
1.289 +@see MSqlPolicyInspector
1.290 +@see RSqlSecurityMap
1.291 +@see CSqlSecurityPolicy
1.292 +
1.293 +@leave KErrNoMemory, an out of memory condition has occurred;
1.294 + KErrArgument, if a system table name found in the security policies (aSecurityPolicy);
1.295 + KErrAlreadyExists, the file already exists;
1.296 + KErrNotReady, the drive does not exist or is not ready;
1.297 + KErrInUse, the file is already open;
1.298 + KErrPermissionDenied, the client application does not satisfy the relevant database security policies.
1.299 + Note that the function may also leave with some other database specific
1.300 + errors categorised as ESqlDbError, and other system-wide error codes.
1.301 +
1.302 +@panic SqlDb 4 In _DEBUG mode if aFileData does not refer to a secure database file name.
1.303 +@panic SqlDb 4 In _DEBUG mode if aSecurityPolicy is NULL.
1.304 +*/
1.305 +CSqlSrvDatabase* CSqlSrvDatabase::CreateSecureL(const TSqlSrvFileData& aFileData, CSqlSecurityPolicy* aSecurityPolicy)
1.306 + {
1.307 + SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_CREATESECUREL_ENTRY, "Entry;0;CSqlSrvDatabase::CreateSecureL"));
1.308 + __ASSERT_DEBUG(aFileData.IsSecureFileNameFmt(), __SQLPANIC2(ESqlPanicBadArgument));
1.309 + __ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.310 + if(!::SqlServer().SecurityInspector().Check(aSecurityPolicy->DbPolicy(RSqlSecurityPolicy::ESchemaPolicy)))
1.311 + {
1.312 + //The caller has no "SCHEMA" policy. Then the client is not given a permission to create the database.
1.313 + //Delete aSecurityPolicy since no database object is going to be created and the security policy object
1.314 + //won't be put in the security policies map.
1.315 + delete aSecurityPolicy;
1.316 + __SQLLEAVE2(KErrPermissionDenied);
1.317 + }
1.318 + //What does happen with aSecurityPolicy instance?
1.319 + // If the database is created successfully, then a lookup will be made in the security policies map.
1.320 + // (the security policies map contains reference counted security policies)
1.321 + // If the same security policy already exists in the map, then aSecurityPolicy will be deleted.
1.322 + // The reference counter of the found policy will be incremented.
1.323 + // If aSecurityPolicy is not in the map, then it will be put in the map and removed
1.324 + // from the map when CSqlSrvDatabase object is destroyed.
1.325 + // (the "remove" operation decrements the security policy counter
1.326 + // and destroys the policy if it reaches 0)
1.327 + //
1.328 + //The security policy map pair is:
1.329 + //{secure_db_name, reference_counted db_security_policy}
1.330 + //The security policy is reference counted, because the same database can be shared between one or more
1.331 + //connections (clients), in which case only a single, reference counted instance of the database security
1.332 + //policy is kept in the map.
1.333 + CleanupStack::PushL(aSecurityPolicy);
1.334 + CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
1.335 + CleanupStack::Pop(aSecurityPolicy);
1.336 + CleanupStack::PushL(self);
1.337 + self->ConstructCreateSecureL(aFileData, aSecurityPolicy);
1.338 + CleanupStack::Pop(self);
1.339 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATESECUREL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CreateSecureL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
1.340 + return self;
1.341 + }
1.342 +
1.343 +/**
1.344 +Creates new CSqlSrvDatabase instance which creates and manages new SQL database.
1.345 +
1.346 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.347 + file session reference and some other database file related properties.
1.348 +
1.349 +@return A pointer to the created CSqlSrvDatabase instance.
1.350 +
1.351 +@see CSqlServer
1.352 +@see TSqlSrvFileData
1.353 +@see MSqlPolicyInspector
1.354 +@see RSqlSecurityMap
1.355 +@see CSqlSecurityPolicy
1.356 +
1.357 +@leave KErrNoMemory, an out of memory condition has occurred;
1.358 + KErrArgument, the file name is a name of a secure database;
1.359 + KErrAlreadyExists, the file already exists;
1.360 + KErrNotReady, the drive does not exist or is not ready;
1.361 + KErrInUse, the file is already open;
1.362 + KErrArgument, the file name refers to a secure database, but aSecurityPolicy is NULL;
1.363 + Note that the function may also leave with some other database specific
1.364 + errors categorised as ESqlDbError, and other system-wide error codes.
1.365 +
1.366 +@panic SqlDb 4 In _DEBUG mode if aFileData refers to a secure database file name.
1.367 +*/
1.368 +CSqlSrvDatabase* CSqlSrvDatabase::CreateL(const TSqlSrvFileData& aFileData)
1.369 + {
1.370 + SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_CREATEL_ENTRY, "Entry;0;CSqlSrvDatabase::CreateL"));
1.371 + __ASSERT_DEBUG(!aFileData.IsSecureFileNameFmt(), __SQLPANIC2(ESqlPanicBadArgument));
1.372 + CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
1.373 + CleanupStack::PushL(self);
1.374 + self->ConstructCreateL(aFileData);
1.375 + CleanupStack::Pop(self);
1.376 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATEL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CreateL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
1.377 + return self;
1.378 + }
1.379 +
1.380 +/**
1.381 +Creates new CSqlSrvDatabase instance which opens and manages an existing SQL database.
1.382 +
1.383 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.384 + file session reference and some other database file related properties.
1.385 + If this is a secure database, then the format of the name must be:
1.386 + \<drive\>:\<[SID]database file name excluding the path\>.
1.387 + If this is a non-secure database, then the file name has to be the full database file name.
1.388 + "[SID]" refers to SID of the application which created the database.
1.389 + If this is application's private database, then the format of aFileData is as it is described
1.390 + in TSqlSrvFileData::SetFromHandleL() comments.
1.391 +
1.392 +@return A pointer to the created CSqlSrvDatabase instance.
1.393 +
1.394 +@leave KErrNoMemory, an out of memory condition has occurred;
1.395 + KErrNotReady, the drive does not exist or is not ready;
1.396 + KErrNotFound, the database file does not exist;
1.397 + KErrInUse, the file is already open;
1.398 + KErrPermissionDenied, the client application does not satisfy the relevant database security policies.
1.399 + Note that the function may also leave with some other database specific
1.400 + errors categorised as ESqlDbError, and other system-wide error codes.
1.401 +
1.402 +@see CSqlServer
1.403 +@see TSqlSrvFileData
1.404 +@see MSqlPolicyInspector
1.405 +@see RSqlSecurityMap
1.406 +@see CSqlSecurityPolicy
1.407 +@see TSqlSrvFileData::SetFromHandleL()
1.408 +*/
1.409 +CSqlSrvDatabase* CSqlSrvDatabase::OpenL(const TSqlSrvFileData& aFileData)
1.410 + {
1.411 + SQL_TRACE_INTERNALS(OstTrace0(TRACE_INTERNALS, CSQLSRVDATABASE_OPENL_ENTRY, "Entry;0;CSqlSrvDatabase::OpenL"));
1.412 + CSqlSrvDatabase* self = new (ELeave) CSqlSrvDatabase();
1.413 + CleanupStack::PushL(self);
1.414 + aFileData.IsSecureFileNameFmt() ? self->ConstructOpenSecureL(aFileData) : self->ConstructOpenL(aFileData);
1.415 + CleanupStack::Pop(self);
1.416 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_OPENL_EXIT, "Exit;0x%X;CSqlSrvDatabase::OpenL;sqlite3*=0x%X", (TUint)self, (TUint)self->iDbHandle));
1.417 + return self;
1.418 + }
1.419 +
1.420 +/**
1.421 +Cleans up the allocated for the database connection memory and other resources.
1.422 +*/
1.423 +CSqlSrvDatabase::~CSqlSrvDatabase()
1.424 + {
1.425 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CSQLSRVDATABASE2_ENTRY, "Entry;0x%X;CSqlSrvDatabase::~CSqlSrvDatabase;sqlite3*=0x%X", (TUint)this, (TUint)iDbHandle));
1.426 + TSqlCompactDbMapIterator compactDbIt(iCompactDbMap);
1.427 + TSqlCompactDbPair compactDbPair;
1.428 + while(compactDbIt.Next(compactDbPair))
1.429 + {
1.430 + __ASSERT_DEBUG(compactDbPair.iData, __SQLPANIC2(ESqlPanicInvalidObj));
1.431 + ::SqlServer().Compactor().ReleaseEntry(*compactDbPair.iData);
1.432 + }
1.433 + iCompactDbMap.Close();
1.434 + //If iSecureDbName is not NULL, the current CSqlSrvDatabase object operates on a secure database.
1.435 + //The database security policy has to be removed from the security policy map.
1.436 + //(The "remove" operation actually decrements the security policy reference counter and destroys the policy
1.437 + //when the counter reaches 0. The counter value may be greater than 1 if the database is shared between
1.438 + //more than one connection)
1.439 + if(iSecureDbName)
1.440 + {
1.441 + ::SqlServer().SecurityMap().Remove(iSecureDbName);
1.442 + //The security policy map owns iSecureDbName and iSecurityPolicy and is responsible for
1.443 + //iSecureDbName and iSecurityPolicy destruction.
1.444 + }
1.445 + //The next step of the "resource release" process is to walk over iAttachDbMap entries, get the data part of
1.446 + //the found TSqlAttachDbPair objects, which is secure database name used as a key in iSecurityMap, and remove
1.447 + //the related entry from iSecurityMap. If the database is closed in normal circumstances, the iAttachDbMap
1.448 + //has no entries. But if the database client forgets to detach the used attached databases or if the Detach() call
1.449 + //fails (for example, with KErrNoMemory error), then at this point iAttachDbMap has one or more entries.
1.450 + //That means there are still some attached databases to this connection. This is not a problem, SQLite will take
1.451 + //care of them. The problem is that there are related entries in iSecurityMap map, owned by CSqlServer object,
1.452 + //and they won't be removed from the map till CSqlServer object is alive. This causes problems in OOM tests and in
1.453 + //real life of the device.
1.454 + //For example, one database client opens "c:[11111111]a.db" and attaches "c:[11111111]b.db":
1.455 + // - c:[11111111]a.db database has been opened successfully. iSecurityMap has 1 entry:
1.456 + // {"c:[11111111]a.db", <database security policy object>}.
1.457 + // - c:[11111111]b.db is attached to c:[11111111]a.db with name "db2". There will be 1 entry in iAttachDbMap:
1.458 + // {"db2", "c:[11111111]a.db"}
1.459 + // and a new entry will be added to iSecurityMap:
1.460 + // {"c:[11111111]b.db", <database security policy object>}. 2 entries in total in iSecurityMap.
1.461 + // - The database client attempts to detach the attached database but the opertaion fails during the execution
1.462 + // of the DETACH sql statement. Both maps are intact.
1.463 + // - The database client attempts to close the database. The previous implementation of CSqlSrvDatabase::~CSqlSrvDatabase()
1.464 + // would only remove "c:[11111111]a.db" entry from iSecurityMap and close the iAttachDbMap map.
1.465 + // The result: no opened or attached databases but there will be one entry in iSecurityMap: "c:[11111111]b.db".
1.466 + // OOM tests will report a memory leak in this case. On a real device, if "c:[11111111]b.db" gets deleted and
1.467 + // recreated again, unexpected memory leak will occur in CSqlSrvDatabase::ConstructCreateSecureL() because
1.468 + // the code there "expects" that is the first time when a "c:[11111111]b.db" entry is added to iSecurityMap.
1.469 + TSqlAttachDbMapIterator it(iAttachDbMap);
1.470 + TSqlAttachDbPair attachDbPair;
1.471 + while(it.Next(attachDbPair))
1.472 + {
1.473 + __ASSERT_DEBUG(attachDbPair.iData, __SQLPANIC2(ESqlPanicInvalidObj));
1.474 + ::SqlServer().SecurityMap().Remove(attachDbPair.iData);
1.475 + }
1.476 + iAttachDbMap.Close();
1.477 + ::CloseDbHandle(iDbHandle);
1.478 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_CSQLSRVDATABASE2_EXIT, "Exit;0x%X;CSqlSrvDatabase::~CSqlSrvDatabase", (TUint)this));
1.479 + }
1.480 +
1.481 +/**
1.482 +Initializes CSqlSrvDatabase data memebers with their default values.
1.483 +
1.484 +
1.485 +@see MSqlPolicyInspector
1.486 +@see RSqlSecurityMap
1.487 +@see CSqlServer
1.488 +*/
1.489 +CSqlSrvDatabase::CSqlSrvDatabase() :
1.490 + iAttachDbMap(TSqlAttachDbLinearOrder(&Compare), TSqlAttachDbDestructor()),
1.491 + iCompactDbMap(TSqlCompactDbLinearOrder(&Compare2), TSqlCompactDbDestructor())
1.492 + {
1.493 + }
1.494 +
1.495 +/**
1.496 +Creates a new SQL database file and executes config pragmas.
1.497 +This function is part of CSqlSrvDatabase instance initialization.
1.498 +If the function leaves and the error is not KErrAlreadyExists, the database file will be deleted.
1.499 +
1.500 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.501 + file session reference and some other database file related properties.
1.502 + If this is a secure database, then the format of the name must be:
1.503 + \<drive\>:\<[SID]database file name excluding the path\>.
1.504 + If this is a non-secure database, then the file name has to be the full database file name.
1.505 + "[SID]" refers to SID of the application which creates the database.
1.506 +
1.507 +@see TSqlSrvFileData
1.508 +
1.509 +@leave KErrNoMemory, an out of memory condition has occurred;
1.510 + KErrAlreadyExists, the file already exists.
1.511 + Note that the function may also leave with some other database specific
1.512 + errors categorised as ESqlDbError, and other system-wide error codes.
1.513 +*/
1.514 +void CSqlSrvDatabase::CreateNewDbFileL(const TSqlSrvFileData& aFileData)
1.515 + {
1.516 + __SQLTRACE_INTERNALSVAR(TPtrC fname = aFileData.FileName());
1.517 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_CREATENEWDBFILEL, "0x%x;CSqlSrvDatabase::CreateNewDbFileL;fname=%S", (TUint)this, __SQLPRNSTR(fname)));
1.518 + if(::FileExists(aFileData.Fs(), aFileData.FileName()))
1.519 + {
1.520 + __SQLLEAVE(KErrAlreadyExists);
1.521 + }
1.522 + TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);
1.523 + CleanupStack::PushL(TCleanupItem(&DbFileCleanup, &dbFileCleanup));
1.524 + ::CreateDbHandleL(aFileData, iDbHandle);
1.525 + SetConfigL(aFileData.ConfigParams(), ETrue);
1.526 + CleanupStack::Pop();//DbFileCleanup
1.527 + }
1.528 +
1.529 +/**
1.530 +Opens an existing SQL database file and executes config pragmas.
1.531 +
1.532 +This function is part of CSqlSrvDatabase instance initialization.
1.533 +
1.534 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.535 + file session reference and some other database file related properties.
1.536 + If this is a secure database, then the format of the name must be:
1.537 + \<drive\>:\<[SID]database file name excluding the path\>.
1.538 + If this is a non-secure database, then the file name has to be the full database file name.
1.539 + "[SID]" refers to SID of the application which creates the database.
1.540 + If this is application's private database, then the format of aFileData is as it is described
1.541 + in TSqlSrvFileData::SetFromHandleL() comments.
1.542 +
1.543 +@leave KErrNoMemory, an out of memory condition has occurred;
1.544 + KErrNotFound, SQL database file not found.
1.545 + Note that the function may also leave with some other database specific
1.546 + errors categorised as ESqlDbError, and other system-wide error codes.
1.547 +
1.548 +@see TSqlSrvFileData
1.549 +@see TSqlSrvFileData::SetFromHandleL()
1.550 +*/
1.551 +void CSqlSrvDatabase::OpenExistingDbFileL(const TSqlSrvFileData& aFileData)
1.552 + {
1.553 + __SQLTRACE_INTERNALSVAR(TPtrC fname = aFileData.FileName());
1.554 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_OPENEXISTINGDBFILEL, "0x%x;CSqlSrvDatabase::OpenExistingDbFileL;fname=%S", (TUint)this, __SQLPRNSTR(fname)));
1.555 + if(!aFileData.ContainHandles())
1.556 + {//This check is valid only if the database is outside application's private data cage
1.557 + if(!::FileExists(aFileData.Fs(), aFileData.FileName()))
1.558 + {
1.559 + __SQLLEAVE(KErrNotFound);
1.560 + }
1.561 + }
1.562 + ::CreateDbHandleL(aFileData, iDbHandle);
1.563 + //this is an existing database, only the cache size can be changed, the page size is persistent database property.
1.564 + //But for private databases, opened on the client side - the page size can be set (for the "create database" operations).
1.565 + SetConfigL(aFileData.ConfigParams(), aFileData.ContainHandles());
1.566 + }
1.567 +
1.568 +/**
1.569 +Installs an authorizer callback function.
1.570 +
1.571 +The callback function is invoked by the SQL parser at SQL statement compile time for each attempt
1.572 +to access a column of a table in the database and is used to assert the calling application's rights to
1.573 +perform specific SQL operation.
1.574 +
1.575 +This function is part of CSqlSrvDatabase instance initialization.
1.576 +
1.577 +@leave The function may leave with some database specific errors categorised as ESqlDbError.
1.578 +*/
1.579 +void CSqlSrvDatabase::InstallAuthorizerL()
1.580 + {
1.581 + //Install the authorizer just once. "Install authorizer" may be expensive and dangerous operation because
1.582 + //it will expire the already prepared statements.
1.583 + if(!iAuthorizerInstalled)
1.584 + {
1.585 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.586 + TInt err = sqlite3_set_authorizer(iDbHandle, &CSqlSrvDatabase::AuthorizeCallback, this);
1.587 + __SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));
1.588 + }
1.589 + iAuthorizerInstalled = ETrue;
1.590 + }
1.591 +
1.592 +#ifdef SYMBIAN_USE_SQLITE_VERSION_3_6_4
1.593 +extern "C" int sqlite3RegisterInternalUtf8Like(sqlite3 *db);
1.594 +#endif
1.595 +/**
1.596 +Installs user-defined functions. At the moment there is only one: LIKE.
1.597 +
1.598 +Replacing the LIKE operator default implementation with user defined LIKE functions.
1.599 +The default implementation need a replacement because it does not work correctly with UTF16 encoded strings.
1.600 +*/
1.601 +void CSqlSrvDatabase::InstallUDFsL()
1.602 + {
1.603 + //Registering user defined LIKE function with 2 parameters for UTF16 encoding
1.604 + TInt err = sqlite3_create_function(iDbHandle, reinterpret_cast <const char*> (KStrLikeFuncName().Ptr()),
1.605 + 2/*arg*/, SQLITE_UTF16, this /*user data*/,
1.606 + &CSqlSrvDatabase::LikeSqlFunc, NULL/*xStep*/, NULL/*xFinal*/);
1.607 + __SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));
1.608 + //Registering user defined LIKE function with 3 parameters for UTF16 encoding
1.609 + err = sqlite3_create_function(iDbHandle, reinterpret_cast <const char*> (KStrLikeFuncName().Ptr()),
1.610 + 3/*arg*/, SQLITE_UTF16, this/*user data*/,
1.611 + &CSqlSrvDatabase::LikeSqlFunc, NULL/*xStep*/, NULL/*xFinal*/);
1.612 + __SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));
1.613 +
1.614 +#ifdef SYMBIAN_USE_SQLITE_VERSION_3_6_4
1.615 + //Registering user defined LIKE function with 2 and 3 parameters for UTF8 encoding
1.616 + //Once registered, these will be treated as built-in functions
1.617 + err = sqlite3RegisterInternalUtf8Like(iDbHandle);
1.618 + __SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));
1.619 +#endif
1.620 + }
1.621 +
1.622 +/**
1.623 +Constructs a key for searching in the security policies map.
1.624 +
1.625 +The key is UTF8 encoded, zero-terminated string.
1.626 +
1.627 +Every time when CSqlSrvDatabase instance creates, opens or attaches a secure database, it updates
1.628 +the contents of the security policies map (RSqlSecurityMap class), which is a single instance owned
1.629 +by the CSqlServer class.
1.630 +
1.631 +@param aDbFileName Full secure database file name, from which the security policies map key
1.632 + will be constructed.
1.633 +
1.634 +@return A const pointer to the constructed security map key. No memory is allocated for the key.
1.635 +
1.636 +@leave KErrGeneral the UTF16 to UTF8 conversion of aDbFileName parameter failed.
1.637 +
1.638 +@see RSqlSecurityMap
1.639 +@see CSqlServer
1.640 +*/
1.641 +const TUint8* CSqlSrvDatabase::SecurityMapKeyL(const TDesC& aDbFileName)
1.642 + {
1.643 + //Form the map item key - the secure database name
1.644 + TParsePtrC parse(aDbFileName);//this call may panic if aDbFileName cannot be parsed. But aDbFileName was preprocessed by TSqlSrvFileData::Set
1.645 + TFileName secureDbName;
1.646 + secureDbName.Copy(parse.Drive());
1.647 + secureDbName.Append(parse.NameAndExt());
1.648 + secureDbName.Append(TChar(0));
1.649 + TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));
1.650 + if(!::UTF16ZToUTF8Z(secureDbName, ptr))
1.651 + {
1.652 + __SQLLEAVE(KErrGeneral);
1.653 + }
1.654 + return iFileNameBuf;
1.655 + }
1.656 +
1.657 +/**
1.658 +Attaches a secure or non-secure database to the current database connection.
1.659 +
1.660 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.661 + file session reference and some other database file related properties.
1.662 + If this is a secure database, then the format of the name must be:
1.663 + \<drive\>:\<[SID]database file name excluding the path\>.
1.664 + If this is a non-secure database, then the file name has to be the full database file name.
1.665 + "[SID]" refers to SID of the application which creates the database.
1.666 +@param aDbName Database name. It must be unique (per database connection). This is the name which can
1.667 + be used for accessing tables in the attached database. The syntax is "database-name.table-name".
1.668 +
1.669 +@leave KErrNotFound, the database file which has to be attached does not exist.
1.670 + KErrPermissionDenied, the client application does not satisfy the relevant security policies of
1.671 + the attached database.
1.672 + Note that the function may also leave with some other database specific
1.673 + errors categorised as ESqlDbError, and other system-wide error codes.
1.674 +
1.675 +@see TSqlSrvFileData
1.676 +*/
1.677 +void CSqlSrvDatabase::AttachDbL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)
1.678 + {
1.679 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_ATTACHDBL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::AttachDbL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
1.680 + if(!aFileData.ContainHandles())
1.681 + {//This check is valid only if the database is outside application's private data cage
1.682 + if(!::FileExists(aFileData.Fs(), aFileData.FileName()))
1.683 + {
1.684 + __SQLLEAVE(KErrNotFound);
1.685 + }
1.686 + }
1.687 + if(!aFileData.IsSecureFileNameFmt())
1.688 + {//A non-secure database to be attached - execute the "ATTACH DB" SQL statement and initialize the attached database.
1.689 + InitAttachedDbL(aFileData, aDbName);
1.690 + }
1.691 + else
1.692 + {//A secure database has to be attached. This is a complex operation and if it fails, proper cleanup
1.693 + //has to be performed. "state" variable keeps the state, after which the "attach db" operation failed.
1.694 + //There are three things needed to be done when atatching a secure database:
1.695 + // 1. Executing the "ATTACH DB" SQL statement and initializing the attached database
1.696 + // 2. Updating the security policy map
1.697 + // 3. Updating the {db name, logical db name} map
1.698 + //The additional map (3) is needed because when the authorizer callback is called by SQLITE, the callback
1.699 + //is given the logical database name, if that's an operation on an attached database. Since the security
1.700 + //policy map uses the database name as a key, the map (3) is used to find what is the physical database
1.701 + //name, which the logical database name points to.
1.702 + //
1.703 + //There is an additional step (0), which may happen when a secure database is attached to a
1.704 + //non-secure database. But this step does not require a cleanup.
1.705 + CSqlSrvDatabase::TAttachState state = CSqlSrvDatabase::EAStNone;
1.706 + const TUint8* securityMapKey = NULL;
1.707 + TRAPD(err, DoAttachSecureDbL(state, aFileData, aDbName, securityMapKey));
1.708 + if(err != KErrNone)
1.709 + {
1.710 + //Cleanup
1.711 + if(state > CSqlSrvDatabase::EAStNone)
1.712 + {
1.713 + (void)FinalizeAttachedDb(aDbName);
1.714 + if(state > CSqlSrvDatabase::EAStDbAttached)
1.715 + {
1.716 + ::SqlServer().SecurityMap().Remove(securityMapKey);
1.717 + }
1.718 + }
1.719 + __SQLLEAVE(err);
1.720 + }
1.721 + }
1.722 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_ATTACHDBL_EXIT, "Exit;0x%X;CSqlSrvDatabase::AttachDbL", (TUint)this));
1.723 + }
1.724 +
1.725 +/**
1.726 +Attaches a secure database to the existing connection.
1.727 +
1.728 +The function also updates the following maps:
1.729 +- Security policies map (CSqlServer::iSecurityMap), where a reference counted copy of database security policies
1.730 + is kept for each created/opened/attached database during the life time of the SQL server;
1.731 +- Attached secure databases map (CSqlSrvDatabase::iAttachDbMap), where an information is kept what SQL database
1.732 + file name corresponds to a specific attached database name. This information is used by the authorizer callback
1.733 + function in order to find what database security policies have to be asserted when a SQL operation is issued
1.734 + for a particular attached database (the attached database name is identified always by its name, not the file name);
1.735 +
1.736 +@param aState Output parameter - the attach progress state, used by the calling function to perform correctly
1.737 + the cleanup, if the attach operation fails.
1.738 + It may have the following values set:
1.739 + - CSqlSrvDatabase::EAStNone - no resources need to be freed;
1.740 + - CSqlSrvDatabase::EAStDbAttached - the function was able to execute the "ATTACH DATABASE"
1.741 + SQL statement before an error occured. The calling function has to execute "DETACH DATABASE"
1.742 + SQL statement to detach the database;
1.743 + - CSqlSrvDatabase::EAStSecurityMapUpdated - the function was able to update the security policies
1.744 + map (CSqlServer::iSecurityMap) before an error occured. The calling function has to remove
1.745 + the attached database security policies from the map and detach the database.
1.746 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.747 + file session reference and some other database file related properties.
1.748 + The secure database name format must be:
1.749 + \<drive\>:\<[SID]database file name excluding the path\>.
1.750 + "[SID]" refers to SID of the application which creates the database.
1.751 +@param aDbName Database name. It must be unique (per database connection). This is the name which can
1.752 + be used for accessing tables in the attached database. The syntax is "database-name.table-name".
1.753 +@param aMapKey Output parameter, UTF8 encoded, zero-terminated string, which can be used for searching
1.754 + of the attached database security policies in the security policies map (CSqlServer::iSecurityMap).
1.755 + No memory is allocated for the key.
1.756 +
1.757 +@see RSqlSecurityMap
1.758 +@see RSqlAttachDbMap
1.759 +@see CSqlServer
1.760 +@see TSqlSrvFileData
1.761 +@see CSqlSrvDatabase
1.762 +
1.763 +@leave KErrNoMemory, an out of memory condition has occurred;
1.764 + KErrPermissionDenied, the client application does not satisfy the relevant security policies of
1.765 + the attached database.
1.766 + Note that the function may also leave with some other database specific
1.767 + errors categorised as ESqlDbError, and other system-wide error codes.
1.768 +*/
1.769 +void CSqlSrvDatabase::DoAttachSecureDbL(CSqlSrvDatabase::TAttachState& aState,
1.770 + const TSqlSrvFileData& aFileData,
1.771 + const TDesC& aDbName, const TUint8*& aMapKey)
1.772 + {
1.773 + //Step 1: Attach the database and initialize the attached database
1.774 + InitAttachedDbL(aFileData, aDbName);
1.775 + aState = CSqlSrvDatabase::EAStDbAttached;
1.776 + //Step 2: Load the database security policy and update the security map
1.777 + const CSqlSecurityPolicy* securityPolicy = NULL;
1.778 + UpdateSecurityMapL(ETrue, aFileData, aMapKey, securityPolicy);
1.779 + aState = CSqlSrvDatabase::EAStSecurityMapUpdated;
1.780 + //Check that the caller has at least one of {Schema, Read, Write} policies.
1.781 + BasicSecurityPolicyCheckL(*securityPolicy);
1.782 + //Step 3: Update the attached databases map
1.783 + InsertInAttachDbMapL(aFileData.FileName(), aDbName);
1.784 + }
1.785 +
1.786 +/**
1.787 +Detaches a database from the current database connection.
1.788 +
1.789 +The function also will search the security policies map (CSqlServer::iSecurityMap) and the attached databases
1.790 +map (CSqlSrvDatabase::iAttachDbMap) for entries which correspond to the database ,
1.791 +which is about to be detached, and will remove the entries.
1.792 +
1.793 +@param aDbName Attached database name. It must be unique (per database connection).
1.794 +
1.795 +@leave The function may leave with some database specific errors categorised as ESqlDbError,
1.796 + and other system-wide error codes.
1.797 +
1.798 +@see CSqlSrvDatabase::DoAttachSecureDbL()
1.799 +@see RSqlSecurityMap
1.800 +@see RSqlAttachDbMap
1.801 +@see CSqlServer
1.802 +@see CSqlSrvDatabase
1.803 +*/
1.804 +void CSqlSrvDatabase::DetachDbL(const TDesC& aDbName)
1.805 + {
1.806 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_DETACHDBL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::DetachDbL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
1.807 + TInt err = FinalizeAttachedDb(aDbName);
1.808 + if(err == KErrNone)
1.809 + {
1.810 + TRAP_IGNORE(RemoveFromMapsL(aDbName));
1.811 + }
1.812 + else
1.813 + {
1.814 + __SQLLEAVE(err);
1.815 + }
1.816 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_DETACHDBL_EXIT, "Exit;0x%X;CSqlSrvDatabase::DetachDbL", (TUint)this));
1.817 + }
1.818 +
1.819 +/**
1.820 +Calculates and returns the database size.
1.821 +
1.822 +@param aDbName Attached database name or KNullDesC for the main database
1.823 +
1.824 +@leave The function may leave with some database specific errors categorised as ESqlDbError,
1.825 + and other system-wide error codes.
1.826 +
1.827 +@return Database size in bytes.
1.828 +*/
1.829 +TInt64 CSqlSrvDatabase::SizeL(const TDesC& aDbName)
1.830 + {
1.831 + iAuthorizerDisabled = ETrue;
1.832 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.833 + TInt pageCount = 0;
1.834 + __SQLLEAVE_IF_ERROR(::DbPageCount(iDbHandle, aDbName, pageCount));
1.835 + __ASSERT_DEBUG(pageCount >= 0, __SQLPANIC(ESqlPanicInternalError));
1.836 + CleanupStack::PopAndDestroy();
1.837 + return (TInt64)pageCount * PageSizeL(aDbName);
1.838 + }
1.839 +
1.840 +/**
1.841 +Retrieves the database free space.
1.842 +
1.843 +@param aDbName Attached database name or KNullDesC for the main database
1.844 +
1.845 +@return Database free space in bytes.
1.846 +
1.847 +@leave The function may leave with some database specific errors categorised as ESqlDbError,
1.848 + and other system-wide error codes.
1.849 +*/
1.850 +TInt64 CSqlSrvDatabase::FreeSpaceL(const TDesC& aDbName)
1.851 + {
1.852 + iAuthorizerDisabled = ETrue;
1.853 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.854 + TInt freePageCount = 0;
1.855 + __SQLLEAVE_IF_ERROR(::DbFreePageCount(iDbHandle, aDbName, freePageCount));
1.856 + CleanupStack::PopAndDestroy();
1.857 + __ASSERT_DEBUG(freePageCount >= 0, __SQLPANIC(ESqlPanicInternalError));
1.858 + return (TInt64)freePageCount * PageSizeL(aDbName);
1.859 + }
1.860 +
1.861 +/**
1.862 +Collects information regarding the current cache size, page, size, encoding, etc. and puts the values
1.863 +in the aDest output string.
1.864 +
1.865 +@param aDest Output parameter, where the result values will be stored. The string format is: "<val1>;<val2>...;".
1.866 +
1.867 +@leave The function may leave with some database specific errors categorised as ESqlDbError,
1.868 + and other system-wide error codes.
1.869 +*/
1.870 +void CSqlSrvDatabase::QueryConfigL(TDes8& aDest)
1.871 + {
1.872 + iAuthorizerDisabled = ETrue;
1.873 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.874 +
1.875 + TInt cacheSize = 0;
1.876 + __SQLLEAVE_IF_ERROR(::DbCacheSize(iDbHandle, KNullDesC, cacheSize));
1.877 +
1.878 + TInt pageSize = 0;
1.879 + __SQLLEAVE_IF_ERROR(::DbPageSize(iDbHandle, KNullDesC, pageSize));
1.880 +
1.881 + TBuf8<16> encoding;
1.882 + __SQLLEAVE_IF_ERROR(::DbEncoding(iDbHandle, KNullDesC, encoding));
1.883 +
1.884 + TInt defaultSoftHeapLimit = TSqlSrvConfigParams::KDefaultSoftHeapLimitKb;
1.885 +
1.886 + TInt vacuum = 0;
1.887 + __SQLLEAVE_IF_ERROR(::DbVacuumMode(iDbHandle, KNullDesC, vacuum));
1.888 +
1.889 + aDest.AppendNum(cacheSize);
1.890 + _LIT8(KSemiColon, ";");
1.891 + aDest.Append(KSemiColon);
1.892 + aDest.AppendNum(pageSize);
1.893 + aDest.Append(KSemiColon);
1.894 + aDest.Append(encoding);
1.895 + aDest.Append(KSemiColon);
1.896 + aDest.AppendNum(defaultSoftHeapLimit);
1.897 + aDest.Append(KSemiColon);
1.898 + aDest.AppendNum(vacuum);
1.899 + aDest.Append(KSemiColon);
1.900 +
1.901 + CleanupStack::PopAndDestroy();
1.902 + }
1.903 +
1.904 +/**
1.905 +Compacts the database free space.
1.906 +
1.907 +@param aSize The requested database space to be compacted, in bytes.
1.908 + If aSize value is RSqlDatabase::EMaxCompaction, then all free pages will be removed.
1.909 + Note that the requested space to be compacted will be rounded up to the nearest page count,
1.910 + e.g. request for removing 1 byte will remove one free page from the database file.
1.911 +
1.912 +@param aDbName Attached database name or KNullDesC for the main database
1.913 +
1.914 +@return The size of the removed free space
1.915 +
1.916 +@leave The function may leave with some database specific errors categorised as ESqlDbError,
1.917 + and other system-wide error codes.
1.918 +*/
1.919 +TInt CSqlSrvDatabase::CompactL(TInt aSize, const TDesC& aDbName)
1.920 + {
1.921 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_COMPACTL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::CompactL;aSize=%d;aDbName=%S", (TUint)this, aSize, __SQLPRNSTR(aDbName)));
1.922 + __ASSERT_DEBUG(aSize > 0 || aSize == RSqlDatabase::EMaxCompaction, __SQLPANIC(ESqlPanicBadArgument));
1.923 + TInt pageSize = PageSizeL(aDbName);//PageSizeL() will disable/enable the authorizer
1.924 + TInt pageCount = KMaxTInt;
1.925 + if(aSize > 0)
1.926 + {//64-bit calculations to avoid the overflow in case if (aSize + pageSize) >= KMaxTInt.
1.927 + pageCount = (TInt64)((TInt64)aSize + pageSize - 1) / pageSize;
1.928 + }
1.929 + if(pageCount > 0)
1.930 + {
1.931 + iAuthorizerDisabled = ETrue;
1.932 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.933 + __SQLLEAVE_IF_ERROR(::DbCompact(iDbHandle, aDbName, pageCount, pageCount));
1.934 + CleanupStack::PopAndDestroy();
1.935 + }
1.936 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_COMPACTL_EXIT, "Exit;0x%X;CSqlSrvDatabase::CompactL;pageCount=%d;pageSize=%d", (TUint)this, pageCount, pageSize));
1.937 + return pageCount * pageSize;
1.938 + }
1.939 +
1.940 +/**
1.941 +This structure is used in case if the InitAttachedDbL() execution fails and the
1.942 +executed operations ("attach database", "init compact") have to be reverted calling
1.943 +FinalizeAttachedDb().
1.944 +
1.945 +@see CSqlSrvDatabase::InitAttachedDbL
1.946 +@see CSqlSrvDatabase::FinalizeAttachedDb
1.947 +@see CSqlSrvDatabase::AttachCleanup
1.948 +
1.949 +@internalComponent
1.950 +*/
1.951 +NONSHARABLE_STRUCT(TAttachCleanup)
1.952 + {
1.953 + inline TAttachCleanup(CSqlSrvDatabase& aSelf, const TDesC& aDbName) :
1.954 + iSelf(aSelf),
1.955 + iDbName(aDbName)
1.956 + {
1.957 + }
1.958 + CSqlSrvDatabase& iSelf;
1.959 + const TDesC& iDbName;
1.960 + };
1.961 +
1.962 +/**
1.963 +Cleanup function. Calls FinalizeAttachedDb() if InitAttachedDbL() has failed.
1.964 +
1.965 +@param aCleanup A pointer to a TAttachCleanup object that contains the needed for the cleanup information.
1.966 +
1.967 +@see TAttachCleanup
1.968 +
1.969 +@internalComponent
1.970 +*/
1.971 +void CSqlSrvDatabase::AttachCleanup(void* aCleanup)
1.972 + {
1.973 + TAttachCleanup* cleanup = reinterpret_cast <TAttachCleanup*> (aCleanup);
1.974 + __ASSERT_DEBUG(cleanup != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.975 + (void)cleanup->iSelf.FinalizeAttachedDb(cleanup->iDbName);
1.976 + }
1.977 +
1.978 +/**
1.979 +Forms and executes "ATTACH DATABASE" SQL statement.
1.980 +If the database is not read-only:
1.981 + - Makes the attached database journal file persistent.
1.982 + - Initializes the attached database compaction mode.
1.983 + - The attached database will be reindexed if the default collation has been changed.
1.984 +
1.985 +@param aFileData Attached database file data
1.986 +@param aDbName Attached database name. It must be unique (per database connection).
1.987 +
1.988 +@leave KErrNoMemory, an out of memory condition has occurred;
1.989 + Note that the function may also leave with some other database specific
1.990 + errors categorised as ESqlDbError, and other system-wide error codes.
1.991 +
1.992 +@see InitCompactionL
1.993 +@see ProcessSettingsL
1.994 +*/
1.995 +void CSqlSrvDatabase::InitAttachedDbL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)
1.996 + {
1.997 + TPtrC dbFileName = aFileData.FileName();
1.998 + TBool readOnlyDbFile = aFileData.IsReadOnly();
1.999 +
1.1000 + InstallAuthorizerL();
1.1001 + iAuthorizerDisabled = ETrue;
1.1002 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.1003 + sqlite3_stmt* stmtHandle = StmtPrepare16L(iDbHandle, KAttachDb);
1.1004 + TInt err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 1, dbFileName.Ptr(), dbFileName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());
1.1005 + if(err == KErrNone)
1.1006 + {
1.1007 + err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 2, aDbName.Ptr(), aDbName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());
1.1008 + if(err == KErrNone)
1.1009 + {
1.1010 + err = StmtExec(stmtHandle);
1.1011 + }
1.1012 + }
1.1013 + (void)::FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.1014 + CleanupStack::PopAndDestroy();//TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled)
1.1015 + __SQLLEAVE_IF_ERROR(err);
1.1016 +
1.1017 + TAttachCleanup attachCleanup(*this, aDbName);
1.1018 + CleanupStack::PushL(TCleanupItem(&CSqlSrvDatabase::AttachCleanup, &attachCleanup));
1.1019 +
1.1020 + SetConfigL(aFileData.ConfigParams(), EFalse, aDbName);
1.1021 +
1.1022 + if(!readOnlyDbFile)
1.1023 + {
1.1024 + iAuthorizerDisabled = ETrue;
1.1025 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.1026 + ProcessSettingsL(aFileData, aDbName);
1.1027 + CleanupStack::PopAndDestroy();//TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled)
1.1028 + }
1.1029 +
1.1030 + CleanupStack::Pop();//TCleanupItem(&CSqlSrvDatabase::AttachCleanup, &attachCleanup)
1.1031 + }
1.1032 +
1.1033 +/**
1.1034 +Forms and executes "DETACH DATABASE" SQL statement.
1.1035 +If the database was scheduled for background compacting, the related database entry will be removed from
1.1036 +the vaccum db map.
1.1037 +
1.1038 +@param aDbName Attached database name. It must be unique (per database connection).
1.1039 +
1.1040 +@return KErrNone, Operation completed successfully;
1.1041 + KErrNoMemory, an out of memory condition has occurred.
1.1042 + Note that the function may also return some other database specific
1.1043 + errors categorised as ESqlDbError, and other system-wide error codes.
1.1044 +*/
1.1045 +TInt CSqlSrvDatabase::FinalizeAttachedDb(const TDesC& aDbName)
1.1046 + {
1.1047 + ReleaseCompactEntry(aDbName);
1.1048 + iAuthorizerDisabled = ETrue;
1.1049 + sqlite3_stmt* stmtHandle = NULL;
1.1050 + TRAPD(err, stmtHandle = StmtPrepare16L(iDbHandle, KDetachDb));
1.1051 + if(err == KErrNone)
1.1052 + {
1.1053 + err = ::Sql2OsErrCode(sqlite3_bind_text16(stmtHandle, 1, aDbName.Ptr(), aDbName.Length() * sizeof(TUint16), SQLITE_STATIC), sqlite3SymbianLastOsError());
1.1054 + if(err == KErrNone)
1.1055 + {
1.1056 + err = StmtExec(stmtHandle);
1.1057 + }
1.1058 + }
1.1059 + (void)::FinalizeStmtHandle(stmtHandle);//sqlite3_finalize() fails only if an invalid statement handle is passed.
1.1060 + iAuthorizerDisabled = EFalse;
1.1061 + return err;
1.1062 + }
1.1063 +
1.1064 +/**
1.1065 +Updates the security policies map (CSqlServer::iSecurityMap).
1.1066 +
1.1067 +Inserts a new item in the security map, or if such item already exists there - its reference counter will
1.1068 +be incremented.
1.1069 +The method guarantees that either the security map will be updated, or the method leaves and the security
1.1070 +policies map stays unchanged.
1.1071 +
1.1072 +@param aAttachedDb True if the currently processed database is an attached database, false if it is the main db.
1.1073 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.1074 + file session reference and some other database file related properties.
1.1075 + The secure database name format must be:
1.1076 + \<drive\>:\<[SID]database file name excluding the path\>.
1.1077 + "[SID]" refers to SID of the application which creates the database.
1.1078 +@param aMapKey Output parameter. UTF8 encoded, zero-terminated string. On function exit cannot be NULL.
1.1079 + It will be set to point to the security policies map key. No memory is allocated for the key.
1.1080 +@param aSecurityPolicy Output parameter. On function exit cannot be NULL. It will be set to point to the security policies.
1.1081 +
1.1082 +@leave KErrNoMemory, an out of memory condition has occurred;
1.1083 + Note that the function may also leave with some other database specific
1.1084 + errors categorised as ESqlDbError, and other system-wide error codes.
1.1085 +
1.1086 +@see RSqlSecurityMap
1.1087 +@see CSqlServer
1.1088 +@see TSqlSrvFileData
1.1089 +@see CSqlSecurityPolicy
1.1090 +*/
1.1091 +void CSqlSrvDatabase::UpdateSecurityMapL(TBool aAttachedDb, const TSqlSrvFileData& aFileData,
1.1092 + const TUint8*& aMapKey, const CSqlSecurityPolicy*& aSecurityPolicy)
1.1093 + {
1.1094 + //Check if a copy of the database security policies is already in the security map.
1.1095 + aMapKey = SecurityMapKeyL(aFileData.FileName());
1.1096 + TSqlSecurityPair* pair = ::SqlServer().SecurityMap().Entry(aMapKey);
1.1097 + if(pair)
1.1098 + {
1.1099 + //Yes, it is in the map. Increment the reference counter.
1.1100 + //(It will be decremented when detaching the database).
1.1101 + pair->iRefCounter.Increment();
1.1102 + aMapKey = pair->iKey;
1.1103 + aSecurityPolicy = pair->iData;
1.1104 + }
1.1105 + else
1.1106 + {
1.1107 + //No, it is not in the map. Read the security policies from the security policies tables and
1.1108 + //insert a new item in the map.
1.1109 + __ASSERT_DEBUG(aMapKey != NULL, __SQLPANIC(ESqlPanicInternalError));
1.1110 + aMapKey = ::CreateStrCopyLC(aMapKey);
1.1111 + CSqlSecurityPolicy* securityPolicy = aAttachedDb ? ::LoadAttachedDbSecurityPolicyLC(aFileData) :
1.1112 + ::LoadDbSecurityPolicyLC(iDbHandle);
1.1113 + __ASSERT_DEBUG(!::SqlServer().SecurityMap().Entry(aMapKey), __SQLPANIC2(ESqlPanicObjExists));
1.1114 + __SQLLEAVE_IF_ERROR(::SqlServer().SecurityMap().Insert(aMapKey, securityPolicy));
1.1115 + CleanupStack::Pop(2);//iSecurityMap owns aMapKey and securityPolicy objects
1.1116 + aSecurityPolicy = securityPolicy;
1.1117 + }
1.1118 + __ASSERT_DEBUG(aMapKey != NULL, __SQLPANIC(ESqlPanicInternalError));
1.1119 + __ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC(ESqlPanicInternalError));
1.1120 + }
1.1121 +
1.1122 +/**
1.1123 +Removes attached secure database entries from the maps.
1.1124 +
1.1125 +The function will search the security policies map (CSqlServer::iSecurityMap) and the attached databases
1.1126 +map (CSqlSrvDatabase::iAttachDbMap) for entries which correspond to the database with aDbName name,
1.1127 +and will remove the entries.
1.1128 +
1.1129 +The sequence of the performed by the function operations is:
1.1130 +1. Looks for a map item which key is aDbName in iAttachDbMap map.
1.1131 +2. If such pair exists, the data part of the pair is used as a key in iSecurityMap map.
1.1132 +3. Remove the iSecurityMap map item pointed by the data part of the found pair.
1.1133 +4. Remove the iAttachDbMap map item pointed by aDbName.
1.1134 +
1.1135 +@param aDbName Attached database name. It must be unique (per database connection).
1.1136 +
1.1137 +@leave KErrGeneral It is not possible to convert aDbName parameter to UTF8 encoded string.
1.1138 +
1.1139 +@see CSqlSrvDatabase::DoAttachDbL()
1.1140 +@see CSqlSrvDatabase::DoAttachSecureDbL()
1.1141 +@see RSqlSecurityMap
1.1142 +@see RSqlAttachDbMap
1.1143 +@see CSqlServer
1.1144 +@see CSqlSrvDatabase
1.1145 +*/
1.1146 +void CSqlSrvDatabase::RemoveFromMapsL(const TDesC& aDbName)
1.1147 + {
1.1148 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_REMOVEFROMMAPSL, "0x%X;CSqlSrvDatabase::RemoveFromMapsL;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbName)));
1.1149 + TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));
1.1150 + if(!::UTF16ToUTF8Z(aDbName, ptr))
1.1151 + {
1.1152 + __SQLLEAVE(KErrGeneral);
1.1153 + }
1.1154 + TSqlAttachDbPair* attachDbPair = iAttachDbMap.Entry(iFileNameBuf);
1.1155 + if(attachDbPair)
1.1156 + {//aDbName refers to attached secure database
1.1157 + ::SqlServer().SecurityMap().Remove(attachDbPair->iData);
1.1158 + iAttachDbMap.Remove(iFileNameBuf);
1.1159 + }
1.1160 + }
1.1161 +
1.1162 +/**
1.1163 +Inserts a new entry in the attached databases map (CSqlSrvDatabase::iAttachDbMap).
1.1164 +
1.1165 +The method guarantees that either a new [logical db name, secure db name] pair will be inserted in
1.1166 +iAttachDbMap or the method fails and the content of iAttachDbMap remains unchanged.
1.1167 +
1.1168 +@param aDbFileName Database file name, including the path.
1.1169 +@param aDbName Database name.
1.1170 +
1.1171 +@leave KErrNoMemory, an out of memory condition has occurred;
1.1172 + KErrGeneral, it is not possible to convert the function parameters to UTF8 encoded strings.
1.1173 +
1.1174 +@see RSqlAttachDbMap
1.1175 +@see CSqlSrvDatabase
1.1176 +*/
1.1177 +void CSqlSrvDatabase::InsertInAttachDbMapL(const TDesC& aDbFileName, const TDesC& aDbName)
1.1178 + {
1.1179 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_INSERTINATTACHDBMAPL, "0x%X;CSqlSrvDatabase::InsertInAttachDbMapL;aDbFileName=%S;aDbName=%S", (TUint)this, __SQLPRNSTR(aDbFileName), __SQLPRNSTR(aDbName)));
1.1180 + //Convert aDbName to UTF8, zero-terminated name
1.1181 + TPtr8 ptr(iFileNameBuf, sizeof(iFileNameBuf));
1.1182 + if(!::UTF16ToUTF8Z(aDbName, ptr))
1.1183 + {
1.1184 + __SQLLEAVE(KErrGeneral);
1.1185 + }
1.1186 + const TUint8* mapKey = ::CreateStrCopyLC(iFileNameBuf);
1.1187 + const TUint8* mapData = SecurityMapKeyL(aDbFileName);
1.1188 + mapData = ::CreateStrCopyLC(mapData);
1.1189 + __ASSERT_DEBUG(!iAttachDbMap.Entry(mapKey), __SQLPANIC(ESqlPanicObjExists));
1.1190 + __SQLLEAVE_IF_ERROR(iAttachDbMap.Insert(mapKey, mapData));
1.1191 + CleanupStack::Pop(2);//iAttachDbMap owns mapKey amd mapData.
1.1192 + }
1.1193 +
1.1194 +/**
1.1195 +Processes the database settings that are currently stored in the settings table.
1.1196 +Makes the journal file persistent.
1.1197 +Initializes the database compaction mode.
1.1198 +Based on the current settings the database may be configured to become 'up-to-date'.
1.1199 +This configuration may include reindexing the database if the collation dll has
1.1200 +changed and/or executing database configuration file operations.
1.1201 +
1.1202 +@param aFileData The file data object,
1.1203 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.1204 +
1.1205 +@leave The function may leave with system-wide error codes or SQL errors of ESqlDbError type
1.1206 +
1.1207 +@panic SqlDb 7 In _DEBUG mode if aFileData does not refer to a r/w database file.
1.1208 +*/
1.1209 +void CSqlSrvDatabase::ProcessSettingsL(const TSqlSrvFileData& aFileData, const TDesC& aDbName)
1.1210 + {
1.1211 + __ASSERT_DEBUG(!aFileData.IsReadOnly(), __SQLPANIC(ESqlPanicInternalError));
1.1212 +#if !defined(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
1.1213 + //Make the journal file persistent - done by SQLite automatically because the locking mode is EXCLUSIVE
1.1214 + //__SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KPersistentJournalPragma, KPersist, aDbName));
1.1215 + //Load the current settings
1.1216 + TFileName storedCollationDllName;
1.1217 + TInt storedDbConfigFileVer = -1;
1.1218 + TInt currVacuumMode = -1;
1.1219 + __SQLLEAVE_IF_ERROR(::DbVacuumMode(iDbHandle, aDbName, currVacuumMode));
1.1220 + //currVacuumMode == ESqliteVacuumOff ==> This is a database created not by the SQL server
1.1221 + TSqlCompactionMode compactionMode = currVacuumMode == ESqliteVacuumOff ? ESqlCompactionManual : ESqlCompactionNotSet;
1.1222 + TSqlDbSysSettings dbSettings(iDbHandle);
1.1223 + dbSettings.LoadSettingsL(aDbName, storedCollationDllName, storedDbConfigFileVer, compactionMode);
1.1224 + if(currVacuumMode == ESqliteVacuumOff && compactionMode != ESqlCompactionManual)
1.1225 + {//The database has been opened and the vacuum mode is "off". Then this is a database, not created by SQL
1.1226 + //server or it is a corrupted database. The compaction mode read from the system table does not match the
1.1227 + //database vacuum mode. Conclusion: this is a corrupted database.
1.1228 + __SQLLEAVE(KErrCorrupt);
1.1229 + }
1.1230 + if(aFileData.ContainHandles() && aFileData.IsCreated())
1.1231 + {
1.1232 + compactionMode = aFileData.ConfigParams().iCompactionMode;
1.1233 + if(compactionMode == ESqlCompactionNotSet)
1.1234 + {
1.1235 + compactionMode = KSqlDefaultCompactionMode;
1.1236 + }
1.1237 + //This is a just created private database. Store the compaction mode (the compaction mode may have been set using a config string).
1.1238 + StoreSettingsL(storedCollationDllName, storedDbConfigFileVer, compactionMode);
1.1239 + }
1.1240 + //Init the database compaction mode
1.1241 + InitCompactionL(compactionMode, aFileData.ConfigParams().iFreePageThresholdKb, aFileData.FileName(),
1.1242 + (TSqliteVacuumMode)currVacuumMode, aDbName);
1.1243 + //Based on the current settings, apply any necessary configuration updates to the database
1.1244 + ApplyConfigUpdatesL(storedCollationDllName, storedDbConfigFileVer, aFileData, aDbName);
1.1245 +#endif // !(__SQL_DISABLE_SYMBIAN_SETTINGS_TABLE__)
1.1246 + }
1.1247 +
1.1248 +/**
1.1249 +Applies any necessary configuration updates to the database, based on the current settings
1.1250 +in the settings table and how the database is being used (i.e. 'Opened' or 'Attached').
1.1251 +The applied configuration may include:
1.1252 +- Reindexing the main database and all attached databases, if the collation dll has been changed.
1.1253 +After the reindexation the new collation dll name will be stored in the settings table of the database.
1.1254 +- Executing all supported operations on the database that are specified in a database configuration
1.1255 +file, if such a file exists and has not already been processed.
1.1256 +The settings table will updated with the current version of the database configuration file if the file
1.1257 +is processed.
1.1258 +
1.1259 +@param aStoredCollationDllName The name of the collation dll that is stored in the settings table,
1.1260 +@param aStoredDbConfigFileVersion The database configuration file version that is stored in the settings table,
1.1261 +@param aFileData The file data object,
1.1262 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.1263 +
1.1264 +@leave The function may leave with system-wide error codes or SQL errors of ESqlDbError type
1.1265 +*/
1.1266 +void CSqlSrvDatabase::ApplyConfigUpdatesL(const TDesC& aStoredCollationDllName, const TInt& aStoredDbConfigFileVersion,
1.1267 + const TSqlSrvFileData& aFileData, const TDesC& aDbName)
1.1268 + {
1.1269 + TSqlDbSysSettings dbSettings(iDbHandle);
1.1270 + //Check whether reindexing is necessary
1.1271 + if(::SqlServer().CollationDllName().CompareF(aStoredCollationDllName) != 0)
1.1272 + {
1.1273 + SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLSRVDATABASE_APPLYCONFIGUPDATES2L, "0x%X;CSqlSrvDatabase::ApplyConfigUpdatesL;Reindex db;aStoredCollationDllName=%S;aDbName=%S", (TUint)this, __SQLPRNSTR(aStoredCollationDllName), __SQLPRNSTR(aDbName)));
1.1274 + dbSettings.ReindexDatabaseL(aDbName, ::SqlServer().CollationDllName());
1.1275 + }
1.1276 +
1.1277 + //Perform any necessary configuration file updates to the database.
1.1278 + //We do not want failures here to cause the database to fail
1.1279 + //to be opened and so any leave error is TRAPed and ignored
1.1280 + //(the error is logged in _DEBUG mode)
1.1281 + TRAPD(err, dbSettings.ConfigureDatabaseL(aStoredDbConfigFileVersion, aFileData, aDbName));
1.1282 + if(KErrNone != err)
1.1283 + {
1.1284 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_APPLYCONFIGUPDATESL, "0x%X;CSqlSrvDatabase::ApplyConfigUpdatesL;ConfigureDatabaseL() failed with error code %d", (TUint)this, err));
1.1285 + }
1.1286 + }
1.1287 +
1.1288 +/**
1.1289 +Sets the "cache size" and "page size" parameter values, if their values are valid.
1.1290 +This is done formatting and executing PRAGMA statements.
1.1291 +@param aConfigParams This object contains the cofiguration parameters
1.1292 +@param aSetPageSize If true, the page size will be set, otherwise not.
1.1293 + The aSetPageSize is set to true if:
1.1294 + 1) The operation is "create database"
1.1295 + 2) The operation is "open private database"
1.1296 +@param aLogicalDbName Parameter with default value of KNullDesC. If aLogicalDbName length is not 0, then the
1.1297 + "cache_size" pragma will be executed on the attached database with aLogicalDbName name.
1.1298 +*/
1.1299 +void CSqlSrvDatabase::SetConfigL(const TSqlSrvConfigParams& aConfigParams, TBool aSetPageSize, const TDesC& aLogicalDbName)
1.1300 + {
1.1301 + __ASSERT_DEBUG(aConfigParams.iPageSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iPageSize >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.1302 + __ASSERT_DEBUG(aConfigParams.iCacheSize == TSqlSrvConfigParams::KConfigPrmValueNotSet || aConfigParams.iCacheSize >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.1303 + if(aSetPageSize && aConfigParams.iPageSize != TSqlSrvConfigParams::KConfigPrmValueNotSet)
1.1304 + {
1.1305 + __SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KPageSizePragma, aConfigParams.iPageSize));
1.1306 + }
1.1307 +
1.1308 + const TDesC& logicalDbName = aLogicalDbName.Length() > 0 ? aLogicalDbName : KMainDb16;
1.1309 +
1.1310 + ::SetJournalSizeLimitL(iDbHandle, iAuthorizerDisabled, aConfigParams.iPageSize, logicalDbName);
1.1311 +
1.1312 + //Setting the cache size.
1.1313 + //Step 1: Check if aConfigParams.iCacheSize value is set. If it is set, then use it.
1.1314 + if(aConfigParams.iCacheSize != TSqlSrvConfigParams::KConfigPrmValueNotSet)
1.1315 + {
1.1316 + __SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KCacheSizePragma, aConfigParams.iCacheSize, logicalDbName));
1.1317 + }
1.1318 + else
1.1319 + {
1.1320 + //Step 2: aConfigParams.iCacheSize value is not set. Then check if aConfigParams.iSoftHeapLimitKb value is set.
1.1321 + if(aConfigParams.iSoftHeapLimitKb != TSqlSrvConfigParams::KConfigPrmValueNotSet)
1.1322 + {
1.1323 + __ASSERT_DEBUG(aConfigParams.iSoftHeapLimitKb >= TSqlSrvConfigParams::KMinSoftHeapLimitKb &&
1.1324 + aConfigParams.iSoftHeapLimitKb <= TSqlSrvConfigParams::KMaxSoftHeapLimitKb, __SQLPANIC(ESqlPanicInternalError));
1.1325 + //Step 3: aConfigParams.iSoftHeapLimitKb value is set. Then use it to calculate the cache size. But we need the page size first.
1.1326 + // aLogicalDbName is used instead of logicalDbName because PageSizeL() if called with non-zero length name,
1.1327 + // "thinks" it is the main database name. KMainDb16 will be interpreted as an attached database name.
1.1328 + TInt pageSize = PageSizeL(aLogicalDbName);
1.1329 + //Step 4: Calculate the cache size.
1.1330 + TInt cacheSize = ((TInt64)aConfigParams.iSoftHeapLimitKb * 1024) / pageSize;//"TInt64" cast is used because of a possible overflow
1.1331 + //Step 5: Set the cache size.
1.1332 + __SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KCacheSizePragma, cacheSize, logicalDbName));
1.1333 + }
1.1334 + }
1.1335 + }
1.1336 +
1.1337 +/**
1.1338 +Initializes the database compaction mode.
1.1339 +If the aCompactionMode parameter is ESqlCompactionBackground, the database with aDbFileName file name will be added
1.1340 +to the compactor for background compacting.
1.1341 +
1.1342 +@param aCompactionMode The database compaction mode. See TSqlCompactionMode enum for the supported database compaction modes.
1.1343 +@param aFreePageThresholdKb Free page threshold. The background compaction won't start if the free pages size in Kb is less than
1.1344 + the free page threshold.
1.1345 +@param aDbFileName Database file name including full path
1.1346 +@param aCurrentVacuumMode The current SQLite vacuum mode, one of TSqliteVacuumMode enum item values.
1.1347 + If the current database vacuum mode is ESqliteVacuumOff, which means
1.1348 + the database has been created not by the SQL server,
1.1349 + then the "off" vacuum mode is kept unchanged.
1.1350 +@param aDbName "main" or the attached database name
1.1351 +
1.1352 +@leave KErrNoMemory, an out of memory condition has occurred;
1.1353 + Note that the function may also leave with some other database specific
1.1354 + errors categorised as ESqlDbError, and other system-wide error codes.
1.1355 +
1.1356 +@see TSqlCompactionMode
1.1357 +@see CSqlCompactor
1.1358 +@see TSqliteVacuumMode
1.1359 +
1.1360 +@panic SqlDb 4 In _DEBUG mode if aCompactionMode parameter value is invalid.
1.1361 +*/
1.1362 +void CSqlSrvDatabase::InitCompactionL(TSqlCompactionMode aCompactionMode, TInt aFreePageThresholdKb,
1.1363 + const TDesC& aDbFileName, TSqliteVacuumMode aCurrentVacuumMode, const TDesC& aDbName)
1.1364 + {
1.1365 + __ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicBadArgument));
1.1366 + __ASSERT_DEBUG(aCurrentVacuumMode == ESqliteVacuumOff || aCurrentVacuumMode == ESqliteVacuumAuto ||
1.1367 + aCurrentVacuumMode == ESqliteVacuumIncremental, __SQLPANIC(ESqlPanicBadArgument));
1.1368 + __ASSERT_DEBUG(aFreePageThresholdKb >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.1369 + TSqliteVacuumMode newSqliteVacuumMode = aCompactionMode == ESqlCompactionAuto ? ESqliteVacuumAuto : ESqliteVacuumIncremental;
1.1370 + if(aCurrentVacuumMode == ESqliteVacuumOff)
1.1371 + {
1.1372 + newSqliteVacuumMode = ESqliteVacuumOff;
1.1373 + }
1.1374 + if(aCurrentVacuumMode != newSqliteVacuumMode)
1.1375 + {
1.1376 + __SQLLEAVE_IF_ERROR(::ExecPragma(iDbHandle, iAuthorizerDisabled, KAutoVacuumPragma, newSqliteVacuumMode, aDbName));
1.1377 + }
1.1378 + if(aCompactionMode == ESqlCompactionBackground)
1.1379 + {
1.1380 + NewCompactEntryL(aFreePageThresholdKb, aDbFileName, aDbName);
1.1381 + }
1.1382 + }
1.1383 +
1.1384 +/**
1.1385 +Adds the aDbFileName database to the compactor object for background compacting.
1.1386 +
1.1387 +@param aFreePageThresholdKb Free page threshold in Kb. The background compaction won't start if the total size of the free pages
1.1388 + is less than the free page threshold.
1.1389 +@param aDbFileName Database file name including full path
1.1390 +@param aDbName "main" or the attached database name
1.1391 +
1.1392 +@leave KErrNoMemory, an out of memory condition has occurred;
1.1393 + Note that the function may also leave with some other database specific
1.1394 + errors categorised as ESqlDbError, and other system-wide error codes.
1.1395 +
1.1396 +@see CSqlCompactor
1.1397 +@see RSqlCompactDbMap
1.1398 +*/
1.1399 +void CSqlSrvDatabase::NewCompactEntryL(TInt aFreePageThresholdKb, const TDesC& aDbFileName, const TDesC& aDbName)
1.1400 + {
1.1401 + SQL_TRACE_INTERNALS(OstTraceExt4(TRACE_INTERNALS, CSQLSRVDATABASE_NEWCOMPACTENTRYL_ENTRY, "Entry;0x%X;CSqlSrvDatabase::NewCompactEntryL;aFreePageThresholdKb=%d;aDbFileName=%S;aDbName=%S", (TUint)this, aFreePageThresholdKb, __SQLPRNSTR(aDbFileName), __SQLPRNSTR(aDbName)));
1.1402 + TSqlCompactSettings settings;
1.1403 + settings.iFreePageThresholdKb = aFreePageThresholdKb;
1.1404 + ::SqlServer().Compactor().AddEntryL(aDbFileName, settings);
1.1405 + TInt err = KErrNoMemory;
1.1406 + HBufC* key = aDbName.Alloc();
1.1407 + HBufC* data = aDbFileName.Alloc();
1.1408 + if(key && data)
1.1409 + {
1.1410 + __ASSERT_DEBUG(!iCompactDbMap.Entry(key), __SQLPANIC(ESqlPanicObjExists));
1.1411 + err = iCompactDbMap.Insert(key, data);//returns the index of the new entry
1.1412 + }
1.1413 + if(err < 0) //If either "key" or "data" or both is NULL, then "err" is KErrNoMemory and the next "if" will be executed.
1.1414 + {
1.1415 + delete data;
1.1416 + delete key;
1.1417 + ::SqlServer().Compactor().ReleaseEntry(aDbFileName);
1.1418 + }
1.1419 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLSRVDATABASE_NEWCOMPACTENTRYL_EXIT, "Exit;0x%X;CSqlSrvDatabase::NewCompactEntryL;err=%d", (TUint)this, err));
1.1420 + __SQLLEAVE_IF_ERROR(err);
1.1421 + }
1.1422 +
1.1423 +/**
1.1424 +Removes database (identified by its logical name) from the compactor.
1.1425 +
1.1426 +@param aDbName "main" or the attached database name
1.1427 +
1.1428 +@see CSqlCompactor
1.1429 +@see RSqlCompactDbMap
1.1430 +*/
1.1431 +void CSqlSrvDatabase::ReleaseCompactEntry(const TDesC& aDbName)
1.1432 + {
1.1433 + TSqlCompactDbMapIterator compactDbIt(iCompactDbMap);
1.1434 + TSqlCompactDbPair compactDbPair;
1.1435 + while(compactDbIt.Next(compactDbPair))
1.1436 + {
1.1437 + if(::CompareNoCase(*compactDbPair.iKey, aDbName) == 0)
1.1438 + {
1.1439 + ::SqlServer().Compactor().ReleaseEntry(*compactDbPair.iData);
1.1440 + iCompactDbMap.Remove(compactDbPair.iKey);
1.1441 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLSRVDATABASE_RELEASECOMPACTENTRY, "0x%X;CSqlSrvDatabase::ReleaseCompactEntry", (TUint)this));
1.1442 + break;
1.1443 + }
1.1444 + }
1.1445 + }
1.1446 +
1.1447 +/**
1.1448 +Cleanup function.
1.1449 +Used during the construction phase of the CSqlSrvDatabase instance when a new database is created.
1.1450 +If the database creation succeeds, the "init compaction" operation succeeds but some other init operation fail,
1.1451 +the just created database file has to be deleted. But before that the database has to be removed from the compactor,
1.1452 +because the compactor creates independent database connection that has to be closed before the database deletion.
1.1453 +
1.1454 +The database will be removed from the compactor as a result of the call.
1.1455 +
1.1456 +@param aCleanup A pointer to the CSqlSrvDatabase object
1.1457 +*/
1.1458 +void CSqlSrvDatabase::CompactCleanup(void* aCleanup)
1.1459 + {
1.1460 + CSqlSrvDatabase* self = reinterpret_cast <CSqlSrvDatabase*> (aCleanup);
1.1461 + __ASSERT_DEBUG(self != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.1462 + self->ReleaseCompactEntry(KMainDb16);
1.1463 + }
1.1464 +
1.1465 +/**
1.1466 +Retrieves the database page size.
1.1467 +If the request is for the main database page size and if the size is not retrieved yet, then the page size value will be
1.1468 +cached in iPageSize data member.
1.1469 +
1.1470 +@param aDbName Attached database name or KNullDesC for the main database
1.1471 +
1.1472 +@leave KErrNoMemory, an out of memory condition has occurred;
1.1473 + Note that the function may also leave with some other database specific
1.1474 + errors categorised as ESqlDbError, and other system-wide error codes.
1.1475 +
1.1476 +@return The database page size
1.1477 +*/
1.1478 +TInt CSqlSrvDatabase::PageSizeL(const TDesC& aDbName)
1.1479 + {
1.1480 + if(iPageSize > 0 && aDbName == KNullDesC)
1.1481 + {
1.1482 + return iPageSize;
1.1483 + }
1.1484 + iAuthorizerDisabled = ETrue;
1.1485 + CleanupStack::PushL(TCleanupItem(&EnableAuthorizer, &iAuthorizerDisabled));
1.1486 + TInt pageSize = 0;
1.1487 + __SQLLEAVE_IF_ERROR(::DbPageSize(iDbHandle, aDbName, pageSize));
1.1488 + CleanupStack::PopAndDestroy();
1.1489 + __ASSERT_DEBUG(pageSize > 0, __SQLPANIC(ESqlPanicInternalError));
1.1490 + if(aDbName == KNullDesC)
1.1491 + {
1.1492 + iPageSize = pageSize;
1.1493 + }
1.1494 + return pageSize;
1.1495 + }
1.1496 +
1.1497 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.1498 +///////////////////////////// ConstructL() methods ///////////////////////////////////////
1.1499 +//////////////////////////////////////////////////////////////////////////////////////////////////////
1.1500 +
1.1501 +/**
1.1502 +Second phase construction method. Creates a new secure database file.
1.1503 +If the function fails, the database file will be closed and deleted.
1.1504 +
1.1505 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.1506 + file session reference and some other database file related properties.
1.1507 + If this is a secure database, then the format of the name must be:
1.1508 + \<drive\>:\<[SID]database file name excluding the path\>.
1.1509 + If this is a non-secure database, then the file name has to be the full database file name.
1.1510 + "[SID]" refers to SID of the application which creates the database.
1.1511 +@param aSecurityPolicy Database security policy
1.1512 +
1.1513 +@panic SqlDb 4 In _DEBUG mode if aSecurityPolicy is NULL.
1.1514 +*/
1.1515 +void CSqlSrvDatabase::ConstructCreateSecureL(const TSqlSrvFileData& aFileData, CSqlSecurityPolicy* aSecurityPolicy)
1.1516 + {
1.1517 + __ASSERT_DEBUG(aSecurityPolicy != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.1518 + //Insert a new item in the security policies map.
1.1519 + CleanupStack::PushL(aSecurityPolicy);
1.1520 + const TUint8* mapKey = SecurityMapKeyL(aFileData.FileName());
1.1521 + mapKey = ::CreateStrCopyLC(mapKey);
1.1522 + __ASSERT_DEBUG(!::SqlServer().SecurityMap().Entry(mapKey), __SQLPANIC(ESqlPanicObjExists));
1.1523 + __SQLLEAVE_IF_ERROR(::SqlServer().SecurityMap().Insert(mapKey, aSecurityPolicy));
1.1524 + CleanupStack::Pop(2);//iSecurityMap owns mapKey and aSecurityPolicy.
1.1525 + iSecureDbName = mapKey;
1.1526 + iSecurityPolicy = aSecurityPolicy;
1.1527 + //
1.1528 + DoCommonConstructCreateL(aFileData, ETrue);
1.1529 + }
1.1530 +
1.1531 +/**
1.1532 +Second phase construction method. Creates a new non-secure database file.
1.1533 +If the function fails, the database file will be closed and deleted.
1.1534 +
1.1535 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.1536 + file session reference and some other database file related properties.
1.1537 + If this is a secure database, then the format of the name must be:
1.1538 + \<drive\>:\<[SID]database file name excluding the path\>.
1.1539 + If this is a non-secure database, then the file name has to be the full database file name.
1.1540 + "[SID]" refers to SID of the application which creates the database.
1.1541 +*/
1.1542 +void CSqlSrvDatabase::ConstructCreateL(const TSqlSrvFileData& aFileData)
1.1543 + {
1.1544 + DoCommonConstructCreateL(aFileData, EFalse);
1.1545 + }
1.1546 +
1.1547 +//Called by the two "Contruct&Create" methods: ConstructCreateL() and ConstructCreateSecureL().
1.1548 +//The aSecureDb parameter tells which method is the caller.
1.1549 +//The function performs common construction and initialization:
1.1550 +// - creates the database file
1.1551 +// - makes the journal file persistent
1.1552 +// - initializes the database compaction mode
1.1553 +// - stores the initial settings in the settings table, including the current collation dll name
1.1554 +// - stores the security settings and installs the authorizer, if aSecureDb is true
1.1555 +// - installs the user-defined functions
1.1556 +// - installs collations
1.1557 +//If the method fails and the error is not KErrAlreadyExists, the database file will be closed and deleted.
1.1558 +void CSqlSrvDatabase::DoCommonConstructCreateL(const TSqlSrvFileData& aFileData, TBool aSecureDb)
1.1559 + {
1.1560 + __ASSERT_DEBUG(!iDbHandle, __SQLPANIC(ESqlPanicInternalError));
1.1561 + __ASSERT_DEBUG(aSecureDb ? iSecurityPolicy != NULL : ETrue, __SQLPANIC(ESqlPanicInternalError));
1.1562 + CreateNewDbFileL(aFileData);
1.1563 + TDbFileCleanup dbFileCleanup(aFileData, iDbHandle);
1.1564 + CleanupStack::PushL(TCleanupItem(&DbFileCleanup, &dbFileCleanup));
1.1565 + //Make the journal file persistent - done by SQLite automatically because the locking mode is EXCLUSIVE
1.1566 + //::ExecPragma(iDbHandle, iAuthorizerDisabled, KPersistentJournalPragma, KPersist);
1.1567 + //Init database compaction mode
1.1568 + TSqlCompactionMode compactionMode = aFileData.ConfigParams().iCompactionMode;
1.1569 + if(compactionMode == ESqlCompactionNotSet)
1.1570 + {
1.1571 + compactionMode = KSqlDefaultCompactionMode;
1.1572 + }
1.1573 + TInt currVacuumMode = -1;
1.1574 + __SQLLEAVE_IF_ERROR(::DbVacuumMode(iDbHandle, KNullDesC, currVacuumMode));
1.1575 + //currVacuumMode == ESqliteVacuumOff ==> This is a database created not by the SQL server
1.1576 + InitCompactionL(compactionMode, aFileData.ConfigParams().iFreePageThresholdKb, aFileData.FileName(), (TSqliteVacuumMode)currVacuumMode);
1.1577 + CleanupStack::PushL(TCleanupItem(&CSqlSrvDatabase::CompactCleanup, this));
1.1578 + //Store the initial settings in the settings table (including the current collation dll name)
1.1579 + StoreSettingsL(::SqlServer().CollationDllName(), KSqlNullDbConfigFileVersion, compactionMode);
1.1580 + if(aSecureDb)
1.1581 + {
1.1582 + //Store the security policies in the security policies tables.
1.1583 + TSqlDbSysSettings dbSysSettings(iDbHandle);
1.1584 + dbSysSettings.StoreSecurityPolicyL(*iSecurityPolicy);
1.1585 + }
1.1586 + InstallAuthorizerL();
1.1587 + InstallUDFsL();
1.1588 + InstallCollationsL();
1.1589 + CleanupStack::Pop(2);//CompactCleanup, DbFileCleanup
1.1590 + SQLPROFILER_DB_CREATE((TUint)iDbHandle, aFileData.FileName());
1.1591 + }
1.1592 +
1.1593 +/**
1.1594 +Second phase construction method. Opens an existing secure database file.
1.1595 +
1.1596 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.1597 + file session reference and some other database file related properties.
1.1598 + If this is a secure database, then the format of the name must be:
1.1599 + \<drive\>:\<[SID]database file name excluding the path\>.
1.1600 + If this is a non-secure database, then the file name has to be the full database file name.
1.1601 + "[SID]" refers to SID of the application which creates the database.
1.1602 +*/
1.1603 +void CSqlSrvDatabase::ConstructOpenSecureL(const TSqlSrvFileData& aFileData)
1.1604 + {
1.1605 + DoCommonConstructOpenL(aFileData, ETrue);
1.1606 + }
1.1607 +
1.1608 +/**
1.1609 +Second phase construction method. Opens an existing non-secure database file.
1.1610 +
1.1611 +@param aFileData A reference to a TSqlSrvFileData instance, which keeps the database name, a
1.1612 + file session reference and some other database file related properties.
1.1613 + If this is a secure database, then the format of the name must be:
1.1614 + \<drive\>:\<[SID]database file name excluding the path\>.
1.1615 + If this is a non-secure database, then the file name has to be the full database file name.
1.1616 + "[SID]" refers to SID of the application which creates the database.
1.1617 + If this is application's private database, then the format of aFileData is as it is described
1.1618 + in TSqlSrvFileData::SetFromHandleL() comments.
1.1619 +@see TSqlSrvFileData::SetFromHandleL()
1.1620 +*/
1.1621 +void CSqlSrvDatabase::ConstructOpenL(const TSqlSrvFileData& aFileData)
1.1622 + {
1.1623 + DoCommonConstructOpenL(aFileData, EFalse);
1.1624 + }
1.1625 +
1.1626 +//Opens a database and does all necessary initializations
1.1627 +//Called by the two "Contruct&Open" methods: ConstructOpenL() and ConstructOpenSecureL().
1.1628 +//The aSecureDb parameter tells which method is the caller.
1.1629 +//The function performs common construction and initialization:
1.1630 +// - opens the database file
1.1631 +// - installs the user-defined functions
1.1632 +// - installs collations
1.1633 +// - installs the authoriser callback
1.1634 +void CSqlSrvDatabase::DoCommonConstructOpenL(const TSqlSrvFileData& aFileData, TBool aSecureDb)
1.1635 + {
1.1636 + OpenExistingDbFileL(aFileData);//iDbHandle is valid after a successful call
1.1637 + //The user-defined collations must be installed before the possible database reindexing!!!
1.1638 + InstallCollationsL();
1.1639 + if(!aFileData.IsReadOnly())
1.1640 + {//No need to disable the authorizer since it is not installed yet.
1.1641 + //Make sure that the user-defined collation have been installed before the reindexing operation.
1.1642 + ProcessSettingsL(aFileData, KMainDb16);
1.1643 + }
1.1644 + if(aSecureDb)
1.1645 + {
1.1646 + const TUint8* mapKey = NULL;
1.1647 + //Load database security policy, update the security policy map
1.1648 + UpdateSecurityMapL(EFalse, aFileData, mapKey, iSecurityPolicy);
1.1649 + iSecureDbName = mapKey;//used in CSqlSrvDatabase destructor.
1.1650 + mapKey = NULL;//it is not used
1.1651 + //Check that the caller has at least one of {Schema, Read, Write} policies.
1.1652 + BasicSecurityPolicyCheckL(*iSecurityPolicy);
1.1653 + }
1.1654 + //Install user-defined functions.
1.1655 + InstallUDFsL();
1.1656 +
1.1657 + //Install the authorizer.
1.1658 + InstallAuthorizerL();
1.1659 +
1.1660 + SQLPROFILER_DB_OPEN((TUint)iDbHandle, aFileData.FileName());
1.1661 + }
1.1662 +
1.1663 +/*
1.1664 +Implementation of the like() SQL function. This function implements
1.1665 +the user defined LIKE operator. The first argument to the function is the
1.1666 +pattern and the second argument is the string. So, the SQL statements:
1.1667 +A LIKE B
1.1668 +is implemented as like(B, A).
1.1669 +
1.1670 +@param aContext Function call context;
1.1671 +@param aArgc Number of LIKE arguments: 2 for the standard LIKE operator, 3 for the LIKE operator with an ESCAPE clause;
1.1672 +@param aArgv LIKE arguments;
1.1673 +
1.1674 +@internalComponent
1.1675 +*/
1.1676 +void CSqlSrvDatabase::LikeSqlFunc(sqlite3_context* aContext, int aArgc, sqlite3_value** aArgv)
1.1677 + {
1.1678 + TUint escapeChar = 0;
1.1679 + if(aArgc == 3)
1.1680 + {
1.1681 + //The escape character string must consist of a single UTF16 character.
1.1682 + //Otherwise, return an error.
1.1683 + const TUint16* esc = static_cast <const TUint16*> (sqlite3_value_text16(aArgv[2]));
1.1684 + if(!esc)
1.1685 + {
1.1686 + sqlite3_result_error(aContext, KErrMsg1, -1);
1.1687 + return;
1.1688 + }
1.1689 + if(User::StringLength(esc) != 1)
1.1690 + {
1.1691 + sqlite3_result_error(aContext, KErrMsg2, -1);
1.1692 + return;
1.1693 + }
1.1694 + escapeChar = *esc;
1.1695 + }
1.1696 + const TUint16* pattern = static_cast <const TUint16*> (sqlite3_value_text16(aArgv[0]));
1.1697 + const TUint16* candidate = static_cast <const TUint16*> (sqlite3_value_text16(aArgv[1]));
1.1698 + if(pattern && candidate)
1.1699 + {
1.1700 + TInt wildChar = '_';
1.1701 + TInt wildSeqChar = '%';
1.1702 + TPtrC16 patternStr(pattern, (TUint)sqlite3_value_bytes16(aArgv[0]) / sizeof(TUint16));
1.1703 + TPtrC16 candidateStr(candidate, (TUint)sqlite3_value_bytes16(aArgv[1]) / sizeof(TUint16));
1.1704 + TInt res = candidateStr.MatchC(patternStr, wildChar, wildSeqChar, escapeChar, 0/*collation level*/);
1.1705 + sqlite3_result_int(aContext, res >= 0);
1.1706 + //RDebug::Print(_L("--res=%d, pattern=%S, candidate=%S\r\n"), res, &patternStr, &candidateStr);
1.1707 + }
1.1708 + }
1.1709 +