sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // Store/Load database system settings (database settings, security policies) sl@0: // sl@0: // sl@0: sl@0: #include sl@0: #include sl@0: #include //CnvUtfConverter sl@0: #include //RSqlSecurityPolicy enum items sl@0: #include "SqlSrvDbSysSettings.h" sl@0: #include "SqlUtil.h" //Sql2OsErrCode() sl@0: #include "sqlite3.h" //SQLITE API sl@0: #include "SqliteSymbian.h" //sqlite3SymbianLastOsError() sl@0: #include "SqlSecurityImpl.h" //CSqlSecurityPolicy sl@0: #include "SqlSrvStatementUtil.h"//Global SQL execution functions sl@0: #include "SqlSrvCollation.h" //TSqlCollate sl@0: #include "SqlSrvStrings.h" //System table names sl@0: #include "SqlSrvUtil.h" //Global functions sl@0: #include "SqlSrvFileData.h" //TSqlSrvFileData sl@0: #include "OstTraceDefinitions.h" sl@0: #ifdef OST_TRACE_COMPILER_IN_USE sl@0: #include "SqlSrvDbSysSettingsTraces.h" sl@0: #endif sl@0: #include "SqlTraceDef.h" sl@0: sl@0: extern TBool IsStatementSupported(const TDesC& aStatementIn, const TDesC& aDbName, TDes& aStatementOut); sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: ///////////////////////////// Local const data /////////////////////////////////////////////////////// sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: enum sl@0: { sl@0: ESqlSystemVersion1 = 1, //Base version sl@0: ESqlSystemVersion2 = 2, //New field into "Settings" table - "Reserved" (unused, set to 0) sl@0: ESqlSystemVersion3 = 3, //New field into "Settings" table - "CollationDllName" sl@0: //Existing field in "Settings" table - "Reserved" - now used to store processed version of db config file sl@0: ESqlSystemVersion4 = 4 //"CompactionMode" field added sl@0: }; sl@0: sl@0: //Current version of the system settings - reflects changes in the system tables. sl@0: const TInt KSqlSystemVersion = ESqlSystemVersion4; sl@0: sl@0: //The database names in all statements are quoted to avoid the "sql injection" threat. sl@0: //(At the moment there is no way to pass an invalid database name for these statements, because the database has to be attached sl@0: // first and a parameter binding is used there. So, the quoting is just for safety and against changes in the future) sl@0: sl@0: _LIT(KCreateSettingsSql,"CREATE TABLE \"%S\".symbian_settings(Id INTEGER,Reserved INTEGER,CollationDllName TEXT, CompactionMode INTEGER);\x0"); sl@0: _LIT(KDropSettingsSql, "DROP TABLE IF EXISTS \"%S\".symbian_settings;\x0"); sl@0: _LIT(KInsertSettingsSql, "INSERT INTO \"%S\".symbian_settings VALUES(%d, %d,'%S',%d);\x0"); sl@0: _LIT(KUpdateCollationSettingsSql, "UPDATE \"%S\".symbian_settings SET CollationDllName='%S';\x0"); sl@0: _LIT(KUpdateFileVersionSettingsSql, "UPDATE \"%S\".symbian_settings SET Reserved=%d;\x0"); sl@0: _LIT(KGetSettingsSql, "SELECT * FROM \"%S\".symbian_settings;\x0"); sl@0: _LIT(KGetIndexSql, "SELECT name FROM \"%S\".sqlite_master WHERE type = 'index' AND sql LIKE '%%%S%%'\x0"); sl@0: _LIT(KSettingsTableCheckSql, "SELECT name from \"%S\".sqlite_master WHERE type = 'table' AND name = 'symbian_settings';\x0"); sl@0: _LIT(KReindexSql, "REINDEX \"%S\";\x0"); sl@0: sl@0: _LIT8(KCreateSecuritySql,"CREATE TABLE symbian_security(Id INTEGER PRIMARY KEY AUTOINCREMENT,ObjectType INTEGER,ObjectName TEXT,PolicyType INTEGER,PolicyData BLOB);\x0"); sl@0: _LIT8(KInsertSecuritySql, "INSERT INTO symbian_security(ObjectType,ObjectName,PolicyType,PolicyData) VALUES(:V1,:V2,:V3,:V4);\x0"); sl@0: _LIT8(KGetSecuritySql, "SELECT * FROM symbian_security;\x0"); sl@0: sl@0: _LIT8(KBeginTransactionSql, "BEGIN;\x0"); sl@0: _LIT8(KCommitTransactionSql, "COMMIT;\x0"); sl@0: _LIT8(KRollbackTransactionSql, "ROLLBACK;\x0"); sl@0: sl@0: sl@0: sl@0: //KInsertSecuritySql statement - parameter indices sl@0: const TInt KObjTypePrmIdx = 1; sl@0: const TInt KObjNamePrmIdx = 2; sl@0: const TInt KObjPolicyTypePrmIdx = 3; sl@0: const TInt KObjPolicyDataPrmIdx = 4; sl@0: sl@0: //Default security policy - object type code and policy type code sl@0: const TInt KDefaultObjType = -2; sl@0: const TInt KDefaultPolicyType = -1; sl@0: sl@0: //Database security policy - object type code sl@0: const TInt KDbObjType = -1; sl@0: sl@0: //KGetSettingsSql sql statement - column indices sl@0: const TInt KSysVersionColIdx = 0; sl@0: const TInt KConfigFileVersionColIdx = 1; sl@0: const TInt KCollationDllNameColIdx = 2; sl@0: const TInt KCompactionModeColIdx = 3; sl@0: sl@0: //KGetSecuritySql sql statement - column indices sl@0: const TInt KObjTypeColIdx = 1; sl@0: const TInt KObjNameColIdx = 2; sl@0: const TInt KObjPolicyTypeColIdx = 3; sl@0: const TInt KObjPolicyDataColIdx = 4; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: ///////////////////////////// Local functions //////////////////////////////////////////////////////// sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: //Finalzes the statement handle (aHandle argument). Used in stack cleanup operations. sl@0: //Panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL. sl@0: static void FinalizeStatementHandle(void* aHandle) sl@0: { sl@0: __ASSERT_DEBUG(aHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument)); sl@0: sqlite3_stmt* stmtHandle = static_cast (aHandle); sl@0: (void)sqlite3_finalize(stmtHandle); sl@0: } sl@0: sl@0: //Transaction rollback. Used in stack cleanup operations. sl@0: //Panic SqlDb 4 In _DEBUG mode if aDbHandle argument is NULL. sl@0: static void RollbackTransaction(void* aDbHandle) sl@0: { sl@0: __ASSERT_DEBUG(aDbHandle != NULL, __SQLPANIC2(ESqlPanicBadArgument)); sl@0: (void)::DbExecStmt8(reinterpret_cast (aDbHandle), KRollbackTransactionSql); sl@0: } sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: ///////////////////////////// TSqlDbSysSettings //////////////////////////////////////////////////////// sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: /** sl@0: Initializes TSqlDbSysSettings data members with default values. sl@0: sl@0: @param aDbHandle Database handle. TSqlDbSysSettings does not own aDbHandle argument. sl@0: sl@0: @panic SqlDb 4 In _DEBUG mode if aDbHandle argument is NULL. sl@0: */ sl@0: TSqlDbSysSettings::TSqlDbSysSettings(sqlite3* aDbHandle) : sl@0: iDbHandle(aDbHandle) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicBadArgument)); sl@0: } sl@0: sl@0: /** sl@0: Creates the database security policy table and stores the security policy in the table. sl@0: sl@0: @param aSecurityPolicy Database security policies container, which data needs to be persisted. sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred. sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes. sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::StoreSecurityPolicyL(const CSqlSecurityPolicy& aSecurityPolicyCon) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql())); sl@0: CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle)); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCreateSecuritySql())); sl@0: StoreSecurityPoliciesL(aSecurityPolicyCon); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql())); sl@0: CleanupStack::Pop();//TCleanupItem(&RollbackTransaction, iDbHandle) sl@0: } sl@0: sl@0: /** sl@0: Stores the database system settings in the settings table. The settings table is recreated. sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name, sl@0: @param aCollationDllName Collation dll name. It uniquely identifies the current collation method in use. sl@0: If the default collation method changes later then the database will be reindexed sl@0: and the new collation dll name will replace the existing one in the settings table. sl@0: @param aDbConfigFileVersion Current config file version or KSqlNullDbConfigFileVersion sl@0: @param aCompactionMode Database compaction mode, one of TSqlCompactionMode enum item values (except ESqlCompactionNotSet) sl@0: sl@0: @see TSqlCompactionMode sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred. sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes. sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: @panic SqlDb 4 In _DEBUG mode if aCompactionMode parameter value is invalid. sl@0: */ sl@0: void TSqlDbSysSettings::StoreSettingsL(const TDesC& aDbName, const TDesC& aCollationDllName, TInt aDbConfigFileVersion, TSqlCompactionMode aCompactionMode) sl@0: { sl@0: __ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicBadArgument)); sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: HBufC* buf = HBufC::NewLC(Max((TInt)sizeof(KDropSettingsSql), sl@0: Max((TInt)sizeof(KCreateSettingsSql), (TInt)sizeof(KInsertSettingsSql))) + sl@0: aDbName.Length() + aCollationDllName.Length() + 10); sl@0: TPtr sql = buf->Des(); sl@0: //Begin transaction sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql())); sl@0: CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle)); sl@0: //Recreate the "settings" table and store the default collation there (the DLL name) sl@0: sql.Format(KDropSettingsSql(), &aDbName); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql)); sl@0: sql.Format(KCreateSettingsSql, &aDbName); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql)); sl@0: sql.Format(KInsertSettingsSql(), &aDbName, KSqlSystemVersion, aDbConfigFileVersion, &aCollationDllName, aCompactionMode); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql)); sl@0: //Commit transaction sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql())); sl@0: CleanupStack::Pop();//TCleanupItem(&RollbackTransaction, iDbHandle) sl@0: CleanupStack::PopAndDestroy(buf); sl@0: } sl@0: sl@0: /** sl@0: Read security policies from security policy table. sl@0: sl@0: The method does not guarantee that either the security policies will be read from the sl@0: security table and stored in aSecurityPolicy parameter or aSecurityPolicy argument sl@0: stays unchanged in a case of failure. sl@0: sl@0: @param aSecurityPolicyCon Security policies container which needs to be initializeed with sl@0: the database security policies. sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred; sl@0: KErrGeneral, missing or invalid data in the system tables; sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes. sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::LoadSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: //Even if the version of the system settings is bigger than the current one (KSqlSystemVersion constant), sl@0: //I think that all future modifications of the system tables shall not affect the already existing sl@0: //fields. So it is correct to think that all information available in version 1 should be available sl@0: //(and accessible) in all future versions of the system settings. sl@0: //Note: no attempt shall be made here to modify the system tables structure! There may be more than one sl@0: // connection to the database being processed! sl@0: // sl@0: //Prepare statement handle sl@0: sqlite3_stmt* stmtHandle = ::StmtPrepare8L(iDbHandle, KGetSecuritySql()); sl@0: CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle)); sl@0: //Read the security policies sl@0: TBool defaultPolicySet = EFalse; sl@0: TInt dbPolicySetFlag = 0; sl@0: TInt err; sl@0: while((err = ::StmtNext(stmtHandle)) == KSqlAtRow) sl@0: { sl@0: TInt objType = KDefaultObjType - 1; sl@0: TPtrC objName(KNullDesC); sl@0: TInt policyType = RSqlSecurityPolicy::ESchemaPolicy - 1; sl@0: TSecurityPolicy policy = ReadCurrSecurityPolicyL(stmtHandle, objType, objName, policyType); sl@0: switch(objType) sl@0: { sl@0: case KDefaultObjType: sl@0: if(defaultPolicySet) sl@0: { sl@0: __SQLLEAVE(KErrGeneral);//two "default policy" records in the table sl@0: } sl@0: StoreDefaultSecurityPolicy(aSecurityPolicyCon, policy, dbPolicySetFlag); sl@0: defaultPolicySet = ETrue; sl@0: break; sl@0: case KDbObjType: sl@0: StoreDbSecurityPolicyL(aSecurityPolicyCon, policyType, policy, dbPolicySetFlag); sl@0: break; sl@0: case RSqlSecurityPolicy::ETable: sl@0: StoreDbObjSecurityPolicyL(aSecurityPolicyCon, objType, objName, policyType, policy); sl@0: break; sl@0: default: sl@0: __SQLLEAVE(KErrGeneral); sl@0: break; sl@0: }//end of "switch(aObjType)" sl@0: } sl@0: CleanupStack::PopAndDestroy();//cleanupItem (statement handle) sl@0: __SQLLEAVE_IF_ERROR(err); sl@0: if(!defaultPolicySet) sl@0: { sl@0: __SQLLEAVE(KErrGeneral);//no default policy sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Loads the database system settings from the settings table. sl@0: If the settings table does not exist then it is created with the default settings sl@0: (the stored collation dll name will be empty and the stored database configuration sl@0: file version will be 0). sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name, sl@0: @param aCollationDllName Output parameter, will contain the stored collation dll name, sl@0: @param aDbConfigFileVersion Output parameter, will contain the stored database config file version. sl@0: @param aCompactionMode Output parameter. Database compaction mode (one of TSqlCompactionMode enum item values except ESqlCompactionNotSet). sl@0: Note that the input value of this parameter might be ESqlCompactionManual if the this is a legacy database, sl@0: created not by the SQL server. sl@0: sl@0: @see TSqlCompactionMode sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred. sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes.. sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: @panic SqlDb 7 In _DEBUG mode if the stored compaction mode is invalid. sl@0: */ sl@0: void TSqlDbSysSettings::LoadSettingsL(const TDesC& aDbName, TDes& aCollationDllName, TInt& aDbConfigFileVersion, TSqlCompactionMode& aCompactionMode) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: aCollationDllName.Zero(); sl@0: aDbConfigFileVersion = KSqlNullDbConfigFileVersion; sl@0: if(aCompactionMode == ESqlCompactionNotSet) sl@0: { sl@0: aCompactionMode = KSqlDefaultCompactionMode; sl@0: } sl@0: sl@0: //If the system settings table does not exist then create it now. sl@0: //For a database created by the SQL Server this will only occur sl@0: //when the database is being created in an application's private data cage - sl@0: //as part of this create call it is now being opened by the server. sl@0: //An externally created database is likely to not contain the settings table sl@0: //and adding it here makes the database 'SQL Server-compatible' sl@0: if(!SettingsTableExistsL(aDbName)) sl@0: { sl@0: StoreSettingsL(aDbName, aCollationDllName, KSqlNullDbConfigFileVersion, aCompactionMode); // store empty collation dll name, then reindexing will occur sl@0: } sl@0: else sl@0: { sl@0: //Get the settings from the existing table sl@0: TInt settingsVersion = 0; sl@0: GetSettingsL(aDbName, aCollationDllName, aDbConfigFileVersion, settingsVersion, aCompactionMode); sl@0: if(settingsVersion < KSqlSystemVersion) sl@0: { sl@0: //Recreate the settings table using the last version number format (this is what the old code did during reindexing) sl@0: StoreSettingsL(aDbName, aCollationDllName, aDbConfigFileVersion, aCompactionMode); // store empty collation dll name, then reindexing will occur sl@0: } sl@0: } sl@0: __ASSERT_DEBUG(aCompactionMode == ESqlCompactionManual || aCompactionMode == ESqlCompactionBackground || aCompactionMode == ESqlCompactionAuto, __SQLPANIC(ESqlPanicInternalError)); sl@0: } sl@0: sl@0: /** sl@0: Retrieves the database system settings from the settings table. sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name, sl@0: @param aCollationDllName Output parameter, will contain the stored collation dll name, sl@0: @param aDbConfigFileVersion Output parameter, will contain the stored database config file version, sl@0: @param aSettingsVersion Output parameter, will contain the version of the settings table. sl@0: @param aCompactionMode Output parameter. Database compaction mode (one of TSqlCompactionMode enum item values except ESqlCompactionNotSet). sl@0: sl@0: @see TSqlCompactionMode sl@0: sl@0: @leave KErrGeneral, either unable to retrieve the data from the settings table or the sl@0: stored table version or config file version is invalid or the stored compaction mode is invalid. sl@0: KErrOverflow, aCollationDllName is not large enough to store the name of the sl@0: collation dll that is stored in the settings table. sl@0: KErrNoMemory, an out of memory condition has occurred. sl@0: Note that the function may also leave with other system-wide error codes or SQL sl@0: errors of ESqlDbError type sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::GetSettingsL(const TDesC& aDbName, TDes& aCollationDllName, TInt& aDbConfigFileVersion, sl@0: TInt& aSettingsVersion, TSqlCompactionMode& aCompactionMode) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: HBufC* buf = HBufC::NewLC(sizeof(KGetSettingsSql) + aDbName.Length()); sl@0: TPtr sql = buf->Des(); sl@0: sl@0: //Prepare statement handle sl@0: sql.Format(KGetSettingsSql(), &aDbName); sl@0: sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql); sl@0: CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle)); sl@0: //Move to the first record sl@0: TInt err = ::StmtNext(stmtHandle); sl@0: __SQLLEAVE_IF_ERROR(err); sl@0: //Check that it is a valid row. The error is checked on the previous line. sl@0: //The "if" bellow will check whether there is a valid record or not. sl@0: if(err != KSqlAtRow) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: //Get the system settings version sl@0: aSettingsVersion = sqlite3_column_int(stmtHandle, KSysVersionColIdx); sl@0: if(aSettingsVersion < ESqlSystemVersion1) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: if(aSettingsVersion > ESqlSystemVersion2) sl@0: { sl@0: //The "ConfigFileVersion" column exists and is used to store the most recent sl@0: //version of the database's config file (if there is one) that has sl@0: //been successfully processed sl@0: aDbConfigFileVersion = sqlite3_column_int(stmtHandle, KConfigFileVersionColIdx); sl@0: if(aDbConfigFileVersion < KSqlNullDbConfigFileVersion) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: sl@0: //The "CollationDllName" column exists and its value can be read. sl@0: //The column type might be different than SQLITE_TEXT - malformed database. sl@0: if(sqlite3_column_type(stmtHandle, KCollationDllNameColIdx) != SQLITE_TEXT) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: const void* ptr = sqlite3_column_text16(stmtHandle, KCollationDllNameColIdx); sl@0: //Null column value - this might be an indication of an "out of memory" problem, if the column text sl@0: //is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion) sl@0: __SQLLEAVE_IF_NULL(const_cast(ptr)); sl@0: TPtrC16 src(reinterpret_cast (ptr)); sl@0: if(src.Length() > aCollationDllName.MaxLength()) sl@0: { sl@0: __SQLLEAVE(KErrOverflow); sl@0: } sl@0: aCollationDllName.Copy(src); sl@0: } sl@0: if(aSettingsVersion > ESqlSystemVersion3) sl@0: { sl@0: aCompactionMode = static_cast (sqlite3_column_int(stmtHandle, KCompactionModeColIdx)); sl@0: if(aCompactionMode != ESqlCompactionManual && aCompactionMode != ESqlCompactionBackground && aCompactionMode != ESqlCompactionAuto) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: } sl@0: CleanupStack::PopAndDestroy();//TCleanupItem(&FinalizeStatementHandle, stmtHandle) sl@0: CleanupStack::PopAndDestroy(buf); sl@0: } sl@0: sl@0: /** sl@0: Deletes and recreates all database indexes which use user-defined collation methods, from scratch. sl@0: Also updates the database settings table with the name of the current collation dll. sl@0: This is all performed as a single atomic transaction. sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name, sl@0: @param aCurrentCollationDllName The name of the current collation dll. sl@0: sl@0: @leave The function may leave with system-wide error codes or SQL errors of ESqlDbError type sl@0: sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::ReindexDatabaseL(const TDesC& aDbName, const TDesC& aCurrentCollationDllName) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: //Allocate memory for the SQL statements sl@0: HBufC* buf = HBufC::NewLC(Max((TInt)sizeof(KUpdateCollationSettingsSql), (TInt)sizeof(KReindexSql)) + sl@0: aDbName.Length() + aCurrentCollationDllName.Length()); sl@0: TPtr sql = buf->Des(); sl@0: sl@0: //Begin transaction sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KBeginTransactionSql())); sl@0: CleanupStack::PushL(TCleanupItem(&RollbackTransaction, iDbHandle)); sl@0: sl@0: const TSqlCollationUtil collationUtil(iDbHandle); sl@0: //Issue a "REINDEX" command for each collation that has at least one index using it sl@0: for(TInt i = collationUtil.CollationCount()-1; i >= 0 ;--i) sl@0: { sl@0: TPtrC collationName = collationUtil.CollationName(i); sl@0: if(IndexExistsL(aDbName, collationName)) sl@0: { sl@0: sql.Format(KReindexSql(), &collationName); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql)); sl@0: } sl@0: } sl@0: sl@0: //Update the settings table to store the current collation DLL name sl@0: sql.Format(KUpdateCollationSettingsSql(), &aDbName, &aCurrentCollationDllName); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, sql)); sl@0: sl@0: //Commit transaction sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt8(iDbHandle, KCommitTransactionSql())); sl@0: CleanupStack::Pop(); //TCleanupItem(&RollbackTransaction, iDbHandle) sl@0: CleanupStack::PopAndDestroy(buf); sl@0: } sl@0: sl@0: /** sl@0: Performs any necessary configuration file updates to the database if a sl@0: configuration file exists for the database that has not yet been processed. sl@0: If a configuration file is processed then the database settings table will sl@0: be updated with the version of the configuration file that was processed. sl@0: sl@0: @param aStoredDbConfigFileVersion The configuration file version that is sl@0: currently stored in the settings table sl@0: @param aFileData The database file data sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name sl@0: sl@0: @leave One of the system-wide error codes or SQL errors of ESqlDbError type sl@0: sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object) sl@0: */ sl@0: void TSqlDbSysSettings::ConfigureDatabaseL(TInt aStoredDbConfigFileVersion, const TSqlSrvFileData& aFileData, sl@0: const TDesC& aDbName) sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_ENTRY, "Entry;0x%X;TSqlDbSysSettings::ConfigureDatabaseL", (TUint)this)); sl@0: sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: if(!aFileData.IsSecureFileNameFmt()) sl@0: { sl@0: //As a first implementation, config files will only be supported for sl@0: //shared, secure databases - not for private, secure databases or public databases sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_EXIT1, "Exit;0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Not a secure db", (TUint)this)); sl@0: return; sl@0: } sl@0: sl@0: //Determine whether there is a configuration file sl@0: //for this database that has not yet been processed sl@0: const CDbConfigFiles* dbConfigFiles = aFileData.DbConfigFiles(); sl@0: if(dbConfigFiles) sl@0: { sl@0: //Get the database file name and extension to search for a corresponding config file sl@0: TPtrC dbName = aFileData.FileName(); sl@0: TParse parse; sl@0: __SQLLEAVE_IF_ERROR(parse.Set(dbName, NULL, NULL)); sl@0: TPtrC dbFileNameAndExt = parse.NameAndExt(); sl@0: HBufC* matchingConfigFile = dbConfigFiles->FindConfigFile(dbFileNameAndExt); sl@0: if(matchingConfigFile) sl@0: { sl@0: //There exists a config file for this database - now check whether its sl@0: //version is greater than the version stored in the settings table and sl@0: //only process the file if it is sl@0: TFileName configFileName; sl@0: configFileName.Copy(matchingConfigFile->Des()); sl@0: TInt offset = configFileName.LocateReverse('.') ; sl@0: if(KErrNotFound != offset) sl@0: { sl@0: TInt lengthOfExt = configFileName.Length() - offset - 1; sl@0: TPtrC versionNum = configFileName.Right(lengthOfExt); sl@0: TLex lex(versionNum); sl@0: TInt fileVersion = 0; sl@0: if(KErrNone == lex.Val(fileVersion)) sl@0: { sl@0: if(fileVersion > aStoredDbConfigFileVersion) sl@0: { sl@0: //The latest version of the configuration file has not yet been processed, so do it now sl@0: SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL1, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Config file '%S'", (TUint)this, __SQLPRNSTR(configFileName))); sl@0: ExecuteConfigurationUpdateL(aFileData, configFileName, fileVersion, aDbName); sl@0: SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL2, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;Config file '%S' was processed, no errors", (TUint)this, __SQLPRNSTR(configFileName))); sl@0: } sl@0: else sl@0: { sl@0: 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))); sl@0: } sl@0: } sl@0: else sl@0: { sl@0: //Invalid config file name extension - it cannot be converted to an integer sl@0: __SQLLEAVE(KErrCorrupt); sl@0: } sl@0: } sl@0: else sl@0: { sl@0: //Invalid config file name - it doesn't contain the character '.' sl@0: __SQLLEAVE(KErrCorrupt); sl@0: } sl@0: } sl@0: else sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL4, "0x%X;TSqlDbSysSettings::ConfigureDatabaseL;No config file found for database '%S'", (TUint)this, __SQLPRNSTR(dbFileNameAndExt))); sl@0: } sl@0: } sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_CONFIGUREDATABASEL_EXIT2, "Exit;0x%X;TSqlDbSysSettings::ConfigureDatabaseL", (TUint)this)); sl@0: } sl@0: sl@0: /** sl@0: Executes the supported operations specified in the given database sl@0: configuration file and updates the settings table to store the sl@0: version of this configuration file. sl@0: sl@0: @param aFileData The database file data sl@0: @param aMatchingConfigFile The configuration file that is to be processed sl@0: @param aDbConfigFileVersion The configuration file version sl@0: @param aDbName Logical database name: "main" for the main database or attached database name sl@0: sl@0: @leave KErrNoMemory, if an out of memory condition occurs. sl@0: One of the other system-wide error codes if the configuration sl@0: file fails to be opened or read. sl@0: One of the SQL errors of ESqlDbError type if the update to the sl@0: database settings table fails sl@0: sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::ExecuteConfigurationUpdateL(const TSqlSrvFileData& aFileData, sl@0: const TDesC& aMatchingConfigFile, sl@0: TInt aDbConfigFileVersion, sl@0: const TDesC& aDbName) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: //Execute the specified database config file operations that are supported sl@0: #ifdef SYSLIBS_TEST sl@0: TDriveUnit drive = EDriveC; sl@0: #else sl@0: TDriveUnit drive = EDriveZ; sl@0: #endif sl@0: TFileName configFilePath; sl@0: TDriveName drvName = drive.Name(); sl@0: configFilePath.Append(drvName); sl@0: configFilePath.Append(aFileData.PrivatePath()); sl@0: configFilePath.Append(aMatchingConfigFile); sl@0: //If this method leaves then either the config file could not be sl@0: //opened or read or an out of memory condition occured. Either way sl@0: //another attempt will be made to process the config file when the sl@0: //database is next opened sl@0: DoExecuteDbConfigFileOpsL(aFileData.Fs(), configFilePath, aDbName); sl@0: sl@0: //Now update the settings table to store the current version of the database config file. sl@0: //If this fails then another attempt will be made to process the config file and update sl@0: //the settings table when the database is next opened sl@0: TBuf buf; sl@0: buf.Format(KUpdateFileVersionSettingsSql(), &aDbName, aDbConfigFileVersion); sl@0: __SQLLEAVE_IF_ERROR(::DbExecStmt16(iDbHandle, buf)); sl@0: } sl@0: sl@0: /** sl@0: Opens the specified database configuration file and executes those operations that sl@0: are specified in it which are currently supported (currently only 'CREATE INDEX' sl@0: operations are supported and will be executed). sl@0: sl@0: @param aFs The server's file server session sl@0: @param aConfigFilePath The configuration file path sl@0: @param aDbName Logical database name: "main" for the main database or attached database name sl@0: sl@0: @leave KErrNoMemory, if an out of memory condition occurs. sl@0: One of the other system-wide error codes if the configuration sl@0: file fails to be opened or read sl@0: sl@0: @panic SqlDb 2 In _DEBUG mode if iDbHandle is NULL (uninitialized TSqlDbSysSettings object). sl@0: */ sl@0: void TSqlDbSysSettings::DoExecuteDbConfigFileOpsL(RFs& aFs, const TDesC& aConfigFilePath, const TDesC& aDbName) sl@0: { sl@0: __ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj)); sl@0: sl@0: //Open the config file and read it into a buffer sl@0: RFile64 file; sl@0: __SQLLEAVE_IF_ERROR(file.Open(aFs, aConfigFilePath, EFileRead)); sl@0: CleanupClosePushL(file); sl@0: TInt64 size = 0; sl@0: __SQLLEAVE_IF_ERROR(file.Size(size)); sl@0: if(size == 0) sl@0: { sl@0: //Config file is empty so just return sl@0: SQL_TRACE_INTERNALS(OstTraceExt1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_DOEXECUTEDBCONFIGFILEOPSL, "0;TSqlDbSysSettings::DoExecuteDbConfigFileOpsL();Config file %S is empty", __SQLPRNSTR(aConfigFilePath))); sl@0: CleanupStack::PopAndDestroy(); // file sl@0: return; sl@0: } sl@0: HBufC8* buffer = HBufC8::NewLC(size); sl@0: TPtr8 bufPtr = buffer->Des(); sl@0: __SQLLEAVE_IF_ERROR(file.Read(bufPtr)); sl@0: sl@0: //Convert buffer to Unicode for processing (the configuration file is expected to be ASCII or UTF-8) sl@0: HBufC16* buf16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(bufPtr); sl@0: CleanupStack::PushL(buf16); sl@0: TPtrC16 ptr16 = buf16->Des(); sl@0: sl@0: //Skip the BOM (byte ordering mark) at the start if there is one sl@0: if((ptr16.Locate(TChar(0xFEFF)) == 0) || (ptr16.Locate(TChar(0xFFFE)) == 0)) sl@0: { sl@0: ptr16.Set(ptr16.Mid(1)); sl@0: } sl@0: sl@0: //Parse the file contents and execute the specified sl@0: //config statements that are supported sl@0: ParseFileL(ptr16, aDbName); sl@0: sl@0: CleanupStack::PopAndDestroy(3); // buf16, buffer, file sl@0: } sl@0: sl@0: /** sl@0: Parses the configuration file buffer, reading each SQL statement sl@0: and processing it. sl@0: sl@0: @param aBuffer Buffer containing the configuration file contents sl@0: @param aDbName Logical database name: "main" for the main database or attached database name sl@0: sl@0: @leave KErrNoMemory, if an out of memory condition occurs sl@0: */ sl@0: void TSqlDbSysSettings::ParseFileL(const TDesC& aBuffer, const TDesC& aDbName) sl@0: { sl@0: TLex fileParser(aBuffer); sl@0: //While not end of file sl@0: while (!fileParser.Eos()) sl@0: { sl@0: //Get the next of the SQL statements, which are seperated by semicolons sl@0: fileParser.SkipSpaceAndMark(); // skip any preceding whitespace before the next statement sl@0: while ((!fileParser.Eos()) && (fileParser.Peek() != ';')) sl@0: { sl@0: fileParser.Inc(); // continue to next character sl@0: } sl@0: TPtrC stmt = fileParser.MarkedToken(); // extract the marked token sl@0: fileParser.Inc(); // to skip the terminating ';' for next iteration sl@0: sl@0: //Process this statement sl@0: ProcessStatementL(stmt, aDbName); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Process an SQL statement contained in the configuration file sl@0: and executes it if it is a supported statement. sl@0: Currently only 'CREATE INDEX' statements are supported. sl@0: The statement can contain comments that are understood by SQLite sl@0: - these can be in the form of an SQL comment or a 'C' comment, sl@0: as defined at http://www.sqlite.org/lang_comment.html. sl@0: sl@0: @param aStmt An SQL statement string, stripped of any whitespace sl@0: at the beginning of it sl@0: @param aDbName Logical database name: "main" for the main database or attached database name sl@0: sl@0: @leave KErrNoMemory, if an out of memory condition occurs sl@0: */ sl@0: void TSqlDbSysSettings::ProcessStatementL(const TDesC& aStmt, const TDesC& aDbName) sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_ENTRY, "Entry;0x%X;TSqlDbSysSettings::ProcessStatementL;Processing statement '%S'", (TUint)this, __SQLPRNSTR(aStmt))); sl@0: sl@0: //If the statement only contained whitespace then just return sl@0: if(aStmt.Length() == 0) sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT1, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains only whitespace", (TUint)this)); sl@0: return; sl@0: } sl@0: sl@0: //Check that the statement does not contain an unsupported comment style sl@0: if(KErrNotFound != aStmt.Find(_L("//"))) sl@0: { sl@0: //The statement contains '//' which is an unsupported comment style, but rather sl@0: //than leave here and cause the full file to fail, we just ignore this statement sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT2, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains invalid comment style", (TUint)this)); sl@0: return; sl@0: } sl@0: sl@0: HBufC* stmtBuf = HBufC::NewLC(aStmt.Length() + 1 + aDbName.Length() + 1); sl@0: TPtr stmtPtr = stmtBuf->Des(); sl@0: //If the 'aStmt' string is an SQL statement that is supported then execute it sl@0: if(::IsStatementSupported(aStmt, aDbName, stmtPtr)) sl@0: { sl@0: TInt err = ::DbExecStmt16(iDbHandle, stmtPtr); sl@0: if(KErrNone == err) sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL1, "0x%X;TSqlDbSysSettings::ProcessStatementL;Successfully executed statement", (TUint)this)); sl@0: } sl@0: else sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL2, "0x%X;TSqlDbSysSettings::ProcessStatementL;Failed to execute the statement;err=%d", (TUint)this, err)); sl@0: if(err == KErrNoMemory) sl@0: { sl@0: __SQLLEAVE(err); sl@0: } sl@0: } sl@0: } sl@0: else sl@0: { sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL3, "0x%X;TSqlDbSysSettings::ProcessStatementL;Non-supported statement, will be ignored", (TUint)this)); sl@0: } sl@0: CleanupStack::PopAndDestroy(); // stmtBuf sl@0: SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT3, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL", (TUint)this)); sl@0: } sl@0: sl@0: sl@0: /** sl@0: Stores the security policies into the security policies table. sl@0: sl@0: @param aSecurityPolicyCon Security policies container, which data needs to be persisted. sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred; sl@0: KErrArgument, system table name found in the list of the tables, which need special protection; sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes. sl@0: sl@0: @panic SqlDb 4 In _DEBUG mode if aSecurityPolicy argument is NULL. sl@0: */ sl@0: void TSqlDbSysSettings::StoreSecurityPoliciesL(const CSqlSecurityPolicy& aSecurityPolicyCon) sl@0: { sl@0: //Prepare the INSERT sql statement sl@0: sqlite3_stmt* stmtHandle = ::StmtPrepare8L(iDbHandle, KInsertSecuritySql()); sl@0: CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle)); sl@0: //Store default security policy into the table sl@0: StoreSecurityPolicyL(stmtHandle, KDefaultObjType, KNullDesC, KDefaultPolicyType, aSecurityPolicyCon.DefaultPolicy()); sl@0: //Store database security policies into the table sl@0: StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::ESchemaPolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy)); sl@0: StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::EReadPolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::EReadPolicy)); sl@0: StoreSecurityPolicyL(stmtHandle, KDbObjType, KNullDesC, RSqlSecurityPolicy::EWritePolicy, aSecurityPolicyCon.DbPolicy(RSqlSecurityPolicy::EWritePolicy)); sl@0: //Store database objects security policies into the table sl@0: TSqlSecurityPolicyIterator it(aSecurityPolicyCon); sl@0: RSqlSecurityPolicy::TObjectType objectType; sl@0: TPtrC objectName; sl@0: RSqlSecurityPolicy::TPolicyType policyType; sl@0: TSecurityPolicy policy; sl@0: while(it.Next(objectType, objectName, policyType, policy)) sl@0: { sl@0: if(objectType == RSqlSecurityPolicy::ETable && ::IsSystemTableName(objectName)) sl@0: { sl@0: //Clients are not allowed to put system table names in the RSqlSecurityPolicy container. sl@0: __SQLLEAVE(KErrArgument); sl@0: } sl@0: StoreSecurityPolicyL(stmtHandle, objectType, objectName, policyType, policy); sl@0: } sl@0: CleanupStack::PopAndDestroy();//cleanupItem (statement handle) sl@0: } sl@0: sl@0: /** sl@0: Stores a security policy object in the security policies table. sl@0: sl@0: @param aStmtHandle Statement handle. sl@0: @param aObjType Database object type: default security policies, database security policies, table security policies sl@0: @param aObjName Database object name. It is expected to be a non-empty string only for tables. sl@0: @param aPolicyType Security policy type: schema, write, read. sl@0: @param aPolicy Security policy object. sl@0: sl@0: @leave KErrNoMemory, an out of memory condition has occurred; sl@0: Note that the function may also leave with some other database specific sl@0: errors categorised as ESqlDbError, and other system-wide error codes. sl@0: sl@0: @panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL. sl@0: */ sl@0: void TSqlDbSysSettings::StoreSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt aObjType, const TDesC& aObjName, sl@0: TInt aPolicyType, const TSecurityPolicy& aPolicy) sl@0: { sl@0: __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument)); sl@0: __SQLLEAVE_IF_ERROR(::StmtReset(aStmtHandle)); sl@0: __SQLLEAVE_IF_ERROR(BindSecurityPolicyPrm(aStmtHandle, aObjType, aObjName, aPolicyType, aPolicy)); sl@0: __SQLLEAVE_IF_ERROR(::StmtExec(aStmtHandle)); sl@0: } sl@0: sl@0: /** sl@0: Binds the parameter values for the insert SQL statement for security policies table. sl@0: sl@0: @param aStmtHandle Statement handle. sl@0: @param aObjType Database object type: default security policy, database security policies, table security policies sl@0: @param aObjName Database object name. It is expected to be a non-empty string only for tables. sl@0: @param aPolicyType Security policy type: schema, write, read. sl@0: @param aPolicy Security policy object. sl@0: sl@0: @see TSqlDbSysSettings::StoreSecurityPolicyL() sl@0: sl@0: @panic SqlDb 4 In _DEBUG mode if aHandle argument is NULL. sl@0: */ sl@0: TInt TSqlDbSysSettings::BindSecurityPolicyPrm(sqlite3_stmt* aStmtHandle, TInt aObjType, const TDesC& aObjName, sl@0: TInt aPolicyType, const TSecurityPolicy& aPolicy) sl@0: { sl@0: (void)sqlite3SymbianLastOsError();//clear last OS error sl@0: TInt err = sqlite3_bind_int(aStmtHandle, KObjTypePrmIdx, aObjType); sl@0: if(err == SQLITE_OK) sl@0: { sl@0: err = sqlite3_bind_text16(aStmtHandle, KObjNamePrmIdx, aObjName.Ptr(), aObjName.Length() * sizeof(TText), SQLITE_STATIC); sl@0: if(err == SQLITE_OK) sl@0: { sl@0: err = sqlite3_bind_int(aStmtHandle, KObjPolicyTypePrmIdx, aPolicyType); sl@0: if(err == SQLITE_OK) sl@0: { sl@0: TPtrC8 policyData(aPolicy.Package()); sl@0: err = sqlite3_bind_blob(aStmtHandle, KObjPolicyDataPrmIdx, policyData.Ptr(), policyData.Length(), SQLITE_STATIC); sl@0: } sl@0: } sl@0: } sl@0: return ::Sql2OsErrCode(err, sqlite3SymbianLastOsError()); sl@0: } sl@0: sl@0: /** sl@0: Reads a record from security policies table. sl@0: sl@0: @param aStmtHandle Statement handle. It cannot be NULL. sl@0: @param aSecurityPolicy Security policies container. sl@0: @param aObjType Output parameter, will be initialized with the database object type: KDefaultObjType, sl@0: KDbObjType, RSqlSecurityPolicy::ETable. sl@0: @param aObjName Output parameter, database object name (for example, table name), which is protected by the sl@0: current security policy. sl@0: @param aPolicyType Output parameter, will be initialized with the database policy type: RSqlSecurityPolicy::EReadPolicy, sl@0: RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy. sl@0: @return The created security policy object. sl@0: sl@0: @leave KErrGeneral, invalid security policy data; sl@0: KErrNoMemory, Out of memory. sl@0: */ sl@0: TSecurityPolicy TSqlDbSysSettings::ReadCurrSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt& aObjType, sl@0: TPtrC& aObjName, TInt& aPolicyType) sl@0: { sl@0: __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument)); sl@0: aObjType = sqlite3_column_int(aStmtHandle, KObjTypeColIdx); sl@0: //The "ObjectName" column type might be different than SQLITE_TEXT - malformed database. sl@0: if(sqlite3_column_type(aStmtHandle, KObjNameColIdx) != SQLITE_TEXT) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: const void* text = sqlite3_column_text16(aStmtHandle, KObjNameColIdx); sl@0: //Null column value - this might be an indication of an "out of memory" problem, if the column text sl@0: //is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion) sl@0: __SQLLEAVE_IF_NULL(const_cast(text)); sl@0: TInt len = (TUint)sqlite3_column_bytes16(aStmtHandle, KObjNameColIdx) / sizeof(TUint16); sl@0: aObjName.Set(reinterpret_cast (text), len); sl@0: aPolicyType = sqlite3_column_int(aStmtHandle, KObjPolicyTypeColIdx); sl@0: len = sqlite3_column_bytes(aStmtHandle, KObjPolicyDataColIdx); sl@0: if(len != sizeof(TSecurityPolicy)) sl@0: { sl@0: //Check if the error is "out of memory" (which may happen when retrieving text column data sl@0: //and the column encoding is different, in which case the column text has to be converted sl@0: //and a new block of memory has to be allocated for the conversion). sl@0: TInt err2 = ::StmtReset(aStmtHandle); sl@0: __SQLLEAVE(err2 == KErrNoMemory ? KErrNoMemory : KErrGeneral); sl@0: } sl@0: const void* data = sqlite3_column_blob(aStmtHandle, KObjPolicyDataColIdx); sl@0: TSecurityPolicy policy; sl@0: policy.Set(TPtrC8(reinterpret_cast (data), len)); sl@0: return policy; sl@0: } sl@0: sl@0: /** sl@0: Stores the default security policy into aSecurityPolicyCon container. sl@0: Initialises all database security policies not set yet with the default security policy. sl@0: sl@0: @param aSecurityPolicyCon Security policies container. sl@0: @param aPolicy Default security policy object sl@0: @param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't. sl@0: sl@0: @see CSqlSecurityPolicy::SetDbPolicy() sl@0: */ sl@0: void TSqlDbSysSettings::StoreDefaultSecurityPolicy(CSqlSecurityPolicy& aSecurityPolicyCon, sl@0: const TSecurityPolicy& aPolicy, TInt aDbPolicySetFlag) sl@0: { sl@0: aSecurityPolicyCon.SetDefaultPolicy(aPolicy); sl@0: if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::ESchemaPolicy))) sl@0: { sl@0: aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, aPolicy); sl@0: } sl@0: if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::EReadPolicy))) sl@0: { sl@0: aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, aPolicy); sl@0: } sl@0: if(!(aDbPolicySetFlag & (1 << RSqlSecurityPolicy::EWritePolicy))) sl@0: { sl@0: aSecurityPolicyCon.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, aPolicy); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Stores a database security policy into aSecurityPolicyCon container. sl@0: sl@0: @param aSecurityPolicyCon Security policies container. sl@0: @param aPolicyType Database policy type: RSqlSecurityPolicy::EReadPolicy, sl@0: RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy. sl@0: @param aPolicy Database security policy object sl@0: @param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't. sl@0: The parameter value may change if some of the database policies are set by sl@0: StoreDbSecurityPolicyL(). sl@0: sl@0: @leave KErrGeneral Invalid security policy type or the corresponding database security policy has been set already. sl@0: */ sl@0: void TSqlDbSysSettings::StoreDbSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon, TInt aPolicyType, sl@0: const TSecurityPolicy& aPolicy, TInt& aDbPolicySetFlag) sl@0: { sl@0: if(aPolicyType < (TInt)RSqlSecurityPolicy::ESchemaPolicy || aPolicyType > (TInt)RSqlSecurityPolicy::EWritePolicy) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: if(aDbPolicySetFlag & (1 << aPolicyType)) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: aSecurityPolicyCon.SetDbPolicy(static_cast (aPolicyType), aPolicy); sl@0: aDbPolicySetFlag |= (1 << aPolicyType); sl@0: } sl@0: sl@0: /** sl@0: Stores a database object security policy into aSecurityPolicyCon container. sl@0: sl@0: @param aSecurityPolicyCon Security policies container. sl@0: @param aObjType Database object type: RSqlSecurityPolicy::ETable. sl@0: @param aObjName Database object name (for example, table name), which is protected by the current security policy. sl@0: @param aPolicyType Database policy type: RSqlSecurityPolicy::EReadPolicy, sl@0: RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy. sl@0: @param aPolicy Database security policy object sl@0: @param aDbPolicySetFlag Bit flag. Keeps information which database security policies are set and which aren't. sl@0: The parameter value may change if some of the database policies are set by sl@0: StoreDbSecurityPolicyL(). sl@0: sl@0: @leave KErrGeneral Invalid security policy type or invalid database object name length. sl@0: */ sl@0: void TSqlDbSysSettings::StoreDbObjSecurityPolicyL(CSqlSecurityPolicy& aSecurityPolicyCon, sl@0: TInt aObjType, const TDesC& aObjName, sl@0: TInt aPolicyType, const TSecurityPolicy& aPolicy) sl@0: { sl@0: if(aPolicyType < (TInt)RSqlSecurityPolicy::EReadPolicy || aPolicyType > (TInt)RSqlSecurityPolicy::EWritePolicy) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: if(aObjName.Length() < 1) sl@0: { sl@0: __SQLLEAVE(KErrGeneral); sl@0: } sl@0: __SQLLEAVE_IF_ERROR(aSecurityPolicyCon.SetPolicy(static_cast (aObjType), sl@0: aObjName, static_cast (aPolicyType), aPolicy)); sl@0: } sl@0: sl@0: /** sl@0: Returns true if settigns table exists. sl@0: (Non-secure databases prior version 3 don't have settings table) sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name. sl@0: */ sl@0: TBool TSqlDbSysSettings::SettingsTableExistsL(const TDesC& aDbName) sl@0: { sl@0: HBufC* buf = HBufC::NewLC(sizeof(KSettingsTableCheckSql) + aDbName.Length()); sl@0: TPtr sql = buf->Des(); sl@0: sql.Format(KSettingsTableCheckSql(), &aDbName); sl@0: sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql); sl@0: CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle)); sl@0: TInt rc = ::StmtNext(stmtHandle); sl@0: CleanupStack::PopAndDestroy();//cleanupItem (statement handle) sl@0: CleanupStack::PopAndDestroy(buf); sl@0: __SQLLEAVE_IF_ERROR(rc); sl@0: return rc == KSqlAtRow; sl@0: } sl@0: sl@0: /** sl@0: Returns true if at least one index using aCollationName exists. sl@0: sl@0: @param aDbName Logical database name: "main" for the main database or attached database name, sl@0: @param aCollationName SQLITE collation name. sl@0: */ sl@0: TBool TSqlDbSysSettings::IndexExistsL(const TDesC& aDbName, const TDesC& aCollationName) sl@0: { sl@0: //KGetIndexSql will contain '%%' search pattern, while Symbian OS search patterns use '*' symbol by default. sl@0: //This time the '%' is OK because the serach is performed in the SQLITE master table and before installing the sl@0: //user-defined Like() function. sl@0: HBufC* buf = HBufC::NewLC(sizeof(KGetIndexSql) + aDbName.Length() + aCollationName.Length()); sl@0: TPtr sql = buf->Des(); sl@0: sql.Format(KGetIndexSql(), &aDbName, &aCollationName); sl@0: sqlite3_stmt* stmtHandle = ::StmtPrepare16L(iDbHandle, sql); sl@0: CleanupStack::PushL(TCleanupItem(&FinalizeStatementHandle, stmtHandle)); sl@0: TInt rc = ::StmtNext(stmtHandle); sl@0: CleanupStack::PopAndDestroy(2);//buf, cleanupItem (statement handle) sl@0: __SQLLEAVE_IF_ERROR(rc); sl@0: return rc == KSqlAtRow; sl@0: }