--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/interpretsislib/dbhelper.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,911 @@
+/*
+* 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:
+*
+*/
+
+
+#include "dbhelper.h"
+#include "dbprocessor.h"
+#include "dbconstants.h"
+#include "is_utils.h"
+#include "sisregistryobject.h"
+#include "sisregistrytoken.h"
+#include "sisregistrypackage.h"
+#include "errors.h"
+#include "../common/exception.h"
+
+#include <sstream>
+#include <stdexcept>
+
+const int DbHelper::Absent = -1;
+
+DbHelper::DbHelper( const std::wstring& aDrivePath, bool aIsSystemDrive)
+ {
+ std::string dllName = "sqlite3.dll";
+ std::string dbName;
+
+ if (aIsSystemDrive)
+ dbName = wstring2string(aDrivePath) + "\\sys\\install\\scr\\scr.db";
+ else
+ dbName = wstring2string(aDrivePath) + "\\sys\\install\\scr\\provisioned\\scr.db";
+
+ try
+ {
+ iScrDbHandler = new CDbProcessor(dllName, dbName);
+ }
+ catch(CException& aException)
+ {
+ int returnCode = aException.GetCode();
+ std::wstring emessage = Utf8ToUcs2( aException.GetMessageA() );
+
+ returnCode = (returnCode == ExceptionCodes::ELibraryLoadError) ? LIBRARYLOAD_ERROR : returnCode;
+ throw InterpretSisError(emessage,returnCode);
+ }
+ }
+
+TBool DbHelper::IsInstalled(TInt32 aUid) const
+ {
+ std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE Name='CompUid' and IntValue=?;");
+ std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));
+
+ stmtUid->BindInt(1, aUid);
+
+ if(!stmtUid->ProcessNextRow())
+ return false;
+
+ TInt32 uid = stmtUid->IntColumn(0);
+ return (uid == aUid);
+ }
+
+TInt32 DbHelper::GetComponentId(TInt32 aUid, const std::wstring aPackageName, const std::wstring aVendorName ) const
+ {
+ std::string selectUid("SELECT ComponentId from ComponentProperties where Name='CompUid' and IntValue=? and ComponentId IN (SELECT ComponentId FROM \
+ ComponentProperties WHERE Name='CompUniqueVendorName' and StrValue=? and ComponentId IN (SELECT ComponentId FROM ComponentLocalizables WHERE Name=?));");
+ std::auto_ptr<CStatement> stmtCompid(iScrDbHandler->PrepareStatement(selectUid));
+
+ stmtCompid->BindInt(1, aUid);
+ stmtCompid->BindStr(2, aVendorName);
+ stmtCompid->BindStr(3, aPackageName);
+
+ TInt32 componentId = DbHelper::Absent;
+ if(stmtCompid->ProcessNextRow())
+ {
+ componentId = stmtCompid->IntColumn(0);
+ }
+ return componentId;
+ }
+
+TInt32 DbHelper::GetComponentId(TInt32 aUid, TInt32 aInstallType ) const
+ {
+ std::string selectUid("SELECT ComponentId from ComponentProperties where Name='CompUid' and IntValue=? and ComponentId IN (SELECT ComponentId FROM \
+ ComponentProperties WHERE Name='CompInstallType' and IntValue=?) ");
+ std::auto_ptr<CStatement> stmtCompid(iScrDbHandler->PrepareStatement(selectUid));
+
+ stmtCompid->BindInt(1, aUid);
+ stmtCompid->BindInt(2, aInstallType);
+
+ TInt32 componentId = DbHelper::Absent;
+ if( stmtCompid->ProcessNextRow())
+ {
+ componentId = stmtCompid->IntColumn(0);
+ }
+
+ return componentId;
+ }
+
+TInt32 DbHelper::GetComponentId( TInt32 aUid ) const
+ {
+ std::string selectCompId( "SELECT ComponentId FROM ComponentProperties WHERE Name='CompUid' \
+ AND IntValue=? AND ComponentId IN (SELECT ComponentId from \
+ ComponentProperties WHERE Name='CompIndex' AND IntValue='0');"
+ );
+
+ std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));
+
+ stmtCompId->BindInt(1, aUid);
+
+ // this might contain multiple entries for the specific uid but as it has been
+ // ordered by propertyid the first entry would be of the first installation.
+ if(stmtCompId->ProcessNextRow())
+ {
+ return stmtCompId->IntColumn(0);
+ }
+
+ return DbHelper::Absent;
+ }
+
+std::vector<TInt32> DbHelper::GetComponentIdList( TInt32 aUid ) const
+ {
+ std::vector<TInt32> componentIdList;
+ std::string selectCompId("SELECT ComponentId FROM ComponentProperties WHERE Name='CompUid' and IntValue=? order by PropertyId;");
+ std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));
+
+ stmtCompId->BindInt(1, aUid);
+
+ // this might contain multiple entries for the specific uid but as it has been
+ // ordered by propertyid the first entry would be of the first installtion.
+ while(stmtCompId->ProcessNextRow())
+ {
+ componentIdList.push_back(stmtCompId->IntColumn(0));
+ }
+
+ return componentIdList;
+ }
+
+bool DbHelper::GetIsRemovable( TInt32 aComponentId ) const
+ {
+ std::string selectIsRemovable("SELECT Removable FROM Components WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtIsRemovable(iScrDbHandler->PrepareStatement(selectIsRemovable));
+
+ stmtIsRemovable->BindInt(1, aComponentId);
+
+ if(!stmtIsRemovable->ProcessNextRow())
+ return false;
+
+ return (stmtIsRemovable->IntColumn(0) == 1);
+ }
+
+bool DbHelper::GetInRom( TInt32 aComponentId ) const
+ {
+ std::string selectInRom("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompInRom';");
+ std::auto_ptr<CStatement> stmtInRom(iScrDbHandler->PrepareStatement(selectInRom));
+
+ stmtInRom->BindInt(1, aComponentId);
+
+ if(!stmtInRom->ProcessNextRow())
+ return DbConstants::KDefaultIsInRom;
+
+ return (stmtInRom->IntColumn(0) == 1);
+ }
+
+std::wstring DbHelper::GetPackageName( TInt32 aComponentId ) const
+ {
+ std::string selectPckgName("SELECT Name FROM ComponentLocalizables WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtPckgName(iScrDbHandler->PrepareStatement(selectPckgName));
+
+ stmtPckgName->BindInt(1, aComponentId);
+
+ if(stmtPckgName->ProcessNextRow())
+ {
+ return stmtPckgName->StrColumn(0);
+ }
+
+ return NULL;
+ }
+
+TUint32 DbHelper::GetUid( TInt32 aComponentId ) const
+ {
+ std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompUid';");
+ std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));
+
+ stmtUid->BindInt(1, aComponentId);
+
+ if(stmtUid->ProcessNextRow())
+ {
+ return stmtUid->IntColumn(0);
+ }
+
+ return DbHelper::Absent;
+ }
+
+
+TUint32 DbHelper::GetUidFromFileName( const std::wstring& aFileName ) const
+ {
+ std::string selCompId("SELECT ComponentId FROM ComponentsFiles WHERE Location=?;");
+ std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selCompId));
+
+ stmtCompId->BindStr(1, aFileName);
+
+ TInt32 componentId = 0;
+ if(stmtCompId->ProcessNextRow())
+ {
+ componentId = stmtCompId->IntColumn(0);
+ return GetUid(componentId);
+ }
+
+ std::string selCompPropsId("SELECT ComponentId FROM ComponentProperties WHERE StrValue=? and Name like 'WCFile%';");
+ std::auto_ptr<CStatement> stmtCompPropsId(iScrDbHandler->PrepareStatement(selCompPropsId));
+
+ stmtCompPropsId->BindStr(1, aFileName);
+
+ if(stmtCompPropsId->ProcessNextRow())
+ {
+ componentId = stmtCompPropsId->IntColumn(0);
+ return GetUid(componentId);
+ }
+
+ return 0;
+ }
+
+
+TUint32 DbHelper::GetInstallType( TInt32 aComponentId ) const
+ {
+ std::string selectInstallType("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompInstallType';");
+ std::auto_ptr<CStatement> stmtInstallType(iScrDbHandler->PrepareStatement(selectInstallType));
+
+ stmtInstallType->BindInt(1, aComponentId);
+
+ if(stmtInstallType->ProcessNextRow())
+ return stmtInstallType->IntColumn(0);
+
+ return DbConstants::KDefaultInstallType;
+ }
+
+TInt DbHelper::GetIndex( TInt32 aComponentId) const
+ {
+ return GetComponentPropertyIntValue(aComponentId,DbConstants::CompIndex);
+ }
+
+void DbHelper::RemoveEntry( TInt32 aComponentId ) const
+ {
+ // delete component properties
+ std::string delCompProps("DELETE FROM ComponentProperties WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtDelCompProps(iScrDbHandler->PrepareStatement(delCompProps));
+ stmtDelCompProps->BindInt(1, aComponentId);
+ stmtDelCompProps->ExecuteStatement();
+
+ // delete component file properties
+ std::string delFileProps("DELETE from FileProperties WHERE CmpFileId IN \
+ (SELECT CmpFileId FROM ComponentsFiles WHERE ComponentId=?);");
+ std::auto_ptr<CStatement> stmtDelFileProps(iScrDbHandler->PrepareStatement(delFileProps));
+ stmtDelFileProps->BindInt(1, aComponentId);
+ stmtDelFileProps->ExecuteStatement();
+
+ // delete component files
+ std::string delCompFiles("DELETE FROM ComponentsFiles WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtCompFiles(iScrDbHandler->PrepareStatement(delCompFiles));
+ stmtCompFiles->BindInt(1, aComponentId);
+ stmtCompFiles->ExecuteStatement();
+
+ // delete component localizables
+ std::string delCompLocs("DELETE FROM ComponentLocalizables WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtCompLocs(iScrDbHandler->PrepareStatement(delCompLocs));
+ stmtCompLocs->BindInt(1, aComponentId);
+ stmtCompLocs->ExecuteStatement();
+
+ // delete component dependencies
+ std::string delCompDeps("DELETE FROM ComponentDependencies WHERE GlobalIdHash IN \
+ (SELECT GlobalIdHash FROM Components WHERE ComponentId=?);");
+ std::auto_ptr<CStatement> stmtCompDeps(iScrDbHandler->PrepareStatement(delCompDeps));
+ stmtCompDeps->BindInt(1, aComponentId);
+ stmtCompDeps->ExecuteStatement();
+
+ // delete components
+ std::string delComps("DELETE FROM Components WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtComps(iScrDbHandler->PrepareStatement(delComps));
+ stmtComps->BindInt(1, aComponentId);
+ stmtComps->ExecuteStatement();
+
+ }
+
+int DbHelper::GetSelectedDrive( TInt32 aComponentId )
+ {
+ std::string selectDrive("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompSelectedDrive';");
+ std::auto_ptr<CStatement> stmtDrive(iScrDbHandler->PrepareStatement(selectDrive));
+
+ stmtDrive->BindInt(1, aComponentId);
+
+ if(stmtDrive->ProcessNextRow())
+ return stmtDrive->IntColumn(0);
+
+ return DbConstants::KDefaultInstalledDrive;
+ }
+
+bool DbHelper::InternalizeIfExists(SisRegistryObject& aSisRegistryObject, const TUint32 aUid ) const
+ {
+ TInt32 componentId = GetComponentId(aUid);
+ if(componentId == DbHelper::Absent)
+ {
+ return false;
+ }
+
+ // retrieve all details from componentproperties
+ GetComponentDetails(componentId, aSisRegistryObject);
+
+ GetComponentLocalizables(componentId, aSisRegistryObject);
+
+ // retrieve all files for this component Id from the componentfiles table
+ GetFileDescriptions(componentId, aSisRegistryObject);
+
+ GetComponentProperties(componentId, aSisRegistryObject);
+
+ return true;
+ }
+
+bool DbHelper::SidExists(const TUint32 aSid) const
+ {
+ std::string selectSid("SELECT IntValue FROM ComponentProperties WHERE Name like 'CompSid%' and IntValue=?;");
+ std::auto_ptr<CStatement> stmtSid(iScrDbHandler->PrepareStatement(selectSid));
+
+ stmtSid->BindInt(1, aSid);
+ if(!stmtSid->ProcessNextRow())
+ return false;
+
+ TInt32 sid = stmtSid->IntColumn(0);
+
+ return ( sid == aSid );
+ }
+
+TUint32 DbHelper::GetUid(const TUint32 aSid) const
+ {
+ std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE ComponentId in \
+ (SELECT ComponentId from ComponentProperties where Name like 'CompSid%' and IntValue=?) and Name='CompUid';");
+ std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));
+
+ stmtUid->BindInt(1, aSid);
+ if(stmtUid->ProcessNextRow())
+ return stmtUid->IntColumn(0);
+
+ return DbHelper::Absent;
+ }
+
+
+TUint32 DbHelper::GetUid( const std::wstring& aSidFile ) const
+ {
+ std::string selectCompId("SELECT ComponentId FROM ComponentProperties WHERE StrValue=? and Name like 'CompSidFileName%';");
+ std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));
+
+ stmtCompId->BindStr(1, aSidFile);
+ if(!stmtCompId->ProcessNextRow())
+ return DbHelper::Absent;
+
+ TInt32 componentId = stmtCompId->IntColumn(0);
+
+ return GetUid(componentId);
+
+ }
+
+std::wstring DbHelper::SidToFileName(TUint32 aSid) const
+ {
+ std::string selectCompId("SELECT ComponentId,Name FROM ComponentProperties WHERE Name like 'CompSid%' and IntValue=?;");
+ std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));
+
+ stmtCompId->BindInt(1, aSid);
+ if(!stmtCompId->ProcessNextRow())
+ return NULL;
+
+ int componentId = stmtCompId->IntColumn(0);
+
+ std::wstring sidName = stmtCompId->StrColumn(1);
+
+ std::wstring finalString(DbConstants::CompSidFileName);
+ finalString += sidName.substr(DbConstants::CompSid.length() );
+
+ std::string selectFile("SELECT StrValue FROM ComponentProperties WHERE ComponentId=? and Name=?;");
+
+ std::auto_ptr<CStatement> stmtFile(iScrDbHandler->PrepareStatement(selectFile));
+
+ stmtFile->BindInt(1, componentId);
+ stmtFile->BindStr(2, finalString);
+
+ if(!stmtFile->ProcessNextRow())
+ return NULL;
+
+ return stmtFile->StrColumn(0);
+
+
+ }
+
+void DbHelper::GetComponentDetails(TInt32 aComponentId, SisRegistryObject& aSisRegistryObject) const
+ {
+
+ std::string selectComponents( "SELECT Removable, Hidden, Version FROM Components WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtSelectComponents(iScrDbHandler->PrepareStatement(selectComponents));
+
+ stmtSelectComponents->BindInt(1, aComponentId);
+ if(!stmtSelectComponents->ProcessNextRow())
+ return;
+
+ // isRemovable
+ TBool isRemovable = false;
+ if(stmtSelectComponents->IntColumn(0) == 1)
+ {
+ isRemovable = true;
+ }
+ aSisRegistryObject.SetIsRemovable(isRemovable);
+
+ // isHidden
+ TBool isHidden = false;
+ if(stmtSelectComponents->IntColumn(1) == 1)
+ {
+ isHidden = true;
+ }
+ aSisRegistryObject.SetIsHidden(isHidden);
+
+ std::wstring textVersion = stmtSelectComponents->StrColumn(2);
+
+ std::wstringstream strMajor(textVersion.substr(0,1));
+ int major = 0;
+ strMajor >> major;
+ std::wstringstream strMinor(textVersion.substr(2,3));
+ int minor = 0;
+ strMinor >> minor;
+ std::wstringstream strBuild(textVersion.substr(4,4));
+ int build = 0;
+ strBuild >> build;
+
+ Version version(major,minor,build);
+
+ // sisregistrytoken
+ aSisRegistryObject.SetVersion(version);
+ }
+
+void DbHelper::GetComponentLocalizables(TInt32 aComponentId, SisRegistryObject& aSisRegistryObject) const
+ {
+ // do we need to specify locale
+ std::string selectCompLocalizables( "SELECT Name,Vendor FROM ComponentLocalizables WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtCompLocalizables(iScrDbHandler->PrepareStatement(selectCompLocalizables));
+
+ stmtCompLocalizables->BindInt(1, aComponentId);
+ if(!stmtCompLocalizables->ProcessNextRow())
+ return;
+
+ std::wstring pckgName = stmtCompLocalizables->StrColumn(0);
+ std::wstring vendor = stmtCompLocalizables->StrColumn(1);
+
+ // sisregistrypackage
+ aSisRegistryObject.SetPackageName(pckgName);
+ // sisregistryobject
+ aSisRegistryObject.SetVendorLocalizedName(vendor);
+
+ }
+
+void DbHelper::GetFileDescriptions( TInt32 aComponentId, SisRegistryObject& aSisRegistryObject ) const
+ {
+ std::vector<FileDescription*> fileDescriptions;
+ GetFileDescriptionFromComponentProperties( aComponentId, fileDescriptions );
+ GetFileDescriptionFromFileProperties( aComponentId, fileDescriptions );
+
+ aSisRegistryObject.SetFileDescriptions(fileDescriptions);
+
+ }
+
+std::vector<FileDescription*> DbHelper::GetFileDescriptions( TInt32 aComponentId ) const
+ {
+ std::vector<FileDescription*> fileDescriptions;
+ GetFileDescriptionFromComponentProperties( aComponentId, fileDescriptions );
+ GetFileDescriptionFromFileProperties( aComponentId, fileDescriptions );
+ return fileDescriptions;
+ }
+
+void DbHelper::GetFileDescriptionFromComponentProperties( int aComponentId, std::vector<FileDescription*>& aFileDescriptions) const
+ {
+ std::string selectWildCardCount( "SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompWildCardFileCount';");
+ std::auto_ptr<CStatement> stmtWildCardCount(iScrDbHandler->PrepareStatement(selectWildCardCount));
+
+ stmtWildCardCount->BindInt(1, aComponentId);
+ if(!stmtWildCardCount->ProcessNextRow())
+ return;
+
+ int wildCardCount = stmtWildCardCount->IntColumn(0);
+
+ for(int count=0; count < wildCardCount; ++count)
+ {
+
+ FileDescription* fileDescription = new FileDescription();
+
+ std::string selectWildCardCount( "SELECT Name,Locale,IntValue,StrValue,IsStr8Bit FROM ComponentProperties WHERE ComponentId=? and Name like ? order by PropertyId;");
+ std::auto_ptr<CStatement> stmtWildCardCount(iScrDbHandler->PrepareStatement(selectWildCardCount));
+
+ std::wstring namePattern = L"WCFile%";
+ std::wstringstream strNamePattern;
+ strNamePattern << namePattern << count;
+
+ stmtWildCardCount->BindInt(1, aComponentId);
+ stmtWildCardCount->BindStr(2, strNamePattern.str());
+
+ AddFileDescription(stmtWildCardCount.get(), *fileDescription, count);
+
+ aFileDescriptions.push_back(fileDescription);
+ }
+ }
+
+void DbHelper::GetFileDescriptionFromFileProperties( int aComponentId, std::vector<FileDescription*>& aFileDescriptions) const
+ {
+ // retrieve the location form the component files table
+ std::string selLocation( "SELECT CmpFileId,Location FROM ComponentsFiles WHERE ComponentId=?;");
+ std::auto_ptr<CStatement> stmtLocation(iScrDbHandler->PrepareStatement(selLocation));
+
+ stmtLocation->BindInt(1, aComponentId);
+
+ while( stmtLocation->ProcessNextRow() )
+ {
+ FileDescription* fileDescription = new FileDescription();
+ fileDescription->SetTarget(stmtLocation->StrColumn(1));
+
+ int cmpFileId = stmtLocation->IntColumn(0);
+
+ std::string selFileProps( "SELECT Name,IntValue,StrValue FROM FileProperties WHERE CmpFileId=?;");
+ std::auto_ptr<CStatement> stmtFileProps(iScrDbHandler->PrepareStatement(selFileProps));
+ stmtFileProps->BindInt(1, cmpFileId);
+
+ AddFileDescription(stmtFileProps.get(), *fileDescription, -1);
+ aFileDescriptions.push_back(fileDescription);
+ }
+ }
+
+void DbHelper::AddFileDescription(CStatement* aStatement, FileDescription& aFileDescription, TInt aCount ) const
+ {
+ bool hashId = false;
+ bool hashData = false;
+ HashContainer hashContainer;
+
+ if( aCount == -1 )
+ {
+ while(aStatement->ProcessNextRow())
+ {
+ std::wstring name = aStatement->StrColumn(0);
+
+ if(name == DbConstants::FileMimeType )
+ {
+ aFileDescription.SetMimeType(aStatement->StrColumn(2));
+ }
+ else if(name == DbConstants::FileSisFileOperation )
+ {
+ int sisFileOperation = aStatement->IntColumn(1);
+ aFileDescription.SetOperation(sisFileOperation);
+ }
+ else if( name == DbConstants::FileFileOperationOptions)
+ {
+ int fileOperationOptions = aStatement->IntColumn(1);
+ aFileDescription.SetOperationOptions(fileOperationOptions);
+ }
+ else if( name == DbConstants::FileUncompressedLength )
+ {
+ TInt64 uncompressedLength = aStatement->Int64Column(1);
+ aFileDescription.SetUncompressedLength( uncompressedLength );
+ }
+ else if( name == DbConstants::FileIndex )
+ {
+ int fileIndex = aStatement->IntColumn(1);
+ aFileDescription.SetIndex( fileIndex );
+ }
+ else if( name == DbConstants::FileSid )
+ {
+ int fileSid = aStatement->IntColumn(1);
+ aFileDescription.SetSid( fileSid );
+ }
+ else if( name == DbConstants::FileHashAlgorithm )
+ {
+ hashContainer.SetHashId(aStatement->IntColumn(1));
+ hashId = true;
+ if(hashData)
+ {
+ aFileDescription.SetHash(hashContainer);
+ hashId = hashData = false;
+ }
+ }
+ else if( name == DbConstants::FileHashData )
+ {
+ hashContainer.SetData(wstring2string(aStatement->StrColumn(2)));
+ hashData = true;
+ if(hashId)
+ {
+ aFileDescription.SetHash(hashContainer);
+ hashId = hashData = false;
+ }
+ }
+ } // while
+ }
+ else
+ {
+ while(aStatement->ProcessNextRow() )
+ {
+ std::wstring name = aStatement->StrColumn(0);
+
+ if(name == FormatDbString(DbConstants::WCFileName,aCount) )
+ {
+ aFileDescription.SetTarget(aStatement->StrColumn(3));
+ }
+ } // while
+ }
+ }
+
+
+void DbHelper::GetComponentProperties( TInt32 aComponentId, SisRegistryObject& aSisRegistryObject ) const
+ {
+ TUint32 installType = GetComponentPropertyIntValue(aComponentId, DbConstants::CompInstallType, DbConstants::KDefaultInstallType);
+ aSisRegistryObject.SetInstallType(installType);
+ aSisRegistryObject.SetDependencies(GetDependencies(aComponentId));
+ aSisRegistryObject.SetEmbeddedPackages(GetEmbeddedPackages(aComponentId));
+ aSisRegistryObject.SetProperties(GetProperties(aComponentId));
+
+ // inrom
+ bool status = GetComponentPropertyIntValue(aComponentId,DbConstants::CompInRom, DbConstants::KDefaultIsInRom);
+ aSisRegistryObject.SetInRom(status);
+
+ // issigned
+ status = GetComponentPropertyIntValue(aComponentId,DbConstants::CompIsSigned, DbConstants::KDefaultIsSigned);
+ aSisRegistryObject.SetSigned(status);
+
+ // signedbysucert
+ status = GetComponentPropertyIntValue(aComponentId,DbConstants::CompSignedBySuCert, DbConstants::KDefaultIsSignedBySuCert);
+ aSisRegistryObject.SetSigned(status);
+
+ // deletepreinstalled
+ status = GetComponentPropertyIntValue(aComponentId,DbConstants::CompDeletablePreinstalled, DbConstants::KDefaultIsDeletablePreInstalled);
+ aSisRegistryObject.SetPreInstalled(status);
+
+ // trust
+ int trust = GetComponentPropertyIntValue(aComponentId,DbConstants::CompTrust, DbConstants::KDefaultTrustValue);
+ aSisRegistryObject.SetTrust(trust);
+
+ // isRemoveWithLastDependent
+ int removeWithLastDep = GetComponentPropertyIntValue(aComponentId,DbConstants::CompIsRemoveWithLastDependent, DbConstants::KDefaultRemoveWithLastDependent);
+ aSisRegistryObject.SetRemoveWithLastDependent(removeWithLastDep);
+
+ // trustTimeStamp
+ TInt64 timeStamp = 0;
+ aSisRegistryObject.SetTrustTimeStamp(timeStamp);
+
+ // trustStatus
+ aSisRegistryObject.SetTrustStatus(GetTrustStatus(aComponentId));
+
+ // installchain indices
+ aSisRegistryObject.SetInstallChainIndices(GetInstallChainIndices(aComponentId));
+
+ //////// sisregistrytoken ///////////////////////
+
+ aSisRegistryObject.SetSids(GetSids(aComponentId));
+
+ aSisRegistryObject.SetControllerInfo(GetControllerInfo(aComponentId));
+
+ // language
+ TInt language = GetComponentPropertyIntValue( aComponentId, DbConstants::CompLanguage, DbConstants::KDefaultInstalledLanguage );
+ aSisRegistryObject.SetLanguage(language);
+
+ //selected drive
+ TInt selectedDrive = GetComponentPropertyIntValue( aComponentId, DbConstants::CompSelectedDrive, DbConstants::KDefaultInstalledDrive );
+ aSisRegistryObject.SetSelectedDrive(selectedDrive);
+
+ //////// sisregistrypackage ///////////////////////
+
+ // uid
+ TUint32 uid = GetComponentPropertyIntValue( aComponentId, DbConstants::CompUid );
+ aSisRegistryObject.SetUid(uid);
+
+ // unique vendor name
+ std::wstring uniqueVendorName = GetComponentPropertyStrValue( aComponentId, DbConstants::CompUniqueVendorName );
+ aSisRegistryObject.SetVendorName(uniqueVendorName);
+
+ // index
+ TInt index = GetComponentPropertyIntValue( aComponentId, DbConstants::CompIndex );
+ aSisRegistryObject.SetIndex(index);
+
+ }
+
+Dependencies DbHelper::GetDependencies( TInt32 aComponentId ) const
+ {
+ std::vector<SisRegistryDependency*> dependencyList;
+
+ // retrieve the location form the component files table
+ std::string selDependencies( "SELECT SupplierGlobalId,VersionFrom,VersionTo FROM ComponentDependencies WHERE GlobalIdHash IN \
+ (SELECT GlobalIdHash from Components where ComponentId=? );");
+ std::auto_ptr<CStatement> stmtDependencies(iScrDbHandler->PrepareStatement(selDependencies));
+
+ stmtDependencies->BindInt(1, aComponentId);
+
+ while( stmtDependencies->ProcessNextRow() )
+ {
+ std::wstring supplierId = stmtDependencies->StrColumn(0);
+ TUint32 uid = Utils::WideStringToInteger(supplierId.substr(4,supplierId.length()));
+
+ SisRegistryDependency* registryDependency = new SisRegistryDependency();
+ registryDependency->SetUid(uid);
+ registryDependency->SetFromVersion(FormatStringToVersion(stmtDependencies->StrColumn(1)));
+ registryDependency->SetToVersion(FormatStringToVersion(stmtDependencies->StrColumn(2)));
+ dependencyList.push_back(registryDependency);
+ }
+
+ return dependencyList;
+ }
+
+Packages DbHelper::GetEmbeddedPackages( TInt32 aComponentId ) const
+ {
+ std::vector<SisRegistryPackage*> packageList;
+
+ int embPckgCount = GetComponentPropertyIntValue(aComponentId,DbConstants::CompEmbeddedPackageCount, DbConstants::KDefaultEmbeddedPackageCount);
+
+ for(int count=0 ; count<embPckgCount ; ++count)
+ {
+
+ TUint32 uid = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompEmbeddedPackageUid, count);
+ std::wstring name = GetComponentPropertyStrValue(aComponentId, DbConstants::CompEmbeddedPackageName, count);
+ std::wstring vendor = GetComponentPropertyStrValue(aComponentId, DbConstants::CompEmbeddedPackageVendor, count);
+ TUint32 pckgIndex = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompEmbeddedPackageIndex, count);
+ SisRegistryPackage* registryPckg = new SisRegistryPackage(uid, name, vendor, pckgIndex);
+ packageList.push_back(registryPckg);
+ }
+
+ return packageList;
+ }
+
+Properties DbHelper::GetProperties( TInt32 aComponentId ) const
+ {
+ std::vector<SisRegistryProperty*> propList;
+
+ int propCount = GetComponentPropertyIntValue(aComponentId,DbConstants::CompPropertyCount, DbConstants::KDefaultCompPropertyCount);
+
+ for(int count=0 ; count<propCount ; ++count)
+ {
+ TUint32 key = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompPropertyKey, count);
+ TUint32 value = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompPropertyValue, count);
+ SisRegistryProperty* regProp = new SisRegistryProperty();
+ regProp->SetKey(key);
+ regProp->SetValue(value);
+ propList.push_back(regProp);
+ }
+
+ return propList;
+ }
+
+TrustStatus DbHelper::GetTrustStatus( TInt32 aComponentId ) const
+ {
+ TrustStatus trustStatus;
+
+ TUint32 validationStatus = GetComponentPropertyIntValue(aComponentId, DbConstants::CompTrustValidationStatus);
+
+ trustStatus.SetValidationStatus(validationStatus);
+
+ return trustStatus;
+ }
+
+std::vector<TInt> DbHelper::GetInstallChainIndices( TInt32 aComponentId ) const
+ {
+ std::vector<TInt> installChainIndices;
+
+ int installChainIndexCount = GetComponentPropertyIntValue(aComponentId,DbConstants::CompInstallChainIndexCount,
+ DbConstants::KDefaultChainIndex);
+
+ for(int count=0 ; count<installChainIndexCount ; ++count)
+ {
+ TInt chainValue = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompInstallChainIndex, count);
+ installChainIndices.push_back(chainValue);
+ }
+
+ return installChainIndices;
+ }
+
+Sids DbHelper::GetSids( TInt32 aComponentId ) const
+ {
+ std::vector<TUint32> sidList;
+
+ int sidCount = GetComponentPropertyIntValue(aComponentId,DbConstants::CompSidCount, DbConstants::KDefaultSidCount);
+
+ for(int count=0 ; count<sidCount ; ++count)
+ {
+ TUint32 sid = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompSid, count);
+ sidList.push_back(sid);
+ }
+
+ return sidList;
+ }
+
+Controllers DbHelper::GetControllerInfo( TInt32 aComponentId ) const
+ {
+ std::vector<ControllerInfo*> controllerInfoList;
+
+ int controllerCount = GetComponentPropertyIntValue(aComponentId,DbConstants::CompControllerCount, DbConstants::KDefaultControllerCount);
+
+ for(int count=0 ; count<controllerCount ; ++count)
+ {
+ ControllerInfo* controllerInfo = new ControllerInfo();
+ std::wstring strVersion = GetComponentPropertyStrValue(aComponentId, DbConstants::CompControllerVersion, count);
+ Version version = FormatStringToVersion(strVersion);
+
+ TInt offset = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompControllerOffset, count);
+ TInt hashAlgo = GetComponentPropertyIntFormattedValue(aComponentId, DbConstants::CompControllerHashAlgorithm, count);
+ std::string hashData(wstring2string(GetComponentPropertyStrValue(aComponentId, DbConstants::CompControllerHashData, count)));
+ HashContainer hashContainer;
+ hashContainer.SetHashId(hashAlgo);
+ hashContainer.SetData(hashData);
+
+ controllerInfo->SetVersion(version);
+ controllerInfo->SetOffset(offset);
+ controllerInfo->SetHashContainer(hashContainer);
+
+ controllerInfoList.push_back(controllerInfo);
+ }
+
+ return controllerInfoList;
+ }
+
+TInt DbHelper::GetIndex( TUint32 aPackageUid) const
+ {
+ TInt32 componentId = GetComponentId(aPackageUid);
+ return GetComponentPropertyIntValue(componentId, DbConstants::CompIndex);
+ }
+
+TInt32 DbHelper::GetComponentPropertyIntValue(TInt32 aComponentId, std::wstring aComponentPropertyName, TInt32 aDefaultValue) const
+ {
+ TInt32 propertyValue = 0;
+
+ std::string selectIntProperty("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name=?;");
+ std::auto_ptr<CStatement> stmtCompProperty(iScrDbHandler->PrepareStatement(selectIntProperty));
+
+ stmtCompProperty->BindInt(1, aComponentId);
+ stmtCompProperty->BindStr(2, aComponentPropertyName);
+
+ if(!stmtCompProperty->ProcessNextRow())
+ return aDefaultValue;
+
+ return stmtCompProperty->IntColumn(0);
+ }
+
+TInt32 DbHelper::GetComponentPropertyIntFormattedValue(TInt32 aComponentId, std::wstring aComponentPropertyName, TInt32 aIntFormatter) const
+ {
+ TInt32 propertyValue = 0;
+
+ std::string selectIntProperty("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name=?;");
+ std::auto_ptr<CStatement> stmtCompProperty(iScrDbHandler->PrepareStatement(selectIntProperty));
+
+ std::wstring formattedCompPropName = FormatDbString(aComponentPropertyName, aIntFormatter);
+
+ stmtCompProperty->BindInt(1, aComponentId);
+ stmtCompProperty->BindStr(2, formattedCompPropName);
+
+ if(!stmtCompProperty->ProcessNextRow())
+ return DbHelper::Absent;
+
+ return stmtCompProperty->IntColumn(0);
+ }
+
+std::wstring DbHelper::GetComponentPropertyStrValue(TInt32 aComponentId, std::wstring aComponentPropertyName) const
+ {
+ TInt32 propertyValue = 0;
+
+ std::string selectStrProperty("SELECT StrValue FROM ComponentProperties WHERE ComponentId=? and Name=?;");
+ std::auto_ptr<CStatement> stmtCompProperty(iScrDbHandler->PrepareStatement(selectStrProperty));
+
+ stmtCompProperty->BindInt(1, aComponentId);
+ stmtCompProperty->BindStr(2, aComponentPropertyName);
+
+ if(!stmtCompProperty->ProcessNextRow())
+ return NULL;
+
+ return stmtCompProperty->StrColumn(0);
+ }
+
+std::wstring DbHelper::GetComponentPropertyStrValue(TInt32 aComponentId, std::wstring aComponentPropertyName, TInt32 aIntFormatter) const
+ {
+
+ std::wstring formattedCompPropName = FormatDbString(aComponentPropertyName, aIntFormatter);
+
+ return GetComponentPropertyStrValue(aComponentId, formattedCompPropName);
+ }
+
+std::wstring DbHelper::FormatDbString(std::wstring aString, int aValue) const
+ {
+ std::wstringstream formatter;
+ formatter << aString << aValue;
+ return formatter.str();
+ }
+
+Version DbHelper::FormatStringToVersion(std::wstring aVersionStr) const
+ {
+
+ std::wstringstream strMajor(aVersionStr.substr(0,1));
+ int major = 0;
+ strMajor >> major;
+ std::wstringstream strMinor(aVersionStr.substr(2,3));
+ int minor = 0;
+ strMinor >> minor;
+ std::wstringstream strBuild(aVersionStr.substr(4,4));
+ int build = 0;
+ strBuild >> build;
+
+ return Version(major,minor,build);
+
+ }