/*

* Copyright (c) 2006-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: 

*

*/

#pragma warning (disable: 4786)

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include "dbhelper.h" 

#include "dirparse.h"

#ifndef __TOOLS2_LINUX__

#include <windows.h>

#endif 

#endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include <exception>

#include <sstream>

#include <algorithm>

#include <functional>

#include <fstream>

#include <stdio.h>

#include <sys/stat.h>

// SisX Library

#include "sisdependency.h"

#include "sisversionrange.h"

#include "sisversion.h"

#include "sisprerequisites.h"

#include "sisfiledescription.h"

#include "sisstring.h"

#include "sishash.h"

// User includes

#include "stringutils.h"

#include "parameterlist.h"

#include "rommanager.h"

#include "configmanager.h"

#include "errors.h"

#include "is_utils.h"

#include "installer.h"

#include "sisregistryobject.h"

#include "adornedutilities.h"

// Constants

const char KRomDriveLetter = 'z';

const TUint32 KSwiDaemonUid = 0x10202DCE;

const std::wstring KSysBinPath = L"\\sys\\bin\\";

TInt CheckWildCard(TInt aVal, TInt aReplace)

{

	return

		aVal == -1

		? aReplace

		: aVal;

}

bool InRange(const Version& aVersion, const CSISVersionRange& aRange)

{

	Version from(

		CheckWildCard(aRange.FromVersion().Major(), aVersion.GetMajor()),

		CheckWildCard(aRange.FromVersion().Minor(), aVersion.GetMinor()),

		CheckWildCard(aRange.FromVersion().Build(), aVersion.GetBuild()));

	if(!aRange.ToVersion().WasteOfSpace())

	{

		Version to(

			CheckWildCard(aRange.ToVersion().Major(), aVersion.GetMajor()),

			CheckWildCard(aRange.ToVersion().Minor(), aVersion.GetMinor()),

			CheckWildCard(aRange.ToVersion().Build(), aVersion.GetBuild()));

		if (aVersion == from ||

			aVersion == to)

		{

			return true;

		}

		return (aVersion > from && aVersion < to);

	}

	else

	{

		return (aVersion >= from);

	}

}

Installer::Installer( SisRegistry& aReg, const CParameterList& aParamList, RomManager& aRomManager, ConfigManager& aConfigManager )

:   iParamList(aParamList), iRegistry(aReg), iRomManager( aRomManager ), iConfigManager( aConfigManager ),

    iExpressionEnvironment( NULL ), iExpressionEvaluator( NULL )

{

}

TInt Installer::Install(const CParameterList::SISFileList& aList)

{

	TInt result = 0;

	CParameterList::SISFileList sisFiles;

	// Get the SIS files

	for (CParameterList::SISFileList::const_iterator curr = aList.begin(); curr != aList.end(); ++curr)

	{

		std::wstring shortName(curr->iFileName);

		// Ensure formatting is correct

		if ( StringUtils::IsLastCharacter( shortName, KDirectorySeparator[ 0 ] ) ||

             StringUtils::IsLastCharacter( shortName, L'/' ) )

		{

			shortName.erase(shortName.length()-1,1);

		}

		if ( IsDirectory(shortName) )

		{

			std::list<std::wstring> contents;

			GetDirContents(shortName, contents);

			for (std::list<std::wstring>::iterator currStr = contents.begin(); currStr != contents.end(); ++currStr)

			{

				if ((currStr->find(L".SIS",0) != std::wstring::npos)

					|| (currStr->find(L".sis",0) != std::wstring::npos))

				{

					InstallSISFile sisFileName(shortName + KDirectorySeparator + *currStr, 

												curr->iTargetDrive, curr->iGenerateStub, 

												curr->iNonRemovable, curr->iReadOnly, curr->iNotRegister, curr->iSUFlag);

					sisFiles.push_back(sisFileName);

				}

			}

			if (sisFiles.empty())

			{

				LWARN(L"No .SIS files found in directory" << shortName);

			}

		}

		else if ((shortName.find(L".SIS",0) != std::wstring::npos)

				|| (shortName.find(L".sis",0) != std::wstring::npos))

		{

			InstallSISFile sisFileName(shortName, curr->iTargetDrive, curr->iGenerateStub, 

										curr->iNonRemovable, curr->iReadOnly, curr->iNotRegister, curr->iSUFlag);

			sisFiles.push_back(sisFileName);

		}

		else

		{

			LWARN(L"Invalid SIS file: " << shortName);

		}

	}

	bool installed = false;

	do

		{

		installed = false;

		iMissing.clear();

		CParameterList::SISFileList::iterator curr = sisFiles.begin();

		while (curr != sisFiles.end())

			{

			// install it

			try 

				{

				LINFO(L"*** Installing " << (curr->iFileName) << L" ***");

				SanitiseSISFileAttributes(*curr);

				result = Install(*curr);

				if ( result == SUCCESS)

					{

                    LINFO(L"");

					LINFO(L"*** Installed " << (curr->iFileName) << L" ***");

					installed =  true;

					curr = sisFiles.erase(curr);

					}

				else

					{

					LERROR(L"Failed to install " << (curr->iFileName));

					++curr;

					}

				}

			catch(CSISException e)

				{

				// catch problems with individual sis files

				LERROR(L"Unable to install " << (curr->iFileName));

				LINFO(e.widewhat());

				curr = sisFiles.erase(curr);

				if (result == 0)

					result =  FILE_ERROR;

				}

			catch  (InterpretSisError& e)

				{

				LERROR(L"Failed installing " << (curr->iFileName));

				LERROR(L"\t" << Utf8ToUcs2(e.what()));

				curr = sisFiles.erase(curr);

				if (result == 0)

					result =  e.GetErrorCode();

				}

			}

		}

	while (installed);

	if (result == 0 && !iMissing.empty())

		result = MISSING_DEPENDENCY;

	if(iParamList.RegistryVersionExists())

		{

	// Backup.lst regenerated at SisRegistry startup

	iRegistry.RemoveBackupLst();

		}

	return result;

}

void Installer::SanitiseSISFileAttributes(const InstallSISFile& aInstallSISFile)

{

	SisFile file(aInstallSISFile.iFileName);

	int targetDrive = aInstallSISFile.iTargetDrive;

	if (!iConfigManager.IsTargetDrivePresent(targetDrive))

	{

		std::wstring shortName(aInstallSISFile.iFileName);

		throw InterpretSisError(L"The installing target drive for " + shortName +

				L" is not defined", CMDLINE_ERROR);

	}

	if (aInstallSISFile.iGenerateStub && !iConfigManager.IsTargetDriveExt(targetDrive))

	{

		std::wstring shortName(aInstallSISFile.iFileName);

		throw InterpretSisError(L"The stub SIS file for " + shortName +

				L" cannot be created to an internal drive", CMDLINE_ERROR);

	}

	if (aInstallSISFile.iGenerateStub && file.GetInstallType() == CSISInfo::EInstPartialUpgrade)

	{

	std::wstring shortName(aInstallSISFile.iFileName);

	throw InterpretSisError(L"Generating stub SIS file for " + shortName +

				L" (PU type) is not supported", SIS_NOT_SUPPORTED);

	}

}

TInt Installer::Install(const InstallSISFile& aInstallSISFile)

{

	SisFile file(aInstallSISFile.iFileName);

	// Setup the expression evaluator

	SetupExpressionEnvironment( file, GetSisRegistry(), iRomManager );

	// check presence of embedded sis files and 

	// display a warning if they are not installed before

	if (file.HasEmbedded())

		{

		CheckEmbedded(file);

		}

	// check file is acceptable

	file.CheckValid();

	if (!DependenciesOk(file))

	{

		return MISSING_DEPENDENCY;

	}

	if (!IsValidUpgrade(file, aInstallSISFile.iSUFlag, aInstallSISFile.iNonRemovable))

	{

		return INVALID_UPGRADE;

	}

	InstallableFiles installable;

	GetInstallableFiles(file, installable, *iExpressionEvaluator, aInstallSISFile.iTargetDrive);

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	TBool iBackupFlag = false;

	Backup(file, installable, iBackupFlag);

#endif

	// Uninstall the same package (if found) prior to any installation

	UninstallPkg(file);

	CheckDestinations(file, installable, aInstallSISFile);

	InstallFiles(installable, iParamList.SystemDriveLetter());

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	UpdateRegistry(file, installable, aInstallSISFile, aInstallSISFile.iSUFlag);

#else

	try {

		UpdateRegistry(file, installable, aInstallSISFile, aInstallSISFile.iSUFlag);

	}

	catch  (...)

	{//Update Registry Failed. UnInstall the files.

		return RSC_PARSING_ERROR;

	}

	if(iBackupFlag)

		RemoveBackup(file, installable);

#endif

	if (aInstallSISFile.iGenerateStub)

	{

		CreateStubSisFile(aInstallSISFile, file);

	}

	FreeInstallableFiles(installable);

	return SUCCESS;

}

/** 

 Prepares a list of ROM files which are allowed to be eclipsed from the right 

 source according to the SIS file upgrade type.

 If a SIS file wants to eclipse a file in ROM, it will fail unless there is an 

 associated stub SIS file present in the ROM that can be used by the Installer to 

 identify the replacement file as a valid upgrade of the original.  

 */

void Installer::PrepareEclipsableFilesList(const SisFile& aSis)

{

	iEclipsableRomFiles.clear();

	iEclipsableOverwriteFiles.clear();

	TUint32 pkgUid = aSis.GetPackageUid();

	// upgrade SIS file attributes

	bool puInstallation = aSis.GetInstallType() == CSISInfo::EInstPartialUpgrade;

	bool spInstallation = aSis.GetInstallType() == CSISInfo::EInstAugmentation;

	// base package

	const SisRegistryObject& registryEntry = iRegistry.GetRegistryObject(pkgUid);

	bool currentPkgIsInRom = registryEntry.GetInRom();

	bool stubExistsInRom = iRegistry.IsRomStubPackage(pkgUid); 

	// SA+RU, PU and SP are all allowed to eclipse ROM files. There must

	// exist a valid ROM stub in order to populate the eclipsable files list.

	if (IsValidEclipsingUpgrade(aSis, registryEntry))

	{

		// when an upgrade happens over an upgrade which has already upgraded the 

		// ROM based pacakge (i.e. ROM Stub -> SA+RU -> PU), don't populate the

		// eclipsable files from the SIS registry entry which may be in-complete.

		// Directly populate the eclipsable files list from the corresponding stub

		// SIS file.

		if (!currentPkgIsInRom && stubExistsInRom && (puInstallation || spInstallation))

		{

			iRegistry.GetStubFileEntries(pkgUid, iEclipsableRomFiles);

		}

		else

		{

			const FileDescriptions& files = registryEntry.GetFileDescriptions();

			FileDescriptions::const_iterator curr = files.begin();

			FileDescriptions::const_iterator end  = files.end();

			for ( ; curr != end ; ++curr)

			{

				std::wstring target((*curr)->GetTarget());

				iEclipsableRomFiles.push_back(target);

			}

		}

	}

}

/**

 Non-SU packages can Eclipse iff:

 a) The package uids match and 

 b) The package to be installed is immediate Upgrade to ROM (SP or PU over ROM)

      (SA is allowed based on next condition)

 c) (or) The package to be installed is (SA+RU type or PU or SP type) and it has a matching ROM stub SIS file

 are allowed to eclipse files.    

 */

bool Installer::IsValidEclipsingUpgrade(const SisFile& aSis, const SisRegistryObject& registryEntry)

{

	TUint32 pkgUid = aSis.GetPackageUid();

	// case a)

	if (pkgUid != registryEntry.GetUid())

		return false;

	bool stubExistsInRom = iRegistry.IsRomStubPackage(pkgUid);

	bool isBaseInRom = registryEntry.GetInRom();

	bool saInstall = aSis.GetInstallType() == CSISInfo::EInstInstallation;

	bool reg51 = true;

	if(iParamList.RegistryVersionExists())

		{

	int regMajor = iParamList.RegistryMajorVersion();

	int regMinor = iParamList.RegistryMinorVersion();

	bool reg51 = (regMajor >= SisRegistry::KSisRegistryMajorVersion) &&  

					(regMinor >= SisRegistry::KSisRegistryMinorVersion);

		}

	// RU flag was introduce when the SISRegistry was 5.1, otherwise, treat it as normal SA file

	bool romUpgradeFlag = (aSis.GetInstallFlags() & CSISInfo::EInstFlagROMUpgrade) && reg51;

	bool romUpgradableSA = saInstall && romUpgradeFlag;

	bool puInstall = aSis.GetInstallType() == CSISInfo::EInstPartialUpgrade;

	bool spInstall = aSis.GetInstallType() == CSISInfo::EInstAugmentation;

	// case b)

	if (isBaseInRom && !saInstall)

		return true;

	// case c)

	return (stubExistsInRom && (romUpgradableSA || puInstall || spInstall));    	

}

void Installer::UninstallPkg(const SisFile& aSis)

{

	TUint32 uid = aSis.GetPackageUid();

	TUint32 installType = aSis.GetInstallType();

	// Check to see the SA is installed, otherwise, RemovePkg() will throw an exception

	if (iRegistry.IsInstalled(uid) && (installType == CSISInfo::EInstInstallation))

	{

		LINFO(L"Removing package \"" << aSis.GetPackageName() << L"\" prior to re-installation");

		// Remove all installed files for this Uid's packages and all the SisRegistry Entries

		iRegistry.RemovePkg(uid, true);

	}

	if (installType == CSISInfo::EInstAugmentation)

	{

		// Clean up the installed files from the specified SP package and the SisRegistry Entry

		iRegistry.RemoveEntry(uid, aSis.GetPackageName(), aSis.GetVendorName());

	}

	// Regenerate the ROM stub registry entries for eclipsing check later.

	iRegistry.GenerateStubRegistry();

}

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

// Backup all installed files for this Uid's packages and all the SisRegistry Entries

void Installer::Backup(const SisFile& aFile, InstallableFiles& aInstallable, TBool& aBackupFlag)

{

	TUint32 uid = aFile.GetPackageUid();

	TUint32 installType = aFile.GetInstallType();

	// Check to see the SA is installed, else backup is not required.

	if (iRegistry.IsInstalled(uid) && ((installType == CSISInfo::EInstInstallation) || (installType == CSISInfo::EInstPartialUpgrade)))

	{

		aBackupFlag = true;

		int err = 0;

		LINFO(L"Backup package \"" << aFile.GetPackageName() << L"\" prior to re-installation");

		// Backup all installed files for this Uid's packages and all the SisRegistry Entries

		iRegistry.BackupCtl(uid);

		//Backup SCR DB

		std::string DbPath = iRegistry.GetDbPath();

		if (FileExists(string2wstring(DbPath)))

		{	

			std::string BackupDb(DbPath);

			BackupDb.append("_backup");

		 	err=FileCopyA(DbPath.c_str(),BackupDb.c_str(),0);

			if (err == 0)

				LERROR(L"Failed to Backup Database scr.db ");

		}

		// Backup all installed files for this Uid's packages and all the SisRegistry Entries

		InstallableFiles::const_iterator filedesIter; 

		//Backup files

		for(filedesIter = aInstallable.begin() ; filedesIter != aInstallable.end(); ++filedesIter)

		{

			std::wstring itargetLocalFile = (*filedesIter)->GetLocalTarget();

			if (FileExists(itargetLocalFile))

			{

				std::wstring itargetBackupFile = (*filedesIter)->GetLocalTarget();

				itargetBackupFile.append(L"_backup");

				int pos =0;

				if((pos = itargetBackupFile.find(L"\\sys\\bin\\", 0)) != std::wstring::npos)

				{

					BackupHashForFile(itargetLocalFile, iParamList.SystemDriveLetter(), iParamList.SystemDrivePath());

				}

				std::string iLocalFile = wstring2string(itargetLocalFile);

				std::string iBackupFile = wstring2string(itargetBackupFile);

				err=FileCopyA(iLocalFile.c_str(),iBackupFile.c_str(),0);

				if (err == 0)

					LERROR(L"Failed to Backup installable file ");

			}

		}

	}

}

// Remove Backup of all installed files for this Uid's packages and all the SisRegistry Entries

void Installer::RemoveBackup(const SisFile& aFile, InstallableFiles& aInstallable)

{

	TUint32 uid = aFile.GetPackageUid();

	TUint32 installType = aFile.GetInstallType();

	// Check to see the SA is installed, else backup is not required.

	if (iRegistry.IsInstalled(uid) && ((installType == CSISInfo::EInstInstallation) || (installType == CSISInfo::EInstPartialUpgrade)))

	{

		LINFO(L"Remove Backup of package \"" << aFile.GetPackageName() << L"\" after re-installation success");