/*

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

* Definition of the CInstallationPlanner

*

*/

/**

 @file

*/

#include "siscontroller.h"

#include "sisstring.h"

#include "sisinstallationresult.h"

#include "sissupportedlanguages.h"

#include "sislanguage.h"

#include "installationplanner.h"

#include "plan.h" 

#include "application.h"

#include "userselections.h"

#include "siscontentprovider.h"

#include "sishelperclient.h"

#include "securitypolicy.h"

#include "secutils.h"

#include <swi/msisuihandlers.h>

#include "sisinstallblock.h"

#include "sisproperties.h"

#include "sisproperty.h"

#include "siselseif.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "sisuihandler.h"

#include "expressionevaluator.h"

#include "log.h"

#include "sisregistrywritableentry.h"

#include "sisregistrysession.h"

#include "sisregistrypackage.h"

#include "sisregistryfiledescription.h"

#include "sisregistrywritablesession.h"

#include "sisinstallerrors.h"

#include "cleanuputils.h"

#include "securitycheckutil.h"

#include "sistruststatus.h"

#include "securitypolicy.h"

#include "certchainconstraints.h"

#include "sisregistryserverconst.h"

#include "dessisdataprovider.h"

#include "adornedutilities.h"

using namespace Swi;

using namespace Swi::Sis;

_LIT(KSysBin, "\\sys\\bin\\");

_LIT(KPluginPath, "\\resource\\plugins\\");

CInstallationPlanner* CInstallationPlanner::NewL(RSisHelper& aSisHelper,

	RUiHandler& aInstallerUI, const CContentProvider& aContentProvider, 

	CInstallationResult& aInstallationResult)

	{

	CInstallationPlanner* self = CInstallationPlanner::NewLC(aSisHelper,

		aInstallerUI, aContentProvider, aInstallationResult);

	CleanupStack::Pop(self);

	return self;

	}

CInstallationPlanner* CInstallationPlanner::NewLC(RSisHelper& aSisHelper,

	RUiHandler& aInstallerUI, const CContentProvider& aContentProvider,

	CInstallationResult& aInstallationResult)

	{

	CInstallationPlanner* self = new (ELeave) CInstallationPlanner(aSisHelper,

		aInstallerUI, aContentProvider, aInstallationResult);

	CleanupStack::PushL(self);

	self->ConstructL(); 

	return self;

	}

CInstallationPlanner::~CInstallationPlanner()

	{

	iControllersToProcess.Close();

	delete iMainApplication;

	delete iExpressionEnvironment;

	delete iExpressionEvaluator;

	iPackagesToBeProcessed.ResetAndDestroy();

	iPackagesProcessed.Close();

	iEclipsableRomFiles.ResetAndDestroy();

	iOverwriteableFiles.ResetAndDestroy();

	iEclipsableOverwriteFiles.Close();

	iFilesFromPlannedControllers.ResetAndDestroy();

	iDrives.Close();

	iDriveSpaces.Close();

	}

CInstallationPlanner::CInstallationPlanner(RSisHelper& aSisHelper,

	RUiHandler& aInstallerUI, const CContentProvider& aContentProvider, 

	CInstallationResult& aInstallationResult) 

	: CPlanner(aInstallerUI, aInstallationResult) ,iSisHelper(aSisHelper), 

	  iContentProvider(aContentProvider), iStubFirstDriveLetter(KNoDriveSelected)

	{

	}

void CInstallationPlanner::ConstructL()

	{

	CPlanner::ConstructL();

	// Setup the application info to the default, until the user selects a language.

	Plan().SetAppInfoL(iContentProvider.DefaultLanguageAppInfoL());	

	// Add the main controller as the first in the list of controllers

	iControllersToProcess.AppendL(TControllerAndParentApplication(iContentProvider.Controller(), NULL));

	// Find out how much space is available on each drive before

	// installation commences. That way we can keep avaialble space

	// up to date as we plan embedded application installations

	iSisHelper.FillDrivesAndSpacesL(iDrives, iDriveSpaces);

	}

void CInstallationPlanner::FinalisePlanL(void)

	{

	// Transfer ownership of the main application

	Plan().SetApplication(iMainApplication);

	iMainApplication = NULL;

	ProcessRemainingPackagesL();

	// Note that the UninstallationPlanner informs the UI of the final progress

	// bar value here - this needs to be done after post-requisite checks for

	// an installation, since orphans to be overwritten will be planned for

	// removal in the post-requisite checks.

	}

void CInstallationPlanner::ChooseOptionsDialogL(CContentProvider& aContent, CApplication& aApplication)

	{

	TAppInfo info = aContent.LocalizedAppInfoL(iDisplayLanguageIndex);

	RPointerArray<TDesC> optionNames = aContent.LocalizedOptionsL(iDisplayLanguageIndex);

	RArray<TBool> optionSelections;

	CleanupClosePushL(optionNames);

	CleanupClosePushL(optionSelections);

	if (optionNames.Count() > 0)

		{

		CDisplayOptions* optionsCmd = CDisplayOptions::NewLC(info, optionNames, optionSelections);

		UiHandler().ExecuteL(*optionsCmd);

		TBool result = optionsCmd->ReturnResult();

		CleanupStack::PopAndDestroy(optionsCmd);

	    if (!result) // User pressed cancel

			{

			AbortL();

			}

		aApplication.UserSelections().SetOptionsL(optionSelections);		

		}

	CleanupStack::PopAndDestroy(2, &optionNames); //&optionSelections

	}

void CInstallationPlanner::ChooseDriveDialogL(CContentProvider& aContent, CApplication& aApplication, const TInt64  &aSize)

	{

	TAppInfo info = aContent.LocalizedAppInfoL(iDisplayLanguageIndex);

	TInt selectedDrive=0;	

	// Only call the dialog if there is more than one drive to choose from

	if (iDrives.Count() > 1)

		{

		CDisplayDrive* driveCmd = CDisplayDrive::NewLC(info, aSize, iDrives, iDriveSpaces);

		UiHandler().ExecuteL(*driveCmd);

		selectedDrive = driveCmd->ReturnResult();

		CleanupStack::PopAndDestroy(driveCmd);

		if ((selectedDrive < 0)||(selectedDrive >= iDrives.Count()))

			{

			// UI returned an out of bound index, abort installation please...

			AbortL();

			}

		aApplication.UserSelections().SetDrive(iDrives[selectedDrive]);

		}

	else 

		{

		// Only one drive, select it automatically.

		aApplication.UserSelections().SetDrive(iDrives[0]);

		}

	}

void CInstallationPlanner::ReclaimUninstallSpaceL(const CApplication& aApplication)

	{

	// Search through the files to remove and add the space saved

	// back to the free space on given drives.

	for(TInt i = 0; i < aApplication.FilesToRemove().Count(); i++)

		{

		CSisRegistryFileDescription& fileDescription = *aApplication.FilesToRemove()[i];

		TChar drive(fileDescription.Target()[0]);

		drive.UpperCase();

		TInt index = iDrives.Find(drive);

		if(index >= 0)

			{

			iDriveSpaces[index] += fileDescription.UncompressedLength();

			}

		}

	}

void CInstallationPlanner::ChooseLanguageDialogL(CContentProvider& aContent, CApplication& aApplication) 

	{

	if(aContent.AvailableLanguages().Count() > 1)

		{

		// Since we do not know the language to use yet, we use the default!

		TAppInfo info = aContent.DefaultLanguageAppInfoL();

		CDisplayLanguage* langCmd = CDisplayLanguage::NewLC(info, aContent.AvailableLanguages());

		UiHandler().ExecuteL(*langCmd);

		iDisplayLanguageIndex = langCmd->ReturnResult();

		CleanupStack::PopAndDestroy(langCmd);

		if((iDisplayLanguageIndex < 0) || (iDisplayLanguageIndex >= aContent.AvailableLanguages().Count()))

			{

			// UI returned an out of bound index, abort installation please...

			AbortL();

			}

		}

	else

		{

		// Only one language availble, no point asking the user to select it

		iDisplayLanguageIndex = 0;

		}

	aApplication.UserSelections().SetLanguage(aContent.AvailableLanguages()[iDisplayLanguageIndex]);

	//if it's the top level controller store the appinfo for this language in the plan

	if (iContentProvider.Controller().Info().Uid().Uid() == aContent.Controller().Info().Uid().Uid())

		{

		Plan().SetAppInfoL(aContent.LocalizedAppInfoL(iDisplayLanguageIndex));

		}

	}

TLanguage CInstallationPlanner::DisplayLanguage() const

	{

	return (iContentProvider.AvailableLanguages()[iDisplayLanguageIndex]);

	}

void CInstallationPlanner::DisplayUpgradeDialogL(const TAppInfo& aCurrentAppInfo, RSisRegistryEntry& aUpgradedApp)

	{

	HBufC* name=aUpgradedApp.PackageNameL();

	CleanupStack::PushL(name);

	HBufC* vendorName=aUpgradedApp.LocalizedVendorNameL();

	CleanupStack::PushL(vendorName);

	TVersion version=aUpgradedApp.VersionL();

	TAppInfo upgradedAppInfo(*name, *vendorName, version);

	CDisplayUpgrade* displayUpgrade=CDisplayUpgrade::NewLC(aCurrentAppInfo, upgradedAppInfo);

	UiHandler().ExecuteL(*displayUpgrade);

	if (!displayUpgrade->ReturnResult())

		{

		User::Leave(KErrCancel); // Installation cancelled

		}

	CleanupStack::PopAndDestroy(3, name);

	}

/// Functions for keeping track of packages which need to be processed

void CInstallationPlanner::NotePackageForProcessingL(CSisRegistryPackage& aPackage, CApplication& aApplication)

	{

	CPackageApplicationPair* processed=CPackageApplicationPair::NewLC(aPackage, aApplication);

	User::LeaveIfError(iPackagesToBeProcessed.Append(processed));

	CleanupStack::Pop(processed);

	}

void CInstallationPlanner::NotePackageProcessedL(TUid aUid)

	{

	// Add pacakge to processed list

	iPackagesProcessed.AppendL(aUid);

	// Remove package with UID=aUid

	for (TInt i=0; i < iPackagesToBeProcessed.Count(); ++i)

		{

		if (iPackagesToBeProcessed[i]->Package().Uid()==aUid)

			{

			CPackageApplicationPair* pair=iPackagesToBeProcessed[i];

			iPackagesToBeProcessed.Remove(i);

			delete pair;

			break;

			}

		}

	}

TBool CInstallationPlanner::IsPackageProcessed(TUid aUid) const

	{

	for (TInt i=0; i < iPackagesProcessed.Count(); ++i)

		{

		if (aUid == iPackagesProcessed[i])

			{

			return ETrue;

			}

		}

	return EFalse;

	}

void CInstallationPlanner::ProcessRemainingPackagesL()

	{

	// The packages remaining on the list need to be uninstalled, since they were present

	// on the device as an embedded package, but weren't present in the new install 

	// Also check that nothing depends on this before removing the package.

	for (TInt i=0; i < iPackagesToBeProcessed.Count(); ++i)

		{

		CApplication* application=UninstallPackageL(iPackagesToBeProcessed[i]->Package(), EFalse);

		CleanupStack::PushL(application);

		iPackagesToBeProcessed[i]->Application().AddEmbeddedApplicationL(application);

		CleanupStack::Pop(application); // ownership has been transferred

		}

	}

TBool CInstallationPlanner::IsValidSaUpgradeL(RSisRegistryWritableEntry& aRegistryEntry, const TBool aIsSisNonRemovable, const TBool aControllerFlag)

	{

	TBool isBaseNonRemovable = !aRegistryEntry.RemovableL();

	TBool isBaseSuSigned = aRegistryEntry.IsSignedBySuCertL();

	TBool isBaseInRom = aRegistryEntry.IsInRomL();

	TBool isSameNonRemovableState = (isBaseNonRemovable == aIsSisNonRemovable);

	TBool isRuFlag = aControllerFlag & EInstFlagROMUpgrade;

	TBool isNrFlag = aControllerFlag & EInstFlagNonRemovable;

	if (iIsValidSystemUpgrade)

		{

		// SU packages can upgrade all ROM packages and non-Rom packages regardless of their state. 

		return ETrue;

		}

	else

		{

		// Non-SU packages can upgrade ROM base only if they have the RU (ROM upgrade flag) and not have the NR flag. 

		// For non-ROM packages, they cannot upgrade if and only if the base is removable and 

		// the upgrade is non-removable, or if the base is non-removable and the upgrade is removable.

		// and also cannot upgrade if Upgrade is less trusted than the base package

		return (isBaseInRom ? (isRuFlag && !isNrFlag) : (isSameNonRemovableState && !isBaseSuSigned));	

		}

	}

TBool CInstallationPlanner::IsValidEclipsingUpgradeL(const Sis::CController& aController, RSisRegistryWritableEntry& aRegistryEntry,  const TBool aStubExistsInRom)

	{

	TBool paInstall = aController.Info().InstallType() == Sis::EInstPreInstalledApp;

	__ASSERT_DEBUG(!paInstall, User::Leave(KErrNotSupported));

	if (aController.Info().Uid().Uid() != aRegistryEntry.UidL())

		{

		return EFalse;	

		}

	if (CurrentController().TrustStatus().ValidationStatus() < EValidatedToAnchor)

		{

		return EFalse;

		}

	TBool isBaseInRom = aRegistryEntry.IsInRomL();

	TBool saInstall = aController.Info().InstallType() == EInstInstallation;

	TBool romUpgradeFlag = aController.Info().InstallFlags() & EInstFlagROMUpgrade;

	TBool romUpgradableSA = saInstall && romUpgradeFlag;

	TBool puInstall = aController.Info().InstallType() == Sis::EInstPartialUpgrade;

	if (isBaseInRom && !saInstall)

		{

		return ETrue;

		}

	return (aStubExistsInRom && (romUpgradableSA || puInstall));			 

	}

void CInstallationPlanner::SetDeviceSupportedLanguages(RArray<TInt>& aDeviceSupportedLanguages)

	{

	iDeviceSupportedLanguages = &aDeviceSupportedLanguages;

	}

/// Processing functions

CApplication* CInstallationPlanner::ProcessControllerL(const Sis::CController& aController, TInt aCumulativeDataIndex, RPointerArray<CFileDescription>& aFilesToCapabilityCheck, TUid aParentUid)

	{	

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	// Skip all the chances of leaving, when the planner is in info collection mode.

	if(!IsInInfoCollectionMode())

		{

	#endif

		// Check to see that we are not trying to install a protected package

		// uid with an untrusted controller

		if(aController.TrustStatus().ValidationStatus() < EValidatedToAnchor

			&& SecurityCheckUtil::IsPackageUidProtected(aController.Info().Uid().Uid().iUid))

			{

			// Can't install a protected package Uid when the controller

			// is untrusted

			DisplayErrorL(EUiUIDPackageViolation, KNullDesC);

			User::Leave(KErrSecurityError);

			}

		// If this package is signed by a DevCert that constraints SIDs,

		// check the pUID is not in the protected range before installing.

		// Otherwise, do not install this package, since it could be upgraded

		if ( ! aController.CertChainConstraints()->SIDIsValid( aController.Info().Uid().Uid().iUid) )

			{

			// Not allowed to install a protected package when sids are constrained

			// e.g. this can occur when a package is signed by a devcert

			DisplayErrorL(EUiConstraintsExceeded, KNullDesC);

			User::Leave(KErrSecurityError);

			}

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		// If this package is set to be 'hidden' and not trusted sufficiently,

		// do not install this package. Notify the user and leave from here.

		if ( (aController.Info().InstallFlags() & EInstFlagHide) && 

			 (aController.TrustStatus().ValidationStatus() < EValidatedToAnchor))

			{

			// Can't install a hidden package signed with a untrusted certificate chain.

			DisplayErrorL(EUiConstraintsExceeded, KNullDesC);

			User::Leave(KErrSecurityError);

			}

		}

	#endif	

	NotePackageProcessedL(aController.Info().Uid().Uid());

	// Reset the list of file allowed to be eclipsed and overwritten for

	// every embedded controller in the package

	iEclipsableRomFiles.ResetAndDestroy();

	iOverwriteableFiles.ResetAndDestroy();

	CApplication* application=CApplication::NewLC();

	application->SetController(aController);

	// Copy the set of device languages to CApplication data member

	application->CopyDeviceSupportedLanguagesL(*iDeviceSupportedLanguages);

	application->SetSisHelper(iSisHelper);

	if(aController.Info().InstallFlags() & EInstFlagShutdownApps)

		{

		application->SetShutdownAllApps(ETrue);

		}

	if (iSisHelper.IsStubL())	

		{

		CSecurityPolicy* securityPolicy=CSecurityPolicy::GetSecurityPolicyL();

		if (!(iSisHelper.IsSisFileReadOnlyL()) && securityPolicy->DeletePreinstalledFilesOnUninstall())

			{

			application->SetDeletablePreinstalled(ETrue);

			}

		iIsStub = ETrue;

		iIsPropagated = !((aController.Info().InstallType() == EInstPreInstalledPatch) || (aController.Info().InstallType() == EInstPreInstalledApp));

		application->SetStub(iIsPropagated);

		}

	Sis::TInstallType type = application->ControllerL().Info().InstallType();

	Sis::TInstallFlags flag = application->ControllerL().Info().InstallFlags();

	TBool ruFlag = (flag & EInstFlagROMUpgrade);

	TBool rejectedType = ( (type == EInstPreInstalledApp  ) || (type == EInstPreInstalledPatch ));

	if ( ruFlag && rejectedType && aController.IsSignedBySuCert())

		{

		// reject PA or PP with RU flag System Upgrade packages ( signed by SU cert)

		DEBUG_PRINTF(_L8("Attempt made to install/preinstall/propagate System Upgrade package with RU flag"));

		User::Leave(KErrInvalidUpgrade);

		}

	iIsValidSystemUpgrade = IsValidSystemUpgradeL(*application);

	if (iIsValidSystemUpgrade)

		{

		application->SetInstallSuCertBased();

		}

	// Check to see if there is a package installed with this UID

	RSisRegistryWritableSession registrySession;

	User::LeaveIfError(registrySession.Connect());

	CleanupClosePushL(registrySession);

	RSisRegistryWritableEntry registryEntry;

	TInt error=registryEntry.Open(registrySession, aController.Info().Uid().Uid());	

	CleanupClosePushL(registryEntry);

	TBool isSisNonRemovable = ((aController.Info().InstallFlags() & EInstFlagNonRemovable) == EInstFlagNonRemovable);

	DEBUG_PRINTF2(_L8("Planning controller of type %d for install"), aController.Info().InstallType());

	//Index from the planned controllers for the base controller of the current controller

	TInt baseControllerIndex = 0;

	if (error == KErrNone)

		{

		CSisRegistryPackage* package=registryEntry.PackageL();

		CleanupStack::PushL(package);

		application->SetPackageL(*package);

		CleanupStack::PopAndDestroy(package);

		TBool isBaseRemovable = registryEntry.RemovableL();

		if (aController.Info().InstallType() == EInstInstallation)

			{

			// The package is already on the device so check whether it

			// is a valid upgrade

			// Stub SIS files cannot be used to perform an upgrade.

			TBool validUpgrade = IsValidSaUpgradeL(registryEntry, isSisNonRemovable, aController.Info().InstallFlags());

			if ((iIsPropagated || !validUpgrade))

				{

				DEBUG_PRINTF(_L8("Invalid Upgrade: SA Attempted"));				

				User::Leave(KErrInvalidUpgrade);

				}

			application->SetUpgrade(aController);