diff -r aba6b8104af3 -r 84a16765cd86 installationservices/swcomponentregistry/source/server/scrrequestimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/installationservices/swcomponentregistry/source/server/scrrequestimpl.cpp Fri Mar 19 09:33:35 2010 +0200 @@ -0,0 +1,3232 @@ +/* +* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Defines the class which implements SCR's service requests. +* +*/ + + +/** + @file + @internalComponent + @released +*/ + +#include "scrrequestimpl.h" +#include "scrdatabase.h" +#include "screntries.h" +#include "scrserver.h" +#include "scrcommon.h" +#include "scrsubsession.h" +#include "usiflog.h" +#include "usiferror.h" +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace Usif; + +_LIT(KComponentIdColumnName, "ComponentId"); +_LIT(KCompFileIdColumnName, "CmpFileId"); +_LIT(KComponentPropertiesTable, "ComponentProperties"); +_LIT(KFilePropertiesTable, "FileProperties"); + +/** Maximum number of log records could be recorded by SCR. */ +// It is estimated that a thousand log entries create 40K-100K log file. +const TInt KMaxScrLogEntries = 1000; +/** The file path of SCR log file. */ +_LIT(KScrLogFileName, "!:\\private\\10285bc0\\scr.log"); +/** The file path of SCR temporary log file. */ +_LIT(KScrTempLogFileName, "!:\\private\\10285bc0\\scr_tmp.log"); + +const TUint KDbInterfaceMajorVersion = 1; +const TUint KDbInterfaceMinorVersion = 1; +#ifdef _DEBUG +const TUint KDbInterfaceBuildNumber = 1; +#endif + +enum TScrPanicId + { + KScrIllegalCallSequence = 1, + KScrIllegalParameter = 2 + }; + +static void PanicClient(const RMessagePtr2& aMessage, TScrPanicId aPanic) + { + _LIT(KPanicMessage, "ScrServer"); + aMessage.Panic(KPanicMessage, aPanic); + } + +HBufC* UpdateFilePathDriveLC(const TDesC& aFilePath, TChar aDrive) + { + HBufC *fileName = HBufC::NewLC(aFilePath.Length()); + TPtr ptrFileName(fileName->Des()); + ptrFileName.Copy(aFilePath); + ptrFileName[0] = aDrive; + return fileName; + } + +//////////////////////// +// CScrRequestImpl +//////////////////////// + +CScrRequestImpl::CScrRequestImpl(RFs& aFs) + : iFs(aFs) + { + } + +CScrRequestImpl::~CScrRequestImpl() + { + delete iDbHandle; + delete iComponentEntry; + iProperties.ResetAndDestroy(); + delete iSingleProperty; + iFileComponents.Close(); + iVerCompIdList.ResetAndDestroy(); + iDeletedMimeTypes.ResetAndDestroy(); + iLogEntries.ResetAndDestroy(); + iMatchingSupportedLanguageList.Close(); + } + +CScrRequestImpl* CScrRequestImpl::CScrRequestImpl::NewL(RFs& aFs, RFile& aDatabaseFile, RFile& aJournalFile) + { + CScrRequestImpl *self = new(ELeave) CScrRequestImpl(aFs); + CleanupStack::PushL(self); + self->ConstructL(aDatabaseFile, aJournalFile); + CleanupStack::Pop(self); + return self; + } + +void CScrRequestImpl::ConstructL(RFile& aDatabaseFile, RFile& aJournalFile) + { + iDbHandle = CDatabase::NewL(aDatabaseFile, aJournalFile); + InitializeDbVersionL(); + VerifyDbVersionCompatibilityL(); + // Make sure that private directory exists - required for temporary and log files + _LIT(KPrivateDirPath, "!:\\private\\10285bc0\\"); + HBufC* privateDirPath = UpdateFilePathDriveLC(KPrivateDirPath, iFs.GetSystemDriveChar()); + TInt res = iFs.MkDirAll(*privateDirPath); + __ASSERT_ALWAYS(res == KErrNone || res == KErrAlreadyExists, User::Leave(res)); + CleanupStack::PopAndDestroy(privateDirPath); + } + +HBufC* CScrRequestImpl::ReadDescLC(const RMessage2& aMessage, TInt aSlot) + { + TInt len = aMessage.GetDesLengthL(aSlot); + HBufC* desc = HBufC::NewLC(len); + TPtr ptrDesc(desc->Des()); + aMessage.ReadL(aSlot, ptrDesc); + return desc; + } + +HBufC8* CScrRequestImpl::ReadDesc8LC(const RMessage2& aMessage, TInt aSlot) + { + TInt len = aMessage.GetDesLengthL(aSlot); + HBufC8* desc = HBufC8::NewLC(len); + TPtr8 ptrDesc(desc->Des()); + aMessage.ReadL(aSlot, ptrDesc); + return desc; + } + +HBufC* CScrRequestImpl::FormatStatementLC(const TDesC& aStatement, TInt aFormattedLength,...) const + { + VA_LIST list; + VA_START(list, aFormattedLength); + HBufC* statementStr = HBufC::NewLC(aStatement.Length() + aFormattedLength + 1); + TPtr statementStrPtr(statementStr->Des()); + statementStrPtr.FormatList(aStatement, list); + VA_END(list); + + // SQLite requires the statement string to end with NULL char. + statementStrPtr.Append('\0'); + return statementStr; + } + +void CScrRequestImpl::CreateTransactionL() + { + DEBUG_PRINTF(_L8("Create Transaction request received.")); + _LIT(KBeginTransaction, "BEGIN IMMEDIATE;"); + ExecuteStatementL(KBeginTransaction()); + DEBUG_PRINTF(_L8("Transaction has begun!")); + } + +void CScrRequestImpl::RollbackTransactionL() + { + DEBUG_PRINTF(_L8("Rollback Transaction request received.")); + _LIT(KRollbackTransaction, "ROLLBACK;"); + ExecuteStatementL(KRollbackTransaction()); + DEBUG_PRINTF(_L8("Transaction has been rolled back successfuly!")); + } + +void CScrRequestImpl::CommitTransactionL() + { + DEBUG_PRINTF(_L8("Commit Transaction request received.")); + _LIT(KCommitTransaction, "COMMIT;"); + ExecuteStatementL(KCommitTransaction()); + DEBUG_PRINTF(_L8("Transaction has been committed successfully!")); + } + +HBufC* CScrRequestImpl::GenerateGlobalIdL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId) const + { + HBufC *globalIdBuf = HBufC::NewL(aUniqueSwTypeName.Length() + aGlobalId.Length() + 1); // 1 is extra memory to put NULL char + TPtr globalIdDes(globalIdBuf->Des()); + + globalIdDes.Copy(aUniqueSwTypeName); + globalIdDes.Append('\0'); + globalIdDes.Append(aGlobalId); + + return globalIdBuf; + } + +TComponentId CScrRequestImpl::CommonAddComponentL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId) + { + DEBUG_PRINTF(_L8("Adding a base component.")); + // Get the current time + TTime time; + time.HomeTime(); + TDateTime datetime = time.DateTime(); + TBuf<16> installTime; + // We cannot use TTime::FormatL, since it starts months and days with 01, which is not accepted by TTime::Set() which starts them from 0 + installTime.Format(_L("%04d%02d%02d:%02d%02d%02d"), datetime.Year(), datetime.Month(), datetime.Day(), datetime.Hour(), datetime.Minute(), datetime.Second()); + + // SoftwareTypeId is the hash of unique software type name. For more information, see CScrRequestImpl::AddSoftwareTypeL. + // In Components table, both SoftwareTypeId and unique SoftwareTypeName is stored so that the software type name of a component + // can be returned even if the corresponding installer (software type) has been uninstalled. The unique sofware type name + // might be used by the client to identify the installer required to uninstall the component. + TUint32 swTypeId = HashCaseSensitiveL(aUniqueSwTypeName); + + if(aGlobalId.CompareF(KNullDesC())) + { // Global Id is supplied by client + HBufC *globalId = GenerateGlobalIdL(aUniqueSwTypeName, aGlobalId); + CleanupStack::PushL(globalId); + TUint32 globalIdHash = HashCaseSensitiveL(*globalId); + + _LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,GlobalIdHash,GlobalId,InstallTime) VALUES(?,?,?,?,?);"); + TInt numberOfValues = 5; + ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueInteger, globalIdHash, EValueString, globalId, EValueString, &installTime); + CleanupStack::PopAndDestroy(globalId); + } + else + {// Global Id is NOT supplied by client + _LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,InstallTime) VALUES(?,?,?);"); + TInt numberOfValues = 3; + ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueString, &installTime); + } + + DEBUG_PRINTF(_L8("The new component has been added to Components table successfully.")); + return iDbHandle->LastInsertedIdL(); + } + +void CScrRequestImpl::AddComponentLocalizablesL(TComponentId aCompId, TLanguage aLocale, const TDesC& aName, const TDesC& aVendor) + { + DEBUG_PRINTF4(_L("Adding the component(%d) localizables: name(%S) and vendor(%S)."), aCompId, &aName, &aVendor); + + if(!aName.CompareF(KNullDesC())) + {// Component name cannot be empty + DEBUG_PRINTF(_L8("Component name cannot be NULL string.")); + User::Leave(KErrArgument); + } + + _LIT(KInsertComponentLocalizables, "INSERT INTO ComponentLocalizables(ComponentId,Locale,Name,Vendor) VALUES(?,?,?,?);"); + TInt numberOfValues = 4; + ExecuteStatementL(KInsertComponentLocalizables(), numberOfValues, EValueInteger, aCompId, EValueInteger, aLocale, EValueString, &aName, EValueString, &aVendor); + + DEBUG_PRINTF(_L8("The component localizables have been added successfully.")); + } + +void CScrRequestImpl::ComponentRollback(TAny* aParam) + { + TRollbackParams *param = static_cast(aParam); + _LIT(KDeleteComponents, "DELETE FROM Components WHERE ComponentId=?;"); + TInt numberOfValues = 1; + TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponents, numberOfValues, EValueInteger, param->iIdColumnVal);); + } + +void CScrRequestImpl::ComponentLocalizablesRollback(TAny* aParam) + { + TRollbackParams *param = static_cast(aParam); + _LIT(KDeleteComponentLocalizables, "DELETE FROM ComponentLocalizables WHERE ComponentId=?;"); + TInt numberOfValues = 1; + TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponentLocalizables, numberOfValues, EValueInteger, param->iIdColumnVal);); + } + +void CScrRequestImpl::AddComponentL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Adding a new component.")); + // First check if the supplied operation type is valid + TScrComponentOperationType compOpType; + TPckg opTypePckg(compOpType); + aMessage.ReadL(3, opTypePckg, 0); + + if(compOpType != EScrCompInstall && compOpType != EScrCompUpgrade && compOpType != EScrCompHidden) + { + DEBUG_PRINTF2(_L("Unexpected component operation type (%d) was provided!"), static_cast(compOpType)); + User::Leave(KErrArgument); + } + + RIpcReadStream componentInfoReader; + CleanupClosePushL(componentInfoReader); + componentInfoReader.Open(aMessage, 1); + + RPointerArray componentInfoArray; + CleanupResetAndDestroyPushL(componentInfoArray); + InternalizePointersArrayL(componentInfoArray, componentInfoReader); + TInt arrayCount = componentInfoArray.Count(); + // This check is done at the client side - if we get this condition here, this means that a rogue client-server call bypassed the R-class + __ASSERT_ALWAYS(arrayCount > 0, PanicClient(aMessage, KScrIllegalParameter)); + + HBufC *uniqueSwTypeName = GetSoftwareTypeNameFromMsgLC(aMessage); + HBufC *globalId = ReadDescLC(aMessage, 2); + TComponentId newComponentId = CommonAddComponentL(*uniqueSwTypeName, *globalId); + + // Add the newly added component into the cleanupstack so that it can be deleted in case of leaving. + TRollbackParams cleanupParam(newComponentId, *this); + CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentRollback, &cleanupParam)); + // Add the component localizables cleanup into the cleanupstack so that they can be deleted in case of leaving. + CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentLocalizablesRollback, &cleanupParam)); + + // For a log record, the component name is chosen for the current locale. If it doesn't exist, + // then the non-localized component name is picked. If none of them exist, the first name in the names + // array is used as default. + TInt componentNameIndexForLog (0); + TInt indexForCurrentLocale = KErrNotFound; + TInt indexForNonLocalized = KErrNotFound; + for(TInt i=0; iLocale()); + const TDesC& name = componentInfoArray[i]->NameL(); + const TDesC& vendor = componentInfoArray[i]->VendorL(); + AddComponentLocalizablesL(newComponentId, locale, name, vendor); + if(locale == User::Language()) + indexForCurrentLocale = i; + else if(locale == KNonLocalized) + indexForNonLocalized = i; + } + CleanupStack::Pop(2, &cleanupParam); // cleanupitem for ComponentRollback, cleanupitem for ComponentLocalizablesRollback + + if(indexForCurrentLocale != KErrNotFound) + componentNameIndexForLog = indexForCurrentLocale; + else if(indexForNonLocalized != KErrNotFound) + componentNameIndexForLog = indexForNonLocalized; + + if(EScrCompHidden != compOpType) + { + CScrLogEntry *logRecord = CScrLogEntry::NewLC(componentInfoArray[componentNameIndexForLog]->NameL(), *uniqueSwTypeName, *globalId, KNullDesC, compOpType); + logRecord->iComponentId = newComponentId; + iLogEntries.Append(logRecord); + CleanupStack::Pop(logRecord); // Ownershipd is transferred + } + CleanupStack::PopAndDestroy(4, &componentInfoReader); // componentInfoReader, componentInfoArray, uniqueSwTypeName, globalId + + TPckg componentIdDes(newComponentId); + aMessage.WriteL(3, componentIdDes); + } + +HBufC* CScrRequestImpl::ReadAndGetGlobalIdLC(const RMessage2& aMessage, TInt aSlot) const + { + // Read global id object from the message + CGlobalComponentId *globalId = ReadObjectFromMessageLC(aMessage, aSlot); + HBufC *globalIdBuf = GenerateGlobalIdL(globalId->SoftwareTypeName(), globalId->GlobalIdName()); + CleanupStack::PopAndDestroy(globalId); + CleanupStack::PushL(globalIdBuf); + return globalIdBuf; + } + +TUint32 CScrRequestImpl::HashGlobalIdsL(const TDesC& aDependantId, const TDesC& aSupplierId) const + { + RBuf concatGlobalIds; + concatGlobalIds.CreateL(aDependantId.Length() + aSupplierId.Length()); + concatGlobalIds.CleanupClosePushL(); + concatGlobalIds.Copy(aDependantId); + concatGlobalIds.Append(aSupplierId); + TUint32 globalIdsHash = HashCaseSensitiveL(concatGlobalIds); + CleanupStack::PopAndDestroy(&concatGlobalIds); + return globalIdsHash; + } + +void CScrRequestImpl::AddComponentDependencyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Adding a new component dependency.")); + + CVersionedComponentId *verCompId = ReadObjectFromMessageLC(aMessage, 1); + HBufC *suppGlobalId = GenerateGlobalIdL(verCompId->GlobalId().SoftwareTypeName(), verCompId->GlobalId().GlobalIdName()); + CleanupStack::PushL(suppGlobalId); + TUint32 suppGlobalIdHash = HashCaseSensitiveL(*suppGlobalId); + + HBufC *depGlobalId = ReadAndGetGlobalIdLC(aMessage, 2); + TUint32 depGlobalIdHash = HashCaseSensitiveL(*depGlobalId); + + TUint32 globalIdsHash = HashGlobalIdsL(*depGlobalId, *suppGlobalId); + + const TDesC* versionFrom = verCompId->VersionFrom(); + const TDesC* versionTo = verCompId->VersionTo(); + + _LIT(KInsertDependencyFront, "INSERT INTO ComponentDependencies(GlobalIdHash,DependantGlobalIdHash,SupplierGlobalIdHash,DependantGlobalId,SupplierGlobalId"); + _LIT(KInsertDependencyEnd, ") VALUES(?,?,?,?,?"); + + const TInt KMaxInsertDependencyLength = 180; ///< Maximum length of a possible dependency insert statement (KInsertDependencyFront + KInsertDependencyEnd + some space for optional columns) + const TInt KMaxInsertDependencyValueLength = 30; ///< Maximum length of the end part of a possible dependency insert statement (KInsertDependencyEnd + some space for optional values). + + TInt numberOfValues = 5; // 5->(GlobalIdHash, DependantGlobalIdHash, SupplierGlobalIdHash, DependantGlobalId, SupplierGlobalId) + RBuf insertStmtStr; + insertStmtStr.CreateL(KMaxInsertDependencyLength); + insertStmtStr.CleanupClosePushL(); + insertStmtStr.Copy(KInsertDependencyFront()); + + RBuf insertStmtEndStr; + insertStmtEndStr.CreateL(KMaxInsertDependencyValueLength); + insertStmtEndStr.CleanupClosePushL(); + insertStmtEndStr.Copy(KInsertDependencyEnd()); + + // VersionFrom and VersionTo values are optional. Hence, a dynamic insert statement will be created. + // insertStmtStr is initialized with the statement including mandatory columns. Then versionFrom/To + // values are checked. If any of them is provided, then the corresponding column name is added to the statement. + // insertStmtEndStr is constructed with a number of value characters(?) as new value chars will be added + // if new columns are added to the statement + // In the end, insertStmtEndStr is added to insertStmtStr in order to complete the dependency insert statement. + + const TDesC* firstVersionParam(0); + const TDesC* secondVersionParam(0); + + _LIT(KInsertValue, ",?"); + if(versionFrom) + { + _LIT(KVersionFrom, ",VersionFrom"); + insertStmtStr.Append(KVersionFrom()); + insertStmtEndStr.Append(KInsertValue()); + firstVersionParam = versionFrom; + ++numberOfValues; + } + + if(versionTo) + { + _LIT(KVersionTo, ",VersionTo"); + insertStmtStr.Append(KVersionTo()); + insertStmtEndStr.Append(KInsertValue()); + if(firstVersionParam) + { + secondVersionParam = versionTo; + } + else + { + firstVersionParam = versionTo; + } + ++numberOfValues; + } + + // Append the end part of the statement to the front part. + insertStmtStr.Append(insertStmtEndStr); + // Close the statement + _LIT(KInsertClose,");"); + insertStmtStr.Append(KInsertClose()); + // SQLite requires the statement string to end with NULL char. + insertStmtStr.Append('\0'); + // All parameters are supplied, but numberOfValues of them will be taken into account. + ExecuteStatementL(insertStmtStr, numberOfValues, EValueInteger, globalIdsHash, EValueInteger, depGlobalIdHash, EValueInteger, suppGlobalIdHash, EValueString, depGlobalId, EValueString, suppGlobalId, EValueString, firstVersionParam, EValueString, secondVersionParam); + + CleanupStack::PopAndDestroy(5, verCompId); // verCompId, suppGlobalId, depGlobalId, insertStmtStr, insertStmtEndStr + } + +CStatement* CScrRequestImpl::CreateGeneralPropertyStatementWithLocaleL(const TDesC& aStmtStr, TInt aIdColumnValue, TLanguage aLocale, const TDesC& aPropName, TBool aDoLocaleResolving) const + { + CStatement *stmt(0); + TInt numberOfValues = 3; + + if(KUnspecifiedLocale == aLocale) + { + // No locale is specified. Client wants SCR to find the property automatically. + // So, first look up the properties for the current locale and its downgraded languages. + ASSERT(aDoLocaleResolving); // We cannot get a situation where KUnspecifiedLocale is given with locale resolving disabled: it is an undefined state. + stmt = CreateStatementObjectWithLocaleL(aStmtStr, User::Language(), numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage); + + if(!stmt) + { + // No property is defined with the current locale. Look up the non-localized properties. + stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage); + } + } + else if(KNonLocalized == aLocale) + { + // Non-localized properties are requested. Look up the non-localized properties. + stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage); + } + else + { + // A particular language is specified. Look up the properties with for this particular language + // and its downgraded languages. + stmt = aDoLocaleResolving ? + CreateStatementObjectWithLocaleL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving) : + CreateStatementObjectWithLocaleNoDowngradeL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving); + } + return stmt; + } + +TInt CScrRequestImpl::FindGeneralPropertyNoLocaleDowngradeL(const TDesC& aTableName, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropertyName, TLanguage aLocale, TPropertyType& aPropertyType) const + { + _LIT(KFindProperty, "SELECT PropertyId,IntValue,StrValue,IsStr8Bit FROM %S WHERE Name=? AND %S=? AND Locale=?;"); + TInt formattedLen = aTableName.Length() + aIdColumnName.Length(); + HBufC *statementStr = FormatStatementLC(KFindProperty(), formattedLen, &aTableName, &aIdColumnName); + + // As we do not require downgrading locales, the last parameter is EFalse + CStatement *stmtFind = CreateGeneralPropertyStatementWithLocaleL(*statementStr, aIdColumnValue, aLocale, aPropertyName, EFalse); + if(!stmtFind) + { // the property does not exist, return + CleanupStack::PopAndDestroy(statementStr); + return KErrNotFound; + } + CleanupStack::PushL(stmtFind); + + // the property in question exists in the properties table + TInt propertyId = stmtFind->IntColumnL(0); // 0 -> PropertyId + TBool isIntPropertyNull = stmtFind->IsFieldNullL(1); // 2 -> IntValue + TBool isStrPropertyNull = stmtFind->IsFieldNullL(2); // 3 -> StrValue + + if(!isIntPropertyNull) + { + aPropertyType = CScrRequestImpl::EPropertyInteger; + } + else if(!isStrPropertyNull) + { + TBool is8BitString = (stmtFind->IntColumnL(3) == 1); + aPropertyType = is8BitString ? CScrRequestImpl::EPropertyBinary : CScrRequestImpl::EPropertyLocalizable; + } + else // None of the columns is defined - corrupt DB + { + DEBUG_PRINTF(_L8("Unexpected situation! Neither int value nor str value are defined for a property")); + User::Leave(KErrCorrupt); + } + CleanupStack::PopAndDestroy(2, statementStr); // stmtFind, statementStr + return propertyId; + } + +void CScrRequestImpl::BindStatementValuesL(CStatement& aStatement, TLanguage aLanguage, TInt aValuesNum, VA_LIST aList) const + { + TInt bindIdx(0); + while(aValuesNum--) + { + CScrRequestImpl::TValueType t = static_cast(VA_ARG(aList, TInt)); + switch(t) + { + case EValueString: + { + const TDesC* strVal = VA_ARG(aList, const TDesC*); + aStatement.BindStrL(++bindIdx, *strVal); + break; + } + case EValueInteger: + { + TInt intVal = VA_ARG(aList, TInt); + aStatement.BindIntL(++bindIdx, intVal); + break; + } + case EValueInteger64: + { + TInt64 intVal64 = VA_ARG(aList, TInt64); + aStatement.BindInt64L(++bindIdx, intVal64); + break; + } + case EValueLanguage: + { + aStatement.BindIntL(++bindIdx, aLanguage); + break; + } + case EValueBinary: + { + const TDesC8* binaryVal = VA_ARG(aList, const TDesC8*); + aStatement.BindBinaryL(++bindIdx, *binaryVal); + break; + } + default: + DEBUG_PRINTF2(_L8("Encountered unexpected value type (%d)!"), t); + ASSERT(0); + } // switch + } // while + } // End of the function + +void CScrRequestImpl::ExecuteStatementL(TRefByValue aStatement, TInt aValuesNum,...) + {// TRefByValue is used to suppress rcvt compile warning + VA_LIST argList; + VA_START(argList, aValuesNum); + + CStatement *stmt = iDbHandle->PrepareStatementLC(aStatement); + BindStatementValuesL(*stmt, KLangNone, aValuesNum, argList); + stmt->ExecuteStatementL(); + CleanupStack::PopAndDestroy(stmt); + + VA_END(argList); + } + +void CScrRequestImpl::SetGeneralLocalizablePropertyL(CScrRequestImpl::TPropertyType aPropType, TInt aPropertyId, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropName, TLanguage aLocale, const TDesC& aPropValue) + { + switch(aPropType) + { + case CScrRequestImpl::EPropertyUndefined: + {// the property does NOT exist, insert a new one + _LIT(KInsertProperty, "INSERT INTO ComponentProperties(Name,Locale,%S,StrValue) VALUES(?,?,?,?);"); + TInt formattedLen = aIdColumnName.Length(); + HBufC *statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aIdColumnName ); + TInt numberOfValues = 4; + ExecuteStatementL(*statementStr, numberOfValues, EValueString, &aPropName, EValueInteger, aLocale, EValueInteger, aIdColumnValue, EValueString, &aPropValue); + CleanupStack::PopAndDestroy(statementStr); + break; + } + case CScrRequestImpl::EPropertyLocalizable: + { + // the property exists, update it + _LIT(KUpdateProperty, "UPDATE ComponentProperties SET StrValue=? WHERE PropertyId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KUpdateProperty(), numberOfValues, EValueString, &aPropValue, EValueInteger, aPropertyId); + break; + } + default: + DEBUG_PRINTF(_L8("The property type isn't localizable string and cannot be updated with this API.")) + User::Leave(KErrAbort); + } + } + +void CScrRequestImpl::SetGeneralBinaryPropertyL(CScrRequestImpl::TPropertyType aPropType, TInt aPropertyId, const TDesC& aTableName, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropName, const TDesC8& aPropValue) + { + switch(aPropType) + { + case CScrRequestImpl::EPropertyUndefined: + {// the property does NOT exist, insert a new one + _LIT(KInsertProperty, "INSERT INTO %S(Name,%S,StrValue,IsStr8Bit) VALUES(?,?,?,1);"); + TInt formattedLen = aTableName.Length() + aIdColumnName.Length(); + HBufC *statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aTableName, &aIdColumnName ); + TInt numberOfValues = 3; + ExecuteStatementL(*statementStr, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueBinary, &aPropValue); + CleanupStack::PopAndDestroy(statementStr); + break; + } + case CScrRequestImpl::EPropertyBinary: + { + // the property exists, update it + _LIT(KUpdateProperty, "UPDATE %S SET StrValue=? WHERE PropertyId=?;"); + HBufC *statementStr = FormatStatementLC(KUpdateProperty(), aTableName.Length(), &aTableName); + TInt numberOfValues = 2; + ExecuteStatementL(*statementStr, numberOfValues, EValueBinary, &aPropValue, EValueInteger, aPropertyId); + CleanupStack::PopAndDestroy(statementStr); + break; + } + default: + DEBUG_PRINTF(_L8("The property type isn't an 8-bit string and cannot be updated with this API.")) + User::Leave(KErrAbort); + } + } + +void CScrRequestImpl::SetGeneralIntPropertyL(TPropertyType aPropType, TInt aPropertyId, const TDesC& aTableName, const TDesC& aIdColumnName , TInt aIdColumnValue, const TDesC& aPropName, TInt64 aPropValue) + { + switch(aPropType) + { + case CScrRequestImpl::EPropertyUndefined: + {// the property does NOT exist, insert a new one + _LIT(KInsertProperty, "INSERT INTO %S(Name,%S,IntValue) VALUES(?,?,?)"); + TInt formattedLen = aTableName.Length() + aIdColumnName.Length(); + HBufC* statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aTableName, &aIdColumnName ); + TInt numberOfValues = 3; + ExecuteStatementL(*statementStr, numberOfValues,EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueInteger64, aPropValue); + CleanupStack::PopAndDestroy(statementStr); + break; + } + case CScrRequestImpl::EPropertyInteger: + {// the property exists, update it + _LIT(KUpdateProperty, "UPDATE %S SET IntValue=? WHERE PropertyId=?;"); + HBufC *statementStr = FormatStatementLC(KUpdateProperty(), aTableName.Length(), &aTableName); + TInt numberOfValues = 2; + ExecuteStatementL(*statementStr, numberOfValues, EValueInteger64, aPropValue, EValueInteger, aPropertyId); + CleanupStack::PopAndDestroy(statementStr); + break; + } + default: + DEBUG_PRINTF(_L8("The property type isn't integer and cannot be updated with this API.")); + User::Leave(KErrAbort); + } + } + +template void VerifySetPropertyParamsL(HBufC* aPropName, A* aPropValue) + { + if (!aPropName || !aPropValue) + User::Leave(KErrArgument); + } + +void CScrRequestImpl::SetComponentLocalizablePropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting component string property.")); + // N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode. + HBufC *propName = ReadDescLC(aMessage, 1); + HBufC *propValue = ReadDescLC(aMessage, 2); + VerifySetPropertyParamsL(propName, propValue); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TLanguage locale = TLanguage(aMessage.Int3()); + + CScrRequestImpl::TPropertyType propType(CScrRequestImpl::EPropertyUndefined); + // The function name states that we don't want automatic locale resolving. If, e.g. we set a property for ELangAmerican, we don't want FindGeneralProperty to match existing value for ELangEnglish + TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, locale, propType); + SetGeneralLocalizablePropertyL(propType, propertyId, KComponentIdColumnName(), componentId, *propName, locale, *propValue); + CleanupStack::PopAndDestroy(2, propName); + } + +void CScrRequestImpl::SetComponentBinaryPropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting component binary property.")); + // N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode. + HBufC *propName = ReadDescLC(aMessage, 1); + HBufC8 *propValue = ReadDesc8LC(aMessage, 2); + + VerifySetPropertyParamsL(propName, propValue); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + + CScrRequestImpl::TPropertyType propType(CScrRequestImpl::EPropertyUndefined); + TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, KLangNone, propType); + SetGeneralBinaryPropertyL(propType, propertyId, KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, *propValue); + CleanupStack::PopAndDestroy(2, propName); + } + +void CScrRequestImpl::SetComponentIntPropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting component integer property.")); + // N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode. + HBufC* propName = ReadDescLC(aMessage, 1); + + if (!propName) + User::Leave(KErrArgument); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TInt64 propValue = MAKE_TINT64(aMessage.Int2(), aMessage.Int3()); + + TPropertyType propType(CScrRequestImpl::EPropertyUndefined); + TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, KLangNone, propType); + SetGeneralIntPropertyL(propType, propertyId, KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, propValue); + CleanupStack::PopAndDestroy(propName); + } + +TUint32 CScrRequestImpl::HashCaseInsensitiveL(const TDesC& aName) + { + RBuf temp; + temp.CreateMaxL(aName.Length()); + temp.CleanupClosePushL(); + temp.Copy(aName); + temp.LowerCase(); // The hashed column is case-insensitive. So, the hashed value must be + // case-insensitive too. To achieve that we need to set to lower-case. + TUint32 hashVal = HashCaseSensitiveL(temp); + CleanupStack::PopAndDestroy(&temp); + return hashVal; + } + +TUint32 CScrRequestImpl::HashCaseSensitiveL(const TDesC& aName) + { + TUint32 hashVal = 0; + Mem::Crc32(hashVal,aName.Ptr(),aName.Size()); + return hashVal; + } + +TInt CScrRequestImpl::GetComponentFileIdL(const TDesC& aFileName, TComponentId aComponentId) const + { + DEBUG_PRINTF3(_L("Looking up a component(%d) file(%S)"), aComponentId, &aFileName); + + TUint32 hash = HashCaseInsensitiveL(aFileName); + _LIT(KFindComponentFile, "SELECT CmpFileId FROM ComponentsFiles WHERE ComponentId=? AND LocationHash=?;"); + CStatement *stmtFind = iDbHandle->PrepareStatementLC(KFindComponentFile()); + stmtFind->BindIntL(1, aComponentId); + stmtFind->BindIntL(2, hash); + + if(!stmtFind->ProcessNextRowL()) + { + DEBUG_PRINTF3(_L("Component %d does not have File=%S!"), aComponentId, &aFileName); + CleanupStack::PopAndDestroy(stmtFind); + return KErrNotFound; + } + TInt componentFileId = stmtFind->IntColumnL(0); + CleanupStack::PopAndDestroy(stmtFind); + return componentFileId; + } + +TInt CScrRequestImpl::FindComponentFileL(const TDesC& aFileName, TComponentId aComponentId) const + { + TInt cmpFileId = GetComponentFileIdL(aFileName, aComponentId); + if(KErrNotFound == cmpFileId) + { + User::Leave(KErrNotFound); + } + return cmpFileId; + } + +TInt CScrRequestImpl::GetDriveFromFilePath(const TDesC& aFilePath, TDriveUnit& aDriveUnit) const + { + if(!iFs.IsValidName(aFilePath)) + {// even if the file name validity is checked before registering the file, do double check + // to be on the safe side. Because, if the file format is invalid, the rest of the code may panic. + DEBUG_PRINTF2(_L("The file (%S) doesn't have a valid name format!"), &aFilePath); + return KErrArgument; + } + + TParsePtrC fileParser(aFilePath); + TPtrC driveLetter(fileParser.Drive()); + if(driveLetter == KNullDesC()) + { + DEBUG_PRINTF2(_L("The file (%S) doesn't contain any drive letter!"), &aFilePath); + return KErrArgument; + } + aDriveUnit = driveLetter; + return KErrNone; + } + +TInt CScrRequestImpl::InstalledDrivesToBitmaskL(const TDriveList& aDriveList) const + { + TInt installedDrives(0); + for(TInt driveNum=EDriveA; driveNum<=EDriveZ; ++driveNum) + { + if(aDriveList[driveNum]) + { + installedDrives |= 1<PrepareStatementLC(KSelectInstalledDrivesBitmask); + stmt->BindIntL(1, aComponentId); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L8("Component (%d) couldn't be found in the SCR database."), aComponentId); + User::Leave(KErrNotFound); + } + TInt res = stmt->IntColumnL(0); + CleanupStack::PopAndDestroy(stmt); + return res; + } + +TBool CScrRequestImpl::HasFilesOnDriveL(TDriveUnit aDrive, TComponentId aComponentId) + { + CStatement *stmt = OpenFileListStatementL(aComponentId); + CleanupStack::PushL(stmt); + HBufC *nextFilePath(NULL); + TBool returnValue(EFalse); + + while ( returnValue == EFalse && (nextFilePath = GetNextFilePathL(*stmt)) != NULL) + { + TDriveUnit fileDrive; + TInt res = GetDriveFromFilePath(*nextFilePath, fileDrive); + // Files with invalid paths are ignored + if (res == KErrNone && fileDrive == aDrive) + { + returnValue = ETrue; + } + delete nextFilePath; + } + + CleanupStack::PopAndDestroy(stmt); + return returnValue; + } + +void CScrRequestImpl::UpdateInstalledDrivesL(TComponentId aComponentId, const TDesC& aFilePath, TFileOperationType aType) + { + TDriveUnit drive; + User::LeaveIfError(GetDriveFromFilePath(aFilePath, drive)); + + TInt driveNum = static_cast(drive); + TInt oldDrivesBitmask = GetInstalledDrivesBitmaskL(aComponentId); + + TInt newDrivesBitmask = oldDrivesBitmask; + // Update the list of installed drives + if(aType == EFileRegistered) + { + newDrivesBitmask |= 0x1 << driveNum; + } + else // aType == EFileUnregistered + { + TBool hasOtherFilesOnTheDrive = HasFilesOnDriveL(drive, aComponentId); + if (!hasOtherFilesOnTheDrive) + { + // Do a logical AND with a bitmask which looks like 111110111111 + TInt andBitmask = ~(0x1 << driveNum); + newDrivesBitmask &= andBitmask; + } + } + + if (newDrivesBitmask != oldDrivesBitmask) + { + // Write back the updated installed drives and list + _LIT(KUpdateInstalledDrives, "UPDATE Components SET InstalledDrives=? WHERE ComponentId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KUpdateInstalledDrives, numberOfValues, EValueInteger, newDrivesBitmask, EValueInteger, aComponentId); + } + } + +void CScrRequestImpl::RegisterComponentFileL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Registering component file.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + TBool considerFileInDrivesList = aMessage.Int2(); + TUint32 hash = HashCaseInsensitiveL(*fileName); + TDriveUnit drive(*fileName); + TVolumeInfo volInfo; + + _LIT(KInsertFile, "INSERT INTO ComponentsFiles(ComponentId,LocationHash,Location) VALUES(?,?,?);"); + TInt numberOfValues = 3; + ExecuteStatementL(KInsertFile(), numberOfValues, EValueInteger, componentId, EValueInteger, hash, EValueString, fileName); + // Reflect this file addition in the installed drives field of the components table + // Or the drive list is updated in case of a FILENULL operation on a removable drive + // If this step fails (for example, this file name is incorrect) then we cannot register the file + if (KErrNone == iFs.Volume(volInfo, drive) || considerFileInDrivesList) + UpdateInstalledDrivesL(componentId, *fileName, EFileRegistered); + + CleanupStack::PopAndDestroy(fileName); + } + +void CScrRequestImpl::SetFileStrPropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting file string property.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + + TInt compFileId = FindComponentFileL(*fileName, componentId); + + HBufC* propName = ReadDescLC(aMessage, 2); + TPropertyType propType(CScrRequestImpl::EPropertyUndefined); + TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, KLangNone, propType); + + HBufC8* propValue = ReadDesc8LC(aMessage, 3); + SetGeneralBinaryPropertyL(propType, propertyId, KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, *propValue); + CleanupStack::PopAndDestroy(3, fileName); + } + +void CScrRequestImpl::SetFileIntPropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting integer file property.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + TInt compFileId = FindComponentFileL(*fileName, componentId); + + HBufC* propName = ReadDescLC(aMessage, 2); + TPropertyType propType(CScrRequestImpl::EPropertyUndefined); + TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, KLangNone, propType); + + TInt propValue = aMessage.Int3(); + SetGeneralIntPropertyL(propType, propertyId, KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, propValue); + CleanupStack::PopAndDestroy(2, fileName); + } + +void CScrRequestImpl::SetComponentLocalizableL(TComponentId aComponentId, TLanguage aLocale, const TDesC& aColumnName, const TDesC& aName, const TDesC& aVendor) + { + _LIT(KFindComponentLocalizable, "SELECT CompLocalId FROM ComponentLocalizables WHERE ComponentId=? AND Locale=?;"); + TInt numberOfValues = 2; + CStatement *stmt = CreateStatementObjectWithLocaleL(KFindComponentLocalizable, aLocale, numberOfValues, EValueInteger, aComponentId, EValueLanguage); + + if(!stmt) + {// Add a new name for this component + AddComponentLocalizablesL(aComponentId, aLocale, aName, aVendor); + } + else + {// Exists, update the localizable field of the component + CleanupStack::PushL(stmt); + TInt compLocId = stmt->IntColumnL(0); + _LIT(KUpdateComponentName, "UPDATE ComponentLocalizables SET %S=? WHERE CompLocalId=?;"); + HBufC *statementStr = FormatStatementLC(KUpdateComponentName, aColumnName.Length(), &aColumnName); + const TDesC *value = aName.Length() ? &aName : &aVendor; + TInt numberOfValues = 2; + ExecuteStatementL(*statementStr, numberOfValues, EValueString, value, EValueInteger, compLocId); + CleanupStack::PopAndDestroy(2, stmt); // stmt, statementStr + } + } + +void CScrRequestImpl::SetComponentNameL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting component name.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC *componentName = ReadDescLC(aMessage, 1); + if (!componentName->CompareF(KNullDesC())) + {// Component name cannot be empty + DEBUG_PRINTF(_L8("Component name cannot be set or modified to a NULL string.")); + User::Leave(KErrArgument); + } + + TLanguage locale = TLanguage(aMessage.Int2()); + _LIT(KComponentNameField,"Name"); + SetComponentLocalizableL(componentId, locale, KComponentNameField, *componentName, KNullDesC()); + CleanupStack::PopAndDestroy(componentName); + } + +void CScrRequestImpl::SetVendorNameL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting vendor name.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC *vendorName = ReadDescLC(aMessage, 1); + TLanguage locale = TLanguage(aMessage.Int2()); + _LIT(KComponentVendorField,"Vendor"); + SetComponentLocalizableL(componentId, locale, KComponentVendorField, KNullDesC(), *vendorName); + CleanupStack::PopAndDestroy(vendorName); + } + +void CScrRequestImpl::ReadAndSetCommonComponentPropertyL(const RMessage2& aMessage, const TDesC& aPropertyColumn) + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TInt propertyValue = aMessage.Int1(); + + _LIT(KUpdateCommonProperty, "UPDATE Components SET %S=? WHERE ComponentId=?;"); + TInt formattedLen = aPropertyColumn.Length(); + HBufC *statementStr = FormatStatementLC(KUpdateCommonProperty(), formattedLen, &aPropertyColumn ); + TInt numberOfValues = 2; + ExecuteStatementL(*statementStr, numberOfValues, EValueInteger, propertyValue, EValueInteger, componentId); + CleanupStack::PopAndDestroy(statementStr); + } + +void CScrRequestImpl::SetIsComponentRemovableL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's removable attribute.")); + _LIT(KColumnNameRemovable, "Removable"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameRemovable); + } + +void CScrRequestImpl::SetIsComponentDrmProtectedL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's DRM protected attribute.")); + _LIT(KColumnNameDrmProtected, "DRMProtected"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameDrmProtected); + } + +void CScrRequestImpl::SetIsComponentHiddenL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's hidden attribute.")); + _LIT(KColumnNameHidden, "Hidden"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameHidden); + } + +void CScrRequestImpl::SetIsComponentKnownRevokedL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's known-revoked attribute.")); + _LIT(KColumnNameKnownRevoked, "KnownRevoked"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameKnownRevoked); + } + +void CScrRequestImpl::SetIsComponentOriginVerifiedL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's removable attribute.")); + _LIT(KColumnNameOriginVerified, "OriginVerified"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameOriginVerified); + } + +void CScrRequestImpl::SetComponentSizeL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component's install-time size.")); + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TInt64 componentSize = MAKE_TINT64(aMessage.Int1(), aMessage.Int2()); + if (componentSize < 0) + { + DEBUG_PRINTF2(_L8("Received incorrect component size: %d."), componentSize); + User::Leave(KErrArgument); + } + _LIT(KUpdateComponentSize, "UPDATE Components SET Size=? WHERE ComponentId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KUpdateComponentSize, numberOfValues, EValueInteger64, componentSize, EValueInteger, componentId); + } + +TBool FindLogEntryWithComponentId(const TComponentId *aKey, const CScrLogEntry& aEntry) + { + return (*aKey == aEntry.ComponentId()); + } + +void CScrRequestImpl::SetComponentVersionL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting component version.")); + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC *version = ReadDescLC(aMessage, 1); + + _LIT(KUpdateVersion, "UPDATE Components SET Version=? WHERE ComponentId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KUpdateVersion, numberOfValues, EValueString, version, EValueInteger, componentId); + + TInt logIdx = iLogEntries.Find(componentId, FindLogEntryWithComponentId); + if(KErrNotFound == logIdx) + { + CleanupStack::PopAndDestroy(version); + return; + } + DeleteObjectZ(iLogEntries[logIdx]->iVersion); + iLogEntries[logIdx]->iVersion = version; // Ownership is transferred + CleanupStack::Pop(version); + } + +void CScrRequestImpl::DeleteComponentPropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Deleting component property.")); + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC *name = ReadDescLC(aMessage, 1); + + _LIT(KDeleteComponentProperty, "DELETE FROM ComponentProperties WHERE Name=? AND ComponentId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KDeleteComponentProperty, numberOfValues, EValueString, name, EValueInteger, componentId); + CleanupStack::PopAndDestroy(name); + } + +void CScrRequestImpl::DeleteFilePropertyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Deleting file property.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + + TInt compFileId = FindComponentFileL(*fileName, componentId); + HBufC *propName = ReadDescLC(aMessage, 2); + + _LIT(KDeleteFileProperty, "DELETE FROM FileProperties WHERE CmpFileId=? AND Name=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KDeleteFileProperty, numberOfValues, EValueInteger, compFileId, EValueString, propName); + CleanupStack::PopAndDestroy(2, fileName); + } + +void CScrRequestImpl::UnregisterComponentFileL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Unregistering a component file.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + + TInt compFileId = GetComponentFileIdL(*fileName, componentId); + if (compFileId == KErrNotFound) + { + CleanupStack::PopAndDestroy(fileName); + return; // If the file is not registered, we do not return an error - this sort of condition is better enforced at upper layers + } + + _LIT(KDeleteComponentFileProperties, "DELETE from FileProperties WHERE CmpFileId=?;"); + TInt numberOfValues = 1; + ExecuteStatementL(KDeleteComponentFileProperties, numberOfValues, EValueInteger, compFileId); + DEBUG_PRINTF3(_L("Properties of the file(%S) of the component(%d) have been deleted."), fileName, componentId); + + _LIT(KUnregisterComponentFile, "DELETE FROM ComponentsFiles WHERE CmpFileId=?;"); + ExecuteStatementL(KUnregisterComponentFile, numberOfValues, EValueInteger, compFileId); + + // Reflect this file deletion in the installed drives field of the components table + UpdateInstalledDrivesL(componentId, *fileName, EFileUnregistered); + CleanupStack::PopAndDestroy(fileName); + } + +void ReadNullableStringFromStatementL(CStatement& aStmt, TPtrC& aValue, TInt aFieldNum) + { + aValue.Set(KNullDesC()); + if(!aStmt.IsFieldNullL(aFieldNum)) + { // If the value is not NULL, set it. + aValue.Set(aStmt.StrColumnL(aFieldNum)); + } + } + +void CScrRequestImpl::DeleteComponentL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Deleting a component.")); + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Deleting component(%d)."), componentId); + + // Create the log record before deleting the component + _LIT(KSelectComponentInfo, "SELECT SoftwareTypeName,GlobalId,Version FROM Components WHERE ComponentId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectComponentInfo); + stmt->BindIntL(1, componentId); + + // if the component doesn't exist, the code shouldn't come here. It should have left with KErrNotFound at security check level. + __ASSERT_ALWAYS(stmt->ProcessNextRowL(), User::Leave(KErrAbort)); + + CComponentEntry *entry2bDeleted = CComponentEntry::NewLC(); + entry2bDeleted->iSwType = stmt->StrColumnL(0).AllocL(); + + TPtrC globalId; + ReadNullableStringFromStatementL(*stmt, globalId, 1); + if(globalId.Length() > 0) + { + CGlobalComponentId *globalIdObj = ParseGlobalComponendIdLC(globalId); + entry2bDeleted->iGlobalId = globalIdObj->GlobalIdName().AllocL(); + CleanupStack::PopAndDestroy(globalIdObj); + } + else + { + entry2bDeleted->iGlobalId = globalId.AllocL(); + } + TPtrC version; + ReadNullableStringFromStatementL(*stmt, version, 2); + entry2bDeleted->iVersion = version.AllocL(); + AddComponentEntryLocalizablesL(componentId, *entry2bDeleted, KUnspecifiedLocale); + + CScrLogEntry *logRecord = CScrLogEntry::NewL(entry2bDeleted->Name(), entry2bDeleted->SoftwareType(), entry2bDeleted->GlobalId(), entry2bDeleted->Version(), EScrCompUnInstall); + logRecord->iComponentId = componentId; + CleanupStack::PopAndDestroy(2, stmt); // stmt, entry2bDeleted + CleanupStack::PushL(logRecord); + + // Now begin the component deletion + TInt numberOfValues = 1; + _LIT(KDeleteComponentProperties,"DELETE FROM ComponentProperties WHERE ComponentId=?;"); + ExecuteStatementL(KDeleteComponentProperties, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("Properties of component(%d) have been deleted."), componentId); + + _LIT(KDeleteComponentFileProperties, "DELETE from FileProperties WHERE CmpFileId IN \ + (SELECT CmpFileId FROM ComponentsFiles WHERE ComponentId=?);"); + ExecuteStatementL(KDeleteComponentFileProperties, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("Properties of files of component(%d) have been deleted."), componentId); + + _LIT(KDeleteComponentFiles, "DELETE FROM ComponentsFiles WHERE ComponentId=?;"); + ExecuteStatementL(KDeleteComponentFiles, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("File registrations of component(%d) have been deleted."), componentId); + + _LIT(KDeleteComponentLocalizables, "DELETE FROM ComponentLocalizables WHERE ComponentId=?;"); + ExecuteStatementL(KDeleteComponentLocalizables, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("Localizables of component(%d) have been deleted."), componentId); + + // Delete all dependencies where this component is dependant + _LIT(KDeleteComponentDependencies, "DELETE FROM ComponentDependencies WHERE DependantGlobalIdHash IN \ + (SELECT GlobalIdHash FROM Components WHERE ComponentId=?);"); + ExecuteStatementL(KDeleteComponentDependencies, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("Dependencies of component(%d) have been deleted."), componentId); + + _LIT(KDeleteComponents, "DELETE FROM Components WHERE ComponentId=?;"); + ExecuteStatementL(KDeleteComponents, numberOfValues, EValueInteger, componentId); + DEBUG_PRINTF2(_L8("Finally component(%d) has been deleted."), componentId); + + // Add log record + iLogEntries.Append(logRecord); + CleanupStack::Pop(logRecord); // Ownership is transferred + } + +void CScrRequestImpl::DeleteComponentDependencyL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Deleting a component dependency.")); + + HBufC *suppGlobalId = ReadAndGetGlobalIdLC(aMessage, 1); + HBufC *depGlobalId = ReadAndGetGlobalIdLC(aMessage, 2); + TUint32 globalIdsHash = HashGlobalIdsL(*depGlobalId, *suppGlobalId); + CleanupStack::PopAndDestroy(2, suppGlobalId); // suppGlobalId,depGlobalId + + _LIT(KDeleteDependency, "DELETE FROM ComponentDependencies WHERE GlobalIdHash=?;"); + TInt numberOfValues = 1; + ExecuteStatementL(KDeleteDependency(), numberOfValues, EValueInteger, globalIdsHash); + } + +TBool CScrRequestImpl::BindAndProcessStatementObjectL(CStatement& aStatementObj, TLanguage aLanguage, TInt aValuesNum, VA_LIST aList) const + { + aStatementObj.ResetL(); + BindStatementValuesL(aStatementObj, aLanguage, aValuesNum, aList); + return aStatementObj.ProcessNextRowL(); + } + +CStatement* CScrRequestImpl::CreateStatementObjectWithoutLocaleL(const TDesC& aStatement, TInt aValuesNum,...) const + { + VA_LIST argList; + VA_START(argList, aValuesNum); + + CStatement *stmt = iDbHandle->PrepareStatementLC(aStatement); + + // The language parameter is irrelevant. The BindAndProcessStatementObjectL is reused here to avoid code duplication. + TBool success = BindAndProcessStatementObjectL(*stmt, ELangNone, aValuesNum, argList); + + VA_END(argList); + + if(!success) + { // if the code reaches here, it means there is no record for the given criteria + CleanupStack::PopAndDestroy(stmt); + return NULL; + } + CleanupStack::Pop(stmt); + return stmt; + } + +CStatement* CScrRequestImpl::CreateStatementObjectWithLocaleNoDowngradeL(const TDesC& aStatement, TLanguage aLocale, TInt aValuesNum,...) const + { + VA_LIST argList; + VA_START(argList, aValuesNum); + + CStatement *stmt = iDbHandle->PrepareStatementLC(aStatement); + TBool success = BindAndProcessStatementObjectL(*stmt, aLocale, aValuesNum, argList); + + if(!success) + { // if the code reaches here, it means there is no record for the given criteria + CleanupStack::PopAndDestroy(stmt); + return NULL; + } + + CleanupStack::Pop(stmt); + return stmt; + + } + +// This function tries automatically downgrading languages to the nearest locale +CStatement* CScrRequestImpl::CreateStatementObjectWithLocaleL(const TDesC& aStatement, TLanguage aLocale, TInt aValuesNum,...) const + { + VA_LIST argList; + VA_START(argList, aValuesNum); + + CStatement *stmt = iDbHandle->PrepareStatementLC(aStatement); + //Avoiding call to BAFL for the current locale. If succeeds, BAFL will not be invoked + TBool success = BindAndProcessStatementObjectL(*stmt, aLocale, aValuesNum, argList); + VA_START(argList, aValuesNum); + + if ( !success ) + { + // Run the given statement for the passed or its equivalent languages + // First, get the Equivalent Language path for the given locale. The first element + // in the array is the given language. + TLanguagePath equivalentLanguages; + BaflUtils::GetEquivalentLanguageList(aLocale, equivalentLanguages); + + TInt i = 1; //skipping the current locale + while ( equivalentLanguages[i] != ELangNone && !success) + { + success = BindAndProcessStatementObjectL(*stmt, equivalentLanguages[i], aValuesNum, argList); + VA_START(argList, aValuesNum); + i++; + } + VA_END(argList); + + if(!success) + { // if the code reaches here, it means there is no record for the given criteria + CleanupStack::PopAndDestroy(stmt); + return NULL; + } + } + else + { + VA_END(argList); + } + + CleanupStack::Pop(stmt); + return stmt; + } + +CComponentEntry* CScrRequestImpl::CreateComponentEntryFromStatementHandleL(CStatement& aStmt) const + { + TComponentId componentId = aStmt.IntColumnL(0); + TInt removable = aStmt.IntColumnL(3); + TInt64 size = aStmt.Int64ColumnL(4); + TScomoState scomoState = TScomoState(aStmt.IntColumnL(5)); + + TInt drmProtected = aStmt.IntColumnL(6); + TInt hidden = aStmt.IntColumnL(7); + TInt knownRevoked = aStmt.IntColumnL(8); + TInt originVerified = aStmt.IntColumnL(9); + + TPtrC globalIdDes; + ReadNullableStringFromStatementL(aStmt, globalIdDes, 10); + HBufC *globalId = NULL; + if(globalIdDes.Length()) + { // if global id is not NULL + CGlobalComponentId *globalIdObj = ParseGlobalComponendIdLC(globalIdDes); + globalId = globalIdObj->GlobalIdName().AllocL(); + CleanupStack::PopAndDestroy(globalIdObj); + CleanupStack::PushL(globalId); + } + else + { // Global Id is NULL + globalId = KNullDesC().AllocLC(); + } + + TInt installedDrivesBitmask = aStmt.IntColumnL(11); + // Convert bitmask to TDriveList + TDriveList installedDriveList; + installedDriveList.FillZ(KMaxDrives); + for (TInt i = 0; i < KMaxDrives && installedDrivesBitmask > 0; ++i, installedDrivesBitmask >>= 1) + { + installedDriveList[i] = installedDrivesBitmask & 0x1; + } + + TPtrC version(KNullDesC()); + if(!aStmt.IsFieldNullL(12)) + version.Set(aStmt.StrColumnL(12)); + + TPtrC installTime = aStmt.StrColumnL(13); + + CComponentEntry *entry = CComponentEntry::NewL(componentId, KNullDesC, KNullDesC, KNullDesC, *globalId, removable, size, scomoState, installedDriveList, version, installTime, drmProtected, hidden, knownRevoked, originVerified); + CleanupStack::PopAndDestroy(globalId); + return entry; + } + +// +// aLocalizableStmtStr = A SELECT statement which queries a table for a specific locale. In other words, the statement has got a locale condition. +// aAnyValueStmtStr = A SELECT statement which doesn't contain a locale condition. The result row set will include records with any locale. +// aConditionIntValue = The value of the integer condition of the statements given. +// aConditionLocale = The value of the locale condition of the localizable statement (first parameter). +// +CStatement* CScrRequestImpl::ExecuteLocalizableStatementL(const TDesC& aLocalizableStmtStr, const TDesC& aAnyValueStmtStr, TInt aConditionIntValue, TLanguage aConditionLocale) const + { + TInt numberOfValues = 2; + CStatement *stmtLoc(0); + + if(KUnspecifiedLocale == aConditionLocale) + { + // The locale is not specified. So, first try to run the statement for the current locale and its downgraded languages. + stmtLoc = CreateStatementObjectWithLocaleL(aLocalizableStmtStr, User::Language(), numberOfValues, EValueInteger, aConditionIntValue, EValueLanguage); + if (!stmtLoc) + { + // No result for the current locale at all. Try to find non-localized values. + stmtLoc = CreateStatementObjectWithLocaleL(aLocalizableStmtStr, KNonLocalized, numberOfValues, EValueInteger, aConditionIntValue, EValueLanguage); + } + + if (!stmtLoc) + { + // No result for the current locale or the non-localized, "neutral" locale. Try finding any locale + stmtLoc = CreateStatementObjectWithoutLocaleL(aAnyValueStmtStr, 1, EValueInteger, aConditionIntValue); + } + } + else if(KNonLocalized == aConditionLocale) + { + // Only non-localized names are requested. + stmtLoc = CreateStatementObjectWithLocaleL(aLocalizableStmtStr, KNonLocalized, numberOfValues, EValueInteger, aConditionIntValue, EValueLanguage); + } + else + { + // Names are requested for a particular locale. + stmtLoc = CreateStatementObjectWithLocaleL(aLocalizableStmtStr, aConditionLocale, numberOfValues, EValueInteger, aConditionIntValue, EValueLanguage); + } + + return stmtLoc; + } + +void CScrRequestImpl::AddComponentEntryLocalizablesL(TComponentId aComponentId, CComponentEntry& aEntry, TLanguage aLocale) const + { + _LIT(KSelectLocalizableNames, "SELECT Name,Vendor FROM ComponentLocalizables WHERE ComponentId=? AND Locale=?;"); + _LIT(KSelectAnyNames, "SELECT Name,Vendor FROM ComponentLocalizables WHERE ComponentId=?;"); + + CStatement *stmtLoc = ExecuteLocalizableStatementL(KSelectLocalizableNames, KSelectAnyNames, aComponentId, aLocale); + if(!stmtLoc) + { + DEBUG_PRINTF3(_L8("Name and Vendor couldn't be found for the component (%d) and locale(%d)."), aComponentId, aLocale); + User::Leave(KErrScrUnsupportedLocale); + } + + CleanupStack::PushL(stmtLoc); + + TPtrC name(stmtLoc->StrColumnL(0)); + TPtrC vendor(stmtLoc->StrColumnL(1)); + DeleteObjectZ(aEntry.iName); + aEntry.iName = name.AllocL(); // Ownership is transferred to the entry object + DeleteObjectZ(aEntry.iVendor); + if ( 0 != vendor.Ptr()) + aEntry.iVendor = vendor.AllocL(); // Ownership is transferred to the entry object + else + aEntry.iVendor = HBufC::NewL(1); + + CleanupStack::PopAndDestroy(stmtLoc); + } + +void CScrRequestImpl::AddSoftwareTypeNameToComponentEntryL(CStatement& aStmt, CComponentEntry& aEntry, TLanguage aLocale) const + { + TInt softwareTypeId = aStmt.IntColumnL(1); + _LIT(KSelectLocalizableSwTypeName, "SELECT Name FROM SoftwareTypeNames WHERE SoftwareTypeId=? AND Locale=?;"); + CStatement *stmtLoc = ExecuteLocalizableStatementL(KSelectLocalizableSwTypeName, KSelectLocalizableSwTypeName, softwareTypeId, aLocale); + if(stmtLoc) + { + CleanupStack::PushL(stmtLoc); + TPtrC name(stmtLoc->StrColumnL(0)); + DeleteObjectZ(aEntry.iSwType); + aEntry.iSwType = name.AllocL(); // Ownership is transferred to the entry object + CleanupStack::PopAndDestroy(stmtLoc); + return; + } + + // The software type doesn't exist or there is no localized name of the software type, add the unique software type name + TPtrC uniqueSwTypeName = aStmt.StrColumnL(2); + DeleteObjectZ(aEntry.iSwType); + aEntry.iSwType = uniqueSwTypeName.AllocL(); // Ownership is transferred to the entry object + } + +void CScrRequestImpl::GetGeneralComponentEntrySizeL(const RMessage2& aMessage, const TDesC& aConditionColumn, TUint32 aConditionValue, TInt aReturnSizeSlot, TLanguage aLocale, CComponentEntry*& aComponentEntry) const + { + _LIT(KSelectComponents, "SELECT ComponentId,SoftwareTypeId,SoftwareTypeName,Removable,Size,ScomoState,DRMProtected,Hidden,KnownRevoked,OriginVerified,GlobalId,InstalledDrives,Version,InstallTime FROM Components WHERE %S=?;"); + + TInt formattedLen = aConditionColumn.Length(); + HBufC *statementStr = FormatStatementLC(KSelectComponents(), formattedLen, &aConditionColumn); + CStatement *stmt = iDbHandle->PrepareStatementLC(*statementStr); + stmt->BindIntL(1, aConditionValue); + + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L8("The component(%d) couldn't be found. The size returned is zero."), aConditionValue); + WriteIntValueL(aMessage, aReturnSizeSlot, 0); + CleanupStack::PopAndDestroy(2, statementStr); // statementStr, stmt + return; + } + + DeleteObjectZ(aComponentEntry); + aComponentEntry = CreateComponentEntryFromStatementHandleL(*stmt); + AddComponentEntryLocalizablesL(aComponentEntry->ComponentId(), *aComponentEntry, aLocale); + AddSoftwareTypeNameToComponentEntryL(*stmt, *aComponentEntry, aLocale); + + WriteObjectSizeL(aMessage, aReturnSizeSlot, aComponentEntry); + CleanupStack::PopAndDestroy(2, statementStr); // statementStr, stmt + } + +void CScrRequestImpl::GetComponentEntrySizeL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Returning the entry size of component(%d)."), componentId); + TLanguage locale = TLanguage(aMessage.Int1()); + + _LIT(KConditionColumn, "ComponentId"); + TInt returnSizeSlot=2; + GetGeneralComponentEntrySizeL(aMessage, KConditionColumn(), componentId, returnSizeSlot, locale, iComponentEntry); + } + +void CScrRequestImpl::GetComponentEntryDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the component entry data.")); + WriteObjectDataL(aMessage, 0, iComponentEntry); + DeleteObjectZ(iComponentEntry); // Delete the object to prevent it to be resent. + } + +void CScrRequestImpl::GetComponentLocalizedEntrySizeL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Returning the localized information entry size of component(%d)."), componentId); + _LIT(KSelectMatchingSupportedLocales, "SELECT Locale, Name, Vendor FROM ComponentLocalizables WHERE ComponentId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectMatchingSupportedLocales); + stmt->BindIntL(1, componentId); + while(stmt->ProcessNextRowL()) + { + TPtrC name(stmt->StrColumnL(1)); + TPtrC vendor(stmt->StrColumnL(2)); + TInt locale(stmt->IntColumnL(0)); + CLocalizableComponentInfo *compLocalizedInfo = Usif::CLocalizableComponentInfo::NewLC( name, vendor,(TLanguage)locale); + iCompLocalizedInfoArray.Insert(compLocalizedInfo,iCompLocalizedInfoArray.Count()); + CleanupStack::Pop(compLocalizedInfo); + } + // Release allocated memories + CleanupStack::PopAndDestroy(1, stmt); // stmt + WriteArraySizeL(aMessage, 1, iCompLocalizedInfoArray); + } + +void CScrRequestImpl::GetComponentLocalizedEntryDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the localized information entry data.")); + WriteArrayDataL(aMessage, 0, iCompLocalizedInfoArray); + iCompLocalizedInfoArray.ResetAndDestroy(); + } + +TBool CompareProperties(const CPropertyEntry& aRhs, const CPropertyEntry& aLhs) + { + return ((aRhs.PropertyType() == aLhs.PropertyType()) && + (aRhs.PropertyName() == aLhs.PropertyName())); + } + +void CScrRequestImpl::AddGeneralPropertiesArrayWithLocaleL(const TDesC& aStmtStr, TLanguage aLocale, TComponentId aIdColumnValue, RPointerArray& aProperties) const + { + TInt numberOfValues = 2; + CStatement *stmt = CreateStatementObjectWithLocaleL(aStmtStr, aLocale, numberOfValues, EValueInteger, aIdColumnValue, EValueLanguage); + if(!stmt) + { + return; + } + CleanupStack::PushL(stmt); + do + { + TPtrC name(stmt->StrColumnL(0)); + CPropertyEntry *entry = GetPropertyEntryL(*stmt, name, 1); // aStartingIndex=1 + CleanupStack::PushL(entry); + if(KErrNotFound == aProperties.Find(entry, TIdentityRelation(CompareProperties))) + { + aProperties.AppendL(entry); + CleanupStack::Pop(entry); // because array is now owner + } + else + { + CleanupStack::PopAndDestroy(entry); + } + } while(stmt->ProcessNextRowL()); + CleanupStack::PopAndDestroy(stmt); + } + +void CScrRequestImpl::GetGeneralPropertiesArrayL(const TDesC& aTableName, const TDesC& aIdColumnName , TComponentId aIdColumnValue, TLanguage aLocale, RPointerArray& aProperties) const + { + _LIT(KSelectGeneralLocalizableProperties, "SELECT Name,IntValue,StrValue,Locale,IsStr8Bit FROM %S WHERE %S=? AND Locale=?;"); + TInt formattedLen = aTableName.Length() + aIdColumnName.Length(); + HBufC *statementStr = FormatStatementLC(KSelectGeneralLocalizableProperties, formattedLen, &aTableName, &aIdColumnName ); + + if(KUnspecifiedLocale == aLocale) + { + // Locale is not specified. First get non-localized properties + AddGeneralPropertiesArrayWithLocaleL(*statementStr, KNonLocalized, aIdColumnValue, aProperties); + // Then get the localizable properties with the current locale + AddGeneralPropertiesArrayWithLocaleL(*statementStr, User::Language(), aIdColumnValue, aProperties); + } + else if(KNonLocalized == aLocale) + { + // Only non-localized properties are requested. + AddGeneralPropertiesArrayWithLocaleL(*statementStr, KNonLocalized, aIdColumnValue, aProperties); + } + else + { + // Locale is specified. It means that only properties with this locale are wanted + AddGeneralPropertiesArrayWithLocaleL(*statementStr, aLocale, aIdColumnValue, aProperties); + } + + CleanupStack::PopAndDestroy(statementStr); +#ifdef _DEBUG + if(!aProperties.Count()) + DEBUG_PRINTF4(_L("Property couldn't be found for column name=(%S), column id=%d and locale=%d."), &aIdColumnName, aIdColumnValue, aLocale); +#endif + } + +void CScrRequestImpl::GetFilePropertiesSizeL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the size of file properties.")); + + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + + TInt compFileId = FindComponentFileL(*fileName, componentId); + + iProperties.ResetAndDestroy(); + GetGeneralPropertiesArrayL(KFilePropertiesTable(), KCompFileIdColumnName, compFileId, KNonLocalized, iProperties); + CleanupStack::PopAndDestroy(fileName); + WriteArraySizeL(aMessage, 2, iProperties); + } + +void CScrRequestImpl::GetFilePropertiesDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the file properties data.")); + WriteArrayDataL(aMessage, 0, iProperties); + } + +CPropertyEntry* CScrRequestImpl::GetPropertyEntryL(CStatement& aStmt, const TDesC& aPropName, TInt aStartingIndex) const + { + CPropertyEntry *entry(0); + + if(!aStmt.IsFieldNullL(aStartingIndex)) + { + TInt64 intVal = aStmt.Int64ColumnL(aStartingIndex); + entry = CIntPropertyEntry::NewL(aPropName, intVal); + } + else if(!aStmt.IsFieldNullL(aStartingIndex+1)) + { + TBool is8BitString = (aStmt.IntColumnL(aStartingIndex + 3) != 0); + if (is8BitString) + { + TPtrC8 binaryVal(aStmt.BinaryColumnL(aStartingIndex+1)); + entry = CBinaryPropertyEntry::NewL(aPropName, binaryVal); + } + else + { + TPtrC strVal(aStmt.StrColumnL(aStartingIndex+1)); + TLanguage locale = TLanguage(aStmt.IntColumnL(aStartingIndex + 2)); + entry = CLocalizablePropertyEntry::NewL(aPropName, strVal, locale); + } + } + else + {// Should never come here - shows DB inconsistency + DEBUG_PRINTF(_L("Both integer and string values are NULL. Inconsistency problem!")); + User::Leave(KErrCorrupt); + } + return entry; + } + +CPropertyEntry* CScrRequestImpl::GetGeneralSinglePropertyL(const TDesC& aTableName, const TDesC& aIdColumnName , TInt aIdColumnValue, const TDesC& aPropName, TLanguage aLocale) const + { + DEBUG_PRINTF5(_L("Getting general single property for %S. PropName=%S, Id=%d, Locale=%d"), &aIdColumnName , &aPropName, aIdColumnValue, aLocale); + + _LIT(KSelectSingleGeneralProperty, "SELECT IntValue,StrValue,Locale,IsStr8Bit FROM %S WHERE Name=? AND %S=? AND Locale=?;"); + TInt formattedLen = aTableName.Length() + aIdColumnName.Length(); + HBufC *statementStr = FormatStatementLC(KSelectSingleGeneralProperty, formattedLen, &aTableName, &aIdColumnName ); + + CStatement *stmt = CreateGeneralPropertyStatementWithLocaleL(*statementStr, aIdColumnValue, aLocale, aPropName); + if(!stmt) + { + DEBUG_PRINTF4(_L("Property couldn't be found for column name=(%S), column id=%d and locale=%d."), &aIdColumnName, aIdColumnValue, aLocale); + CleanupStack::PopAndDestroy(statementStr); + return NULL; + } + CleanupStack::PushL(stmt); + + CPropertyEntry *entry = GetPropertyEntryL(*stmt, aPropName, 0); // aStartingIndex=0 + CleanupStack::PopAndDestroy(2, statementStr); // statementStr, stmt + return entry; + } + +void CScrRequestImpl::GetSingleFilePropertySizeL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the size of single file property.")); + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC* fileName = ReadFileNameFromMsgLC(aMessage); + HBufC *propName = ReadDescLC(aMessage, 2); + + TInt compFileId = FindComponentFileL(*fileName, componentId); + + DeleteObjectZ(iSingleProperty); + iSingleProperty = GetGeneralSinglePropertyL(KFilePropertiesTable(), KCompFileIdColumnName, compFileId, *propName, KNonLocalized); + CleanupStack::PopAndDestroy(2, fileName); // fileName, propName + WriteObjectSizeL(aMessage, 3, iSingleProperty); + } + +void CScrRequestImpl::GetSingleFilePropertyDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the single file property data.")); + WriteObjectDataL(aMessage, 0, iSingleProperty); + DeleteObjectZ(iSingleProperty); // Delete the object to prevent it to be resent. + } + +void CScrRequestImpl::GetComponentFilesCountL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + + DEBUG_PRINTF2(_L8("Returning the files count for component %d."), componentId); + + _LIT(KGetComponentFilesCount, "SELECT COUNT(CmpFileId) FROM ComponentsFiles WHERE ComponentId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KGetComponentFilesCount); + stmt->BindIntL(1, componentId); + + TBool res = stmt->ProcessNextRowL(); + // DB Query did not return a single row for component files count query - internal error! + __ASSERT_ALWAYS(res, User::Leave(KErrAbort)); + + TInt filesCountTmp = stmt->IntColumnL(0); + __ASSERT_DEBUG(filesCountTmp >= 0, User::Leave(KErrAbort)); + TUint filesCount = static_cast(filesCountTmp); + CleanupStack::PopAndDestroy(stmt); + + TPckg filesCountPkg(filesCount); + aMessage.WriteL(1, filesCountPkg); + } + +void CScrRequestImpl::GetFileComponentsL(const TDesC& aFileName, RArray& aComponents) const + { + _LIT(KSelectFileComponents, "SELECT ComponentId FROM ComponentsFiles WHERE LocationHash=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectFileComponents); + TUint32 hash = HashCaseInsensitiveL(aFileName); + stmt->BindIntL(1, hash); + + while(stmt->ProcessNextRowL()) + { + User::LeaveIfError(aComponents.InsertInOrder(stmt->IntColumnL(0))); + } + CleanupStack::PopAndDestroy(stmt); + } + +void CScrRequestImpl::GetFileComponentsSizeL(const RMessage2& aMessage) const + { + HBufC *fileName = ReadDescLC(aMessage, 0); + + iFileComponents.Reset(); + GetFileComponentsL(*fileName, iFileComponents); + CleanupStack::PopAndDestroy(fileName); + + WriteArraySizeL(aMessage, 1, iFileComponents); + } + +void CScrRequestImpl::GetFileComponentsDataL(const RMessage2& aMessage) const + { + WriteArrayDataL(aMessage, 0, iFileComponents); + } + +void CScrRequestImpl::GetComponentPropertiesSizeL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TLanguage locale = TLanguage(aMessage.Int1()); + + iProperties.ResetAndDestroy(); + GetGeneralPropertiesArrayL(KComponentPropertiesTable(), KComponentIdColumnName, componentId, locale, iProperties); + WriteArraySizeL(aMessage, 2, iProperties); + } + +void CScrRequestImpl::GetComponentPropertiesDataL(const RMessage2& aMessage) const + { + WriteArrayDataL(aMessage, 0, iProperties); + } + +void CScrRequestImpl::GetComponentSinglePropertySizeL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + HBufC *propName = ReadDescLC(aMessage, 1); + TLanguage locale = TLanguage(aMessage.Int2()); + + DeleteObjectZ(iSingleProperty); + iSingleProperty = GetGeneralSinglePropertyL(KComponentPropertiesTable(), KComponentIdColumnName, componentId, *propName, locale); + CleanupStack::PopAndDestroy(propName); + WriteObjectSizeL(aMessage, 3, iSingleProperty); + } + +void CScrRequestImpl::GetComponentSinglePropertyDataL(const RMessage2& aMessage) const + { + WriteObjectDataL(aMessage, 0, iSingleProperty); + DeleteObjectZ(iSingleProperty); // Delete the object to prevent it to be resent. + } + +TUint32 CScrRequestImpl::ReadAndHashGlobalIdL(const RMessage2& aMessage, TInt aGlobalIdNameSlot, TInt aSwTypeNameSlot) const + { + HBufC *globalIdName = ReadDescLC(aMessage, aGlobalIdNameSlot); + HBufC *swTypeName = ReadDescLC(aMessage, aSwTypeNameSlot); + + // Concatenate the software type id with the global id name + HBufC *globalId = GenerateGlobalIdL(*swTypeName, *globalIdName); + CleanupStack::PushL(globalId); + // Hash the concatenated value + TUint32 globalIdHash = HashCaseSensitiveL(*globalId); + CleanupStack::PopAndDestroy(3, globalIdName); // globalIdName, swTypeName, concatGlobalId + return globalIdHash; + } + +void CScrRequestImpl::GetComponentIdL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the local component id of a received global id.")); + + TUint32 globalIdHash = ReadAndHashGlobalIdL(aMessage, 0, 1); + + _LIT(KSelectComponentId, "SELECT ComponentId FROM Components WHERE GlobalIdHash=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectComponentId); + stmt->BindIntL(1, globalIdHash); + + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L8("There is no local component id corresponding to the supplied global id (hash=%d)."), globalIdHash); + User::Leave(KErrNotFound); + } + + TComponentId compId = stmt->IntColumnL(0); + CleanupStack::PopAndDestroy(stmt); + + TPckg componentIdDes(compId); + aMessage.WriteL(2, componentIdDes); + } + +void CScrRequestImpl::GetComponentWithGlobalIdSizeL(const RMessage2& aMessage) const + { + TUint32 globalIdHash = ReadAndHashGlobalIdL(aMessage, 0, 1); + TLanguage locale = TLanguage(aMessage.Int2()); + + _LIT(KConditionColumn, "GlobalIdHash"); + TInt returnSizeSlot=3; + GetGeneralComponentEntrySizeL(aMessage, KConditionColumn(), globalIdHash, returnSizeSlot, locale, iComponentEntry); + } + +void CScrRequestImpl::GetComponentWithGlobalIdDataL(const RMessage2& aMessage) const + { + WriteObjectDataL(aMessage, 0, iComponentEntry); + DeleteObjectZ(iComponentEntry); // Delete the object to prevent the usage of this function + // without calling GetComponentWithGlobalIdSizeL. + } + +CGlobalComponentId* CScrRequestImpl::ParseGlobalComponendIdLC(const TDesC& aGlobalId) const + { + TChar nullCr = '\0'; + TInt pos = aGlobalId.Locate(nullCr); + __ASSERT_ALWAYS(pos != KErrNotFound, User::Leave(KErrCorrupt)); + + TPtrC swTypeName = aGlobalId.Left(pos); + TPtrC globalIdName = aGlobalId.Right(aGlobalId.Length() - pos - 1); + + return CGlobalComponentId::NewLC(globalIdName, swTypeName); + } + +void CScrRequestImpl::GetGeneralDependencyListL(const TDesC& aSelectColumn, const TDesC& aConditionColumn, const TDesC& aConditionValue, RPointerArray &aVerCompIdList) const + { + _LIT(KSelectDependencies, "SELECT %S,VersionFrom,VersionTo FROM ComponentDependencies WHERE %S=?;"); + TInt formattedLen = aSelectColumn.Length() + aConditionColumn.Length(); + HBufC *stmtStr = FormatStatementLC(KSelectDependencies(), formattedLen, &aSelectColumn, &aConditionColumn); + + CStatement *stmt = iDbHandle->PrepareStatementLC(*stmtStr); + TUint32 conditionValueHash = HashCaseSensitiveL(aConditionValue); + stmt->BindIntL(1, conditionValueHash); + + while(stmt->ProcessNextRowL()) + { + TPtrC selectedGlobalId(stmt->StrColumnL(0)); + CGlobalComponentId *globalId = ParseGlobalComponendIdLC(selectedGlobalId); + + TPtrC versionFrom; + ReadNullableStringFromStatementL(*stmt, versionFrom, 1); + TPtrC versionTo; + ReadNullableStringFromStatementL(*stmt, versionTo, 2); + + CVersionedComponentId *verCompId = CVersionedComponentId::NewLC(*globalId, &versionFrom, &versionTo); + aVerCompIdList.AppendL(verCompId); + + CleanupStack::Pop(verCompId); // Ownership passed to the array + CleanupStack::PopAndDestroy(globalId); + } + + CleanupStack::PopAndDestroy(2, stmtStr); // stmtStr, stmt + } + +void CScrRequestImpl::GetSupplierComponentsSizeL(const RMessage2& aMessage) const + { + HBufC *dependantGlobalId = ReadAndGetGlobalIdLC(aMessage, 0); + + _LIT(KSelectColumn, "SupplierGlobalId"); + _LIT(KConditionColumn, "DependantGlobalIdHash"); + iVerCompIdList.ResetAndDestroy(); + + GetGeneralDependencyListL(KSelectColumn(), KConditionColumn(), *dependantGlobalId, iVerCompIdList); + CleanupStack::PopAndDestroy(dependantGlobalId); + WriteArraySizeL(aMessage, 1, iVerCompIdList); + } + +void CScrRequestImpl::GetSupplierComponentsDataL(const RMessage2& aMessage) const + { + WriteArrayDataL(aMessage, 0, iVerCompIdList); + } + +void CScrRequestImpl::GetDependantComponentsSizeL(const RMessage2& aMessage) const + { + + HBufC *supplierGlobalId = ReadAndGetGlobalIdLC(aMessage, 0); + + _LIT(KSelectColumn, "DependantGlobalId"); + _LIT(KConditionColumn, "SupplierGlobalIdHash"); + iVerCompIdList.ResetAndDestroy(); + + GetGeneralDependencyListL(KSelectColumn(), KConditionColumn(), *supplierGlobalId, iVerCompIdList); + CleanupStack::PopAndDestroy(supplierGlobalId); + WriteArraySizeL(aMessage, 1, iVerCompIdList); + } + +void CScrRequestImpl::GetDependantComponentsDataL(const RMessage2& aMessage) const + { + WriteArrayDataL(aMessage, 0, iVerCompIdList); + } + +void CScrRequestImpl::GetIsMediaPresentL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Retrieving media presence of component(%d)."), componentId); + + TBool result = CheckForMediaPresenceL(componentId); + + TPckg resultPkg(result); + aMessage.WriteL(1, resultPkg); + } + +TBool CScrRequestImpl::CheckForMediaPresenceL(TComponentId aComponentId) const + { + TInt componentDrivesBitmask = GetInstalledDrivesBitmaskL(aComponentId); + + TDriveList presentDriveSet; + User::LeaveIfError(iFs.DriveList(presentDriveSet)); + + // Check for each drive whether it is present in the system + for (TInt drive=0; componentDrivesBitmask; componentDrivesBitmask >>= 1, ++drive) + { + if ((componentDrivesBitmask & 0x1) && (presentDriveSet.Length() <= drive || !presentDriveSet[drive])) + { + DEBUG_PRINTF3(_L8("Component %d registers a file at drive %c which is not present. Returning EFalse for IsMediaPresent)."), aComponentId, drive + 'a'); + return EFalse; + } + } + + return ETrue; + } + +void CScrRequestImpl::SetScomoStateL(const RMessage2& aMessage) + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TScomoState state = static_cast(aMessage.Int1()); + DEBUG_PRINTF3(_L8("Updating the scomo state of component(%d). New value=%d."), componentId, state); + + _LIT(KUpdateScomoState, "UPDATE Components SET ScomoState=? WHERE ComponentId=?;"); + TInt numberOfValues = 2; + ExecuteStatementL(KUpdateScomoState, numberOfValues, EValueInteger, state, EValueInteger, componentId); + } + +void CScrRequestImpl::GetPluginUidWithMimeTypeL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning plugin for MIME type.")); + HBufC *mimeType = ReadDescLC(aMessage, 0); + + _LIT(KSelectPluginsWithMimeType, "SELECT SifPluginUid FROM SoftwareTypes WHERE SoftwareTypeId IN (SELECT SoftwareTypeId FROM MimeTypes WHERE MimeType=?);"); + CStatement* stmt = iDbHandle->PrepareStatementLC(KSelectPluginsWithMimeType); + stmt->BindStrL(1, *mimeType); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L("Sif Plugin Uid couldn't be found for Mime Type (%S)!"), mimeType); + User::Leave(KErrSifUnsupportedSoftwareType); + } + TUint32 uid = stmt->IntColumnL(0); + CleanupStack::PopAndDestroy(2, mimeType); // mimeType, stmt + + TPckg uidDes(uid); + aMessage.WriteL(1, uidDes); + } + +TBool CScrRequestImpl::GetIntSoftwareTypeDataForComponentLC(TComponentId aComponentId, const TDesC& aColumnName, TInt& aValue) const + { + _LIT(KSelectComponents, "SELECT SoftwareTypeId FROM Components WHERE ComponentId=?;"); + TBool found = EFalse; + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectComponents); + stmt->BindIntL(1, aComponentId); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L("Component Id (%d) doesn't exist in the SCR database!"), aComponentId); + User::LeaveIfError(KErrNotFound); + } + TInt swTypeId = stmt->IntColumnL(0); + CleanupStack::PopAndDestroy(stmt); + + _LIT(KSelectSoftwareTypes, "SELECT %S FROM SoftwareTypes WHERE SoftwareTypeId=?;"); + HBufC *statementStr = FormatStatementLC(KSelectSoftwareTypes(), aColumnName.Length(), &aColumnName); + CStatement *stmtSwType = iDbHandle->PrepareStatementLC(*statementStr); + stmtSwType->BindIntL(1, swTypeId); + + if(stmtSwType->ProcessNextRowL()) + { + aValue = stmtSwType->IntColumnL(0); + found = ETrue; + } + CleanupStack::PopAndDestroy(2, statementStr); // statementStr, stmtSwType + return found; + } + +TBool CScrRequestImpl::GetInstallerSidForComponentL(TComponentId aComponentId, TSecureId& aSid) const + { + _LIT(KInstallerSecureId, "InstallerSecureId"); + TInt secureIdInt (0); + TBool found = GetIntSoftwareTypeDataForComponentLC(aComponentId, KInstallerSecureId, secureIdInt); + aSid.iId = secureIdInt; + return found; + } + +TBool CScrRequestImpl::GetExecutionEnvSidForComponentL(TComponentId aComponentId, TSecureId& aSid) const + { + _LIT(KExecutionLayerSecureId, "ExecutionLayerSecureId"); + TInt secureIdInt(0); + TBool found = GetIntSoftwareTypeDataForComponentLC(aComponentId, KExecutionLayerSecureId, secureIdInt); + aSid.iId = secureIdInt; + return found; + } + +TBool CScrRequestImpl::IsInstallerOrExecutionEnvSidL(TSecureId& aSid) const + { + _LIT(KSelectStatement, "SELECT InstallerSecureId FROM SoftwareTypes WHERE InstallerSecureId=? OR ExecutionLayerSecureId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectStatement); + stmt->BindIntL(1, aSid); + stmt->BindIntL(2, aSid); + TBool res = ETrue; + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L("%d is not an installer SID"), TUint32(aSid)); + res = EFalse; + } + CleanupStack::PopAndDestroy(stmt); + return res; + } + +void CScrRequestImpl::GetPluginUidWithComponentIdL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Returning the plugin of component(%d)."), componentId); + _LIT(KSifPluginUid, "SifPluginUid"); + TInt uid (0); + TBool found = GetIntSoftwareTypeDataForComponentLC(componentId, KSifPluginUid, uid); + __ASSERT_ALWAYS(found, User::Leave(KErrNotFound)); + + TPckg uidDes(uid); + aMessage.WriteL(1, uidDes); + } + +// This function returns whether the SID looked up has been found in the software types table. +TBool CScrRequestImpl::GetSidsForSoftwareTypeL(const HBufC* aSoftwareTypeName, TSecureId& aInstallerSid, TSecureId& aExecutableEnvSid) const + { + DEBUG_PRINTF2(_L("Returning SIDs for software type(%S)."), aSoftwareTypeName); + TBool found = EFalse; + TUint32 swTypeId = HashCaseSensitiveL(*aSoftwareTypeName); + + _LIT(KSelectStatement, "SELECT ExecutionLayerSecureId, InstallerSecureId FROM SoftwareTypes WHERE SoftwareTypeId =?;"); + CStatement* stmt = iDbHandle->PrepareStatementLC(KSelectStatement); + stmt->BindIntL(1, swTypeId); + + if(stmt->ProcessNextRowL()) + { + aExecutableEnvSid = stmt->IntColumnL(0); + aInstallerSid = stmt->IntColumnL(1); + found = ETrue; + } + + CleanupStack::PopAndDestroy(stmt); + return found; + } + +void IntersectSortedArraysL(RArray& aLhs, RArray aRhs) + { + RArray tmp; + CleanupClosePushL(tmp); + TInt idxLhs(0); + TInt idxRhs(0); + TInt countLhs = aLhs.Count(); + TInt countRhs = aRhs.Count(); + + while(idxLhs < countLhs && idxRhs < countRhs) + { + if(aLhs[idxLhs] < aRhs[idxRhs]) + ++idxLhs; + else if(aLhs[idxLhs] > aRhs[idxRhs]) + ++idxRhs; + else + { + tmp.AppendL(aRhs[idxRhs]); + ++idxRhs; + ++idxLhs; + } + } + + aLhs.Reset(); + CopyFixedLengthArrayL(aLhs, tmp); + CleanupStack::PopAndDestroy(&tmp); + } + +void CScrRequestImpl::GetComponentIdsHavingThePropertiesL(RArray& aComponentIds, RPointerArray aProperties, TBool aDoIntersect) const + { + // GROUP BY is added at the end to avoid fetching twice components which have the same localizable values for different locales + _LIT(KFindComponentsFromProperties, "SELECT ComponentId FROM ComponentProperties WHERE Name=? AND %S GROUP BY ComponentId;"); + _LIT(KPropertyIntValue,"IntValue=?"); + _LIT(KPropertyStrValue,"StrValue=?"); + _LIT(KPropertyLocalizedValue,"StrValue=? AND Locale=?"); + + TInt propCount = aProperties.Count(); + + HBufC *statementStr(0); + RArray propCompIds; + CleanupClosePushL(propCompIds); + + for(TInt i=0; iPropertyType()) + { + case CPropertyEntry::EIntProperty: + statementStr = FormatStatementLC(KFindComponentsFromProperties, KPropertyIntValue().Length(), &KPropertyIntValue()); + break; + case CPropertyEntry::EBinaryProperty: + statementStr = FormatStatementLC(KFindComponentsFromProperties, KPropertyStrValue().Length(), &KPropertyStrValue()); + break; + case CPropertyEntry::ELocalizedProperty: + { + CLocalizablePropertyEntry *localizedProp = static_cast(aProperties[i]); + if (localizedProp->LocaleL() == KUnspecifiedLocale) // If the locale was not specified, then we match across all locales + statementStr = FormatStatementLC(KFindComponentsFromProperties, KPropertyStrValue().Length(), &KPropertyStrValue()); + else // Otherwise we match for a specific locale + statementStr = FormatStatementLC(KFindComponentsFromProperties, KPropertyLocalizedValue().Length(), &KPropertyLocalizedValue()); + } + break; + default: + DEBUG_PRINTF(_L8("The property type couldn't be recognized.")); + User::Leave(KErrAbort); + } + + CStatement *stmt = iDbHandle->PrepareStatementLC(*statementStr); + stmt->BindStrL(1, aProperties[i]->PropertyName()); + + switch(aProperties[i]->PropertyType()) + { + case CPropertyEntry::EIntProperty: + { + CIntPropertyEntry *intProp = static_cast(aProperties[i]); + stmt->BindInt64L(2, intProp->Int64Value()); + break; + } + case CPropertyEntry::EBinaryProperty: + { + CBinaryPropertyEntry *binaryProp = static_cast(aProperties[i]); + stmt->BindBinaryL(2, binaryProp->BinaryValue()); + break; + } + case CPropertyEntry::ELocalizedProperty: + { + CLocalizablePropertyEntry *localizedProp = static_cast(aProperties[i]); + stmt->BindStrL(2, localizedProp->StrValue()); + if (localizedProp->LocaleL() != KUnspecifiedLocale) + stmt->BindIntL(3, localizedProp->LocaleL()); + break; + } + default: + DEBUG_PRINTF(_L8("The property type couldn't be recognized.")); + User::Leave(KErrAbort); + } + + while(stmt->ProcessNextRowL()) + { + User::LeaveIfError(propCompIds.InsertInOrder(stmt->IntColumnL(0))); + } + + CleanupStack::PopAndDestroy(2, statementStr); // stmt, statementStr + + if (aDoIntersect) + { + IntersectSortedArraysL(aComponentIds, propCompIds); + } + else + { + CopyFixedLengthArrayL(aComponentIds, propCompIds); + aDoIntersect = ETrue; // If many properties are present in the filter, we need to intersect the component Ids on further iterations + } + + propCompIds.Reset(); + } + CleanupStack::PopAndDestroy(&propCompIds); + } + +void ReallocStatementIfNeededL(RBuf& aStatementStr, TInt aAddedLength) + { + TInt freeSpace = aStatementStr.MaxLength() - aStatementStr.Length(); + TInt extraSpace = aAddedLength - freeSpace; + if (extraSpace > 0) + { + aStatementStr.ReAllocL(aStatementStr.MaxLength() + extraSpace); + } + } + +void AppendConditionToStatementL(RBuf& aStatementStr, const TDesC& aConditionStr, TBool& aIsFirstCondition) + { + TInt addedLength = 2 + aConditionStr.Length(); // 2 chars used by spaces + + _LIT(KConditionAnd, " AND"); + _LIT(KConditionWhere, " WHERE"); + + if(aIsFirstCondition) + { + addedLength += KConditionWhere().Length(); + } + else + { + addedLength += KConditionAnd().Length(); + } + + ReallocStatementIfNeededL(aStatementStr, addedLength); + + if(aIsFirstCondition) + { + aStatementStr.Append(KConditionWhere); + aIsFirstCondition = EFalse; + } + else + { + aStatementStr.Append(KConditionAnd); + } + aStatementStr.Append(aConditionStr); + } + +CStatement* CScrRequestImpl::CreateStatementObjectForComponentLocalizablesLC(const TDesC& aName, const TDesC& aVendor, TUint aSetFlag, TComponentId aComponentId /* = 0*/ ) const + { + _LIT(KSelectComponentLocalizables, "SELECT ComponentId,Name,Vendor FROM ComponentLocalizables"); + RBuf stmtStr; + stmtStr.CreateL(100); // 100 should be enough for this statement + stmtStr.CleanupClosePushL(); + stmtStr.Copy(KSelectComponentLocalizables); + TBool isFirstCondition = ETrue; + + if(aComponentId > 0) + { + _LIT(KConditionComponentId, " ComponentId=?"); + AppendConditionToStatementL(stmtStr, KConditionComponentId, isFirstCondition); + } + + if (aSetFlag & CComponentFilter::EName) + { + _LIT(KConditionName, " Name=?"); + AppendConditionToStatementL(stmtStr, KConditionName, isFirstCondition); + } + + if (aSetFlag & CComponentFilter::EVendor) + { + _LIT(KConditionVendor, " Vendor=?"); + AppendConditionToStatementL(stmtStr, KConditionVendor, isFirstCondition); + } + // Take care not to return the same component id twice in case we have the same name or vendor for two different locales + _LIT(KComponentIdGroupBy, " GROUP BY ComponentId;"); + ReallocStatementIfNeededL(stmtStr, KComponentIdGroupBy().Length() + 1); // one space for the NULL char + stmtStr.Append(KComponentIdGroupBy()); + // SQLite requires the statement string to end with NULL char. + stmtStr.Append('\0'); + + CStatement *stmt = iDbHandle->PrepareStatementLC(stmtStr); + + TInt bindIdx = 1; + if(aComponentId > 0) + { + stmt->BindIntL(bindIdx++, aComponentId); + } + if (aSetFlag & CComponentFilter::EName) + { + stmt->BindStrL(bindIdx++, aName); + } + if (aSetFlag & CComponentFilter::EVendor) + { + stmt->BindStrL(bindIdx, aVendor); + } + CleanupStack::Pop(stmt); + CleanupStack::PopAndDestroy(&stmtStr); + CleanupStack::PushL(stmt); + return stmt; + } + +void CScrRequestImpl::GetComponentsHavingNameVendorL(RArray& aComponentIds, const TDesC& aName, const TDesC& aVendor, TUint16 aSetFlag, TBool aDoIntersect) const + { + CStatement *stmt = CreateStatementObjectForComponentLocalizablesLC(aName, aVendor, aSetFlag); + + RArray foundCompIds; + CleanupClosePushL(foundCompIds); + + while(stmt->ProcessNextRowL()) + { + User::LeaveIfError(foundCompIds.InsertInOrder(stmt->IntColumnL(0))); + } + + if (aDoIntersect) + IntersectSortedArraysL(aComponentIds, foundCompIds); + else + CopyFixedLengthArrayL(aComponentIds, foundCompIds); + + CleanupStack::PopAndDestroy(2, stmt); // stmt, foundCompIds + } + +CComponentFilter* CScrRequestImpl::ReadComponentFilterL(const RMessage2& aMessage) const + { + CComponentFilter *filter = ReadObjectFromMessageLC(aMessage, 0); + CleanupStack::Pop(filter); + return filter; + } + +void AppendFilterConditionToStatementL(TUint16 aSetFlag, TUint16 aConditionFlag, RBuf& aStatementStr, const TDesC& aConditionStr, TBool& aIsFirstCondition) + { + if(aSetFlag & aConditionFlag) + { + AppendConditionToStatementL(aStatementStr, aConditionStr, aIsFirstCondition); + } + } + +void BindIntegerFilterToStatementL(CStatement& aStatement, TUint16 aSetFlag, TUint16 aConditionFlag, TInt aValue, TInt& aStmtIdx) + { + if(aSetFlag & aConditionFlag) + { + aStatement.BindIntL(aStmtIdx++, aValue); + } + } + +CStatement* CScrRequestImpl::OpenComponentViewL(CComponentFilter& aFilter, RArray& aComponentFilterSuperset, TBool& aFilterSupersetInUse) const + { + aComponentFilterSuperset.Reset(); + aFilterSupersetInUse = EFalse; + + TBool doIntersect = EFalse; // We should intersect component ids iff one of the previous filters on component ids was invoked + if(aFilter.iSetFlag & CComponentFilter::EFile) + { + GetFileComponentsL(*aFilter.iFile, aComponentFilterSuperset); + // The component Ids which own the given file is copied into componentIds array. + doIntersect = ETrue; + aFilterSupersetInUse = ETrue; + } + + if(aFilter.iSetFlag & CComponentFilter::EProperty) + { + GetComponentIdsHavingThePropertiesL(aComponentFilterSuperset, aFilter.iPropertyList, doIntersect); + // Inside the function, componentIds array is intersected with the components Ids which have the given properties. + doIntersect = ETrue; + aFilterSupersetInUse = ETrue; + } + + if(aFilter.iSetFlag & (CComponentFilter::EName | CComponentFilter::EVendor)) + { + GetComponentsHavingNameVendorL(aComponentFilterSuperset, *aFilter.iName, *aFilter.iVendor, aFilter.iSetFlag, doIntersect); + // Inside the function, componentIds array is intersected with the components Ids which have the given name/vendor. + aFilterSupersetInUse = ETrue; + } + + _LIT(KSelectComponents, "SELECT ComponentId,SoftwareTypeId,SoftwareTypeName,Removable,Size,ScomoState,DRMProtected,Hidden,KnownRevoked,OriginVerified,GlobalId,InstalledDrives,Version,InstallTime FROM Components"); + + RBuf statementStr; + statementStr.CreateL(KSelectComponents().Length()+ 50); // A reasonable starting buffer length + statementStr.CleanupClosePushL(); + statementStr.Copy(KSelectComponents); + + TBool isFirstCondition = ETrue; + + _LIT(KConditionSoftwareType, " SoftwareTypeId=?"); // as only unique sw type name can be defined in the filter. + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::ESoftwareType, statementStr, KConditionSoftwareType, isFirstCondition); + + _LIT(KConditionRemovable, " Removable=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::ERemovable, statementStr, KConditionRemovable, isFirstCondition); + + _LIT(KConditionScomoState, " ScomoState=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EScomoState, statementStr, KConditionScomoState, isFirstCondition); + + _LIT(KConditionInstalledDrives, " InstalledDrives&?"); // & -> bitwise AND operator + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EInstalledDrive, statementStr, KConditionInstalledDrives, isFirstCondition); + + _LIT(KConditionDrmProtected, " DRMProtected=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EDrmProtected, statementStr, KConditionDrmProtected, isFirstCondition); + + _LIT(KConditionHidden, " Hidden=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EHidden, statementStr, KConditionHidden, isFirstCondition); + + _LIT(KConditionKnownRevoked, " KnownRevoked=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EKnownRevoked, statementStr, KConditionKnownRevoked, isFirstCondition); + + _LIT(KConditionOriginVerified, " OriginVerified=?"); + AppendFilterConditionToStatementL(aFilter.iSetFlag, CComponentFilter::EOriginVerified, statementStr, KConditionOriginVerified, isFirstCondition); + + statementStr.Append(';'); + // SQLite requires the statement string to end with NULL char. + statementStr.Append('\0'); + + CStatement *stmt = iDbHandle->PrepareStatementLC(statementStr); + TInt stmtIdx = 1; + + if(aFilter.iSetFlag & CComponentFilter::ESoftwareType) + { + TUint32 swTypeId = HashCaseSensitiveL(*aFilter.iSwType); + stmt->BindIntL(stmtIdx++, swTypeId); + } + + if(aFilter.iSetFlag & CComponentFilter::EInstalledDrive) + { + if (aFilter.iInstalledDrives.Length() != KMaxDrives) + { + DEBUG_PRINTF2(_L("Incorrect size of drive list supplied in filter, the string supplied was %S"), &aFilter.iInstalledDrives); + User::Leave(KErrArgument); + } + TInt installedDrivesBitmask = InstalledDrivesToBitmaskL(aFilter.iInstalledDrives); + stmt->BindIntL(stmtIdx++, installedDrivesBitmask); + } + + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::ERemovable, aFilter.iRemovable, stmtIdx); + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::EScomoState, aFilter.iScomoState, stmtIdx); + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::EDrmProtected, aFilter.iDrmProtected, stmtIdx); + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::EHidden, aFilter.iHidden, stmtIdx); + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::EKnownRevoked, aFilter.iKnownRevoked, stmtIdx); + BindIntegerFilterToStatementL(*stmt, aFilter.iSetFlag, CComponentFilter::EOriginVerified, aFilter.iOriginVerified, stmtIdx); + + CleanupStack::Pop(stmt); + CleanupStack::PopAndDestroy(&statementStr); + return stmt; + } + +void CScrRequestImpl::AddComponentEntryLocalizablesL(TComponentId aComponentId, CComponentEntry& aEntry, TLanguage aLocale, const CComponentFilter& aFilter) const + { + if(aFilter.iSetFlag & (CComponentFilter::EName | CComponentFilter::EVendor)) + { // If a name or vendor is specified in the filter, the locale is ignored + // and the provided names are retrieved from the ComponentLocalizables table. + CStatement *stmt = CreateStatementObjectForComponentLocalizablesLC(*aFilter.iName, *aFilter.iVendor, aFilter.iSetFlag, aComponentId); + TBool res = stmt->ProcessNextRowL(); + // If the name and the vendor are not found, it means that there is a defect in this class, the filter shouldn't have returned the component in the first place + __ASSERT_ALWAYS(res, User::Leave(KErrNotFound)); + DeleteObjectZ(aEntry.iName); + aEntry.iName = stmt->StrColumnL(1).AllocL(); // Ownership is transferred to the entry object + DeleteObjectZ(aEntry.iVendor); + aEntry.iVendor = stmt->StrColumnL(2).AllocL(); // Ownership is transferred to the entry object + CleanupStack::PopAndDestroy(stmt); + } + else + {// if name and/or vendor are not defined in the filter, try to find them by using the nearest language algorithm. + AddComponentEntryLocalizablesL(aComponentId, aEntry, aLocale); + } + } + + +TBool CScrRequestImpl::IsSoftwareTypeExistingL(TInt aSoftwareTypeId) const + { + TBool result = EFalse; + _LIT(KComponentSoftwareType, "SELECT SoftwareTypeId FROM SoftwareTypes WHERE SoftwareTypeId=?;"); + + CStatement *stmt = iDbHandle->PrepareStatementLC(KComponentSoftwareType); + stmt->BindIntL(1, aSoftwareTypeId); + + if(stmt->ProcessNextRowL()) + { // The software type exists. + result = ETrue; + } + CleanupStack::PopAndDestroy(stmt); + return result; + } + +void CScrRequestImpl::SubsessionAddLocalizableSoftwareTypeNameL(CStatement& aStmt, CComponentEntry& aEntry, TLanguage aLocale, CCompViewSubsessionContext* aSubsessionContext) const + { + TInt softwareTypeId = aStmt.IntColumnL(1); + // Check if we've already cached this software type name - caching is important here as fetching the same software type name for all components in the sub-session is expensive + if (softwareTypeId == aSubsessionContext->iLastSoftwareTypeId) + { + DeleteObjectZ(aEntry.iSwType); + aEntry.iSwType = aSubsessionContext->iLastSoftwareTypeName->AllocL(); + } + else + { + AddSoftwareTypeNameToComponentEntryL(aStmt, aEntry, aLocale); + // Save the last results - if the next component in the filter has the same software type id, we won't have to recalculate the name + aSubsessionContext->iLastSoftwareTypeId = softwareTypeId; + DeleteObjectZ(aSubsessionContext->iLastSoftwareTypeName); + aSubsessionContext->iLastSoftwareTypeName = aEntry.iSwType->AllocL(); + } + } + +CComponentEntry* CScrRequestImpl::GetNextComponentEntryL(CStatement& aStmt, CComponentFilter& aFilter, TLanguage aLocale, CCompViewSubsessionContext* aSubsessionContext) const + { + // Since the query does not account for filter's name, vendor, property and file conditions, + // we intersect the resut of the query with components which answer these conditions, i.e. iComponentFilterSuperset + while (1) + { + if(!aStmt.ProcessNextRowL()) + { + return NULL; + } + TComponentId queryComponentId = aStmt.IntColumnL(0); + if (!aSubsessionContext->iFilterSupersetInUse || aSubsessionContext->iComponentFilterSuperset.FindInOrder(queryComponentId) >= 0) + break; // The component id exists in both parts of the filter - return it. + } + + CComponentEntry *component = CreateComponentEntryFromStatementHandleL(aStmt); + CleanupStack::PushL(component); + AddComponentEntryLocalizablesL(component->ComponentId(), *component, aLocale, aFilter); + SubsessionAddLocalizableSoftwareTypeNameL(aStmt, *component, aLocale, aSubsessionContext); + CleanupStack::Pop(component); + return component; + } + +void CScrRequestImpl::NextComponentSizeL(const RMessage2& aMessage, CStatement* aStmt, CComponentFilter* aFilter, CComponentEntry*& aEntry, CCompViewSubsessionContext* aSubsessionContext) const + { + __ASSERT_ALWAYS(aStmt && aFilter, PanicClient(aMessage, KScrIllegalCallSequence)); + + TLanguage locale = TLanguage(aMessage.Int0()); + + DeleteObjectZ(aEntry); + aEntry = GetNextComponentEntryL(*aStmt, *aFilter, locale, aSubsessionContext); + TInt sizeSlot = 1; + if(!aEntry) + { + DEBUG_PRINTF(_L8("Reached the end of the view.")); + WriteIntValueL(aMessage, sizeSlot, 0); + return; + } + WriteObjectSizeL(aMessage, sizeSlot, aEntry); + } + +void CScrRequestImpl::NextComponentDataL(const RMessage2& aMessage, CComponentEntry*& aEntry) const + { + DEBUG_PRINTF(_L8("Returning the component entry data.")); + WriteObjectDataL(aMessage, 0, aEntry); + DeleteObjectZ(aEntry); // Delete the object to prevent it to be resent. + } + +void CScrRequestImpl::NextComponentSetSizeL(const RMessage2& aMessage, CStatement* aStmt, CComponentFilter* aFilter, RPointerArray& aEntryList, CCompViewSubsessionContext* aSubsessionContext) const + { + DEBUG_PRINTF(_L8("Returning the size of the next component entry set.")); + __ASSERT_ALWAYS(aStmt && aFilter, PanicClient(aMessage, KScrIllegalCallSequence)); + + TInt maxArraySize = aMessage.Int0(); + TLanguage locale = TLanguage(aMessage.Int1()); + + aEntryList.ResetAndDestroy(); + for(TInt i=0; i& aEntryList) const + { + DEBUG_PRINTF(_L8("Returning the next component entry set.")); + WriteArrayDataL(aMessage, 0, aEntryList); + } + +void CScrRequestImpl::GetComponentIdListSizeL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning the required size to copy all components IDs from the components view.")); + // Get filter from the client + CComponentFilter *filter = ReadComponentFilterL(aMessage); + CleanupStack::PushL(filter); + + RArray componentFilterSuperset; + CleanupClosePushL(componentFilterSuperset); + TBool filterSupersetInUse; + // Create a statement based on the filter + CStatement *stmt = OpenComponentViewL(*filter, componentFilterSuperset, filterSupersetInUse); + CleanupStack::PushL(stmt); + iComponentIdList.Reset(); + // Fetch all components from the row set and put them into the component list + while(stmt->ProcessNextRowL()) + { + TComponentId componentId = stmt->IntColumnL(0); + if (filterSupersetInUse && componentFilterSuperset.FindInOrder(componentId) < 0) + continue; // The component id does not match the name/vendor/file/property filter - do not add it to the result + iComponentIdList.InsertInOrder(componentId); + } + // Release allocated memories + CleanupStack::PopAndDestroy(3, filter); // stmt, componentFilterSuperset, filter + WriteArraySizeL(aMessage, 1, iComponentIdList); + } + +void CScrRequestImpl::GetComponentIdListDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Returning all components IDs from the components view.")); + WriteArrayDataL(aMessage, 0, iComponentIdList); + } + +CStatement* CScrRequestImpl::OpenFileListStatementL(TComponentId aComponentId) const + { + _LIT(KSelectFilesOfComponent, "SELECT Location FROM ComponentsFiles WHERE ComponentId=?;"); + + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectFilesOfComponent); + stmt->BindIntL(1, aComponentId); + CleanupStack::Pop(stmt); // Ownership is transferred to the caller + + return stmt; + } + +CStatement* CScrRequestImpl::OpenFileListL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Creating the requested file list for component(%d)."), componentId); + return OpenFileListStatementL(componentId); + } + +HBufC* CScrRequestImpl::GetNextFilePathL(CStatement& aStmt) const + { + if(!aStmt.ProcessNextRowL()) + { + return NULL; + } + return aStmt.StrColumnL(0).AllocL(); + } + +void CScrRequestImpl::NextFileSizeL(const RMessage2& aMessage, CStatement* aStmt, HBufC*& aFilePath) const + { + __ASSERT_ALWAYS(aStmt, PanicClient(aMessage, KScrIllegalCallSequence)); + DeleteObjectZ(aFilePath); + aFilePath = GetNextFilePathL(*aStmt); + WriteObjectSizeL(aMessage, 0, aFilePath); + } + +void CScrRequestImpl::NextFileDataL(const RMessage2& aMessage, HBufC*& aFilePath) const + { + WriteObjectDataL(aMessage, 0, aFilePath); + DeleteObjectZ(aFilePath); // Delete the file path to prevent it to be resent. + } + +void CScrRequestImpl::NextFileSetSizeL(const RMessage2& aMessage, CStatement* aStmt, RPointerArray& aFileList) const + { + __ASSERT_ALWAYS(aStmt, PanicClient(aMessage, KScrIllegalCallSequence)); + TInt maxArraySize = aMessage.Int0(); + aFileList.ResetAndDestroy(); + for(TInt i=0; i& aFileList) const + { + DEBUG_PRINTF(_L8("Returning the next file path set.")); + WriteArrayDataL(aMessage, 0, aFileList); + } + +TComponentId CScrRequestImpl::GetComponentIdFromMsgL(const RMessage2& aMessage) + { + return aMessage.Int0(); + } + +HBufC* CScrRequestImpl::GetSoftwareTypeNameFromMsgLC(const RMessage2& aMessage) + { + switch (CScsServer::StripScsFunctionMask(aMessage.Function())) + { + case EAddComponent: + case EAddComponentDependency: + case EDeleteComponentDependency: + { + return ReadDescLC(aMessage, 0); + } + default: + __ASSERT_ALWAYS(0, User::Invariant()); + } + return NULL; + } + +HBufC* CScrRequestImpl::ReadFileNameFromMsgLC(const RMessage2& aMessage) + { + return ReadDescLC(aMessage, 1); + } + +void CScrRequestImpl::InitializeDbVersionL() + { + _LIT(KSelectStatement, "SELECT MajorVersion, MinorVersion, BuildNumber FROM ScrVersion;"); + CStatement* stmt = iDbHandle->PrepareStatementLC(KSelectStatement); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF(_L("Could not find entries in the version table - internal problem")); + User::Leave(KErrCorrupt); + } + + iDbVersion.iMajor = stmt->IntColumnL(0); + iDbVersion.iMinor = stmt->IntColumnL(1); + iDbVersion.iBuild = stmt->IntColumnL(2); + CleanupStack::PopAndDestroy(stmt); + DEBUG_PRINTF4(_L8("Opened SCR database with major version %d, minor version %d, and build number %d."), iDbVersion.iMajor, + iDbVersion.iMinor, iDbVersion.iBuild); + } + +void CScrRequestImpl::VerifyDbVersionCompatibilityL() const + { + if (iDbVersion.iMajor != KDbInterfaceMajorVersion) + { + DEBUG_PRINTF3(_L8("The SCR DB is incompatible! Supported major version is %d, and the DB major version is %d"), KDbInterfaceMajorVersion, iDbVersion.iMajor); + User::Leave(KErrCorrupt); + } + + if (iDbVersion.iMinor > KDbInterfaceMinorVersion) + { + DEBUG_PRINTF3(_L8("The SCR DB supports newer features which are not available in this software version. The DB minor version is %d, while the supported minor version is %d"), iDbVersion.iMinor, KDbInterfaceMinorVersion); + return; + } + + if (iDbVersion.iMinor < KDbInterfaceMinorVersion) + { + DEBUG_PRINTF3(_L8("The SCR DB does not support some newer features available in this software version. The DB minor version is %d, while the supported minor version is %d"), iDbVersion.iMinor, KDbInterfaceMinorVersion); + return; + } + + DEBUG_PRINTF4(_L8("The SCR DB has matching version with the supported interface. Supported major version is %d, minor version %d and build number %d"), KDbInterfaceMajorVersion, KDbInterfaceMinorVersion, KDbInterfaceBuildNumber); + } + +void ExtractNumberFromHexStringL(TInt& aPosition, const TDesC8& aString, TUint32& aIntValue) + { + TLex8 l(aString.Mid(aPosition, KUidStringLen)); + l.Val(aIntValue, EHex); + aPosition += KUidStringLen; + } + +void ParseUidHexStringL(const TDesC8& aUidString, TUint32& aSifPluginUid, TUint32& aInstallerSid, TUint32& aExecutionLayerSid) + { + __ASSERT_ALWAYS(aUidString.Length() >= 3*KUidStringLen, User::Leave(KErrArgument)); + TInt pos (0); // The starting position of aUidString + ExtractNumberFromHexStringL(pos, aUidString, aSifPluginUid); + ExtractNumberFromHexStringL(pos, aUidString, aInstallerSid); + ExtractNumberFromHexStringL(pos, aUidString, aExecutionLayerSid); + } + +TBool CompareLocalizedSoftwareTypeName(const CLocalizedSoftwareTypeName& aLeft, const CLocalizedSoftwareTypeName& aRight) + { + TBool result = EFalse; + + TRAPD(err, result = (aLeft.Locale() == aRight.Locale() && !aLeft.NameL().CompareF(aRight.NameL()))); + if (err != KErrNone) + { + DEBUG_PRINTF2(_L("CompareLocalizedSoftwareTypeName has left with error %d"), err); + return EFalse; + } + else + { + return result; + } + } + +TBool CompareHBufDescs(const HBufC& aLeft, const HBufC& aRight) + { + return !aLeft.CompareF(aRight); + } + +TBool CScrRequestImpl::IsSoftwareTypeExistingL(TUint32 aSwTypeId, TUint32 aSifPluginUid, TUint32 aInstallerSecureId, TUint32 aExecutionLayerSecureId, const RPointerArray& aMimeTypesArray, const RPointerArray& aLocalizedNamesArray) + { + _LIT(KSelectSoftwareType, "SELECT SifPluginUid,InstallerSecureId,ExecutionLayerSecureId FROM SoftwareTypes WHERE SoftwareTypeId=?;"); + CStatement* stmt = iDbHandle->PrepareStatementLC(KSelectSoftwareType); + stmt->BindIntL(1, aSwTypeId); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L8("IsSoftwareTypeExistingL: Software Type Id (%d) doesn't exist in the SCR."), aSwTypeId); + CleanupStack::PopAndDestroy(stmt); + return EFalse; + } + TBool uidsNotEqual = aSifPluginUid != stmt->IntColumnL(0) || + aInstallerSecureId != stmt->IntColumnL(1) || + aExecutionLayerSecureId != stmt->IntColumnL(2); + if(uidsNotEqual) + { + DEBUG_PRINTF(_L8("IsSoftwareTypeExistingL: One of the UIDs is different from the one in the database.")); + CleanupStack::PopAndDestroy(stmt); + return EFalse; + } + CleanupStack::PopAndDestroy(stmt); + + _LIT(KSelectSwTypeNames, "SELECT Locale,Name FROM SoftwareTypeNames WHERE SoftwareTypeId=? AND Locale!=?;"); + CStatement* stmtNames = iDbHandle->PrepareStatementLC(KSelectSwTypeNames); + stmtNames->BindIntL(1, aSwTypeId); + stmtNames->BindIntL(2, KNonLocalized); + TInt numOfFoundNames (0); + while(stmtNames->ProcessNextRowL()) + { + ++numOfFoundNames; + const TDesC& swTypeNameValue = stmtNames->StrColumnL(1); + CLocalizedSoftwareTypeName *swTypeName = CLocalizedSoftwareTypeName::NewLC(swTypeNameValue, TLanguage(stmtNames->IntColumnL(0))); + TInt ret = aLocalizedNamesArray.Find(swTypeName, TIdentityRelation(CompareLocalizedSoftwareTypeName)); + CleanupStack::PopAndDestroy(swTypeName); + if(KErrNotFound == ret) + { + DEBUG_PRINTF2(_L("IsSoftwareTypeExistingL: %S doesn't exist in the provided sofwtare type names list."), &swTypeNameValue); + CleanupStack::PopAndDestroy(stmtNames); + return EFalse; + } + } + CleanupStack::PopAndDestroy(stmtNames); + if(numOfFoundNames != aLocalizedNamesArray.Count()) + { + DEBUG_PRINTF3(_L("IsSoftwareTypeExistingL: the number of provided software type names (%d) is different than the number of existing software type names (%d) in the SCR."), numOfFoundNames, aLocalizedNamesArray.Count()); + return EFalse; + } + + _LIT(KSelectMimeTypes, "SELECT MimeType FROM MimeTypes WHERE SoftwareTypeId=?;"); + CStatement* stmtMimes = iDbHandle->PrepareStatementLC(KSelectMimeTypes); + stmtMimes->BindIntL(1, aSwTypeId); + TInt numOfFoundMimes (0); + while(stmtMimes->ProcessNextRowL()) + { + ++numOfFoundMimes; + HBufC *mimeType = stmtMimes->StrColumnL(0).AllocLC(); + TInt ret = aMimeTypesArray.Find(mimeType, TIdentityRelation(CompareHBufDescs)); + if(KErrNotFound == ret) + { + DEBUG_PRINTF2(_L("IsSoftwareTypeExistingL: %S doesn't exist in the provided MIME types list."), mimeType); + CleanupStack::PopAndDestroy(2, stmtMimes); // stmtMimes, mimeType + return EFalse; + } + CleanupStack::PopAndDestroy(mimeType); + } + CleanupStack::PopAndDestroy(stmtMimes); + if(numOfFoundMimes != aMimeTypesArray.Count()) + { + DEBUG_PRINTF3(_L("IsSoftwareTypeExistingL: the number of provided MIME types (%d) is different than the number of existing MIME types (%d) in the SCR."), numOfFoundMimes, aMimeTypesArray.Count()); + return EFalse; + } + // All software type details are identical + DEBUG_PRINTF(_L8("IsSoftwareTypeExistingL: All software type details are identical. This is a software type update.")); + return ETrue; + } + +void CScrRequestImpl::AddSoftwareTypeL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Adding a new software type.")); + // NB SoftwareTypeId is the hash of unique software type name. Since this name is unique, it is expected + // that there won't be any conflicts with software type ids. If an installer is uninstalled and then re-installed, + // the same software type id will be assigned for it as its unique name is not changed. The advantage is that + // the orphaned components will become non-orphaned again automatically when their installer is re-installed. + // Otherwise, we would have to find a complex solution to associate the software type id of orphaned components + // with the corresponding installer which had been re-installed. + // Another advantage of this approach is that it is not mandatory to query SoftwareTypes table in order to get + // the software type id of an installer. If the uniqe software type name of the installer is known, its hash + // is simply calculated to obtain its software type id. + + // Slot-0 contains Unique Software Type Name + HBufC *uniqueSwTypeName = ReadDescLC(aMessage, 0); + TUint32 swTypeId = HashCaseSensitiveL(*uniqueSwTypeName); + + // Slot-1 contains the concatenated values of SifPluginUid, InstallerSecureId and ExecutionLayerSecureId in turn. + HBufC8 *uidString = ReadDesc8LC(aMessage, 1); + TUint32 sifPluginUid (0); + TUint32 installerSecureId (0); + TUint32 executionLayerSecureId (0); + ParseUidHexStringL(*uidString, sifPluginUid, installerSecureId, executionLayerSecureId); + CleanupStack::PopAndDestroy(uidString); + + // Slot-2 contains the list of MIME types + RIpcReadStream mimeTypesReader; + CleanupClosePushL(mimeTypesReader); + mimeTypesReader.Open(aMessage, 2); + + RPointerArray mimeTypesArray; + CleanupResetAndDestroyPushL(mimeTypesArray); + InternalizePointersArrayL(mimeTypesArray, mimeTypesReader); + + // Slot-3 contains Localized Software Type Names + RIpcReadStream localizedNamesReader; + CleanupClosePushL(localizedNamesReader); + localizedNamesReader.Open(aMessage, 3); + + RPointerArray localizedNamesArray; + CleanupResetAndDestroyPushL(localizedNamesArray); + InternalizePointersArrayL(localizedNamesArray, localizedNamesReader); + + if (IsSoftwareTypeExistingL(swTypeId, sifPluginUid, installerSecureId, executionLayerSecureId, mimeTypesArray, localizedNamesArray)) + { // If the software type exists, do nothing and return; + CleanupStack::PopAndDestroy(5, uniqueSwTypeName); // uniqueSwTypeName, mimeTypesReader, mimeTypesArray, localizedNamesReader, localizedNamesArray + return; + } + + // First, insert the main record to SoftwareTypes table + _LIT(KInsertSwType, "INSERT INTO SoftwareTypes(SoftwareTypeId,SifPluginUid,InstallerSecureId,ExecutionLayerSecureId) VALUES(?,?,?,?);"); + TInt numberOfValuesSwType = 4; + ExecuteStatementL(KInsertSwType(), numberOfValuesSwType, EValueInteger, swTypeId, EValueInteger, sifPluginUid, EValueInteger, installerSecureId, EValueInteger, executionLayerSecureId); + + // Then, insert MIME types of this software type into MimeTypes table + _LIT(KInsertMimeType, "INSERT INTO MimeTypes(SoftwareTypeId,MimeType) VALUES(?,?);"); + TInt numberOfValuesMimeType = 2; + TInt countMimeTypes = mimeTypesArray.Count(); + for(TInt i=0; iLocale(); + const TDesC& name = localizedNamesArray[i]->NameL(); + ExecuteStatementL(KInsertSwTypeName(), numberOfValuesSwTypeName, EValueInteger, swTypeId, EValueInteger, locale, EValueString, &name); + } + CleanupStack::PopAndDestroy(5, uniqueSwTypeName); // uniqueSwTypeName, mimeTypesReader, mimeTypesArray, localizedNamesReader, localizedNamesArray + } + +void CScrRequestImpl::DeleteSoftwareTypeL(const RMessage2& aMessage) + { + HBufC *uniqueSwTypeName = ReadDescLC(aMessage, 0); + DEBUG_PRINTF2(_L("Deleting Software type (%S)."), uniqueSwTypeName); + + TUint32 swTypeId = HashCaseSensitiveL(*uniqueSwTypeName); + CleanupStack::PopAndDestroy(uniqueSwTypeName); + + // First, delete software type names + _LIT(KDeleteSoftwareTypeNames, "DELETE FROM SoftwareTypeNames WHERE SoftwareTypeId=?;"); + TInt numberOfValues = 1; + ExecuteStatementL(KDeleteSoftwareTypeNames(), numberOfValues, EValueInteger, swTypeId); + + // Secondly, delete the actual software type record + _LIT(KDeleteSoftwareType, "DELETE FROM SoftwareTypes WHERE SoftwareTypeId=?;"); + ExecuteStatementL(KDeleteSoftwareType(), numberOfValues, EValueInteger, swTypeId); + + // Thirdly, get the list of MIME types belong to the deleted software type. + // This list will be returned to the client with another request (GetDeletedMimeTypesL) + _LIT(KSelectMimeTypes, "SELECT MimeType FROM MimeTypes WHERE SoftwareTypeId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectMimeTypes); + stmt->BindIntL(1, swTypeId); + + iDeletedMimeTypes.ResetAndDestroy(); + while(stmt->ProcessNextRowL()) + { + iDeletedMimeTypes.AppendL(stmt->StrColumnL(0).AllocL()); + } + CleanupStack::PopAndDestroy(stmt); + + // Finally, delete the MIME types belong to the deleted software type name + _LIT(KDeleteMimeTypes, "DELETE FROM MimeTypes WHERE SoftwareTypeId=?;"); + ExecuteStatementL(KDeleteMimeTypes(), numberOfValues, EValueInteger, swTypeId); + WriteArraySizeL(aMessage, 1, iDeletedMimeTypes); + } + +void CScrRequestImpl::GetDeletedMimeTypesL(const RMessage2& aMessage) const + { + WriteArrayDataL(aMessage, 0, iDeletedMimeTypes); + iDeletedMimeTypes.ResetAndDestroy(); + } + +TBool CScrRequestImpl::GetIsComponentOrphanedL(TComponentId aComponentId) const + { + _LIT(KComponentSoftwareTypeId, "SELECT SoftwareTypeId FROM Components WHERE ComponentId=?;"); + + CStatement *stmt = iDbHandle->PrepareStatementLC(KComponentSoftwareTypeId); + stmt->BindIntL(1, aComponentId); + + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L("Component Id (%d) couldn't be found!"), aComponentId); + User::Leave(KErrNotFound); + } + + TUint32 swTypeId = stmt->IntColumnL(0); + CleanupStack::PopAndDestroy(stmt); + + // The component is orphaned iff the software type does not exist. + return !IsSoftwareTypeExistingL(swTypeId); + } + +void CScrRequestImpl::GetIsComponentOrphanedL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + TBool result = GetIsComponentOrphanedL(componentId); + DEBUG_PRINTF2(_L8("Retrieving whether the component(%d) is orphaned."), componentId); + + TPckg resultPkg(result); + + aMessage.WriteL(1, resultPkg); + } + +void CheckAndCreateLogFileL(RFs& aFs, const TDesC& aFileName) + { + TEntry entry; + TInt err = aFs.Entry(aFileName, entry); + + if(KErrNone == err) + return; + + if (KErrPathNotFound == err) + { + User::LeaveIfError(aFs.MkDirAll(aFileName)); + } + else if(KErrNotFound != err) + { + DEBUG_PRINTF2(_L("The log file couldn't be opened. Error=%d."), err); + User::Leave(err); + } + + RFileWriteStream stream; + User::LeaveIfError(stream.Create(aFs, aFileName, EFileWrite | EFileShareAny | EFileStream)); + stream.PushL(); + stream.WriteInt32L(1); // The major version of the log file + stream.WriteInt32L(0); // The minor version of the log file + // Please note that the log file version is not used currently. It is implemented for a possible future need. + // If the version format is changed, then the end of FlushLogEntriesArrayL function where the final log count is written must be updated. + // FlushLogEntriesArrayL assumes that first 8 bytes store version information. + stream.WriteInt32L(0); // The number of log records in the log file + stream.CommitL(); + CleanupStack::PopAndDestroy(&stream); + } + +void CScrRequestImpl::FlushLogEntriesArrayL() + { + TInt logCount2bFlushed = iLogEntries.Count(); + if(!logCount2bFlushed) + return; // No record to write into the log file. + + // Get the log file name + HBufC *logFileName = UpdateFilePathDriveLC(KScrLogFileName, iFs.GetSystemDriveChar()); + // Check whether the log file exists. If not, create one. + CheckAndCreateLogFileL(iFs, *logFileName); + + RFileReadStream readStream; + User::LeaveIfError(readStream.Open(iFs, *logFileName, EFileRead|EFileShareExclusive|EFileStream)); + readStream.PushL(); + (void)readStream.ReadInt32L(); // skip the major version of the log file + (void)readStream.ReadInt32L(); // skip the minor version of the log file + TInt currentLogCount = readStream.ReadInt32L(); + + if(KMaxScrLogEntries <= currentLogCount + logCount2bFlushed) + { + //Create a temporary file and read the log file in that + //oldest entries will be removed in the temporary log file + HBufC *tempLogName = UpdateFilePathDriveLC(KScrTempLogFileName, iFs.GetSystemDriveChar()); + TInt err = iFs.Delete(*tempLogName); + __ASSERT_ALWAYS(err == KErrNotFound || err == KErrNone, User::Leave(err)); + CheckAndCreateLogFileL(iFs, *tempLogName); + + RFileWriteStream writeStream; + User::LeaveIfError(writeStream.Open(iFs, *tempLogName, EFileWrite | EFileStream)); + writeStream.PushL(); + writeStream.Sink()->SeekL(MStreamBuf::EWrite,EStreamEnd); // Skip the version info and log count + + TInt tmpLogCount (0); + CScrLogEntry *log = NULL; + + for (TInt i = logCount2bFlushed; i < currentLogCount; ++i, ++tmpLogCount) + { + log = CScrLogEntry::NewLC(readStream); + writeStream << *log; + CleanupStack::PopAndDestroy(log); + } // for + + currentLogCount = tmpLogCount; + writeStream.CommitL(); + CleanupStack::PopAndDestroy(&writeStream); + readStream.Release(); + + RStsSession stsSession; // transaction service + CleanupClosePushL(stsSession); + stsSession.CreateTransactionL(); + + stsSession.RemoveL(*logFileName); + stsSession.RegisterNewL(*logFileName); + stsSession.RegisterTemporaryL(*tempLogName); + + TInt renameErr = iFs.Rename(*tempLogName,*logFileName); + if (KErrNone == renameErr) + { + // commit file changes. + stsSession.CommitL(); + } + else + { + // rollback file changes and leave with the error code. + stsSession.RollBackL(); + DEBUG_PRINTF2(_L("The log file couldn't be renamed. Error=%d."), renameErr); + User::Leave(renameErr); + } + CleanupStack::PopAndDestroy(2, tempLogName); // tempLogName, stsSession + } // endif KMaxScrLogEntries <= + + CleanupStack::PopAndDestroy(&readStream); + + RFile file; + User::LeaveIfError(file.Open(iFs, *logFileName, EFileRead|EFileWrite| EFileShareExclusive| EFileStream)); + CleanupClosePushL(file); + TInt pos (0); + User::LeaveIfError(file.Seek(ESeekEnd, pos)); + RFileWriteStream stream(file, pos); + stream.PushL(); + + TInt startIdx = (logCount2bFlushed - KMaxScrLogEntries)>0 ? (logCount2bFlushed - KMaxScrLogEntries) : 0; + TInt logCountFlushed (0); + for(TInt i=startIdx; iExternalizeL(stream); + } + iLogEntries.ResetAndDestroy(); + stream.CommitL(); + stream.Release(); + file.Close(); + + // Update the log count + User::LeaveIfError(stream.Open(iFs, *logFileName, EFileRead|EFileWrite|EFileShareExclusive|EFileStream)); + stream.Sink()->SeekL(MStreamBuf::EWrite,EStreamBeginning,8); // Skip the version info + stream.WriteInt32L(logCountFlushed + currentLogCount); + stream.CommitL(); + + CleanupStack::PopAndDestroy(3, logFileName); // logFileName, file, stream + } + +void CScrRequestImpl::GetLogFileHandleL(const RMessage2& aMessage) const + { + // Get the log file name + HBufC *logFileName = UpdateFilePathDriveLC(KScrLogFileName, iFs.GetSystemDriveChar()); + // Check whether the log file exists. If not, create one. + CheckAndCreateLogFileL(iFs, *logFileName); + + RFile file; + User::LeaveIfError(file.Open(iFs, *logFileName, EFileRead | EFileShareAny | EFileStream)); + CleanupClosePushL(file); + + // Store the RFile handle into the package buffer in slot 0 and complete the message with the RFs handle + User::LeaveIfError(file.TransferToClient(aMessage, 0)); + ASSERT(aMessage.IsNull()); // The message should have been completed + CleanupStack::PopAndDestroy(2, logFileName); // logFileName, file + } + +void CScrRequestImpl::GetIsComponentOnReadOnlyDriveL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Checking if the component(%d) is on read-only drive."), componentId); + + // Get the drives on which the component files' are registered + TInt driveBitmask = GetInstalledDrivesBitmaskL(componentId); + + TBool result = EFalse; + + for (TInt index = 0; index < KMaxDrives; ++index, driveBitmask >>= 1) + { + if ((driveBitmask & 0x1) && IsDriveReadOnlyL(index)) + { + DEBUG_PRINTF3(_L8("Component %d has registered a file at read-only drive %c ."), componentId, index + 'a'); + result = ETrue; + break; + } + } + + TPckg resPkg(result); + aMessage.WriteL(1, resPkg); + } + +TBool CScrRequestImpl::IsDriveReadOnlyL(TInt driveIndex) const + { + TDriveInfo driveInfo; + User::LeaveIfError(iFs.Drive(driveInfo,driveIndex)); + + TBool result = EFalse; + if ((driveInfo.iDriveAtt&KDriveAttRom) || (driveInfo.iType==EMediaRom)) + result = ETrue; + + return result; + } + +void CScrRequestImpl::GetIsComponentPresentL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Checking if the component(%d) is available."), componentId); + + _LIT(KSelectCompPresent, "SELECT CompPresence FROM Components WHERE ComponentId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectCompPresent); + stmt->BindIntL(1, componentId); + if(!stmt->ProcessNextRowL()) + { + DEBUG_PRINTF2(_L8("Component (%d) couldn't be found in the SCR database."), componentId); + User::Leave(KErrNotFound); + } + TBool result = (stmt->IntColumnL(0) == 1); + CleanupStack::PopAndDestroy(stmt); + + // The default value for CompPresence is ETrue. So when we find that the SCR DB contains the + // default property value we check if the drives registered by the component are present. + if (result && !CheckForMediaPresenceL(componentId)) + { + result = EFalse; + } + + TPckg isCompPresent(result); + aMessage.WriteL(1, isCompPresent); + } + +void CScrRequestImpl::SetIsComponentPresentL(const RMessage2& aMessage) + { + DEBUG_PRINTF(_L8("Setting the component as present.")); + _LIT(KColumnNameCompPresence, "CompPresence"); + ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameCompPresence); + } + +void CScrRequestImpl::GetComponentSupportedLocalesListSizeL(const RMessage2& aMessage) const + { + TComponentId componentId = GetComponentIdFromMsgL(aMessage); + DEBUG_PRINTF2(_L8("Returning the required size to copy all matching supported language IDs for component =(%d)"), componentId); + + _LIT(KSelectMatchingSupportedLocales, "SELECT Locale FROM ComponentLocalizables WHERE ComponentId=?;"); + CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectMatchingSupportedLocales); + stmt->BindIntL(1, componentId); + iMatchingSupportedLanguageList.Close(); + while(stmt->ProcessNextRowL()) + { + TLanguage languageId = (TLanguage)stmt->IntColumnL(0); + iMatchingSupportedLanguageList.Insert(languageId,iMatchingSupportedLanguageList.Count()); + } + if (iMatchingSupportedLanguageList.Count() == 1) + { + iMatchingSupportedLanguageList.Close(); + } + + // Release allocated memories + CleanupStack::PopAndDestroy(1, stmt); // stmt + WriteArraySizeL(aMessage, 1, iMatchingSupportedLanguageList); + + } + +void CScrRequestImpl::GetComponentSupportedLocalesListDataL(const RMessage2& aMessage) const + { + DEBUG_PRINTF(_L8("Getting the Data of matching supported languages")); + WriteArrayDataL(aMessage, 0, iMatchingSupportedLanguageList); + iMatchingSupportedLanguageList.Close(); + }