1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvDbSysSettings.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1023 @@
1.4 +// Copyright (c) 2006-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 +// Store/Load database system settings (database settings, security policies)
1.18 +//
1.19 +//
1.20 +
1.21 +#include <f32file.h>
1.22 +#include <f32file64.h>
1.23 +#include <utf.h> //CnvUtfConverter
1.24 +#include <sqldb.h> //RSqlSecurityPolicy enum items
1.25 +#include "SqlSrvDbSysSettings.h"
1.26 +#include "SqlUtil.h" //Sql2OsErrCode()
1.27 +#include "sqlite3.h" //SQLITE API
1.28 +#include "SqliteSymbian.h" //sqlite3SymbianLastOsError()
1.29 +#include "SqlSecurityImpl.h" //CSqlSecurityPolicy
1.30 +#include "SqlSrvStatementUtil.h"//Global SQL execution functions
1.31 +#include "SqlSrvCollation.h" //TSqlCollate
1.32 +#include "SqlSrvStrings.h" //System table names
1.33 +#include "SqlSrvUtil.h" //Global functions
1.34 +#include "SqlSrvFileData.h" //TSqlSrvFileData
1.35 +#include "OstTraceDefinitions.h"
1.36 +#ifdef OST_TRACE_COMPILER_IN_USE
1.37 +#include "SqlSrvDbSysSettingsTraces.h"
1.38 +#endif
1.39 +#include "SqlTraceDef.h"
1.40 +
1.41 +extern TBool IsStatementSupported(const TDesC& aStatementIn, const TDesC& aDbName, TDes& aStatementOut);
1.42 +
1.43 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.44 +///////////////////////////// Local const data ///////////////////////////////////////////////////////
1.45 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.46 +
1.47 +enum
1.48 + {
1.49 + ESqlSystemVersion1 = 1, //Base version
1.50 + ESqlSystemVersion2 = 2, //New field into "Settings" table - "Reserved" (unused, set to 0)
1.51 + ESqlSystemVersion3 = 3, //New field into "Settings" table - "CollationDllName"
1.52 + //Existing field in "Settings" table - "Reserved" - now used to store processed version of db config file
1.53 + ESqlSystemVersion4 = 4 //"CompactionMode" field added
1.54 + };
1.55 +
1.56 +//Current version of the system settings - reflects changes in the system tables.
1.57 +const TInt KSqlSystemVersion = ESqlSystemVersion4;
1.58 +
1.59 +//The database names in all statements are quoted to avoid the "sql injection" threat.
1.60 +//(At the moment there is no way to pass an invalid database name for these statements, because the database has to be attached
1.61 +// first and a parameter binding is used there. So, the quoting is just for safety and against changes in the future)
1.62 +
1.63 +_LIT(KCreateSettingsSql,"CREATE TABLE \"%S\".symbian_settings(Id INTEGER,Reserved INTEGER,CollationDllName TEXT, CompactionMode INTEGER);\x0");
1.64 +_LIT(KDropSettingsSql, "DROP TABLE IF EXISTS \"%S\".symbian_settings;\x0");
1.65 +_LIT(KInsertSettingsSql, "INSERT INTO \"%S\".symbian_settings VALUES(%d, %d,'%S',%d);\x0");
1.66 +_LIT(KUpdateCollationSettingsSql, "UPDATE \"%S\".symbian_settings SET CollationDllName='%S';\x0");
1.67 +_LIT(KUpdateFileVersionSettingsSql, "UPDATE \"%S\".symbian_settings SET Reserved=%d;\x0");
1.68 +_LIT(KGetSettingsSql, "SELECT * FROM \"%S\".symbian_settings;\x0");
1.69 +_LIT(KGetIndexSql, "SELECT name FROM \"%S\".sqlite_master WHERE type = 'index' AND sql LIKE '%%%S%%'\x0");
1.70 +_LIT(KSettingsTableCheckSql, "SELECT name from \"%S\".sqlite_master WHERE type = 'table' AND name = 'symbian_settings';\x0");
1.71 +_LIT(KReindexSql, "REINDEX \"%S\";\x0");
1.72 +
1.73 +_LIT8(KCreateSecuritySql,"CREATE TABLE symbian_security(Id INTEGER PRIMARY KEY AUTOINCREMENT,ObjectType INTEGER,ObjectName TEXT,PolicyType INTEGER,PolicyData BLOB);\x0");
1.74 +_LIT8(KInsertSecuritySql, "INSERT INTO symbian_security(ObjectType,ObjectName,PolicyType,PolicyData) VALUES(:V1,:V2,:V3,:V4);\x0");
1.75 +_LIT8(KGetSecuritySql, "SELECT * FROM symbian_security;\x0");
1.76 +
1.77 +_LIT8(KBeginTransactionSql, "BEGIN;\x0");
1.78 +_LIT8(KCommitTransactionSql, "COMMIT;\x0");
1.79 +_LIT8(KRollbackTransactionSql, "ROLLBACK;\x0");
1.80 +
1.81 +
1.82 +
1.83 +//KInsertSecuritySql statement - parameter indices
1.84 +const TInt KObjTypePrmIdx = 1;
1.85 +const TInt KObjNamePrmIdx = 2;
1.86 +const TInt KObjPolicyTypePrmIdx = 3;
1.87 +const TInt KObjPolicyDataPrmIdx = 4;
1.88 +
1.89 +//Default security policy - object type code and policy type code
1.90 +const TInt KDefaultObjType = -2;
1.91 +const TInt KDefaultPolicyType = -1;
1.92 +
1.93 +//Database security policy - object type code
1.94 +const TInt KDbObjType = -1;
1.95 +
1.96 +//KGetSettingsSql sql statement - column indices
1.97 +const TInt KSysVersionColIdx = 0;
1.98 +const TInt KConfigFileVersionColIdx = 1;
1.99 +const TInt KCollationDllNameColIdx = 2;
1.100 +const TInt KCompactionModeColIdx = 3;
1.101 +
1.102 +//KGetSecuritySql sql statement - column indices
1.103 +const TInt KObjTypeColIdx = 1;
1.104 +const TInt KObjNameColIdx = 2;
1.105 +const TInt KObjPolicyTypeColIdx = 3;
1.106 +const TInt KObjPolicyDataColIdx = 4;
1.107 +
1.108 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.109 +///////////////////////////// Local functions ////////////////////////////////////////////////////////
1.110 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.111 +
1.112 +//Finalzes the statement handle (aHandle argument). Used in stack cleanup operations.
1.113 +//Panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL.
1.114 +static void FinalizeStatementHandle(void* aHandle)
1.115 + {
1.116 + __ASSERT_DEBUG(aHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.117 + sqlite3_stmt* stmtHandle = static_cast <sqlite3_stmt*> (aHandle);
1.118 + (void)sqlite3_finalize(stmtHandle);
1.119 + }
1.120 +
1.121 +//Transaction rollback. Used in stack cleanup operations.
1.122 +//Panic SqlDb 4 In _DEBUG mode if aDbHandle argument is NULL.
1.123 +static void RollbackTransaction(void* aDbHandle)
1.124 + {
1.125 + __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.126 + (void)::DbExecStmt8(reinterpret_cast <sqlite3*> (aDbHandle), KRollbackTransactionSql);
1.127 + }
1.128 +
1.129 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.130 +///////////////////////////// TSqlDbSysSettings ////////////////////////////////////////////////////////
1.131 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.132 +
1.133 +/**
1.134 +Initializes TSqlDbSysSettings data members with default values.
1.135 +
1.136 +@param aDbHandle Database handle. TSqlDbSysSettings does not own aDbHandle argument.
1.137 +
1.138 +@panic SqlDb 4 In _DEBUG mode if aDbHandle argument is NULL.
1.139 +*/
1.140 +TSqlDbSysSettings::TSqlDbSysSettings(sqlite3* aDbHandle) :
1.141 + iDbHandle(aDbHandle)
1.142 + {
1.143 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.144 + }
1.145 +
1.146 +/**
1.147 +Creates the database security policy table and stores the security policy in the table.
1.148 +
1.149 +@param aSecurityPolicy Database security policies container, which data needs to be persisted.
1.150 +
1.151 +@leave KErrNoMemory, an out of memory condition has occurred.
1.152 + Note that the function may also leave with some other database specific
1.153 + errors categorised as ESqlDbError, and other system-wide error codes.
1.154 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.155 +*/
1.156 +void TSqlDbSysSettings::StoreSecurityPolicyL(const CSqlSecurityPolicy& aSecurityPolicyCon)
1.157 + {
1.158 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.159 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql()));
1.160 + CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle));
1.161 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCreateSecuritySql()));
1.162 + StoreSecurityPoliciesL(aSecurityPolicyCon);
1.163 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql()));
1.164 + CleanupStack::Pop();//TCleanupItem(&RollbackTransaction, iDbHandle)
1.165 + }
1.166 +
1.167 +/**
1.168 +Stores the database system settings in the settings table. The settings table is recreated.
1.169 +
1.170 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.171 +@param aCollationDllName Collation dll name. It uniquely identifies the current collation method in use.
1.172 + If the default collation method changes later then the database will be reindexed
1.173 + and the new collation dll name will replace the existing one in the settings table.
1.174 +@param aDbConfigFileVersion Current config file version or KSqlNullDbConfigFileVersion
1.175 +@param aCompactionMode Database compaction mode, one of TSqlCompactionMode enum item values (except ESqlCompactionNotSet)
1.176 +
1.177 +@see TSqlCompactionMode
1.178 +
1.179 +@leave KErrNoMemory, an out of memory condition has occurred.
1.180 + Note that the function may also leave with some other database specific
1.181 + errors categorised as ESqlDbError, and other system-wide error codes.
1.182 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.183 +@panic SqlDb 4 In _DEBUG mode if aCompactionMode parameter value is invalid.
1.184 +*/
1.185 +void TSqlDbSysSettings::StoreSettingsL(const TDesC& aDbName, const TDesC& aCollationDllName, TInt aDbConfigFileVersion, TSqlCompactionMode aCompactionMode)
1.186 + {
1.187 + __ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicBadArgument));
1.188 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.189 + HBufC* buf = HBufC::NewLC(Max((TInt)sizeof(KDropSettingsSql),
1.190 + Max((TInt)sizeof(KCreateSettingsSql), (TInt)sizeof(KInsertSettingsSql))) +
1.191 + aDbName.Length() + aCollationDllName.Length() + 10);
1.192 + TPtr sql = buf->Des();
1.193 + //Begin transaction
1.194 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql()));
1.195 + CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle));
1.196 + //Recreate the "settings" table and store the default collation there (the DLL name)
1.197 + sql.Format(KDropSettingsSql(), &aDbName);
1.198 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql));
1.199 + sql.Format(KCreateSettingsSql, &aDbName);
1.200 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql));
1.201 + sql.Format(KInsertSettingsSql(), &aDbName, KSqlSystemVersion, aDbConfigFileVersion, &aCollationDllName, aCompactionMode);
1.202 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql));
1.203 + //Commit transaction
1.204 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql()));
1.205 + CleanupStack::Pop();//TCleanupItem(&RollbackTransaction, iDbHandle)
1.206 + CleanupStack::PopAndDestroy(buf);
1.207 + }
1.208 +
1.209 +/**
1.210 +Read security policies from security policy table.
1.211 +
1.212 +The method does not guarantee that either the security policies will be read from the
1.213 +security table and stored in aSecurityPolicy parameter or aSecurityPolicy argument
1.214 +stays unchanged in a case of failure.
1.215 +
1.216 +@param aSecurityPolicyCon Security policies container which needs to be initializeed with
1.217 + the database security policies.
1.218 +
1.219 +@leave KErrNoMemory, an out of memory condition has occurred;
1.220 + KErrGeneral, missing or invalid data in the system tables;
1.221 + Note that the function may also leave with some other database specific
1.222 + errors categorised as ESqlDbError, and other system-wide error codes.
1.223 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.224 +*/
1.225 +void TSqlDbSysSettings::LoadSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon)
1.226 + {
1.227 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.228 + //Even if the version of the system settings is bigger than the current one (KSqlSystemVersion constant),
1.229 + //I think that all future modifications of the system tables shall not affect the already existing
1.230 + //fields. So it is correct to think that all information available in version 1 should be available
1.231 + //(and accessible) in all future versions of the system settings.
1.232 + //Note: no attempt shall be made here to modify the system tables structure! There may be more than one
1.233 + // connection to the database being processed!
1.234 + //
1.235 + //Prepare statement handle
1.236 + sqlite3_stmt* stmtHandle = ::StmtPrepare8L(iDbHandle, KGetSecuritySql());
1.237 + CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle));
1.238 + //Read the security policies
1.239 + TBool defaultPolicySet = EFalse;
1.240 + TInt dbPolicySetFlag = 0;
1.241 + TInt err;
1.242 + while((err = ::StmtNext(stmtHandle)) == KSqlAtRow)
1.243 + {
1.244 + TInt objType = KDefaultObjType - 1;
1.245 + TPtrC objName(KNullDesC);
1.246 + TInt policyType = RSqlSecurityPolicy::ESchemaPolicy - 1;
1.247 + TSecurityPolicy policy = ReadCurrSecurityPolicyL(stmtHandle, objType, objName, policyType);
1.248 + switch(objType)
1.249 + {
1.250 + case KDefaultObjType:
1.251 + if(defaultPolicySet)
1.252 + {
1.253 + __SQLLEAVE(KErrGeneral);//two "default policy" records in the table
1.254 + }
1.255 + StoreDefaultSecurityPolicy(aSecurityPolicyCon, policy, dbPolicySetFlag);
1.256 + defaultPolicySet = ETrue;
1.257 + break;
1.258 + case KDbObjType:
1.259 + StoreDbSecurityPolicyL(aSecurityPolicyCon, policyType, policy, dbPolicySetFlag);
1.260 + break;
1.261 + case RSqlSecurityPolicy::ETable:
1.262 + StoreDbObjSecurityPolicyL(aSecurityPolicyCon, objType, objName, policyType, policy);
1.263 + break;
1.264 + default:
1.265 + __SQLLEAVE(KErrGeneral);
1.266 + break;
1.267 + }//end of "switch(aObjType)"
1.268 + }
1.269 + CleanupStack::PopAndDestroy();//cleanupItem (statement handle)
1.270 + __SQLLEAVE_IF_ERROR(err);
1.271 + if(!defaultPolicySet)
1.272 + {
1.273 + __SQLLEAVE(KErrGeneral);//no default policy
1.274 + }
1.275 + }
1.276 +
1.277 +/**
1.278 +Loads the database system settings from the settings table.
1.279 +If the settings table does not exist then it is created with the default settings
1.280 +(the stored collation dll name will be empty and the stored database configuration
1.281 +file version will be 0).
1.282 +
1.283 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.284 +@param aCollationDllName Output parameter, will contain the stored collation dll name,
1.285 +@param aDbConfigFileVersion Output parameter, will contain the stored database config file version.
1.286 +@param aCompactionMode Output parameter. Database compaction mode (one of TSqlCompactionMode enum item values except ESqlCompactionNotSet).
1.287 + Note that the input value of this parameter might be ESqlCompactionManual if the this is a legacy database,
1.288 + created not by the SQL server.
1.289 +
1.290 +@see TSqlCompactionMode
1.291 +
1.292 +@leave KErrNoMemory, an out of memory condition has occurred.
1.293 + Note that the function may also leave with some other database specific
1.294 + errors categorised as ESqlDbError, and other system-wide error codes..
1.295 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.296 +@panic SqlDb 7 In _DEBUG mode if the stored compaction mode is invalid.
1.297 +*/
1.298 +void TSqlDbSysSettings::LoadSettingsL(const TDesC& aDbName, TDes& aCollationDllName, TInt& aDbConfigFileVersion, TSqlCompactionMode& aCompactionMode)
1.299 + {
1.300 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.301 +
1.302 + aCollationDllName.Zero();
1.303 + aDbConfigFileVersion = KSqlNullDbConfigFileVersion;
1.304 + if(aCompactionMode == ESqlCompactionNotSet)
1.305 + {
1.306 + aCompactionMode = KSqlDefaultCompactionMode;
1.307 + }
1.308 +
1.309 + //If the system settings table does not exist then create it now.
1.310 + //For a database created by the SQL Server this will only occur
1.311 + //when the database is being created in an application's private data cage -
1.312 + //as part of this create call it is now being opened by the server.
1.313 + //An externally created database is likely to not contain the settings table
1.314 + //and adding it here makes the database 'SQL Server-compatible'
1.315 + if(!SettingsTableExistsL(aDbName))
1.316 + {
1.317 + StoreSettingsL(aDbName, aCollationDllName, KSqlNullDbConfigFileVersion, aCompactionMode); // store empty collation dll name, then reindexing will occur
1.318 + }
1.319 + else
1.320 + {
1.321 + //Get the settings from the existing table
1.322 + TInt settingsVersion = 0;
1.323 + GetSettingsL(aDbName, aCollationDllName, aDbConfigFileVersion, settingsVersion, aCompactionMode);
1.324 + if(settingsVersion < KSqlSystemVersion)
1.325 + {
1.326 + //Recreate the settings table using the last version number format (this is what the old code did during reindexing)
1.327 + StoreSettingsL(aDbName, aCollationDllName, aDbConfigFileVersion, aCompactionMode); // store empty collation dll name, then reindexing will occur
1.328 + }
1.329 + }
1.330 + __ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicInternalError));
1.331 + }
1.332 +
1.333 +/**
1.334 +Retrieves the database system settings from the settings table.
1.335 +
1.336 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.337 +@param aCollationDllName Output parameter, will contain the stored collation dll name,
1.338 +@param aDbConfigFileVersion Output parameter, will contain the stored database config file version,
1.339 +@param aSettingsVersion Output parameter, will contain the version of the settings table.
1.340 +@param aCompactionMode Output parameter. Database compaction mode (one of TSqlCompactionMode enum item values except ESqlCompactionNotSet).
1.341 +
1.342 +@see TSqlCompactionMode
1.343 +
1.344 +@leave KErrGeneral, either unable to retrieve the data from the settings table or the
1.345 + stored table version or config file version is invalid or the stored compaction mode is invalid.
1.346 + KErrOverflow, aCollationDllName is not large enough to store the name of the
1.347 + collation dll that is stored in the settings table.
1.348 + KErrNoMemory, an out of memory condition has occurred.
1.349 + Note that the function may also leave with other system-wide error codes or SQL
1.350 + errors of ESqlDbError type
1.351 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.352 +*/
1.353 +void TSqlDbSysSettings::GetSettingsL(const TDesC& aDbName, TDes& aCollationDllName, TInt& aDbConfigFileVersion,
1.354 + TInt& aSettingsVersion, TSqlCompactionMode& aCompactionMode)
1.355 + {
1.356 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.357 +
1.358 + HBufC* buf = HBufC::NewLC(sizeof(KGetSettingsSql) + aDbName.Length());
1.359 + TPtr sql = buf->Des();
1.360 +
1.361 + //Prepare statement handle
1.362 + sql.Format(KGetSettingsSql(), &aDbName);
1.363 + sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql);
1.364 + CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle));
1.365 + //Move to the first record
1.366 + TInt err = ::StmtNext(stmtHandle);
1.367 + __SQLLEAVE_IF_ERROR(err);
1.368 + //Check that it is a valid row. The error is checked on the previous line.
1.369 + //The "if" bellow will check whether there is a valid record or not.
1.370 + if(err != KSqlAtRow)
1.371 + {
1.372 + __SQLLEAVE(KErrGeneral);
1.373 + }
1.374 + //Get the system settings version
1.375 + aSettingsVersion = sqlite3_column_int(stmtHandle, KSysVersionColIdx);
1.376 + if(aSettingsVersion < ESqlSystemVersion1)
1.377 + {
1.378 + __SQLLEAVE(KErrGeneral);
1.379 + }
1.380 + if(aSettingsVersion > ESqlSystemVersion2)
1.381 + {
1.382 + //The "ConfigFileVersion" column exists and is used to store the most recent
1.383 + //version of the database's config file (if there is one) that has
1.384 + //been successfully processed
1.385 + aDbConfigFileVersion = sqlite3_column_int(stmtHandle, KConfigFileVersionColIdx);
1.386 + if(aDbConfigFileVersion < KSqlNullDbConfigFileVersion)
1.387 + {
1.388 + __SQLLEAVE(KErrGeneral);
1.389 + }
1.390 +
1.391 + //The "CollationDllName" column exists and its value can be read.
1.392 + //The column type might be different than SQLITE_TEXT - malformed database.
1.393 + if(sqlite3_column_type(stmtHandle, KCollationDllNameColIdx) != SQLITE_TEXT)
1.394 + {
1.395 + __SQLLEAVE(KErrGeneral);
1.396 + }
1.397 + const void* ptr = sqlite3_column_text16(stmtHandle, KCollationDllNameColIdx);
1.398 + //Null column value - this might be an indication of an "out of memory" problem, if the column text
1.399 + //is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion)
1.400 + __SQLLEAVE_IF_NULL(const_cast<void*>(ptr));
1.401 + TPtrC16 src(reinterpret_cast <const TUint16*> (ptr));
1.402 + if(src.Length() > aCollationDllName.MaxLength())
1.403 + {
1.404 + __SQLLEAVE(KErrOverflow);
1.405 + }
1.406 + aCollationDllName.Copy(src);
1.407 + }
1.408 + if(aSettingsVersion > ESqlSystemVersion3)
1.409 + {
1.410 + aCompactionMode = static_cast <TSqlCompactionMode> (sqlite3_column_int(stmtHandle, KCompactionModeColIdx));
1.411 + if(aCompactionMode != ESqlCompactionManual && aCompactionMode != ESqlCompactionBackground && aCompactionMode != ESqlCompactionAuto)
1.412 + {
1.413 + __SQLLEAVE(KErrGeneral);
1.414 + }
1.415 + }
1.416 + CleanupStack::PopAndDestroy();//TCleanupItem(&FinalizeStatementHandle, stmtHandle)
1.417 + CleanupStack::PopAndDestroy(buf);
1.418 + }
1.419 +
1.420 +/**
1.421 +Deletes and recreates all database indexes which use user-defined collation methods, from scratch.
1.422 +Also updates the database settings table with the name of the current collation dll.
1.423 +This is all performed as a single atomic transaction.
1.424 +
1.425 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.426 +@param aCurrentCollationDllName The name of the current collation dll.
1.427 +
1.428 +@leave The function may leave with system-wide error codes or SQL errors of ESqlDbError type
1.429 +
1.430 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.431 +*/
1.432 +void TSqlDbSysSettings::ReindexDatabaseL(const TDesC& aDbName, const TDesC& aCurrentCollationDllName)
1.433 + {
1.434 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.435 +
1.436 + //Allocate memory for the SQL statements
1.437 + HBufC* buf = HBufC::NewLC(Max((TInt)sizeof(KUpdateCollationSettingsSql), (TInt)sizeof(KReindexSql)) +
1.438 + aDbName.Length() + aCurrentCollationDllName.Length());
1.439 + TPtr sql = buf->Des();
1.440 +
1.441 + //Begin transaction
1.442 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql()));
1.443 + CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle));
1.444 +
1.445 + const TSqlCollationUtil collationUtil(iDbHandle);
1.446 + //Issue a "REINDEX" command for each collation that has at least one index using it
1.447 + for(TInt i = collationUtil.CollationCount()-1; i >= 0 ;--i)
1.448 + {
1.449 + TPtrC collationName = collationUtil.CollationName(i);
1.450 + if(IndexExistsL(aDbName, collationName))
1.451 + {
1.452 + sql.Format(KReindexSql(), &collationName);
1.453 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql));
1.454 + }
1.455 + }
1.456 +
1.457 + //Update the settings table to store the current collation DLL name
1.458 + sql.Format(KUpdateCollationSettingsSql(), &aDbName, &aCurrentCollationDllName);
1.459 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql));
1.460 +
1.461 + //Commit transaction
1.462 + __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql()));
1.463 + CleanupStack::Pop(); //TCleanupItem(&RollbackTransaction, iDbHandle)
1.464 + CleanupStack::PopAndDestroy(buf);
1.465 + }
1.466 +
1.467 +/**
1.468 +Performs any necessary configuration file updates to the database if a
1.469 +configuration file exists for the database that has not yet been processed.
1.470 +If a configuration file is processed then the database settings table will
1.471 +be updated with the version of the configuration file that was processed.
1.472 +
1.473 +@param aStoredDbConfigFileVersion The configuration file version that is
1.474 + currently stored in the settings table
1.475 +@param aFileData The database file data
1.476 +
1.477 +@param aDbName Logical database name: "main" for the main database or attached database name
1.478 +
1.479 +@leave One of the system-wide error codes or SQL errors of ESqlDbError type
1.480 +
1.481 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object)
1.482 +*/
1.483 +void TSqlDbSysSettings::ConfigureDatabaseL(TInt aStoredDbConfigFileVersion, const TSqlSrvFileData& aFileData,
1.484 + const TDesC& aDbName)
1.485 + {
1.486 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_ENTRY, "Entry;0x%X;TSqlDbSysSettings::ConfigureDatabaseL", (TUint)this));
1.487 +
1.488 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.489 +
1.490 + if(!aFileData.IsSecureFileNameFmt())
1.491 + {
1.492 + //As a first implementation, config files will only be supported for
1.493 + //shared, secure databases - not for private, secure databases or public databases
1.494 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_EXIT1, "Exit;0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Not a secure db", (TUint)this));
1.495 + return;
1.496 + }
1.497 +
1.498 + //Determine whether there is a configuration file
1.499 + //for this database that has not yet been processed
1.500 + const CDbConfigFiles* dbConfigFiles = aFileData.DbConfigFiles();
1.501 + if(dbConfigFiles)
1.502 + {
1.503 + //Get the database file name and extension to search for a corresponding config file
1.504 + TPtrC dbName = aFileData.FileName();
1.505 + TParse parse;
1.506 + __SQLLEAVE_IF_ERROR(parse.Set(dbName, NULL, NULL));
1.507 + TPtrC dbFileNameAndExt = parse.NameAndExt();
1.508 + HBufC* matchingConfigFile = dbConfigFiles->FindConfigFile(dbFileNameAndExt);
1.509 + if(matchingConfigFile)
1.510 + {
1.511 + //There exists a config file for this database - now check whether its
1.512 + //version is greater than the version stored in the settings table and
1.513 + //only process the file if it is
1.514 + TFileName configFileName;
1.515 + configFileName.Copy(matchingConfigFile->Des());
1.516 + TInt offset = configFileName.LocateReverse('.') ;
1.517 + if(KErrNotFound != offset)
1.518 + {
1.519 + TInt lengthOfExt = configFileName.Length() - offset - 1;
1.520 + TPtrC versionNum = configFileName.Right(lengthOfExt);
1.521 + TLex lex(versionNum);
1.522 + TInt fileVersion = 0;
1.523 + if(KErrNone == lex.Val(fileVersion))
1.524 + {
1.525 + if(fileVersion > aStoredDbConfigFileVersion)
1.526 + {
1.527 + //The latest version of the configuration file has not yet been processed, so do it now
1.528 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL1, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Config file '%S'", (TUint)this, __SQLPRNSTR(configFileName)));
1.529 + ExecuteConfigurationUpdateL(aFileData, configFileName, fileVersion, aDbName);
1.530 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL2, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Config file '%S' was processed, no errors", (TUint)this, __SQLPRNSTR(configFileName)));
1.531 + }
1.532 + else
1.533 + {
1.534 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL3, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Config file '%S' as this or a later version has already been processed", (TUint)this, __SQLPRNSTR(configFileName)));
1.535 + }
1.536 + }
1.537 + else
1.538 + {
1.539 + //Invalid config file name extension - it cannot be converted to an integer
1.540 + __SQLLEAVE(KErrCorrupt);
1.541 + }
1.542 + }
1.543 + else
1.544 + {
1.545 + //Invalid config file name - it doesn't contain the character '.'
1.546 + __SQLLEAVE(KErrCorrupt);
1.547 + }
1.548 + }
1.549 + else
1.550 + {
1.551 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL4, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;No config file found for database '%S'", (TUint)this, __SQLPRNSTR(dbFileNameAndExt)));
1.552 + }
1.553 + }
1.554 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_EXIT2, "Exit;0x%X;TSqlDbSysSettings::ConfigureDatabaseL", (TUint)this));
1.555 + }
1.556 +
1.557 +/**
1.558 +Executes the supported operations specified in the given database
1.559 +configuration file and updates the settings table to store the
1.560 +version of this configuration file.
1.561 +
1.562 +@param aFileData The database file data
1.563 +@param aMatchingConfigFile The configuration file that is to be processed
1.564 +@param aDbConfigFileVersion The configuration file version
1.565 +@param aDbName Logical database name: "main" for the main database or attached database name
1.566 +
1.567 +@leave KErrNoMemory, if an out of memory condition occurs.
1.568 + One of the other system-wide error codes if the configuration
1.569 + file fails to be opened or read.
1.570 + One of the SQL errors of ESqlDbError type if the update to the
1.571 + database settings table fails
1.572 +
1.573 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.574 +*/
1.575 +void TSqlDbSysSettings::ExecuteConfigurationUpdateL(const TSqlSrvFileData& aFileData,
1.576 + const TDesC& aMatchingConfigFile,
1.577 + TInt aDbConfigFileVersion,
1.578 + const TDesC& aDbName)
1.579 + {
1.580 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.581 +
1.582 + //Execute the specified database config file operations that are supported
1.583 +#ifdef SYSLIBS_TEST
1.584 + TDriveUnit drive = EDriveC;
1.585 +#else
1.586 + TDriveUnit drive = EDriveZ;
1.587 +#endif
1.588 + TFileName configFilePath;
1.589 + TDriveName drvName = drive.Name();
1.590 + configFilePath.Append(drvName);
1.591 + configFilePath.Append(aFileData.PrivatePath());
1.592 + configFilePath.Append(aMatchingConfigFile);
1.593 + //If this method leaves then either the config file could not be
1.594 + //opened or read or an out of memory condition occured. Either way
1.595 + //another attempt will be made to process the config file when the
1.596 + //database is next opened
1.597 + DoExecuteDbConfigFileOpsL(aFileData.Fs(), configFilePath, aDbName);
1.598 +
1.599 + //Now update the settings table to store the current version of the database config file.
1.600 + //If this fails then another attempt will be made to process the config file and update
1.601 + //the settings table when the database is next opened
1.602 + TBuf<sizeof(KUpdateFileVersionSettingsSql) + KMaxFileName + 10> buf;
1.603 + buf.Format(KUpdateFileVersionSettingsSql(), &aDbName, aDbConfigFileVersion);
1.604 + __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, buf));
1.605 + }
1.606 +
1.607 +/**
1.608 +Opens the specified database configuration file and executes those operations that
1.609 +are specified in it which are currently supported (currently only 'CREATE INDEX'
1.610 +operations are supported and will be executed).
1.611 +
1.612 +@param aFs The server's file server session
1.613 +@param aConfigFilePath The configuration file path
1.614 +@param aDbName Logical database name: "main" for the main database or attached database name
1.615 +
1.616 +@leave KErrNoMemory, if an out of memory condition occurs.
1.617 + One of the other system-wide error codes if the configuration
1.618 + file fails to be opened or read
1.619 +
1.620 +@panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object).
1.621 +*/
1.622 +void TSqlDbSysSettings::DoExecuteDbConfigFileOpsL(RFs& aFs, const TDesC& aConfigFilePath, const TDesC& aDbName)
1.623 + {
1.624 + __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
1.625 +
1.626 + //Open the config file and read it into a buffer
1.627 + RFile64 file;
1.628 + __SQLLEAVE_IF_ERROR(file.Open(aFs, aConfigFilePath, EFileRead));
1.629 + CleanupClosePushL(file);
1.630 + TInt64 size = 0;
1.631 + __SQLLEAVE_IF_ERROR(file.Size(size));
1.632 + if(size == 0)
1.633 + {
1.634 + //Config file is empty so just return
1.635 + SQL_TRACE_INTERNALS(OstTraceExt1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_DOEXECUTEDBCONFIGFILEOPSL, "0;TSqlDbSysSettings::DoExecuteDbConfigFileOpsL();Config file %S is empty", __SQLPRNSTR(aConfigFilePath)));
1.636 + CleanupStack::PopAndDestroy(); // file
1.637 + return;
1.638 + }
1.639 + HBufC8* buffer = HBufC8::NewLC(size);
1.640 + TPtr8 bufPtr = buffer->Des();
1.641 + __SQLLEAVE_IF_ERROR(file.Read(bufPtr));
1.642 +
1.643 + //Convert buffer to Unicode for processing (the configuration file is expected to be ASCII or UTF-8)
1.644 + HBufC16* buf16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(bufPtr);
1.645 + CleanupStack::PushL(buf16);
1.646 + TPtrC16 ptr16 = buf16->Des();
1.647 +
1.648 + //Skip the BOM (byte ordering mark) at the start if there is one
1.649 + if((ptr16.Locate(TChar(0xFEFF)) == 0) || (ptr16.Locate(TChar(0xFFFE)) == 0))
1.650 + {
1.651 + ptr16.Set(ptr16.Mid(1));
1.652 + }
1.653 +
1.654 + //Parse the file contents and execute the specified
1.655 + //config statements that are supported
1.656 + ParseFileL(ptr16, aDbName);
1.657 +
1.658 + CleanupStack::PopAndDestroy(3); // buf16, buffer, file
1.659 + }
1.660 +
1.661 +/**
1.662 +Parses the configuration file buffer, reading each SQL statement
1.663 +and processing it.
1.664 +
1.665 +@param aBuffer Buffer containing the configuration file contents
1.666 +@param aDbName Logical database name: "main" for the main database or attached database name
1.667 +
1.668 +@leave KErrNoMemory, if an out of memory condition occurs
1.669 +*/
1.670 +void TSqlDbSysSettings::ParseFileL(const TDesC& aBuffer, const TDesC& aDbName)
1.671 + {
1.672 + TLex fileParser(aBuffer);
1.673 + //While not end of file
1.674 + while (!fileParser.Eos())
1.675 + {
1.676 + //Get the next of the SQL statements, which are seperated by semicolons
1.677 + fileParser.SkipSpaceAndMark(); // skip any preceding whitespace before the next statement
1.678 + while ((!fileParser.Eos()) && (fileParser.Peek() != ';'))
1.679 + {
1.680 + fileParser.Inc(); // continue to next character
1.681 + }
1.682 + TPtrC stmt = fileParser.MarkedToken(); // extract the marked token
1.683 + fileParser.Inc(); // to skip the terminating ';' for next iteration
1.684 +
1.685 + //Process this statement
1.686 + ProcessStatementL(stmt, aDbName);
1.687 + }
1.688 + }
1.689 +
1.690 +/**
1.691 +Process an SQL statement contained in the configuration file
1.692 +and executes it if it is a supported statement.
1.693 +Currently only 'CREATE INDEX' statements are supported.
1.694 +The statement can contain comments that are understood by SQLite
1.695 +- these can be in the form of an SQL comment or a 'C' comment,
1.696 +as defined at http://www.sqlite.org/lang_comment.html.
1.697 +
1.698 +@param aStmt An SQL statement string, stripped of any whitespace
1.699 + at the beginning of it
1.700 +@param aDbName Logical database name: "main" for the main database or attached database name
1.701 +
1.702 +@leave KErrNoMemory, if an out of memory condition occurs
1.703 +*/
1.704 +void TSqlDbSysSettings::ProcessStatementL(const TDesC& aStmt, const TDesC& aDbName)
1.705 + {
1.706 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_ENTRY, "Entry;0x%X;TSqlDbSysSettings::ProcessStatementL;Processing statement '%S'", (TUint)this, __SQLPRNSTR(aStmt)));
1.707 +
1.708 + //If the statement only contained whitespace then just return
1.709 + if(aStmt.Length() == 0)
1.710 + {
1.711 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT1, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains only whitespace", (TUint)this));
1.712 + return;
1.713 + }
1.714 +
1.715 + //Check that the statement does not contain an unsupported comment style
1.716 + if(KErrNotFound != aStmt.Find(_L("//")))
1.717 + {
1.718 + //The statement contains '//' which is an unsupported comment style, but rather
1.719 + //than leave here and cause the full file to fail, we just ignore this statement
1.720 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT2, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains invalid comment style", (TUint)this));
1.721 + return;
1.722 + }
1.723 +
1.724 + HBufC* stmtBuf = HBufC::NewLC(aStmt.Length() + 1 + aDbName.Length() + 1);
1.725 + TPtr stmtPtr = stmtBuf->Des();
1.726 + //If the 'aStmt' string is an SQL statement that is supported then execute it
1.727 + if(::IsStatementSupported(aStmt, aDbName, stmtPtr))
1.728 + {
1.729 + TInt err = ::DbExecStmt16(iDbHandle, stmtPtr);
1.730 + if(KErrNone == err)
1.731 + {
1.732 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL1, "0x%X;TSqlDbSysSettings::ProcessStatementL;Successfully executed statement", (TUint)this));
1.733 + }
1.734 + else
1.735 + {
1.736 + SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL2, "0x%X;TSqlDbSysSettings::ProcessStatementL;Failed to execute the statement;err=%d", (TUint)this, err));
1.737 + if(err == KErrNoMemory)
1.738 + {
1.739 + __SQLLEAVE(err);
1.740 + }
1.741 + }
1.742 + }
1.743 + else
1.744 + {
1.745 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL3, "0x%X;TSqlDbSysSettings::ProcessStatementL;Non-supported statement, will be ignored", (TUint)this));
1.746 + }
1.747 + CleanupStack::PopAndDestroy(); // stmtBuf
1.748 + SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT3, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL", (TUint)this));
1.749 + }
1.750 +
1.751 +
1.752 +/**
1.753 +Stores the security policies into the security policies table.
1.754 +
1.755 +@param aSecurityPolicyCon Security policies container, which data needs to be persisted.
1.756 +
1.757 +@leave KErrNoMemory, an out of memory condition has occurred;
1.758 + KErrArgument, system table name found in the list of the tables, which need special protection;
1.759 + Note that the function may also leave with some other database specific
1.760 + errors categorised as ESqlDbError, and other system-wide error codes.
1.761 +
1.762 +@panic SqlDb 4 In _DEBUG mode if aSecurityPolicy argument is NULL.
1.763 +*/
1.764 +void TSqlDbSysSettings::StoreSecurityPoliciesL(const CSqlSecurityPolicy& aSecurityPolicyCon)
1.765 + {
1.766 + //Prepare the INSERT sql statement
1.767 + sqlite3_stmt* stmtHandle = ::StmtPrepare8L(iDbHandle, KInsertSecuritySql());
1.768 + CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle));
1.769 + //Store default security policy into the table
1.770 + StoreSecurityPolicyL(stmtHandle, KDefaultObjType, KNullDesC, KDefaultPolicyType, aSecurityPolicyCon.DefaultPolicy());
1.771 + //Store database security policies into the table
1.772 + StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::ESchemaPolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy));
1.773 + StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::EReadPolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::EReadPolicy));
1.774 + StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::EWritePolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::EWritePolicy));
1.775 + //Store database objects security policies into the table
1.776 + TSqlSecurityPolicyIterator it(aSecurityPolicyCon);
1.777 + RSqlSecurityPolicy::TObjectType objectType;
1.778 + TPtrC objectName;
1.779 + RSqlSecurityPolicy::TPolicyType policyType;
1.780 + TSecurityPolicy policy;
1.781 + while(it.Next(objectType, objectName, policyType, policy))
1.782 + {
1.783 + if(objectType == RSqlSecurityPolicy::ETable && ::IsSystemTableName(objectName))
1.784 + {
1.785 + //Clients are not allowed to put system table names in the RSqlSecurityPolicy container.
1.786 + __SQLLEAVE(KErrArgument);
1.787 + }
1.788 + StoreSecurityPolicyL(stmtHandle, objectType, objectName, policyType, policy);
1.789 + }
1.790 + CleanupStack::PopAndDestroy();//cleanupItem (statement handle)
1.791 + }
1.792 +
1.793 +/**
1.794 +Stores a security policy object in the security policies table.
1.795 +
1.796 +@param aStmtHandle Statement handle.
1.797 +@param aObjType Database object type: default security policies, database security policies, table security policies
1.798 +@param aObjName Database object name. It is expected to be a non-empty string only for tables.
1.799 +@param aPolicyType Security policy type: schema, write, read.
1.800 +@param aPolicy Security policy object.
1.801 +
1.802 +@leave KErrNoMemory, an out of memory condition has occurred;
1.803 + Note that the function may also leave with some other database specific
1.804 + errors categorised as ESqlDbError, and other system-wide error codes.
1.805 +
1.806 +@panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL.
1.807 +*/
1.808 +void TSqlDbSysSettings::StoreSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt aObjType, const TDesC& aObjName,
1.809 + TInt aPolicyType, const TSecurityPolicy& aPolicy)
1.810 + {
1.811 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.812 + __SQLLEAVE_IF_ERROR(::StmtReset(aStmtHandle));
1.813 + __SQLLEAVE_IF_ERROR(BindSecurityPolicyPrm(aStmtHandle, aObjType, aObjName, aPolicyType, aPolicy));
1.814 + __SQLLEAVE_IF_ERROR(::StmtExec(aStmtHandle));
1.815 + }
1.816 +
1.817 +/**
1.818 +Binds the parameter values for the insert SQL statement for security policies table.
1.819 +
1.820 +@param aStmtHandle Statement handle.
1.821 +@param aObjType Database object type: default security policy, database security policies, table security policies
1.822 +@param aObjName Database object name. It is expected to be a non-empty string only for tables.
1.823 +@param aPolicyType Security policy type: schema, write, read.
1.824 +@param aPolicy Security policy object.
1.825 +
1.826 +@see TSqlDbSysSettings::StoreSecurityPolicyL()
1.827 +
1.828 +@panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL.
1.829 +*/
1.830 +TInt TSqlDbSysSettings::BindSecurityPolicyPrm(sqlite3_stmt* aStmtHandle, TInt aObjType, const TDesC& aObjName,
1.831 + TInt aPolicyType, const TSecurityPolicy& aPolicy)
1.832 + {
1.833 + (void)sqlite3SymbianLastOsError();//clear last OS error
1.834 + TInt err = sqlite3_bind_int(aStmtHandle, KObjTypePrmIdx, aObjType);
1.835 + if(err == SQLITE_OK)
1.836 + {
1.837 + err = sqlite3_bind_text16(aStmtHandle, KObjNamePrmIdx, aObjName.Ptr(), aObjName.Length() * sizeof(TText), SQLITE_STATIC);
1.838 + if(err == SQLITE_OK)
1.839 + {
1.840 + err = sqlite3_bind_int(aStmtHandle, KObjPolicyTypePrmIdx, aPolicyType);
1.841 + if(err == SQLITE_OK)
1.842 + {
1.843 + TPtrC8 policyData(aPolicy.Package());
1.844 + err = sqlite3_bind_blob(aStmtHandle, KObjPolicyDataPrmIdx, policyData.Ptr(), policyData.Length(), SQLITE_STATIC);
1.845 + }
1.846 + }
1.847 + }
1.848 + return ::Sql2OsErrCode(err, sqlite3SymbianLastOsError());
1.849 + }
1.850 +
1.851 +/**
1.852 +Reads a record from security policies table.
1.853 +
1.854 +@param aStmtHandle Statement handle. It cannot be NULL.
1.855 +@param aSecurityPolicy Security policies container.
1.856 +@param aObjType Output parameter, will be initialized with the database object type: KDefaultObjType,
1.857 + KDbObjType, RSqlSecurityPolicy::ETable.
1.858 +@param aObjName Output parameter, database object name (for example, table name), which is protected by the
1.859 + current security policy.
1.860 +@param aPolicyType Output parameter, will be initialized with the database policy type: RSqlSecurityPolicy::EReadPolicy,
1.861 + RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy.
1.862 +@return The created security policy object.
1.863 +
1.864 +@leave KErrGeneral, invalid security policy data;
1.865 + KErrNoMemory, Out of memory.
1.866 +*/
1.867 +TSecurityPolicy TSqlDbSysSettings::ReadCurrSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt& aObjType,
1.868 + TPtrC& aObjName, TInt& aPolicyType)
1.869 + {
1.870 + __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument));
1.871 + aObjType = sqlite3_column_int(aStmtHandle, KObjTypeColIdx);
1.872 + //The "ObjectName" column type might be different than SQLITE_TEXT - malformed database.
1.873 + if(sqlite3_column_type(aStmtHandle, KObjNameColIdx) != SQLITE_TEXT)
1.874 + {
1.875 + __SQLLEAVE(KErrGeneral);
1.876 + }
1.877 + const void* text = sqlite3_column_text16(aStmtHandle, KObjNameColIdx);
1.878 + //Null column value - this might be an indication of an "out of memory" problem, if the column text
1.879 + //is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion)
1.880 + __SQLLEAVE_IF_NULL(const_cast<void*>(text));
1.881 + TInt len = (TUint)sqlite3_column_bytes16(aStmtHandle, KObjNameColIdx) / sizeof(TUint16);
1.882 + aObjName.Set(reinterpret_cast <const TUint16*> (text), len);
1.883 + aPolicyType = sqlite3_column_int(aStmtHandle, KObjPolicyTypeColIdx);
1.884 + len = sqlite3_column_bytes(aStmtHandle, KObjPolicyDataColIdx);
1.885 + if(len != sizeof(TSecurityPolicy))
1.886 + {
1.887 + //Check if the error is "out of memory" (which may happen when retrieving text column data
1.888 + //and the column encoding is different, in which case the column text has to be converted
1.889 + //and a new block of memory has to be allocated for the conversion).
1.890 + TInt err2 = ::StmtReset(aStmtHandle);
1.891 + __SQLLEAVE(err2 == KErrNoMemory ? KErrNoMemory : KErrGeneral);
1.892 + }
1.893 + const void* data = sqlite3_column_blob(aStmtHandle, KObjPolicyDataColIdx);
1.894 + TSecurityPolicy policy;
1.895 + policy.Set(TPtrC8(reinterpret_cast <const TUint8*> (data), len));
1.896 + return policy;
1.897 + }
1.898 +
1.899 +/**
1.900 +Stores the default security policy into aSecurityPolicyCon container.
1.901 +Initialises all database security policies not set yet with the default security policy.
1.902 +
1.903 +@param aSecurityPolicyCon Security policies container.
1.904 +@param aPolicy Default security policy object
1.905 +@param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't.
1.906 +
1.907 +@see CSqlSecurityPolicy::SetDbPolicy()
1.908 +*/
1.909 +void TSqlDbSysSettings::StoreDefaultSecurityPolicy(CSqlSecurityPolicy& aSecurityPolicyCon,
1.910 + const TSecurityPolicy& aPolicy, TInt aDbPolicySetFlag)
1.911 + {
1.912 + aSecurityPolicyCon.SetDefaultPolicy(aPolicy);
1.913 + if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::ESchemaPolicy)))
1.914 + {
1.915 + aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, aPolicy);
1.916 + }
1.917 + if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::EReadPolicy)))
1.918 + {
1.919 + aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, aPolicy);
1.920 + }
1.921 + if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::EWritePolicy)))
1.922 + {
1.923 + aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, aPolicy);
1.924 + }
1.925 + }
1.926 +
1.927 +/**
1.928 +Stores a database security policy into aSecurityPolicyCon container.
1.929 +
1.930 +@param aSecurityPolicyCon Security policies container.
1.931 +@param aPolicyType Database policy type: RSqlSecurityPolicy::EReadPolicy,
1.932 + RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy.
1.933 +@param aPolicy Database security policy object
1.934 +@param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't.
1.935 + The parameter value may change if some of the database policies are set by
1.936 + StoreDbSecurityPolicyL().
1.937 +
1.938 +@leave KErrGeneral Invalid security policy type or the corresponding database security policy has been set already.
1.939 +*/
1.940 +void TSqlDbSysSettings::StoreDbSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon, TInt aPolicyType,
1.941 + const TSecurityPolicy& aPolicy, TInt& aDbPolicySetFlag)
1.942 + {
1.943 + if(aPolicyType < (TInt)RSqlSecurityPolicy::ESchemaPolicy || aPolicyType > (TInt)RSqlSecurityPolicy::EWritePolicy)
1.944 + {
1.945 + __SQLLEAVE(KErrGeneral);
1.946 + }
1.947 + if(aDbPolicySetFlag & (1 << aPolicyType))
1.948 + {
1.949 + __SQLLEAVE(KErrGeneral);
1.950 + }
1.951 + aSecurityPolicyCon.SetDbPolicy(static_cast <RSqlSecurityPolicy::TPolicyType> (aPolicyType), aPolicy);
1.952 + aDbPolicySetFlag |= (1 << aPolicyType);
1.953 + }
1.954 +
1.955 +/**
1.956 +Stores a database object security policy into aSecurityPolicyCon container.
1.957 +
1.958 +@param aSecurityPolicyCon Security policies container.
1.959 +@param aObjType Database object type: RSqlSecurityPolicy::ETable.
1.960 +@param aObjName Database object name (for example, table name), which is protected by the current security policy.
1.961 +@param aPolicyType Database policy type: RSqlSecurityPolicy::EReadPolicy,
1.962 + RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy.
1.963 +@param aPolicy Database security policy object
1.964 +@param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't.
1.965 + The parameter value may change if some of the database policies are set by
1.966 + StoreDbSecurityPolicyL().
1.967 +
1.968 +@leave KErrGeneral Invalid security policy type or invalid database object name length.
1.969 +*/
1.970 +void TSqlDbSysSettings::StoreDbObjSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon,
1.971 + TInt aObjType, const TDesC& aObjName,
1.972 + TInt aPolicyType, const TSecurityPolicy& aPolicy)
1.973 + {
1.974 + if(aPolicyType < (TInt)RSqlSecurityPolicy::EReadPolicy || aPolicyType > (TInt)RSqlSecurityPolicy::EWritePolicy)
1.975 + {
1.976 + __SQLLEAVE(KErrGeneral);
1.977 + }
1.978 + if(aObjName.Length() < 1)
1.979 + {
1.980 + __SQLLEAVE(KErrGeneral);
1.981 + }
1.982 + __SQLLEAVE_IF_ERROR(aSecurityPolicyCon.SetPolicy(static_cast<RSqlSecurityPolicy::TObjectType> (aObjType),
1.983 + aObjName, static_cast <RSqlSecurityPolicy::TPolicyType> (aPolicyType), aPolicy));
1.984 + }
1.985 +
1.986 +/**
1.987 +Returns true if settigns table exists.
1.988 +(Non-secure databases prior version 3 don't have settings table)
1.989 +
1.990 +@param aDbName Logical database name: "main" for the main database or attached database name.
1.991 +*/
1.992 +TBool TSqlDbSysSettings::SettingsTableExistsL(const TDesC& aDbName)
1.993 + {
1.994 + HBufC* buf = HBufC::NewLC(sizeof(KSettingsTableCheckSql) + aDbName.Length());
1.995 + TPtr sql = buf->Des();
1.996 + sql.Format(KSettingsTableCheckSql(), &aDbName);
1.997 + sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql);
1.998 + CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle));
1.999 + TInt rc = ::StmtNext(stmtHandle);
1.1000 + CleanupStack::PopAndDestroy();//cleanupItem (statement handle)
1.1001 + CleanupStack::PopAndDestroy(buf);
1.1002 + __SQLLEAVE_IF_ERROR(rc);
1.1003 + return rc == KSqlAtRow;
1.1004 + }
1.1005 +
1.1006 +/**
1.1007 +Returns true if at least one index using aCollationName exists.
1.1008 +
1.1009 +@param aDbName Logical database name: "main" for the main database or attached database name,
1.1010 +@param aCollationName SQLITE collation name.
1.1011 +*/
1.1012 +TBool TSqlDbSysSettings::IndexExistsL(const TDesC& aDbName, const TDesC& aCollationName)
1.1013 + {
1.1014 + //KGetIndexSql will contain '%<CollationName>%' search pattern, while Symbian OS search patterns use '*' symbol by default.
1.1015 + //This time the '%' is OK because the serach is performed in the SQLITE master table and before installing the
1.1016 + //user-defined Like() function.
1.1017 + HBufC* buf = HBufC::NewLC(sizeof(KGetIndexSql) + aDbName.Length() + aCollationName.Length());
1.1018 + TPtr sql = buf->Des();
1.1019 + sql.Format(KGetIndexSql(), &aDbName, &aCollationName);
1.1020 + sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql);
1.1021 + CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle));
1.1022 + TInt rc = ::StmtNext(stmtHandle);
1.1023 + CleanupStack::PopAndDestroy(2);//buf, cleanupItem (statement handle)
1.1024 + __SQLLEAVE_IF_ERROR(rc);
1.1025 + return rc == KSqlAtRow;
1.1026 + }