/*
* Copyright (c) 2006-2010 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:
*
*/
#pragma warning (disable: 4786)
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
#include "dbhelper.h"
#include "dblayer.h"
#include "dbconstants.h"
#include "xmlgenerator.h"
#include "xmlparser.h"
#include "util.h"
#include <algorithm>
#include <iostream>
#include <stdexcept>
#include <iostream>
#include "dirparse.h"
#include "parse.h"
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// constants
#define IGNORE_FORMATTING -1
#define ENABLE 1
#define DISABLE 0
// System Includes
#include <list>
#include <fstream>
#include <algorithm>
#include <sys/stat.h>
#include <sstream>
#ifndef __TOOLS2_LINUX__
#include <windows.h>
#endif
// SisX Library Includes
#include "sisfiledescription.h"
#include "sisstring.h"
#include "utility.h"
// User Includes
#include "sisregistry.h"
#include "errors.h"
#include "rommanager.h"
#include "stringutils.h"
#include "is_utils.h"
#include "sisfile.h"
#include "sisregistrypackage.h"
#include "sisregistryobject.h"
#include "configmanager.h"
// Constants
#ifndef __TOOLS2_LINUX__
const std::wstring SisRegistry::KPathToRegistry(L"\\sys\\install\\sisregistry/");
const std::wstring SisRegistry::KPathToRomStubs(L"\\system\\install\\");
const std::wstring SisRegistry::KPathToRegistryVersionMarker(L"\\system\\data\\");
#else
const std::wstring SisRegistry::KPathToRegistry(L"/sys/install/sisregistry/");
const std::wstring SisRegistry::KPathToRomStubs(L"/system/install/");
const std::wstring SisRegistry::KPathToRegistryVersionMarker(L"/system/data/");
#endif
const std::wstring KRegistryEntry(L"00000000.reg");
const std::wstring KControllerEntry(L"00000000_0000.ctl");
const std::wstring KBackupLst(L"backup.lst");
const int SisRegistry::KSisRegistryMajorVersion = 5;
const int SisRegistry::KSisRegistryMinorVersion = 1;
// Supported SisRegistry versions
const std::wstring SisRegistry::KRegistryFormat(L"sisregistry_?.?.txt");
const std::wstring SisRegistry::KRegistryV40(L"sisregistry_4.0.txt");
const std::wstring SisRegistry::KRegistryV51(L"sisregistry_5.1.txt");
const std::wstring SisRegistry::KRegistryV52(L"sisregistry_5.2.txt");
const std::wstring SisRegistry::KRegistryV53(L"sisregistry_5.3.txt");
const std::wstring SisRegistry::KRegistryV54(L"sisregistry_5.4.txt");
#ifndef __TOOLS2_LINUX__
const std::wstring SisRegistry::KRomStubDir(L"z:\\system\\install\\");
const std::wstring SisRegistry::KRomRegistryVersionMarker(L"z:\\system\\data\\");
#else
const std::wstring SisRegistry::KRomStubDir(L"z:/system/install/");
const std::wstring SisRegistry::KRomRegistryVersionMarker(L"z:/system/data/");
#endif
const std::string SisRegistry::KRegistryV40string("4.0");
const std::string SisRegistry::KRegistryV50string("5.0");
const std::string SisRegistry::KRegistryV51string("5.1");
const std::string SisRegistry::KRegistryV52string("5.2");
const std::string SisRegistry::KRegistryV53string("5.3");
const std::string SisRegistry::KRegistryV54string("5.4");
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
const std::wstring SisRegistry::NativeSoftwareType(L"native");
#ifdef _MSC_VER
// "." and ".ctl"
// VC does not have ".." entry
const int KDirFileCount = 2;
#else
// "." ".." and ".ctl"
const int KDirFileCount = 3;
#endif
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// KRegDirFileCount is the number of directory entries present
// in the reg directory when there is no upgrade is made to the
// package. i.e. one .reg and one .ctl file
//
#ifdef _MSC_VER
// "." ".reg" and ".ctl"
// VC does not have ".." entry
const int KRegDirFileCount = 3;
#else
// "." ".." ".reg" and ".ctl"
const int KRegDirFileCount = 4;
#endif
// function object for determining if all characters are valid hex chars
struct AllHexDigits
{
bool result;
AllHexDigits() : result(true) {}
void operator()(char a)
{
if (!((a >= '0' && a <= '9') ||
(a >= 'a' && a <= 'f') ||
(a >= 'A' && a <= 'F')))
{
result = false;
}
}
};
// function object for retreiving keys from the sisregistry entry map
struct CopyUids
{
CopyUids(std::vector<TUint32>& uids) : iUids(uids) {}
std::vector<TUint32>& iUids;
void operator()(SisRegistry::EntryMap::value_type& a)
{ iUids.push_back(a.first); }
};
struct FindFile
{
FindFile(const std::wstring& aFile) : iFile(aFile), iFileDescr(0) {}
bool operator()(const SisRegistry::EntryMap::value_type& val)
{
const SisRegistryObject& obj = *val.second;
return (iFileDescr = obj.GetFile(iFile)) != 0;
}
std::wstring iFile;
const FileDescription* iFileDescr;
};
struct FindFile2
{
FindFile2(TUint32 aSid, const FileDescription*& aFd) :
iSid(aSid), iFileDescr(aFd) {}
bool operator()(const SisRegistry::EntryMap::value_type& val)
{
const SisRegistryObject& obj = *val.second;
if (iFileDescr = obj.GetFile(iSid))
{
return true;
}
return false;
}
TUint32 iSid;
const FileDescription*& iFileDescr;
};
struct Contains
{
const std::wstring& iFile;
Contains(const std::wstring& aFilename) : iFile(aFilename)
{}
SisRegistryObject* operator()(const SisRegistry::EntryMap::value_type& aObj)
{
if (aObj.second->GetFile(iFile) != 0)
{
return aObj.second;
}
}
};
SisRegistry::SisRegistry( CParameterList& aOptions, RomManager& aRomManager, ConfigManager& aConfigManager)
: iParamList( aOptions ), iRomManager( aRomManager ), iConfigManager( aConfigManager )
{
// Determine which version of the SisRegistry to generate
if (iParamList.RegistryVersionExists() == false)
{
ReadSisRegistryVersion();
}
if(iParamList.RegistryVersionExists())
{
LINFO(L"Using SIS Registry v" << iParamList.RegistryMajorVersion() << L"." << iParamList.RegistryMinorVersion());
std::wstring registryPathDriveC = KPathToRegistry;
ConvertToLocalPath( registryPathDriveC, iParamList.SystemDrivePath() );
ReadRegistry( registryPathDriveC );
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// this code is for handling the database registry implementation
else
{
LINFO(L"Using database implementation of SIS Registry");
int val = iParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet);
if (
(iParamList.RomLogFileNames().size() != 0 && iParamList.RomDrivePath().size() == 0 ) ||
iParamList.IsFlagSet( CParameterList::EFlagsDisableZDriveChecksSet)
)
{
iDbHelper = new DbHelper(iParamList.SystemDrivePath(), true);
}
else
{
iDbHelper = new DbHelper(iParamList.RomDrivePath(), false);
}
}
#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
GenerateStubRegistry();
}
SisRegistry::~SisRegistry()
{
if(iParamList.RegistryVersionExists())
{
EntryMap::const_iterator end = iEntries.end();
for (EntryMap::const_iterator curr = iEntries.begin() ;
curr != end; ++curr)
{
delete curr->second;
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
delete iDbHelper;
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
/**
* If the ROM drive has been defined, find the marker file in the stub directory
* e.g. z:\system\data\. If using the ROM/ROFS logs, find the marker file in the
* logs. If not found, then check to see if the marker file exists in the ROM stub directory
* specified using the -t option. If still not found, use the default version of the Sis Registry.
*/
void SisRegistry::ReadSisRegistryVersion()
{
// ROM drive defined
if (iParamList.IsFlagSet(CParameterList::EFlagsZDriveSet))
{
// ROM SisRegistry marker file
std::wstring stubPathZ = KPathToRegistryVersionMarker;
ConvertToLocalPath( stubPathZ, iParamList.RomDrivePath() );
FindMarkerAndSetVersion(stubPathZ);
}
// ROM/ROFS logs defined
else if (iParamList.IsFlagSet(CParameterList::EFlagsRomRofsLogFilesSet))
{
// Check the stub dir
if (iParamList.IsFlagSet(CParameterList::EFlagsStubDirectorySet))
{
// ROM SisRegistry marker file
std::wstring customStubPath = iParamList.SisStubPath();
FindMarkerAndSetVersion(customStubPath);
}
// Search in the ROM/ROFS logs. This takes precedence over the stub dir
if(iRomManager.RomFileExists(KPathToRegistryVersionMarker+KRegistryV40))
{
iParamList.SetRegistryMajorVersion(4);
iParamList.SetRegistryMinorVersion(0);
}
else if(iRomManager.RomFileExists(KRomRegistryVersionMarker+KRegistryV51))
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(1);
}
else if(iRomManager.RomFileExists(KRomRegistryVersionMarker+KRegistryV52))
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(2);
}
else if(iRomManager.RomFileExists(KRomRegistryVersionMarker+KRegistryV53))
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(3);
}
else if(iRomManager.RomFileExists(KRomRegistryVersionMarker+KRegistryV54))
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(4);
}
}
#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// No valid ROM stub marker (sisregistry_x.x.txt) found!
// Revert to the default (5.1) SisRegistry version as defined
// by KSisRegistryMajorVersion and KSisRegistryMinorVersion
if (iParamList.RegistryMajorVersion() == 0 && iParamList.RegistryMinorVersion() == 0)
{
iParamList.SetRegistryMajorVersion(KSisRegistryMajorVersion);
iParamList.SetRegistryMinorVersion(KSisRegistryMinorVersion);
}
#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
void SisRegistry::FindMarkerAndSetVersion(const std::wstring& aPath)
{
// Make sure the system\data directory name is properly terminated.
std::wstring basePath = StringUtils::EnsureDirectoryTerminated( aPath );
std::list<std::wstring> systemDir;
GetDirContents( basePath, systemDir );
// Loop on the system\data files until we find a SisRegistry marker file
std::list<std::wstring>::iterator curr = systemDir.begin();
while (curr != systemDir.end())
{
std::wstring fileFound ( *curr );
// Found the SisRegistry marker file
if (fileFound.compare(KRegistryV40) == 0)
{
iParamList.SetRegistryMajorVersion(4);
iParamList.SetRegistryMinorVersion(0);
}
else if (fileFound.compare(KRegistryV51) == 0) // introduced isRemovable flag
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(1);
}
else if (fileFound.compare(KRegistryV52) == 0) // fixed DEF114705 - SIS controller incorrect
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(2);
}
else if (fileFound.compare(KRegistryV53) == 0) // introduced SU cert flag
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(3);
}
else if (fileFound.compare(KRegistryV54) == 0) // Support for exact & equivalent device supported languages
{
iParamList.SetRegistryMajorVersion(5);
iParamList.SetRegistryMinorVersion(4);
}
++curr;
}
}
bool SisRegistry::IsPackageDir(const std::wstring& aString)
{
AllHexDigits digits;
std::for_each(aString.begin(), aString.end(), digits);
return aString.length() == 8 && digits.result;
}
TBool SisRegistry::IsInstalled(TUint32 aUid) const
{
if(iParamList.RegistryVersionExists())
{
return iEntries.find(aUid) != iEntries.end();;
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
return iDbHelper->IsInstalled(aUid);
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
return false;
}
const SisRegistryObject& SisRegistry::GetRegistryObject(TUint32 aUid) const
{
if(iParamList.RegistryVersionExists())
{
EntryMap::const_iterator end = iEntries.end();
for (EntryMap::const_iterator curr = iEntries.begin() ;
curr != end; ++curr)
{
if ((curr->first == aUid) && ((*curr->second).GetIndex() == 0))
{
return *curr->second;
}
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
SisRegistryObject* sisRegistryObject = new SisRegistryObject(iConfigManager);
if(iDbHelper->InternalizeIfExists(*sisRegistryObject, aUid))
{
return *sisRegistryObject;
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
throw std::runtime_error("Couldn't find specified package");
}
SisRegistryObject* SisRegistry::GetRegistryObjectPtr(TUint32 aUid)
{
if(iParamList.RegistryVersionExists())
{
EntryMap::const_iterator end = iEntries.end();
for (EntryMap::const_iterator curr = iEntries.begin() ;
curr != end; ++curr)
{
if ((curr->first == aUid) && ((curr->second)->GetIndex() == 0))
{
return curr->second;
}
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
SisRegistryObject* sisRegistryObject = new SisRegistryObject(iConfigManager);
if(iDbHelper->InternalizeIfExists(*sisRegistryObject, aUid))
{
return sisRegistryObject;
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
throw std::runtime_error("Couldn't find specified package");
}
const SisRegistryPackage& SisRegistry::SidToPackage(TUint32 aSid)
{
const FileDescription* fileDesc = 0;
FindFile2 fileFinder(aSid, fileDesc);
EntryMap::iterator x = std::find_if(iEntries.begin(),
iEntries.end(),
fileFinder);
if (x != iEntries.end())
{
return *x->second;
}
else
{
throw std::runtime_error("Couldn't find specified file");
}
}
void SisRegistry::SidToFileName(TUint32 aSid, std::wstring& aFileName)
{
if(iParamList.RegistryVersionExists())
{
const FileDescription* fileDesc = 0;
FindFile2 fileFinder(aSid, fileDesc);
EntryMap::iterator x = std::find_if(iEntries.begin(),
iEntries.end(),
fileFinder);
if (x != iEntries.end())
{
aFileName = fileFinder.iFileDescr->GetTarget();
}
else
{
throw std::runtime_error("Couldn't find specified file");
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
aFileName = iDbHelper->SidToFileName(aSid);
if(aFileName.empty())
{
throw std::runtime_error("Couldn't find specified file");
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
bool SisRegistry::SidExists(TUint32 aSid) const
{
if(iParamList.RegistryVersionExists())
{
const FileDescription* fileDesc = 0;
FindFile2 fileFinder(aSid, fileDesc);
EntryMap::const_iterator x = std::find_if(iEntries.begin(),
iEntries.end(),
fileFinder);
return x != iEntries.end();
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
return iDbHelper->SidExists(aSid);
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
return false;
}
void SisRegistry::RemoveEntry(const TUint32 aUid, const std::wstring& aPackageName, const std::wstring& aVendorName)
{
if(iParamList.RegistryVersionExists())
{
EntryMap::iterator it = iEntries.find(aUid);
while(it != iEntries.end())
{
if (aUid == it->first && !wcscmp(aPackageName.c_str(), it->second->GetPackageName().c_str()) && aVendorName == it->second->GetVendorName() )
{
LINFO(L"Removing package \"" << it->second->GetPackageName()
<< L"\" prior to re-installation");
// Remove .reg file
std::wstring registryPath = it->second->GetRegistryDir( iParamList.SystemDrivePath() );
RemoveFile(registryPath + StringUtils::BuildSisRegistryFileName( it->second->GetIndex() ));
// Remove .ctl file
int drive = tolower(it->second->GetSelectedDrive());
std::wstring localTargetPath = iConfigManager.GetLocalDrivePath(drive);
registryPath = it->second->GetRegistryDir( localTargetPath );
RemoveFile(registryPath + StringUtils::BuildControllerFileName( it->second->GetIndex(), 0 ));
// Remove the installed files for this SisRegistryObject
const FileDescriptions& files = it->second->GetFileDescriptions();
RemoveInstalledFiles(files, localTargetPath);
// Clean up the SisRegistryObject
delete it->second;
iEntries.erase(it);
return;
}
++it;
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
// the vendor name here is the unique vendore name
TInt32 componentId = iDbHelper->GetComponentId(aUid, aPackageName, aVendorName);
if(componentId == DbHelper::Absent)
{
return;
}
LINFO(L"Removing package \"" << aPackageName << L"\" prior to re-installation");
// Remove .ctl file
int drive = tolower(iDbHelper->GetSelectedDrive(componentId));
std::wstring localTargetPath = iConfigManager.GetLocalDrivePath(drive);
std::wstring registryPath = GetRegistryDir( localTargetPath,componentId );
RemoveFile(registryPath + StringUtils::BuildControllerFileName( iDbHelper->GetIndex(componentId), 0 ));
// Remove the installed files for this SisRegistryObject
const FileDescriptions& files = iDbHelper->GetFileDescriptions(componentId);
RemoveInstalledFiles(files, localTargetPath);
iDbHelper->RemoveEntry(componentId);
}
#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
void SisRegistry::RemovePkg(const TUint32& aUid, bool aSkipRomStub)
{
if(iParamList.RegistryVersionExists())
{
RemovePkgLegacy(aUid,aSkipRomStub);
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
RemovePkgWithScr(aUid,aSkipRomStub);
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
void SisRegistry::RemovePkgLegacy(const TUint32& aUid, bool aSkipRomStub)
{
EntryMap::iterator currObj = iEntries.find(aUid);
if (currObj == iEntries.end())
{
// No SisRegistry file found!!
std::stringstream err;
err << " SisRegistry entry for 0x" << std::hex << aUid << L" Not found";
throw std::runtime_error(err.str());
}
std::list<std::wstring> regDirFiles;
std::wstring path = currObj->second->GetRegistryDir( iParamList.SystemDrivePath() );
GetDirContents(path, regDirFiles);
if (regDirFiles.size() == KRegDirFileCount && currObj->second->GetInRom())
{
// I.e. there are only .., one .reg and one .ctl file present
// check whether it is a ROM stub object (without any upgrades)
if (aSkipRomStub)
{
// Since this is only a ROM stub entry, leave it as it is;
// to avoid regenerate it again.
return;
}
std::stringstream err;
err << "Illegal uninstall of ROM package 0x" << std::hex << aUid;
throw InterpretSisError(err.str(), ATTEMPT_TO_UNINSTALL_ROM_PKG);
}
std::list<std::wstring>::iterator currFile = regDirFiles.begin();
// Remove all the .reg and .ctl files in the system drive for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
RemoveFile(path + *currFile);
}
++currFile;
}
// Remove the installed files for all packages (SA, SP, PU)
while (currObj != iEntries.end())
{
// For ROM stub, the SelectedDrive = 0; as there could be ROM->SP.
// Therefore, the rest can only apply to at least a ROM stub upgrades
int drive = tolower(currObj->second->GetSelectedDrive());
if (drive)
{
std::wstring localTargetPath = iConfigManager.GetLocalDrivePath(drive);
path = currObj->second->GetRegistryDir( localTargetPath );
regDirFiles.clear();
GetDirContents(path, regDirFiles);
currFile = regDirFiles.begin();
// Remove all the .ctl files for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
RemoveFile(path + *currFile);
}
++currFile;
}
// This iterator's object has the same Uid as aUid
const FileDescriptions& files = currObj->second->GetFileDescriptions();
RemoveInstalledFiles(files, localTargetPath);
}
// Clean up the SisRegistryObject
delete currObj->second;
iEntries.erase(currObj);
currObj = iEntries.find(aUid);
}
}
std::wstring SisRegistry::GetRegistryDir( const std::wstring& aDrivePath, TUint32 aUid ) const
{
std::wstring ret = StringUtils::MakePathFromSID( aDrivePath + L"/sys/install/sisregistry/", aUid );
return ret;
}
void SisRegistry::RemoveInstalledFiles(const FileDescriptions& aFileDes, std::wstring& aLocalPath)
{
FileDescriptions::const_iterator curr = aFileDes.begin();
FileDescriptions::const_iterator end = aFileDes.end();
for ( ; curr != end ; ++curr)
{
std::wstring target((*curr)->GetTarget());
ConvertToLocalPath(target, aLocalPath);
RemoveFile(target);
RemoveHashForFile(target, iParamList.SystemDriveLetter(), iParamList.SystemDrivePath());
}
}
void SisRegistry::AddRegistryEntry( const SisFile& aSis, const InstallableFiles& aFiles,
const InstallSISFile& aInstallSISFile )
{
SisRegistryObject* obj = new SisRegistryObject( aSis, aFiles, aInstallSISFile.iTargetDrive,
iParamList.RegistryMajorVersion(), iParamList.RegistryMinorVersion(), aInstallSISFile.iSUFlag, iConfigManager );
// Generate .reg and .ctl file for native installation.
// Installation based on database registration, generate only the .ctl file.
GenerateRegistryEntry(*obj, aSis);
if(iParamList.RegistryVersionExists())
{
// Add the registry entry to the registry
iEntries.insert(EntryMap::value_type(obj->GetUid(),obj));
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
// if the entry already exists then remove it first
// this is the case where an in rom application is getting
// overwritten by an SA type.
// in case of db the entry is stored in the database from where first it has
// to be removed and then readded based on the updated registry object which is
// in memory. In case of file based registry update this is done is a separate
// way, it reads the existing registry entry and store it in memory, and updates the same
// entry in memory and then over-writes the old registry entry with the update entry.
TInt32 componentId = iDbHelper->GetComponentId(obj->GetUid(), obj->GetInstallType() );
if(componentId != DbHelper::Absent)
{
iDbHelper->RemoveEntry(componentId);
}
obj->SetValidationStatus(iParamList.OriginVerificationStatus());
GenerateDbRegistryEntry(*obj, iParamList.OriginVerificationStatus());
}
#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
void SisRegistry::UpdateRegistryEntry(const SisFile& aSis,
const InstallableFiles& aFiles, const InstallSISFile& aInstallSISFile)
{
TUint32 pkg = aSis.GetPackageUid();
SisRegistryObject* obj = GetRegistryObjectPtr(pkg);
obj->UpgradeEntry(aSis, aFiles, aInstallSISFile.iTargetDrive, aInstallSISFile.iSUFlag, aInstallSISFile.iNonRemovable, iConfigManager);
// Update/Create the .reg and .ctl files
GenerateRegistryEntry(*obj, aSis);
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
if(!iParamList.RegistryVersionExists())
{
TUint32 componentId = iDbHelper->GetComponentId(pkg);
// remove the application from database
iDbHelper->RemoveEntry(componentId);
obj->SetValidationStatus(iParamList.OriginVerificationStatus());
GenerateDbRegistryEntry(*obj, iParamList.OriginVerificationStatus());
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
const SisRegistryObject* SisRegistry::OwningPackage( const std::wstring& aFilename, TUint32& aUid ) const
{
if(iParamList.RegistryVersionExists())
{
// Loop through iEntries, then loop through file desc for spec UID, then return the obj
for (EntryMap::const_iterator curr = iEntries.begin() ;
curr != iEntries.end() ;
++curr)
{
// Get the file descriptions
if (curr->second->GetFile(aFilename) != 0)
{
aUid = curr->first;
return curr->second;
}
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
aUid = iDbHelper->GetUidFromFileName(aFilename);
if(aUid != 0)
{
SisRegistryObject* sisRegistryObject = new SisRegistryObject(iConfigManager);
if(iDbHelper->InternalizeIfExists(*sisRegistryObject,aUid))
{
return sisRegistryObject;
}
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
return NULL;
}
void SisRegistry::RemoveBackupLst()
{
std::wstring backup = KPathToRegistry + KBackupLst;
ConvertToLocalPath( backup, iParamList.SystemDrivePath() );
if ( FileExists( backup ) )
{
RemoveFile( backup );
}
}
void SisRegistry::ReadStubs( const std::wstring& aDirectory )
{
// Make sure the directory name is properly terminated.
std::wstring basePath = StringUtils::EnsureDirectoryTerminated( aDirectory );
std::list<std::wstring> stubDirs;
GetDirContents( basePath, stubDirs );
std::list<std::wstring>::iterator curr;
for(curr = stubDirs.begin(); curr!= stubDirs.end(); ++curr)
{
std::wstring stubPath ( basePath + *curr );
if( !IsSisValid(stubPath) )
continue;
_TCHAR* fileName = const_cast<_TCHAR *>(stubPath.c_str());
std::auto_ptr<CSISController> sisController(ReadStubController( fileName ));
if (!sisController.get())
{
LERROR(L"\tCannot create CSISController for "<< stubPath);
continue;
}
if (IsInstalled(sisController->UID1()))
{
// Has already been upgraded
continue;
}
SisRegistryObject* aObj = new SisRegistryObject(*sisController, iRomManager,
iParamList.RegistryMajorVersion(),
iParamList.RegistryMinorVersion(),
iConfigManager);
GenerateStubRegistry(aObj,sisController.get());
} // for
}
TBool SisRegistry::IsSisValid(const std::wstring& aStubPath)
{
int dotIndex = aStubPath.rfind(L".");
if(dotIndex == std::wstring::npos)
return false;
std::wstring extOfString = aStubPath.substr(dotIndex+1);
std::wstring extOfStringUpper = StringUtils::ToUpper(extOfString);
if (extOfStringUpper != L"SIS" && extOfStringUpper != L"SISX")
return false;
return true;
}
void SisRegistry::GenerateStubRegistry(SisRegistryObject* aSisRegistryObject, CSISController* aSisController)
{
// create the directory to be used for storing reg and ctl files
std::wstring regPath = aSisRegistryObject->GetRegistryDir( L"" );
ConvertToLocalPath( regPath, iParamList.SystemDrivePath() );
if ( !MakeDir( regPath ) )
{
throw InterpretSisError(L"Directory Creation Error - "+regPath, DIRECTORY_CREATION_ERROR);
}
LINFO(L"\tAdding ROM Stub: 0x" << std::hex << aSisRegistryObject->GetUid() << L" \"" << aSisRegistryObject->GetPackageName() << L"\"");
if(iParamList.RegistryVersionExists())
{
iEntries.insert( EntryMap::value_type( aSisRegistryObject->GetUid(), aSisRegistryObject ) );
// Create the ROM Stub registry entries
std::fstream regFile;
std::wstring reg = regPath+KRegistryEntry;
OpenFile( reg, regFile, std::ios::out | std::ios::binary );
Serialiser s(regFile);
// Create the .reg file:
s << aSisRegistryObject;
regFile.close();
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
GenerateDbRegistryEntry(*aSisRegistryObject, iParamList.OriginVerificationStatus());
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// Create the .ctl file:
std::fstream ctlFile;
OpenFile( regPath+KControllerEntry, ctlFile, std::ios::out | std::ios::binary );
const unsigned char* ctl = aSisController->RawBuffer();
int len = aSisController->BufferSize();
ctlFile.write((const char*)&len, 4);
ctlFile.write((char*)ctl, len);
ctlFile.close();
}
bool SisRegistry::IsFileWideCard(const std::wstring& aFileName)
{
return (aFileName.find(L'?') != std::wstring::npos ||
aFileName.find(L'*') != std::wstring::npos ||
#ifndef __TOOLS2_LINUX__
aFileName[aFileName.length() - 1] == L'\\');
#else
aFileName[aFileName.length() - 1] == L'/');
#endif
}
void SisRegistry::GenerateStubRegistry()
{
if (!iParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet))
{
// If the -z option were used to launch the tool, then read any
// SIS stubs that we have gathered from the emulated z:\system\install
// location.
if (iParamList.IsFlagSet(CParameterList::EFlagsZDriveSet))
{
std::wstring stubPathZ = KPathToRomStubs;
ConvertToLocalPath( stubPathZ, iParamList.RomDrivePath() );
ReadStubs( stubPathZ );
}
// If an additional SIS stub path were specified, we'll
// also handle that here too.
if (iParamList.IsFlagSet(CParameterList::EFlagsStubDirectorySet))
{
bool readCustomStubPath = true;
std::wstring customStubPath = iParamList.SisStubPath();
// But make sure we don't read the same directory twice!
const bool haveRomDrive = iParamList.IsFlagSet(CParameterList::EFlagsZDriveSet);
if ( haveRomDrive )
{
std::wstring stubPathZ = KPathToRomStubs;
ConvertToLocalPath( stubPathZ, iParamList.RomDrivePath() );
readCustomStubPath = ( stubPathZ != customStubPath );
}
if ( readCustomStubPath )
{
ReadStubs( customStubPath );
}
}
}
}
void SisRegistry::ReadRegistry( const std::wstring& aRegistryBasePath )
{
std::list<std::wstring> regDirs;
GetDirContents( aRegistryBasePath, regDirs );
std::list<std::wstring>::iterator curr = regDirs.begin();
LINFO(L"Reconstructing SIS Registry...");
for( curr = regDirs.begin(); curr != regDirs.end(); ++curr )
{
struct stat s;
const std::wstring entryPath = aRegistryBasePath + *curr;
const int err = GetStat(entryPath.c_str(), &s);
if ( err )
continue;
const bool isDir = (s.st_mode & S_IFDIR) != 0;
if (isDir && IsPackageDir(*curr))
{
ExtractRegistryFiles(entryPath);
}
}
}
void SisRegistry::ExtractRegistryFiles(const std::wstring& aPath)
{
std::list<std::wstring> contents;
GetDirContents(aPath, contents);
for (std::list<std::wstring>::iterator c = contents.begin(); c != contents.end(); ++c)
{
if (c->find(L".reg",0) == std::wstring::npos)
continue;
std::fstream input;
#ifndef __TOOLS2_LINUX__
std::wstring filename(aPath + L"\\" + *c);
#else
std::wstring filename(aPath + L"/" + *c);
#endif
OpenFile(filename.c_str(), input, std::fstream::in | std::fstream::binary);
if (!input.good())
continue;
SisRegistryObject* obj = new SisRegistryObject(iConfigManager);
if (!obj)
{
throw std::runtime_error("Cannot create SisRegistryObject for " + wstring2string(filename));
}
Deserialiser des(input);
des >> *obj;
iEntries.insert(EntryMap::value_type(obj->GetUid(), obj));
LINFO(L"\tExtracting: 0x" << std::hex << obj->GetUid() << L" \"" << obj->GetPackageName() << L"\"");
}
}
bool SisRegistry::IsRomStubPackage(const TUint32 aUid)
{
CSISController* sisController = GetStubController(aUid);
if (sisController)
{
delete sisController;
return true;
}
return false;
}
void SisRegistry::GetStubFileEntries(const TUint32 aUid, std::list<std::wstring>& aFilesEntries)
{
std::auto_ptr<CSISController> sisController(GetStubController(aUid));
if (!sisController.get())
return;
const CSISInstallBlock& installBlock = sisController->InstallBlock();
int fileCount = installBlock.FileCount();
for (int i = 0; i < fileCount; ++i)
{
std::wstring target(installBlock.FileDescription(i).Target().GetString());
aFilesEntries.push_back(target);
}
}
CSISController* SisRegistry::GetStubController(const TUint32 aUid)
{
if (iParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet))
{
return NULL;
}
// If the -z option were used to launch the tool, then read any
// SIS stubs that we have gathered from the emulated Z:\System\Install
// location.
if (iParamList.IsFlagSet(CParameterList::EFlagsZDriveSet))
{
std::wstring stubPathZ = KPathToRomStubs;
ConvertToLocalPath( stubPathZ, iParamList.RomDrivePath() );
CSISController* sisController = GetStubControllerInDir( stubPathZ, aUid );
if (sisController)
{
return sisController;
}
}
// If an additional SIS stub path were specified, we'll
// also handle that here too.
if (iParamList.IsFlagSet(CParameterList::EFlagsStubDirectorySet))
{
bool readCustomStubPath = true;
std::wstring customStubPath = iParamList.SisStubPath();
// But make sure we don't read the same directory twice!
const bool haveRomDrive = iParamList.IsFlagSet(CParameterList::EFlagsZDriveSet);
if ( haveRomDrive )
{
std::wstring stubPathZ = KPathToRomStubs;
ConvertToLocalPath( stubPathZ, iParamList.RomDrivePath() );
readCustomStubPath = ( stubPathZ != customStubPath );
}
if ( readCustomStubPath )
{
CSISController* sisController = GetStubControllerInDir( customStubPath, aUid );
if (sisController)
{
return sisController;
}
}
}
return NULL;
}
CSISController* SisRegistry::GetStubControllerInDir( const std::wstring& aDirectory, const TUint32 aUid)
{
// Make sure the directory name is properly terminated.
std::wstring basePath = StringUtils::EnsureDirectoryTerminated( aDirectory );
std::list<std::wstring> stubDirs;
GetDirContents( basePath, stubDirs );
std::list<std::wstring>::iterator curr;
for (curr = stubDirs.begin(); curr != stubDirs.end() ; ++curr)
{
std::wstring stubPath ( basePath + *curr );
int dotIndex = stubPath.rfind(L".");
if(dotIndex == std::wstring::npos)
continue;
std::wstring extOfString = stubPath.substr(dotIndex+1);
std::wstring extOfStringUpper = StringUtils::ToUpper(extOfString);
if (extOfStringUpper != L"SIS" && extOfStringUpper != L"SISX")
continue;
_TCHAR* fileName = const_cast<_TCHAR *>(stubPath.c_str());
CSISController* sisController = ReadStubController( fileName );
if (!sisController)
continue;
if (sisController->UID1() == aUid)
{
return sisController;
}
delete sisController;
}
return NULL;
}
CSISController* SisRegistry::ReadStubController( const wchar_t* aFileName )
{
const bool isSisFile = CSISContents::IsSisFile(aFileName);
CSISController* sisController = NULL;
if (isSisFile)
{
LWARN(L"\tIgnoring invalid SIS stub: " << aFileName);
return sisController;
}
SisRegistryObject* aObj = NULL;
TSISStream input;
std::wstring fileName = FixPathDelimiters(aFileName);
HANDLE file = ::MakeSISOpenFile(fileName.c_str(),GENERIC_READ,OPEN_EXISTING);
if (INVALID_HANDLE_VALUE == file)
{
LERROR(L" Error : Cannot open file : " << fileName << std::endl);
throw CSISException(CSISException::EFileProblem, std::wstring (L"cannot open ") + fileName);
}
bool success = input.import (file, NULL);
::CloseHandle(file);
if(!success)
{
LERROR(L" Error : Cannot read file : " << fileName << std::endl);
throw CSISException(CSISException::EFileProblem, std::wstring (L"cannot read ") + fileName);
}
sisController = new CSISController;
sisController->Read(input, input.length());
return sisController;
}
void SisRegistry::GenerateRegistryEntry(SisRegistryObject& aObj, const SisFile& aSis)
{
SetNextIndex(aObj);
if(iParamList.RegistryVersionExists())
{
GenerateRegFile(aObj);
}
GenerateCtlFile(aObj, aSis);
}
void SisRegistry::SetNextIndex(SisRegistryObject& aObj) const
{
TUint32 pkgUid = aObj.GetUid();
TUint32 installType = aObj.GetInstallType();
int index = 0;
if(iParamList.RegistryVersionExists())
{
if (installType == CSISInfo::EInstAugmentation)
{
// set the .reg and .ctl file index for SP installation
index = aObj.NextSisRegistryIndex( iParamList.SystemDrivePath() );
if (index == 0)
{
// No SisRegistry file found!!
std::wstring msg = StringUtils::MakePathFromSID ( iParamList.SystemDrivePath()+L"\\", pkgUid );
msg.append(L" does not have any SisRegistry file");
throw std::runtime_error( wstring2string(msg) );
}
aObj.SetIndex( index );
if ( !CheckSisRegistryDirPresent(iParamList.SystemDrivePath(), pkgUid) )
{
// c:\sys\install\sisregistry\<UID>\ directory not exist
std::wstring msg = StringUtils::MakePathFromSID ( iParamList.SystemDrivePath()+L"\\", pkgUid );
msg.append(L" directory NOT found");
throw std::runtime_error( wstring2string(msg) );
}
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
if (installType == CSISInfo::EInstAugmentation)
{
// set .ctl file index for SP installation
index = iDbHelper->GetIndex(pkgUid);
int nextIndex = index +1;
aObj.SetIndex( nextIndex );
if ( !CheckSisRegistryDirPresent(iParamList.SystemDrivePath(), pkgUid) )
{
std::wstring msg = StringUtils::MakePathFromSID ( iParamList.SystemDrivePath()+L"\\", pkgUid );
msg.append(L" directory NOT found");
throw std::runtime_error( wstring2string(msg) );
}
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
}
void SisRegistry::GenerateRegFile(SisRegistryObject& aObj) const
{
TUint32 installType = aObj.GetInstallType();
std::wstring regPath = aObj.GetRegistryDir( L"" );
ConvertToLocalPath( regPath, iParamList.SystemDrivePath() );
if (installType == CSISInfo::EInstInstallation)
{
if ( !MakeDir( regPath ) )
{
throw InterpretSisError(L"Directory Creation Error - "+regPath, DIRECTORY_CREATION_ERROR);
}
}
std::fstream regFile;
std::wstring reg = regPath + StringUtils::BuildSisRegistryFileName(aObj.GetIndex());
OpenFile( reg, regFile, std::ios::out | std::ios::binary );
Serialiser s(regFile);
s << aObj;
regFile.close();
}
void SisRegistry::GenerateCtlFile(SisRegistryObject& aObj, const SisFile& aSis) const
{
TUint32 pkgUid = aObj.GetUid();
TUint32 installType = aObj.GetInstallType();
// Controller
int index = 0;
if (installType == CSISInfo::EInstPartialUpgrade)
{
index = aObj.NextSisControllerIndex( iParamList.SystemDrivePath() );
if (index == 0)
{
// No SIS controller file found!!
std::wstring msg = StringUtils::MakePathFromSID ( iParamList.SystemDrivePath()+L"\\", pkgUid );
msg.append(L" does not have any Sis Controller file");
throw std::runtime_error( wstring2string(msg) );
}
}
// Finally, externalise the new controller file
std::fstream ctlFile;
std::wstring ctlPath = aObj.GetRegistryDir( L"" );
ConvertToLocalPath( ctlPath, iParamList.SystemDrivePath() );
if (installType == CSISInfo::EInstInstallation)
{
if ( !MakeDir( ctlPath ) )
{
throw InterpretSisError(L"Directory Creation Error - "+ctlPath, DIRECTORY_CREATION_ERROR);
}
}
std::wstring ctrl = ctlPath + StringUtils::BuildControllerFileName( aObj.GetIndex(), index );
OpenFile( ctrl, ctlFile, std::ios::out | std::ios::binary );
const char* ctl = 0;
int len = 0;
aSis.GetControllerData(ctl, len);
ctlFile.write((const char*)&len, 4);
ctlFile.write(ctl, len);
ctlFile.close();
int targetDrive = tolower(aObj.GetSelectedDrive());
if (iConfigManager.IsTargetDriveExt(targetDrive))
{
// For external target drive, generate the ctl file to that drive also
std::wstring ctlPath = aObj.GetRegistryDir( L"" );
std::wstring localTargetPath = iConfigManager.GetLocalDrivePath(targetDrive);
ConvertToLocalPath( ctlPath, localTargetPath );
if ( !MakeDir( ctlPath ) )
{
throw InterpretSisError(L"Directory Creation Error - "+ctlPath, DIRECTORY_CREATION_ERROR);
}
ctrl = ctlPath + StringUtils::BuildControllerFileName( aObj.GetIndex(), index );
OpenFile( ctrl, ctlFile, std::ios::out | std::ios::binary );
ctlFile.write((const char*)&len, 4);
ctlFile.write(ctl, len);
ctlFile.close();
}
}
int SisRegistry::GetAugmentationsNumber(TUint32 aUid)
{
int num = 0;
if(iParamList.RegistryVersionExists())
{
EntryMap::const_iterator x = iEntries.begin();
for (;x != iEntries.end(); ++x)
{
if (x->first == aUid && x->second->GetIndex() != 0 )
++num;
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
else
{
TInt32 componentId = iDbHelper->GetComponentId(aUid);
TInt index = iDbHelper->GetIndex(componentId);
if( index != DbHelper::Absent )
num = ++index;
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
return num;
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
std::wstring SisRegistry::FormatVersionToString( const Version& aVersion )
{
std::wstringstream versionText;
versionText << aVersion.GetMajor() << L"." << aVersion.GetMinor() << L"." << aVersion.GetBuild();
return versionText.str();
}
const DbHelper* SisRegistry::GetDbHelper() const
{
return iDbHelper;
}
void SisRegistry::GenerateDbRegistryEntry(const SisRegistryObject& aSisRegistryObject, bool aOriginVerified)
{
// store the object in registry database
XmlDetails::TScrPreProvisionDetail scrPreProvisionDetail;
// for sis file entries the software type would always be Native.
scrPreProvisionDetail.iSoftwareTypeName = SisRegistry::NativeSoftwareType;
XmlDetails::TScrPreProvisionDetail::TComponent component = CreateRegistryEntry(aSisRegistryObject);
SetOriginVerification(component, aOriginVerified);
scrPreProvisionDetail.iComponents.push_back(component);
UpdateInstallationInformation(scrPreProvisionDetail);
}
void SisRegistry::SetOriginVerification(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, bool aOriginVerified)
{
// If not origin verified, set so. By default origin is verified.
if (!aOriginVerified)
{
aComponent.iComponentDetails.iOriginVerified = 0;
}
}
void SisRegistry::UpdateInstallationInformation(XmlDetails::TScrPreProvisionDetail aScrPreProvisionDetail)
{
CXmlGenerator xmlGenerator;
#ifndef __TOOLS2_LINUX__
char* tmpFileName = tmpnam(NULL);
#else
char tmpFileName[] = "/tmp/interpretsis_XXXXXX";
int temp_fd;
temp_fd=mkstemp(tmpFileName);
fclose(fdopen(temp_fd,"w"));
#endif
std::wstring filename(string2wstring(tmpFileName));
int isRomApplication = 0;
xmlGenerator.WritePreProvisionDetails(filename , aScrPreProvisionDetail, isRomApplication);
#ifdef __TOOLS2_LINUX__
std::string executable = "scrtool";
#else
std::string executable = "scrtool.exe";
#endif
std::string command;
command = executable + " -d " + GetDbPath() + " -p " + tmpFileName;
int error = system(command.c_str());
int err = remove(tmpFileName);
if(err != 0)
LERROR(L"Temporary file removal failed.");
if(error != 0)
{
std::string err = "Scrtool failed to upload the database registry entry.";
LERROR(L"Scrtool failed to upload the database registry entry.");
throw InterpretSisError(err, DATABASE_UPDATE_FAILED);
}
}
std::string SisRegistry::GetDbPath()
{
if (
(iParamList.RomLogFileNames().size() != 0 && iParamList.RomDrivePath().size() == 0 ) ||
iParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet)
)
{
#ifndef __TOOLS2_LINUX__
return wstring2string(iParamList.SystemDrivePath()) + "\\sys\\install\\scr\\scr.db";
#else
return wstring2string(iParamList.SystemDrivePath()) + "/sys/install/scr/scr.db";
#endif
}
#ifndef __TOOLS2_LINUX__
return wstring2string(iParamList.RomDrivePath()) + "\\sys\\install\\scr\\provisioned\\scr.db";
#else
return wstring2string(iParamList.RomDrivePath()) + "/sys/install/scr/provisioned/scr.db";
#endif
}
std::string SisRegistry::GetEpocRoot()
{
const char* epocRoot = getenv("EPOCROOT");
if(NULL == epocRoot)
{
std::string err = "EPOCROOT environment variable not specified. Please specify it as part of your environment variable." \
"It should point uptil the start of the epoc32 directory.";
LERROR(L"EPOCROOT environment variable not specified. Please specify it as part of your environment variable." \
"It should point uptil the start of the epoc32 directory.");
throw InterpretSisError(err, ENV_NOT_SPECIFIED);
}
std::string epocRootStr(epocRoot);
return epocRootStr;
}
std::wstring SisRegistry::GetGlobalId( TUint32 aUid , TInt aInstallType, std::wstring aPackageName)
{
wchar_t textGlobalId[20];
#ifdef _MSC_VER
swprintf(textGlobalId,L"%08x",aUid);
#else
swprintf(textGlobalId,20,L"%08x",aUid);
#endif
std::wstring globalId = textGlobalId;
if( aInstallType == CSISInfo::EInstAugmentation || aInstallType == CSISInfo::EInstPreInstalledPatch )
{
if(aPackageName.empty())
{
std::string err = "Package Name not specified for global id creation.";
LERROR(L"Package Name not specified for global id creation.");
throw InterpretSisError(err, GLOBALID_CREATION_ERROR);
}
globalId += L"_" + aPackageName;
}
return globalId;
}
void SisRegistry::RemovePkgWithScr(TUint32 aUid, bool aSkipRomStub)
{
TUint32 componentId = iDbHelper->GetComponentId(aUid);
if ( DbHelper::Absent == componentId )
{
// No database entry found!!
std::stringstream err;
err << " SisRegistry entry for 0x" << std::hex << aUid << L" Not found";
throw InterpretSisError(err.str(), DATABASE_ENTRY_MISSING);
}
std::list<std::wstring> regDirFiles;
std::wstring path = GetRegistryDir( iParamList.SystemDrivePath(), aUid );
GetDirContents(path, regDirFiles);
// The directory should only consist of the .ctl file. Comparison with
// 2 is for the ctl file and link to the parent directory.
if ( regDirFiles.size() == KDirFileCount && iDbHelper->GetInRom(componentId))
{
// I.e. there are only one .ctl file present
// check whether it is a ROM stub object (without any upgrades)
if (aSkipRomStub)
{
// Since this is only a ROM stub entry, leave it as it is;
// to avoid regenerate it again.
return;
}
std::stringstream err;
err << "Illegal uninstall of ROM package 0x" << std::hex << aUid;
throw InterpretSisError(err.str(), ATTEMPT_TO_UNINSTALL_ROM_PKG);
}
std::list<std::wstring>::iterator currFile = regDirFiles.begin();
// Remove all .ctl files in the system drive for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
int pos = 0;
if((pos = currFile->find(L".ctl_backup", 0)) == std::wstring::npos)
#endif
RemoveFile(path + *currFile);
}
++currFile;
}
// Remove the installed files for all packages (SA, SP, PU)
// retrieve component id for the specified uid
std::vector<TInt32> compIdList = iDbHelper->GetComponentIdList(aUid);
std::vector<TInt32> ::iterator compIter;
for( compIter = compIdList.begin(); compIter != compIdList.end() ; ++compIter )
{
// For ROM stub, the SelectedDrive = 0; as there could be ROM->SP.
// Therefore, the rest can only apply to at least a ROM stub upgrades
int drive = tolower(iDbHelper->GetSelectedDrive(*compIter));
if (drive)
{
std::wstring localTargetPath = iConfigManager.GetLocalDrivePath(drive);
path = GetRegistryDir( localTargetPath, aUid );
regDirFiles.clear();
GetDirContents(path, regDirFiles);
currFile = regDirFiles.begin();
// Remove all the .ctl files for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
int pos = 0;
if((pos = currFile->find(L".ctl_backup", 0)) == std::wstring::npos)
#endif
RemoveFile(path + *currFile);
}
++currFile;
}
// This iterator's object has the same Uid as aUid
const FileDescriptions& files = iDbHelper->GetFileDescriptions(*compIter);
RemoveInstalledFiles(files, localTargetPath);
}
// remove the application from database
iDbHelper->RemoveEntry(*compIter);
}
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
void SisRegistry::BackupCtl(TUint32 aUid)
{
std::list<std::wstring> regDirFiles;
std::wstring path = GetRegistryDir( iParamList.SystemDrivePath(), aUid );
GetDirContents(path, regDirFiles);
std::list<std::wstring>::iterator currFile = regDirFiles.begin();
std::wstring path1 = FixPathDelimiterstap(path);
// Backup all .ctl files in the system drive for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
std::string ifile = wstring2string(path1 +*currFile);
std::string ibackupfile(ifile);
ibackupfile.append("_backup");
int err=FileCopyA(ifile.c_str(),ibackupfile.c_str(),0);
if (err != 0)
LERROR(L"Failed to Backup .ctl ");
}
++currFile;
}
}
void SisRegistry::RestoreCtl(TUint32 aUid, TBool& aBackupFlag)
{
std::list<std::wstring> regDirFiles;
std::wstring path = GetRegistryDir( iParamList.SystemDrivePath(), aUid );
GetDirContents(path, regDirFiles);
std::list<std::wstring>::iterator currFile = regDirFiles.begin();
// Restore all .ctl files in the system drive for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
if(aBackupFlag)
{
int pos =0;
if((pos = currFile->find(L".ctl_backup", 0)) == std::wstring::npos)
{
std::string ifile = wstring2string(path +*currFile);
std::string ibackupfile(ifile);
ibackupfile.append("_backup");
RemoveFile(path + *currFile);
int err = FileMoveA(ibackupfile.c_str(),ifile.c_str());
if (err != 0)
LERROR(L"Failed to Restore .ctl ");
}
}
else
{
RemoveFile(path + *currFile);
}
}
++currFile;
}
}
void SisRegistry::RemoveCtlBackup(TUint32 aUid)
{
std::list<std::wstring> regDirFiles;
std::wstring path = GetRegistryDir( iParamList.SystemDrivePath(), aUid );
GetDirContents(path, regDirFiles);
std::list<std::wstring>::iterator currFile = regDirFiles.begin();
// Remove all .ctl backup files in the system drive for this package
while (currFile != regDirFiles.end())
{
if (*currFile != L"." && *currFile != L"..")
{
std::wstring ifile(path +*currFile);
ifile.append(L"_backup");
if (FileExists(ifile))
RemoveFile(ifile);
}
++currFile;
}
}
#endif
TUint32 SisRegistry::GetUid(TUint32 aSid) const
{
return iDbHelper->GetUid(aSid);
}
TUint32 SisRegistry::GetUid(const std::wstring& aSidFile) const
{
return iDbHelper->GetUid(aSidFile);
}
bool SisRegistry::GetInRom(TUint32 aUid) const
{
TUint32 componentId = iDbHelper->GetComponentId(aUid);
return iDbHelper->GetInRom(componentId);
}
XmlDetails::TScrPreProvisionDetail::TComponent SisRegistry::CreateRegistryEntry(const SisRegistryObject& aSisRegistryObject)
{
XmlDetails::TScrPreProvisionDetail::TComponent component;
// add registry token information
AddSisRegistryToken(component, dynamic_cast<const SisRegistryToken&> (aSisRegistryObject));
// update SisregistryObject
AddLocalizedNames(component,aSisRegistryObject);
// This flag cannot be made optional as it is used in queries
AddComponentProperty(component, DbConstants::CompInstallType, aSisRegistryObject.GetInstallType(), IGNORE_FORMATTING);
AddComponentDependencies(component, aSisRegistryObject);
AddEmbeddedPackages(component, aSisRegistryObject.GetEmbeddedPackages());
AddProperties(component, aSisRegistryObject.GetProperties());
AddFileDescription(component, aSisRegistryObject.GetFileDescriptions());
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
AddApplicationRegistrationInfoL(component, aSisRegistryObject.GetFileDescriptions(), aSisRegistryObject.GetInRom());
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
// inROM
if(DbConstants::KDefaultIsInRom != aSisRegistryObject.GetInRom())
AddComponentProperty(component, DbConstants::CompInRom, aSisRegistryObject.GetInRom(), IGNORE_FORMATTING );
// isSigned
if(DbConstants::KDefaultIsSigned != aSisRegistryObject.GetSigned())
AddComponentProperty(component, DbConstants::CompIsSigned, aSisRegistryObject.GetSigned(), IGNORE_FORMATTING);
// SignedBySuCert
if(DbConstants::KDefaultIsSignedBySuCert != aSisRegistryObject.GetSignedBySuCert())
AddComponentProperty(component, DbConstants::CompSignedBySuCert, aSisRegistryObject.GetSignedBySuCert(), IGNORE_FORMATTING);
// DeletablePreinstalled
if(DbConstants::KDefaultIsDeletablePreInstalled != aSisRegistryObject.GetPreInstalled())
AddComponentProperty(component, DbConstants::CompDeletablePreinstalled, aSisRegistryObject.GetPreInstalled(), IGNORE_FORMATTING);
// iTrust
if(DbConstants::KDefaultTrustValue != aSisRegistryObject.GetTrust())
AddComponentProperty(component, DbConstants::CompTrust, aSisRegistryObject.GetTrust(), IGNORE_FORMATTING );
// iRemoveWithLastDependent
if(DbConstants::KDefaultRemoveWithLastDependent != aSisRegistryObject.GetRemoveWithLastDependent())
AddComponentProperty(component, DbConstants::CompIsRemoveWithLastDependent, aSisRegistryObject.GetRemoveWithLastDependent(), IGNORE_FORMATTING );
// iTrustTimeStamp will be deprecated
// 64 bit value
std::wstring strTimeStamp = Utils::Int64ToWideString(aSisRegistryObject.GetTrustTimeStamp());
AddComponentProperty(component, DbConstants::CompTrustTimeStamp, strTimeStamp, IGNORE_FORMATTING, false );
// iTrustStatus
AddTrustStatus(component, aSisRegistryObject.GetTrustStatus() );
// installChainIndices
AddInstallChainIndices(component, aSisRegistryObject.GetInstallChainIndices() );
// iIsRemovable
if(aSisRegistryObject.GetIsRemovable() )
{
component.iComponentDetails.iIsRemovable = 1;
}
else
{
component.iComponentDetails.iIsRemovable = 0;
}
// iIsHidden
if(aSisRegistryObject.GetIsHidden() )
{
component.iComponentDetails.iIsHidden = 1;
}
else
{
component.iComponentDetails.iIsHidden = 0;
}
return component;
}
void SisRegistry::AddSisRegistryToken ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const SisRegistryToken& aSisRegistryToken
)
{
// add sisregistrypackage details
AddSisRegistryPackage( aComponent, dynamic_cast<const SisRegistryPackage&>(aSisRegistryToken), aSisRegistryToken.GetLanguage() );
// add sid count
// sids would be added later alongwith their corresponding executables.
int sidCount = aSisRegistryToken.GetSids().size();
if (DbConstants::KDefaultSidCount != sidCount)
AddComponentProperty( aComponent, DbConstants::CompSidCount, sidCount, IGNORE_FORMATTING);
if( sidCount > 0)
{
AddComponentProperty(aComponent, DbConstants::CompSidsPresent, ENABLE, IGNORE_FORMATTING);
}
AddControllerInfo(aComponent, aSisRegistryToken.GetControllerInfo());
AddVersion(aComponent, aSisRegistryToken.GetVersion());
if (aSisRegistryToken.GetLanguage() != DbConstants::KDefaultInstalledLanguage)
AddComponentProperty( aComponent, DbConstants::CompLanguage, aSisRegistryToken.GetLanguage(), IGNORE_FORMATTING);
if (aSisRegistryToken.GetSelectedDrive() != DbConstants::KDefaultInstalledDrive)
AddComponentProperty( aComponent, DbConstants::CompSelectedDrive, aSisRegistryToken.GetSelectedDrive(), IGNORE_FORMATTING);
}
void SisRegistry::AddSisRegistryPackage ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const SisRegistryPackage& aSisRegistryPackage,
int aLanguage
)
{
// vendor
AddComponentProperty( aComponent, DbConstants::CompUniqueVendorName, aSisRegistryPackage.GetVendorName(),IGNORE_FORMATTING,false);
// uid
std::wstringstream strPropName;
strPropName << DbConstants::CompUid;
std::wstringstream strPropValue;
TInt32 uid = aSisRegistryPackage.GetUid();
strPropValue << uid;
XmlDetails::TScrPreProvisionDetail::TComponentProperty
compProperty = CreateComponentProperty(strPropName.str(), strPropValue.str(), true, false);
aComponent.iComponentProperties.push_back(compProperty);
// index
AddComponentProperty( aComponent, DbConstants::CompIndex, aSisRegistryPackage.GetIndex(),IGNORE_FORMATTING );
// calculate the globalid for this component
int installType = dynamic_cast<const SisRegistryObject&>(aSisRegistryPackage).GetInstallType();
std::wstring globalId = GetGlobalId(aSisRegistryPackage.GetUid(), installType, aSisRegistryPackage.GetPackageName());
aComponent.iComponentDetails.iGlobalId = globalId;
}
void SisRegistry::AddControllerInfo ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const std::vector<ControllerInfo*>& aControllerInfo
)
{
if(DbConstants::KDefaultControllerCount != aControllerInfo.size())
AddComponentProperty( aComponent, DbConstants::CompControllerCount, aControllerInfo.size(), IGNORE_FORMATTING);
std::vector<ControllerInfo*>::const_iterator controllerInfoIter;
int count = 0;
for(controllerInfoIter = aControllerInfo.begin() ; controllerInfoIter != aControllerInfo.end() ; ++controllerInfoIter )
{
std::wstring version = FormatVersionToString((*controllerInfoIter)->GetVersion());
AddComponentProperty( aComponent, DbConstants::CompControllerVersion, version, count, false);
// offset
AddComponentProperty( aComponent, DbConstants::CompControllerOffset, (*controllerInfoIter)->GetOffset(), count );
// add hash information
AddHashContainer(aComponent, (*controllerInfoIter)->GetHashContainer(), count );
++count;
}
}
void SisRegistry::AddVersion ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const Version& aVersion
)
{
aComponent.iComponentDetails.iVersion.iMajor = Utils::IntegerToWideString(aVersion.GetMajor());
aComponent.iComponentDetails.iVersion.iMinor = Utils::IntegerToWideString(aVersion.GetMinor());
aComponent.iComponentDetails.iVersion.iBuild = Utils::IntegerToWideString(aVersion.GetBuild());
}
void SisRegistry::AddHashContainer ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const HashContainer& aHashContainer,
int aCount
)
{
if (aHashContainer.GetHashId() != HashContainer::EHashSHA)
AddComponentProperty( aComponent, DbConstants::CompControllerHashAlgorithm, aHashContainer.GetHashId(), aCount);
int algorithmId = aHashContainer.GetHashId();
// The property is a concatenation of the algorithm id and the hash data
const std::string hashData = aHashContainer.GetData();
std::string encodedHashData = Util::Base64Encode(hashData);
std::wstring wideHashData = string2wstring(encodedHashData);
AddComponentProperty( aComponent, DbConstants::CompControllerHashData, wideHashData, aCount, true);
}
void SisRegistry::AddLocalizedNames(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const SisRegistryObject& aSisRegistryObject)
{
TInt size = aSisRegistryObject.GetMatchingSupportedLanguages().size();
if ( 0 == size )
{
XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable;
componentLocalizable.iVendor = aSisRegistryObject.GetVendorLocalizedName();
componentLocalizable.iName = aSisRegistryObject.GetPackageName();
componentLocalizable.iLocale = aSisRegistryObject.GetLanguage();
aComponent.iComponentLocalizables.push_back(componentLocalizable);
}
else
{
for ( TInt i=0; i < size; i++)
{
XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable;
componentLocalizable.iName = aSisRegistryObject.GetLocalizedPackageNames()[i]->GetString();
componentLocalizable.iLocale = aSisRegistryObject.GetMatchingSupportedLanguages().at(i);
componentLocalizable.iVendor = aSisRegistryObject.GetLocalizedVendorNames()[i]->GetString();
aComponent.iComponentLocalizables.push_back(componentLocalizable);
}
}
}
void SisRegistry::AddComponentDependencies(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const SisRegistryObject& aSisRegistryObject)
{
const std::vector<SisRegistryDependency*>& dependencies = aSisRegistryObject.GetDependencies();
if(dependencies.size() == 0)
return;
std::wstring dependentGlobalId = GetGlobalId( aSisRegistryObject.GetUid(), aSisRegistryObject.GetInstallType(), aSisRegistryObject.GetPackageName() );
XmlDetails::TScrPreProvisionDetail::TComponentDependency componentDependency;
componentDependency.iDependentId = dependentGlobalId;
for(std::vector<SisRegistryDependency*>::const_iterator depIter = dependencies.begin() ; depIter != dependencies.end() ; ++depIter)
{
XmlDetails::TScrPreProvisionDetail::TComponentDependency::TComponentDependencyDetail componentDependencyDetail;
TUint32 uid = (*depIter)->GetUid();
std::wstring supplierGlobalId = GetGlobalId(uid,CSISInfo::EInstInstallation,L"");
componentDependencyDetail.iSupplierId = supplierGlobalId;
// add fromVersion
std::wstring fromVersion = FormatVersionToString((*depIter)->GetFromVersion());
componentDependencyDetail.iFromVersion = fromVersion;
// add toVersion
std::wstring toVersion = FormatVersionToString((*depIter)->GetToVersion());
componentDependencyDetail.iToVersion = toVersion;
componentDependency.iComponentDependencyList.push_back(componentDependencyDetail);
}
aComponent.iComponentDependency = componentDependency;
}
void SisRegistry::AddEmbeddedPackages(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const std::vector<SisRegistryPackage*>& aEmbeddedPackages )
{
// EmbeddedPckgCount
int embeddedPckgCount = aEmbeddedPackages.size();
if (DbConstants::KDefaultEmbeddedPackageCount != embeddedPckgCount)
AddComponentProperty(aComponent, DbConstants::CompEmbeddedPackageCount, embeddedPckgCount, IGNORE_FORMATTING );
if( embeddedPckgCount > 0)
{
AddComponentProperty(aComponent, DbConstants::CompEmbeddedPackagePresent, ENABLE, IGNORE_FORMATTING );
}
std::vector<SisRegistryPackage*>::const_iterator pckgIter;
int count = 0;
for(pckgIter = aEmbeddedPackages.begin() ; pckgIter != aEmbeddedPackages.end() ; ++pckgIter, ++count)
{
// package uid
AddComponentProperty( aComponent, DbConstants::CompEmbeddedPackageUid, (*pckgIter)->GetUid(), count);
// package name
AddComponentProperty( aComponent, DbConstants::CompEmbeddedPackageName, (*pckgIter)->GetPackageName(), count, false);
// vendor name
AddComponentProperty( aComponent, DbConstants::CompEmbeddedPackageVendor, (*pckgIter)->GetVendorName(), count, false);
// index
AddComponentProperty( aComponent, DbConstants::CompEmbeddedPackageIndex, (*pckgIter)->GetIndex(), count);
}
}
void SisRegistry::AddProperties(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const std::vector<SisRegistryProperty*>& aProperties )
{
if (aProperties.size() != DbConstants::KDefaultCompPropertyCount)
AddComponentProperty(aComponent, DbConstants::CompPropertyCount, aProperties.size(), IGNORE_FORMATTING );
std::vector<SisRegistryProperty*>::const_iterator propIter;
int count = 0;
for(propIter = aProperties.begin() ; propIter != aProperties.end() ; ++propIter, ++count)
{
// key
AddComponentProperty( aComponent, DbConstants::CompPropertyKey, (*propIter)->GetKey(), count);
// value
AddComponentProperty( aComponent, DbConstants::CompPropertyValue, (*propIter)->GetValue(), count);
}
}
void SisRegistry::AddFileDescription(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const std::vector<FileDescription*>& aFileDescription )
{
std::vector<FileDescription*>::const_iterator filedesIter;
int wildcardFileCount = 0;
int exeFileIndex = 0;
for(filedesIter = aFileDescription.begin() ; filedesIter != aFileDescription.end(); ++filedesIter)
{
// if it has wild card characters then add it as part of componentproperties table
if( IsFileWideCard((*filedesIter)->GetTarget()) )
{
// file target
AddComponentProperty( aComponent, DbConstants::WCFileName, (*filedesIter)->GetTarget(), wildcardFileCount++, false);
continue;
}
TInt sid = (*filedesIter)->GetSid();
if( sid != 0 )
{
// add sid file format
AddComponentProperty(aComponent, DbConstants::CompSidFileName, (*filedesIter)->GetTarget(), exeFileIndex, false);
AddComponentProperty(aComponent, DbConstants::CompSid, sid, exeFileIndex);
++exeFileIndex;
}
// add the location in the component files table
XmlDetails::TScrPreProvisionDetail::TComponentFile componentFile;
componentFile.iLocation = (*filedesIter)->GetTarget();
AddFileDescriptionAsFileProperty(componentFile, *filedesIter);
aComponent.iComponentFiles.push_back(componentFile);
}
if (DbConstants::KDefaultWildCardFileCount != wildcardFileCount)
AddComponentProperty(aComponent, DbConstants::CompWildCardFileCount, wildcardFileCount, IGNORE_FORMATTING);
}
#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
void SisRegistry::AddApplicationRegistrationInfoL(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, const std::vector<FileDescription*>& aFileDescription, int aInRom )
{
std::vector<FileDescription*>::const_iterator filedesIter;
std::wstring iLocalFile;
std::string RegistrationFileName;
//Find Registration File from list of filelist
for(filedesIter = aFileDescription.begin() ; filedesIter != aFileDescription.end(); ++filedesIter)
{
// if it has wild card characters then donot process. Continue.
if( IsFileWideCard((*filedesIter)->GetLocalFile()) )
{
continue;
}
iLocalFile = (*filedesIter)->GetLocalFile();
RegistrationFileName = wstring2string(iLocalFile);
std::string iRomPath = wstring2string(iParamList.RomDrivePath());
if(aInRom)
{
std::string localpath = FullNameWithoutDrive(RegistrationFileName);
RegistrationFileName = iRomPath + localpath;
}
size_t found=RegistrationFileName.rfind(".rsc");
if(found==string::npos)
continue;
//Return 0 for Registration file else 1
TInt err = FindRegistrationResourceFileL(RegistrationFileName);
if(err)
continue;
std::string folder;
#ifdef __LINUX__
const char *privateFolder = "private/10003a3f/";
#else
const char *privateFolder = "private\\10003a3f\\";
#endif
found=RegistrationFileName.find(privateFolder);
if( found != string::npos )
folder = RegistrationFileName.substr(0,found);
else
folder = RegistrationFileName;
CAppInfoReader* appInfoReader = NULL;
appInfoReader = CAppInfoReader::NewL(RegistrationFileName, NullUid, folder);
if (!appInfoReader)
{
std::string errMsg= "Error in Reading File. Memory Allocation Failed";
throw CResourceFileException(errMsg);
}
else
{
TBool readSuccessful=EFalse;
readSuccessful= appInfoReader->ReadL(aFileDescription, iRomPath, aInRom);
if (readSuccessful)
{
CreateApplicationRegistrationInfoL(aComponent,appInfoReader);
}
else
{
delete appInfoReader;
std::string errMsg= "Reading Resource File failed.";
throw CResourceFileException(errMsg);
}
}
delete appInfoReader;
}
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
void SisRegistry::AddFileDescriptionAsFileProperty ( XmlDetails::TScrPreProvisionDetail::TComponentFile& aComponentFile,
const FileDescription* aFileDescription
)
{
// mime type
if( !aFileDescription->GetMimeType().empty())
{
AddFileProperty( aComponentFile, DbConstants::FileMimeType, aFileDescription->GetMimeType(), true);
}
// operation
if(aFileDescription->GetOperation() != CSISFileDescription::EOpInstall)
{
AddFileProperty( aComponentFile, DbConstants::FileSisFileOperation, aFileDescription->GetOperation(), false);
}
// operation option
if( aFileDescription->GetOperationOptions() )
{
AddFileProperty( aComponentFile, DbConstants::FileFileOperationOptions, aFileDescription->GetOperationOptions(), false);
}
// uncompressed length
if( aFileDescription->GetUncompressedLength() )
{
AddFileProperty( aComponentFile, DbConstants::FileUncompressedLength, aFileDescription->GetUncompressedLength(), false);
}
// file index
if( aFileDescription->GetIndex() )
{
AddFileProperty( aComponentFile, DbConstants::FileIndex, aFileDescription->GetIndex(), false);
}
// sid
if( aFileDescription->GetSid() )
{
AddFileProperty( aComponentFile, DbConstants::FileSid, aFileDescription->GetSid(), false);
}
// filehash algorithm
if (aFileDescription->GetHash().GetHashId() != HashContainer::EHashSHA )
{
AddFileProperty( aComponentFile, DbConstants::FileHashAlgorithm, aFileDescription->GetHash().GetHashId(), false);
}
// file hash data
if(!aFileDescription->GetHash().GetData().empty())
{
std::string binHashData = Util::Base64Encode(aFileDescription->GetHash().GetData());
std::wstring hashData = string2wstring(binHashData);
AddFileProperty( aComponentFile, DbConstants::FileHashData, hashData, true);
}
}
void SisRegistry::AddTrustStatus ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const TrustStatus& aTrustStatus
)
{
// iValidationStatus
AddComponentProperty( aComponent, DbConstants::CompTrustValidationStatus, aTrustStatus.GetValidationStatus(), IGNORE_FORMATTING);
}
void SisRegistry::AddInstallChainIndices ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const std::vector<TInt>& aInstallChainIndices
)
{
if (aInstallChainIndices.size() != DbConstants::KDefaultChainIndex)
AddComponentProperty( aComponent, DbConstants::CompInstallChainIndexCount, aInstallChainIndices.size(), IGNORE_FORMATTING);
std::vector<TInt>::const_iterator chainIndicesIter;
int count = 0;
for(chainIndicesIter = aInstallChainIndices.begin(); chainIndicesIter != aInstallChainIndices.end() ; ++chainIndicesIter)
{
AddComponentProperty(aComponent, DbConstants::CompInstallChainIndex, *chainIndicesIter, count++);
}
}
void SisRegistry::AddComponentProperty ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const std::wstring& aPropName,
int aPropValue,
int aCount
)
{
std::wstringstream strPropName;
if(aCount != IGNORE_FORMATTING)
{
strPropName << aPropName << aCount;
}
else
{
strPropName << aPropName;
}
std::wstringstream strPropValue;
strPropValue << aPropValue;
XmlDetails::TScrPreProvisionDetail::TComponentProperty
compProperty = CreateComponentProperty(strPropName.str(), strPropValue.str(), true, false);
aComponent.iComponentProperties.push_back(compProperty);
}
void SisRegistry::AddComponentProperty ( XmlDetails::TScrPreProvisionDetail::TComponent& aComponent,
const std::wstring& aPropName,
const std::wstring& aPropValue,
int aCount,
bool aIsBinary
)
{
std::wstringstream strPropName;
if(aCount != IGNORE_FORMATTING)
{
strPropName << aPropName << aCount;
}
else
{
strPropName << aPropName;
}
XmlDetails::TScrPreProvisionDetail::TComponentProperty compProperty;
if(aIsBinary)
{
compProperty = CreateComponentProperty(strPropName.str(), aPropValue,false, true);
}
else
{
compProperty = CreateComponentProperty(strPropName.str(), aPropValue,false, false);
}
aComponent.iComponentProperties.push_back(compProperty);
}
void SisRegistry::AddFileProperty ( XmlDetails::TScrPreProvisionDetail::TComponentFile& aComponentFile,
const std::wstring& aPropName,
const std::wstring& aPropValue,
bool aIsBinary
)
{
XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty fileProperty;
fileProperty.iName = aPropName;
fileProperty.iValue = aPropValue;
fileProperty.iIsIntValue = !aIsBinary;
aComponentFile.iFileProperties.push_back(fileProperty);
}
void SisRegistry::AddFileProperty ( XmlDetails::TScrPreProvisionDetail::TComponentFile& aComponentFile,
const std::wstring& aPropName,
int aPropValue,
bool aIsBinary
)
{
std::wstringstream strPropValue;
strPropValue << aPropValue;
AddFileProperty(aComponentFile, aPropName, strPropValue.str(), aIsBinary);
}
XmlDetails::TScrPreProvisionDetail::TComponentProperty
SisRegistry::CreateComponentProperty( const std::wstring& aPropName, const std::wstring& aPropValue,
bool aIsInt, bool aIsStr8Bit, int aLocale
)
{
XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty;
componentProperty.iName = aPropName;
componentProperty.iLocale = aLocale;
componentProperty.iValue = aPropValue;
componentProperty.iIsIntValue = aIsInt;
componentProperty.iIsStr8Bit = aIsStr8Bit;
return componentProperty;
}
#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK