/*

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

*

*/

#define __INCLUDE_CAPABILITY_NAMES__ 

#include <s32mem.h>

#include "installmachine.h"

#include "plan.h"

#include "dessisdataprovider.h"

#include "siscontroller.h"

#include "siscertificatechain.h"

#include "sisinstallerrors.h"

#include "siscontentprovider.h"

#include "sisinstallblock.h"

#include "prerequisiteschecker.h"

#include "postrequisiteschecker.h"

#include "installationplanner.h"

#include "log.h"

#include "cleanuputils.h"

#include "sisfiledescription.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "siscapabilities.h"

#include "securitypolicy.h"

#include "swispubsubdefs.h"

#include "installationprocessor.h"

#include "swi/launcher.h"

#include "certchainconstraints.h"

#include "swi/sistruststatus.h"

#include <pkixcertchain.h>

#include <swicertstore.h>

#include <sacls.h>

#include <f32file.h>

#include "securitycheckutil.h"

#include "sisptrprovider.h"

#include <e32capability.h>

#include <ocsp.h>

#include "secutils.h"

#include "sislauncherclient.h"

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include "swi/sisversion.h"

#include "swi/nativecomponentinfo.h"

#include <usif/usifcommon.h>

#include "scrdbconstants.h"

#endif

using namespace Swi;

using namespace Swi::Sis;

//

// TInstallState

//

CInstallMachine::TInstallState::TInstallState(CInstallMachine& aInstallMachine)

:	iInstallMachine(aInstallMachine)

	{

	}

//

// TRegistrationState

//

CInstallMachine::TRegistrationState::TRegistrationState(

	CInstallMachine& aInstallMachine)

/**

	Constructor.

 */

:   CInstallMachine::TInstallState(aInstallMachine)

	{

	}

void CInstallMachine::TRegistrationState::EnterL()

/**

	Send registration request to the SWI Observer and then activate the

	installation machine.

 */

	{

	DEBUG_PRINTF(_L8("Install Machine - Entering Registration State"));

	//connect to the SWI Observer

	User::LeaveIfError(iInstallMachine.Observer().Connect());

	//Register to the SWI Observer; which completes this request 

	//when the SWI Observer Processor is idle.

	iInstallMachine.Observer().Register(iInstallMachine.iStatus);

	iInstallMachine.SetActive();

	}

CInstallMachine::TState* CInstallMachine::TRegistrationState::CompleteL()

/**

	Obtains the log file handle and its name from the SWI Observer.

	Adds the log file to the transaction.

 */

	{

	DEBUG_PRINTF(_L8("Install Machine - Registration State complete"));

	RBuf logFileName;

	logFileName.CreateL(KMaxFileName);

	logFileName.CleanupClosePushL();

	//Get created a log file and obtains its full name.

	iInstallMachine.Observer().GetFileHandleL(logFileName);

	//Add the log file the transaction

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	iInstallMachine.TransactionSession().RegisterNewL(logFileName);

#else

	iInstallMachine.IntegrityServicesL().AddL(logFileName);

#endif

	CleanupStack::PopAndDestroy(&logFileName);

	// Get Controllers.

	return static_cast<TState*>(&iInstallMachine.iGetControllerState);		

	}

CInstallMachine::TState* CInstallMachine::TRegistrationState::ErrorL(TInt aCode)

/**

	If there is any error, closes the SWI Observer connection.

 */

	{

	DEBUG_PRINTF2(_L8("Install Machine - Registration State failed with code '%d'"), aCode);

	User::Leave(aCode);

	return NULL;

	}

void CInstallMachine::TRegistrationState::Cancel()

/**

	Cancels the registration request.

 */

	{

	DEBUG_PRINTF(_L8("Install Machine - Registration State cancelled!"));

	iInstallMachine.Observer().CancelRegistration();	

	}

//

// TGetControllerState

//

CInstallMachine::TGetControllerState::TGetControllerState(

	CInstallMachine& aInstallMachine)

:   CInstallMachine::TInstallState(aInstallMachine)

	{

	}

void CInstallMachine::TGetControllerState::EnterL()

	{

	DEBUG_PRINTF(_L8("Install Machine - Entering Get Controller state"));

	if (iInstallMachine.iSecurityManager->SecurityPolicy().DrmEnabled())

		{

		iInstallMachine.iSisHelper.OpenDrmContentL(static_cast<ContentAccess::TIntent>(iInstallMachine.iSecurityManager->SecurityPolicy().DrmIntent()));

		}

	iInstallMachine.iControllerData=

		iInstallMachine.iSisHelper.SisControllerLC();

	CleanupStack::Pop();

	DEBUG_PRINTF2(_L8("Retrieved controller size %d"), iInstallMachine.iControllerData->Size());

	TPtrProvider provider(iInstallMachine.iControllerData->Des());

	// Create controller

	iInstallMachine.iController=Sis::CController::NewL(provider);

	if(!iInstallMachine.iSecurityManager->SecurityPolicy().AllowPackagePropagate() 

		 && iInstallMachine.iSisHelper.IsStubL())

		{

		// If it's a stub and our SWIPolicy AllowPackagePropagate

		// flag is false we can only install if it's a 

		// preinstalled stub not a removable media stub

		if(iInstallMachine.iController->Info().InstallType() != EInstPreInstalledApp

		 && iInstallMachine.iController->Info().InstallType() != EInstPreInstalledPatch)

			{

			// It is a removable media stub but our SWI policy forbids

			// installation

			User::Leave(KErrSecurityError);

			}

		}

	// Create content provider which will be used everywhere for things like 

	// TAppInfo etc.

	iInstallMachine.iContentProvider=

		CContentProvider::NewL(*iInstallMachine.iController);

	iInstallMachine.iCurrentContentProvider = iInstallMachine.iContentProvider;

	// Create stuff for the installation planner to use later

	iInstallMachine.iResult=CInstallationResult::NewL();

	iInstallMachine.iPlanner=CInstallationPlanner::NewL(iInstallMachine.iSisHelper,iInstallMachine.UiHandler(), 

		*iInstallMachine.iCurrentContentProvider, *iInstallMachine.iResult);

	iInstallMachine.iPlanner->SetDeviceSupportedLanguages(iInstallMachine.iDeviceSupportedLanguages);

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	// Check if the machine runs in info collection mode. If so, set the planner too in the same mode.

	if (iInstallMachine.IsInInfoMode())

		{

		iInstallMachine.iPlanner->SetInInfoCollectionMode(ETrue);

		}

	#endif

	iInstallMachine.CompleteSelf();

	iInstallMachine.SetActive();

	}

CInstallMachine::TState* CInstallMachine::TGetControllerState::CompleteL()

	{

	DEBUG_PRINTF(_L8("Install Machine - Get Controller State complete"));

	// Confirm installation with the user.

	return static_cast<TState*>(&iInstallMachine.iConfirmationState);

	}

CInstallMachine::TState* CInstallMachine::TGetControllerState::ErrorL(

	TInt aCode)

	{

	DEBUG_PRINTF2(_L8("Install Machine - Get Controller State failed with code '%d'"), aCode);

	User::Leave(aCode);

	return NULL;

	}

void CInstallMachine::TGetControllerState::Cancel()

	{

	}

//

// TConfirmationState

//

CInstallMachine::TConfirmationState::TConfirmationState(

	CInstallMachine& aInstallMachine)

:   CInstallMachine::TInstallState(aInstallMachine)

	{

	}

void CInstallMachine::TConfirmationState::EnterL()

	{	

	DEBUG_PRINTF(_L8("Install Machine - Entering Confirmation State"));

	TBool retval;

	TAppInfo appInfo(

		iInstallMachine.iCurrentContentProvider->DefaultLanguageAppInfoL());

	RPointerArray<CX509Certificate> x509certs;

	CleanupResetAndDestroyPushL(x509certs);

	iInstallMachine.iSecurityManager->GetCertificatesFromControllerL(

		*iInstallMachine.iController,x509certs);

	RPointerArray<CCertificateInfo> certs;

	CleanupResetAndDestroyPushL(certs);

	CSecurityManager::FillCertInfoArrayL(x509certs,certs);

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	if (iInstallMachine.IsInInfoMode())

		{

		// If we operate in info mode, we just need the certs, no UI confirmation or logo will be displayed

		CleanupStack::PopAndDestroy(2, &x509certs); // certs, x509certs

		iInstallMachine.CompleteSelf();

		iInstallMachine.SetActive();

		iInstallMachine.iOperationConfirmed = ETrue;				

		return;

		}

	#endif

	RFs fs;

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

	CleanupClosePushL(fs);

	User::LeaveIfError(fs.ShareProtected());

	// Retrieve logo data which may not be present.

	const CLogo* logo=iInstallMachine.iController->Logo();

	if (logo)

		{

		const CFileDescription& fdesc(logo->FileDescription());

		// Create a temporary file for the logo.

		// Construct temporary file name for the logo.

		TUint driveCh(RFs::GetSystemDriveChar());

		TFileName logoFileName;

		_LIT(KLogoFileNameFmt, "%c:\\sys\\install\\temp\\%08X-logo");

		logoFileName.Format(KLogoFileNameFmt, driveCh,

			iInstallMachine.iController->Info().Uid().Uid().iUid);

		TInt err = fs.MkDirAll(logoFileName);

		if (err!= KErrNone && err != KErrAlreadyExists)

			User::LeaveIfError(err);

		RFile logoFile;

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		iInstallMachine.TransactionSession().RegisterTemporaryL(logoFileName);

#else

		iInstallMachine.IntegrityServicesL().TemporaryL(logoFileName);

#endif

		User::LeaveIfError(logoFile.Replace(fs, logoFileName, 

			EFileStream|EFileWrite|EFileRead|EFileShareExclusive));

		CleanupClosePushL(logoFile);

		// Extract logo to a temporary file.

		err=iInstallMachine.iSisHelper.ExtractFileL(fs, logoFile, 

			fdesc.Index(), iInstallMachine.iController->DataIndex(), 

			iInstallMachine.UiHandler());

		User::LeaveIfError(err);

		CleanupStack::PopAndDestroy(&logoFile);

		// Reopen file for reading (the handle will have been closed 

		// by SISHelper).

		User::LeaveIfError(logoFile.Open(fs, logoFileName, 

			EFileStream|EFileRead|EFileShareExclusive));

		CleanupClosePushL(logoFile);

		CDisplayInstall* cmd=CDisplayInstall::NewLC(appInfo, fs, &logoFile, 

			certs);

		iInstallMachine.UiHandler().ExecuteL(*cmd);

		retval=cmd->ReturnResult();

		CleanupStack::PopAndDestroy(2, &logoFile); // logoFile, cmd

		RLoader loader;

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

		CleanupClosePushL(loader);

		// Delete temporary logo file.

		User::LeaveIfError(loader.Delete(logoFileName));

		CleanupStack::PopAndDestroy(&loader);

		}

	else

		{

		CDisplayInstall* cmd=CDisplayInstall::NewLC(appInfo, fs, NULL, certs);

		iInstallMachine.UiHandler().ExecuteL(*cmd);

		retval=cmd->ReturnResult();

		CleanupStack::PopAndDestroy(cmd);

		}

	CleanupStack::PopAndDestroy(3, &x509certs); // fs, certs, x509certs

	// Check if the user cancelled installation.

	if (!retval)

		{

		DEBUG_PRINTF(_L8("User canceled install at install dialog"));

		User::Leave(KErrCancel);

		}

	iInstallMachine.CompleteSelf();

	iInstallMachine.SetActive();

	// user hasn't cancelled so mark the installation as confirmed. This

	// will allow the registry cache to be regenerated further on during the

	// installation process.

	iInstallMachine.iOperationConfirmed = ETrue;	

	}

CInstallMachine::TState* CInstallMachine::TConfirmationState::CompleteL()

	{

	DEBUG_PRINTF(_L8("Install Machine - Confirmation State complete"));

	// Verify signature(s) if any.

	return static_cast<TState*>(&iInstallMachine.iVerifyControllerState);

	}

CInstallMachine::TState* CInstallMachine::TConfirmationState::ErrorL(

	TInt aCode)

	{

	DEBUG_PRINTF2(_L8("Install Machine - Confirmation State failed with code '%d'"), aCode);

	User::Leave(aCode);

	return NULL;

	}

void CInstallMachine::TConfirmationState::Cancel()

	{

	}

//

// TVerifyControllerState

//

CInstallMachine::TVerifyControllerState::TVerifyControllerState(

	CInstallMachine& aInstallMachine)

:   CInstallMachine::TInstallState(aInstallMachine)

	{

	}

// Verify signatures and cert chains using security manager

void CInstallMachine::TVerifyControllerState::EnterL()

	{

	DEBUG_PRINTF(_L8("Install Machine - Entering Verify Controller State"));

	// Clear any results from previous controllers

 	iInstallMachine.iSigValidationResult=EValidationSucceeded;

 	iInstallMachine.iPkixResults.ResetAndDestroy();

 	iInstallMachine.iCertificates.ResetAndDestroy();

 	iInstallMachine.iGrantableCapabilitySet.SetEmpty();

	iInstallMachine.iSecurityManager->ResetValidCertChains();

	iInstallMachine.iOcspOutcomes.ResetAndDestroy();

	iInstallMachine.iCertInfos.ResetAndDestroy();

	TInt64 dataOffset = iInstallMachine.CurrentController().DataOffset()-iInstallMachine.iController->DataOffset();

	// Get current controller data.

	TPtrC8 data(iInstallMachine.iControllerData->Mid(dataOffset));

	// Verify certificate chains and prepare for OCSP.

	iInstallMachine.iSecurityManager->VerifyControllerL(

		data,

		iInstallMachine.CurrentController(), 

		&iInstallMachine.iSigValidationResult, 

		iInstallMachine.iPkixResults,

		iInstallMachine.iCertificates,

		&iInstallMachine.iGrantableCapabilitySet,

		iInstallMachine.iAllowUnsigned,

		iInstallMachine.iEmbedded,

		iInstallMachine.iStatus);

	iInstallMachine.SetActive();

	}

// Handle signature and certificate validation errors

CInstallMachine::TState* CInstallMachine::TVerifyControllerState::CompleteL()

	{	

	DEBUG_PRINTF(_L8("Install Machine - Verify Controller State Complete"));

	// Populate the cert info array in preparation for any

	// dialogs we have to launch

	CSecurityManager::FillCertInfoArrayL(iInstallMachine.iCertificates,

			iInstallMachine.iCertInfos);

	DEBUG_PRINTF2(_L8("Signature Validation Result is set to code %d"), iInstallMachine.iSigValidationResult);

	// check what was the result of validation

	switch (iInstallMachine.iSigValidationResult)

		{

		default:

			// BC break, unknown validation code, abort

			User::Leave(KErrNotSupported);

			break;

		case EValidationSucceeded:

			// Chain was validated

			// Increase the trust status of this install process

			iInstallMachine.SetTrust(ESisPackageCertificateChainValidatedToTrustAnchor);

			iInstallMachine.SetValidationStatus(EValidatedToAnchor);

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			// Alert only when machine not runs in info collection mode

			if(iInstallMachine.IsInInfoMode())

				break;

			#endif

			// Continue normally, display security warning dialog so that the 

			// UI gets certificate information.

			// If the package is embedded, then skip notification to hide the embedding details from the user

			if (!iInstallMachine.iEmbedded && !SecurityAlertL(ETrue))

				User::Leave(KErrCancel); // User or UI cancelled installation.

			break;

		case ESignatureNotPresent:

			// This is a special case because we need to look at the policy 

			// setting to determine if unsigned SIS files are allowed at all.

			// Display security warning dialog.

			{

			iInstallMachine.SetTrust(ESisPackageUnsignedOrSelfSigned);

			iInstallMachine.SetValidationStatus(EUnsigned);   

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			// Alert only when machine not runs in info collection mode

			if(iInstallMachine.IsInInfoMode())

				break;

			#endif

			TBool cont = SecurityAlertL(iInstallMachine.iAllowUnsigned);

			if (!cont || !iInstallMachine.iAllowUnsigned)

				User::Leave(KErrSecurityError);

			break;	

			}

		case ESignatureSelfSigned:	

			iInstallMachine.SetTrust(ESisPackageCertificateChainNoTrustAnchor);

		    iInstallMachine.SetValidationStatus(EValidated);

		    #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		    // Alert only when machine not runs in info collection mode

			if(iInstallMachine.IsInInfoMode())

				break;

			#endif

			if (!SecurityAlertL(ETrue))

		    	User::Leave(KErrCancel);			

		    break;

        case ECertificateValidationError:

		case ENoCertificate:

		case ENoCodeSigningExtension:

		case ENoSupportedPolicyExtension:

			{

			// Unable to validate the chain

			// We apply the same policy as per unsigned SIS files

			iInstallMachine.SetTrust(ESisPackageValidationFailed);	

			iInstallMachine.SetValidationStatus(EInvalid);

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			// Alert only when machine not runs in info collection mode

			if(iInstallMachine.IsInInfoMode())

				break;

			#endif

			// uh-oh, not good, ask the user because these are not fatal

			TBool cont = SecurityAlertL(iInstallMachine.iAllowUnsigned);

			if (!cont || !iInstallMachine.iAllowUnsigned)

				User::Leave(KErrSecurityError);