/*

* 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" 

#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));

				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);

	}

}

void Installer::ProcessConditionalBlockWarnings(const CSISInstallBlock& aInstallBlock, 

											  ExpressionEvaluator& aEvaluator,

											  const SisFile& aFile

											  ) 

	{

	const CSISArray<CSISIf, CSISFieldRoot::ESISIf>& ifs = aInstallBlock.Ifs();

	for (int i = 0; i < ifs.size(); ++i)

		{

		const CSISIf& ifBlock = ifs[i];

		if (ifBlock.WasteOfSpace())

			{

			return;

			}

		// Main expression

		if ( aEvaluator.Evaluate(ifBlock.Expression(),false).BoolValue() )

			{

			ProcessInstallBlockWarnings(ifBlock.InstallBlock(), aFile);

			ProcessConditionalBlockWarnings(ifBlock.InstallBlock(), aEvaluator, aFile);

			continue;

			}

		int elseCount = ifBlock.ElseIfCount();

		for (int i = 0; i < elseCount; ++i)

			{

			const CSISElseIf& elseIfBlock = ifBlock.ElseIf(i) ;

			if ( aEvaluator.Evaluate(elseIfBlock.Expression(),false).BoolValue())

				{

				ProcessInstallBlockWarnings(elseIfBlock.InstallBlock(), aFile);

				ProcessConditionalBlockWarnings(elseIfBlock.InstallBlock(), aEvaluator, aFile);

				break;	// Stop processing else if blocks

				}

			}

		} 

	}

void Installer::ProcessInstallBlockWarnings(const CSISInstallBlock& aInstallBlock, const SisFile& aFile)

	{

	aFile.ProcessEmbeddedFileWarning(aInstallBlock);

	std::string error;

	bool result = aFile.ProcessInstallOptionsWarning(aInstallBlock,error);	

	if(result == false)

		{

		std::string x;

		throw InvalidSis(Ucs2ToUtf8(aFile.GetPackageName(),x),

			error, 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();

	const CSISController& ctrl = file.GetController();	

	ProcessConditionalBlockWarnings(ctrl.InstallBlock(), *iExpressionEvaluator, file);

	if (!DependenciesOk(file))

	{

		return MISSING_DEPENDENCY;

	}

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

	{

		return INVALID_UPGRADE;

	}

	InstallableFiles installable;

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

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

	UninstallPkg(file);

	CheckDestinations(file, installable, aInstallSISFile);

	InstallFiles(installable, iParamList.SystemDriveLetter());

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

	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

	}

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

	iRegistry.GenerateStubRegistry();

}

struct CheckDependencyMet

{

	CheckDependencyMet(

		Installer& aInstaller,

		std::vector<SisRegistryDependency>& aMissing)

		: iInstaller(aInstaller),

		iMissingDependencies(aMissing)

	{}

	void operator()(const CSISDependency* dep)

	{

		if (!iInstaller.CheckDependency(dep))

		{

			iMissingDependencies.push_back(SisRegistryDependency(*dep));

		}

	}

	Installer& iInstaller;

	std::vector<SisRegistryDependency>& iMissingDependencies;

};

bool Installer::CheckDependency(const CSISDependency* aDep)

{

	bool result = false;

	try

	{

		const SisRegistryObject& pkg =

			iRegistry.GetRegistryObject(aDep->SisUID().UID1());

		const CSISVersionRange& range = aDep->VersionRange();

		if (!range.WasteOfSpace() && InRange(pkg.GetVersion(), range))

			{

			result = true;

			}

		else

			{

			result = false;