/*

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

*

*/

#include <s32mem.h>

#include "restorecontroller.h"

#include "arrayutils.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "sisversion.h"

#include "sissupportedlanguages.h"

#include "sisinstallblock.h"

#include "sishash.h"

#include "userselections.h"

#include "siselseif.h"

#include "log.h"

#include "securitycheckutil.h"

#include "siscapabilities.h"

#include "certchainconstraints.h"

#include "sisregistryfiledescription.h"

#include "sistruststatus.h"

#include "secutils.h"

#include <f32file.h>

using namespace Swi;

using namespace Swi::Sis;

//

// TRestoreFileInformation

//

TRestoreFileInformation::TRestoreFileInformation(CFileDescription& aFileDescription, CApplication& aParentApplication)

	: iFileDescription(aFileDescription), 

	iParentApplication(aParentApplication)	

	{

	}

//

// CRestoreController

// 

void CRestoreController::ConstructL(TDesC8& aController)

	{				

	iSystemDriveChar = RFs::GetSystemDriveChar();

	// Read the controllers from the buffer		

	InternalizeControllersL(aController);

	//We also create a dummy plan for use when writing the 

	//registry entries

	TInt augmentationIndex(0);

	TInt noOfMatchingLanguages = iMatchingSupportedLanguagesArray.Count();

	TInt matchingLanguageCount = 0;

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

		{

		CPlan* plan = CPlan::NewL();

		CleanupStack::PushL(plan);

		User::LeaveIfError(iInstallPlans.Append(plan));

		CleanupStack::Pop(plan);

		CApplication* application = CApplication::NewLC();

		CController* controller = iControllers[i];

		DEBUG_PRINTF3(_L8("Restore - Metadata controller %d is of type %d"),

			i, controller->Info().InstallType());

 		// Set the install type 		

 		switch (controller->Info().InstallType())

 			{

 		case EInstInstallation:

 			application->SetInstall(*controller);

			application->UserSelections().SetDrive(iInstallDrive);		

			//if there are macthing languages then populate iMatchingDeviceLanguages array of application object

			if ( noOfMatchingLanguages )

				{

				while( iMatchingSupportedLanguagesArray[matchingLanguageCount] != ELangNone)

					{

					application->PopulateMatchingDeviceLanguagesL(iMatchingSupportedLanguagesArray[matchingLanguageCount++]);

					}

				}

 			break;

 		case EInstPartialUpgrade:

 			application->SetPartialUpgrade(*controller);

			application->UserSelections().SetDrive(iInstallDrive);	

			// Carry forwards the in-rom flag

			if (i == 0 || iTopLevelApplications[0]->IsInROM()) 				

				{

				// If the first controller is a parial upgrade then 

				// it must be a partial upgrade to a ROM stub.

				// If there are multiple PUs then they must also be in-rom

				application->SetInROM();

				}

	         if ( noOfMatchingLanguages )

	                {

	                TInt i = 0;

	                while( iMatchingSupportedLanguagesArray[i] != ELangNone)

	                    {

	                    application->PopulateMatchingDeviceLanguagesL(iMatchingSupportedLanguagesArray[i++]);

	                    }

	                }

 			break;

		case EInstAugmentation:	

			application->SetAugmentation(*controller);

			application->UserSelections().SetDrive(iAugmentationDrives[augmentationIndex++]);

			//if there are macthing languages then populate iMatchingDeviceLanguages array of application object

			if ( noOfMatchingLanguages )

				{

				while( iMatchingSupportedLanguagesArray[matchingLanguageCount] != ELangNone)

					  {

					   application->PopulateMatchingDeviceLanguagesL(iMatchingSupportedLanguagesArray[matchingLanguageCount++]);

					  }

				}

			break;

 		default:

 			User::Leave(KErrNotSupported);

 			break;

 			}

		TPtrC8* buf = iControllerBinaries[i];

		application->SetController(*controller);

		CSisCertificateVerifier* verifier = CSisCertificateVerifier::NewLC(controller, *buf, iSecurityManager, application);

		User::LeaveIfError(iVerifiers.Append(verifier));

		CleanupStack::Pop(verifier);

		TInt languageIndex = SetApplicationLanguageL(*application);

		//This is the first controller, add it to the plan

		User::LeaveIfError(iTopLevelApplications.Append(application));

		plan->SetApplication(application); // ownership transferred.

		const CVersion& version = controller->Info().Version();

		TVersion appVersion(version.Major(), version.Minor(), version.Build());

		plan->SetApplicationInformationL(controller->Info().Names()[languageIndex]->Data(),

			controller->Info().VendorNames()[languageIndex]->Data(),

			appVersion);	

		CleanupStack::Pop(application);			

		}	

	}

/**

 Locates the relevant file description in the controller and adds the file

 to be restored to the list of files for the new SIS registry object.

 This also checks the hash of the file if needed and generates an appropriate temporary

 filename to be used by integrity services.

 @param		aFile				file handle to temporary restore file.

 @param		aTempFileName		temporary filename to use with integrity services.

 @param		aHashCheckRequried	whether the restore files hash must be checked against the controllers

 */

void CRestoreController::AddFileDescriptionL(RFile& aFile, TDesC& aTarget, TDes& aTempFilename, TBool aHashCheckRequired)

  	{

  	// Lookup file information and check the hash if needed  	

  	TRestoreFileInformation info = LookupFileInformationL(aFile, aTarget, aHashCheckRequired);

  	// Add the file description to the plan

  	CApplication& application = info.ParentApplication();

  	application.AddFileL(info.FileDescription(), application.UserSelections().Drive());

  	// Construct the temporary file name for this file

  	TParsePtrC parse(aTarget);  	

  	_LIT(KTemporaryFileFormat, "%c:%Stfile-%d-%d-%d-");

  	TUint driveCh(iSystemDriveChar);

  	aTempFilename.Format(KTemporaryFileFormat, driveCh, &KSysInstallTempPath, 

  		application.ControllerL().Info().Uid().Uid().iUid, application.AbsoluteDataIndex(), info.FileDescription().Index());

  	// Append a hex representation of a hash of the filename. We need the

  	// temporary filename to be effectively unique, but the filename itself

  	// may be too long.

  	// Use the real target path (after path subsitution) minus the drive letter.

  	HBufC* hashBuf = SecUtils::HexHashL(aTarget.Right(aTarget.Length() - 1));

  	aTempFilename.Append(*hashBuf);

  	delete hashBuf;

  	// finally, remove this file from the list of files to add entries for

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

  		{  		

  		HBufC* filename = iInstalledFiles[i];	

  		if (aTarget.CompareF(*filename) == 0)

  			{

  			delete filename;

  			iInstalledFiles.Remove(i);

  			break;

  			}  		

  		}  	

  	}

void CRestoreController::AddEmbeddedAppsAndFilesL()

  	{

	//for each application/controller pair, add fake file and embedded package descriptions

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

		{

		DoAddEmbeddedAppsAndFilesL(iTopLevelApplications[i]->ControllerL().InstallBlock(), *iTopLevelApplications[i]); 

		}

	}

// Preserves the links between embedded applications in the registry, so uninstalling the 

// top level package will attempt to uninstall the packages below it in the tree

// However, these applications are not processed as part of the restore 

// hence they are entirely fake	

void CRestoreController::DoAddEmbeddedAppsAndFilesL(

	const CInstallBlock& aInstallBlock, CApplication& aApplication)

	{

	const RPointerArray<CController>& controllers = aInstallBlock.EmbeddedControllers();

  	TInt i;	

	for (i = 0; i < controllers.Count(); ++i)

		{

		CController* controller = controllers[i];

		CApplication* application = CApplication::NewLC();

		application->SetController(*controller);

		SetApplicationLanguageL(*application);

		aApplication.AddEmbeddedApplicationL(application); // Ownership transfered

		CleanupStack::Pop(application);

		}

  	const RPointerArray<CFileDescription>& fileDescriptions = aInstallBlock.FileDescriptions();

  	TChar foldedDrive = aApplication.UserSelections().Drive();

  	if (foldedDrive != 255)

  		{

  		foldedDrive.Fold();	// don't convert 'no drive selection' to the y drive 

  		}

  	for (i = 0; i < fileDescriptions.Count(); ++i)

  		{

  		const TDesC& description = fileDescriptions[i]->Target().Data();

  		if (description.Length() != 0)

  			{

  			TChar sisDrive = description[0];

  			if (sisDrive == '$')

  				{

  				sisDrive = iFs.GetSystemDriveChar();	

  				}  			

  			sisDrive.Fold();

  			for (TInt j = 0; j < iInstalledFiles.Count(); j++)

  				{

  				HBufC* filename = iInstalledFiles[j];

  				TChar targetDrive = (*filename)[0];

  				targetDrive.Fold();

				// if the file description matches this filename (taking into account drive letter)

				// add it to the application.

				// This may not be 100% the correct file description, but it will be close enough

				if (description.Mid(1).CompareF(filename->Mid(1)) == 0 &&

				    ((targetDrive == foldedDrive) || (targetDrive == sisDrive)))

				       {

				       aApplication.AddFileL(*fileDescriptions[i], aApplication.UserSelections().Drive());

				       // Cut down the search space some

				       delete filename;

				       iInstalledFiles.Remove(j);

				       break;

				       }

				}

			}

  		}

	const RPointerArray<CIf>& ifBlocks = aInstallBlock.IfStatements();

	for (i = 0; i < ifBlocks.Count(); ++i)

		{

		CIf* ifBlock = ifBlocks[i];

		DoAddEmbeddedAppsAndFilesL(ifBlock->InstallBlock(), aApplication);

		const RPointerArray<CElseIf>& elseBlocks = ifBlock->ElseIfs();

		for (TInt j = 0; j < elseBlocks.Count(); j++)

			{

			CElseIf* elseBlock = elseBlocks[j];

			DoAddEmbeddedAppsAndFilesL(elseBlock->InstallBlock(), aApplication);

			}

		}

	}	

// Creates a TPtrC8* which points to the data of controllers stored in MetaData which was backedup.

// Not using HBufC8::NewLC as it allocates memory afresh for the data.

TPtrC8* CRestoreController::CreateRawControllerPtrLC(RDesReadStream& aStream, const TUint8* aBasePtr, TInt& aOffset )

	{

	TCardinality card;

	aStream>>card;

	TInt tmpLen = (TInt)card;

	//Right shift TCardinality by one as its LSB is not

	// used to represent the length of the descriptor

	TInt len = ((TInt)card) >> 1;

	//TCardinality uses 

	// 1 Byte to store the length if it is between 0-127 

	// 2 Bytes if length is between 128-16383

	// 4 Bytes if length > 16383

	if ( tmpLen < 128 )

		aOffset+=1;

	else if ( tmpLen < 16384 )

		aOffset+=2;

	else

		aOffset+=4;

	TPtrC8* controllerBuf = new (ELeave)TPtrC8(); 

	controllerBuf->Set(aBasePtr+aOffset,len);

	CleanupStack::PushL(controllerBuf);

	aOffset += len;

	while( len-- )

		aStream.ReadInt8L();

	return controllerBuf;

	}

void CRestoreController::InternalizeControllersL(TDesC8& aController)

	{

	RDesReadStream stream(aController);

	CleanupClosePushL(stream);

	TInt offset = 0;

	const TUint8* basePtr = aController.Ptr();

	// Drive letter to install to

	iInstallDrive = TChar(stream.ReadUint32L());

	offset+=4;

	// We need to count the augmentations to know how many selected drives to

	// read after the list of files.

	TInt augmentationsCount(0);

	TInt controllerCount = stream.ReadInt32L();

	DEBUG_PRINTF2(_L8("Restore - Metadata consists of %d seperate controllers"), 

		controllerCount);

	offset+=4;

	while (controllerCount--)

		{

		TPtrC8* controllerBuf = CreateRawControllerPtrLC(stream,basePtr,offset);

		User::LeaveIfError(iControllerBinaries.Append(controllerBuf));

		CleanupStack::Pop(controllerBuf);

		// Create a CController object from the binary

		CDesDataProvider* provider = CDesDataProvider::NewLC(*controllerBuf);

		CController* controller = CController::NewLC(*provider, EAssumeType);

		User::LeaveIfError(iControllers.Append(controller));

		CleanupStack::Pop(controller);

		if (controller->Info().InstallType() == EInstAugmentation)

			{

			augmentationsCount++;

			}

		CleanupStack::PopAndDestroy(provider);

		}

  	// Trap this to make the metadata file format BC	

  	TInt filesCount = 0;

  	TRAPD(err, filesCount = stream.ReadInt32L());

  	// If this is an old style backup metadata file, it won't include this section

  	if (err == KErrNone)

  		{

  		while (filesCount--)

  			{

  			HBufC* filename = HBufC::NewLC(stream, KMaxTInt);

  			User::LeaveIfError(iInstalledFiles.Append(filename));

  			CleanupStack::Pop(filename);

  			}

 		// Trap reading augmentations' selected drives, which appear after the

 		// file list in metadata files created after the fix for DEF087124.

 		// Leave if the read fails beyond the first augmentation, since we should

 		// have all or none.

  		for (TInt i = 0; i < augmentationsCount; i++)

			{

			if (err == KErrNone)

				{

  				TChar selectedDrive(iInstallDrive);

  				TRAP(err, selectedDrive = stream.ReadInt32L());

  				if (i != 0)

  					{

  					User::LeaveIfError(err);

  					}

				iAugmentationDrives.AppendL(selectedDrive);

				}

			else

				{

				// If we failed on reading the first drive, fill the rest of

				// the array with the selected drive for the base package.

				iAugmentationDrives.AppendL(iInstallDrive);			

				}

			}

  		}

  		// Reading the array of matching device supported languages

  		TRAP(err, InternalizeArrayL(iMatchingSupportedLanguagesArray,stream));

	CleanupStack::PopAndDestroy(&stream);

	}

CRestoreController* CRestoreController::NewL(TDesC8& aController, CSecurityManager& aSecurityManager, RFs& aFs)

	{

	CRestoreController* self = CRestoreController::NewLC(aController, aSecurityManager, aFs);

	CleanupStack::Pop(self);

	return self;

	}

CRestoreController* CRestoreController::NewLC(TDesC8& aController, CSecurityManager& aSecurityManager, RFs& aFs)

	{

	CRestoreController* self = new (ELeave) CRestoreController(aSecurityManager, aFs);

	CleanupStack::PushL(self);

	self->ConstructL(aController);

	return self;

	}

CRestoreController::CRestoreController(CSecurityManager& aSecurityManager, RFs& aFs)

	: iFs(aFs), iSecurityManager(aSecurityManager)

	{

	}

 /**

  Finds the matching file description in the controller and checks the hash if required.

  @param		aFile				handle to the file to restore

  @param 	aTarget				path that the file handle should be restored.

  @param		aHashCheckRequired	if the target path is TCB protected and a hash check is required.

  */

 TRestoreFileInformation CRestoreController::LookupFileInformationL(RFile& aFile, TDesC& aTarget, TBool aHashCheckRequired)

	{

	CFileDescription* desc = NULL;

	// Search through the controllers backwards in case an executable has been ugpraded with 

	// a partial upgrade

	TBool foundMatch = EFalse;

	TInt i = iControllers.Count() - 1;

	CApplication* application = NULL;

	while (i >= 0 && ! foundMatch)

		{

		CController* controller = iControllers[i];

		application = iTopLevelApplications[i];

		TChar drive = application->UserSelections().Drive();

		desc = FindFileDescriptionL(controller->InstallBlock(), aFile, aTarget, aHashCheckRequired, drive);

		if (desc)

			{

			foundMatch = ETrue;

			}

		else

			{

			--i;	// Check the next controller

			}

		}

	if (aHashCheckRequired && ! foundMatch)

		{

		// Previously the code would return either KErrNotFound or KErrSISWouldOverWrite

		// both of these errors are incorrect and SBE does not depend on the exact error code

		// in this scenario.

		// N.B. It is already possible for KErrSecurityError to be returned so the backup

		// client MUST be able to handle this.

		DEBUG_PRINTF2(_L("No matching hash for file %S"), &aTarget);

		User::Leave(KErrSecurityError);

		}

	else if (! foundMatch)

		{

		// It's difficult to report VerifyOnRestore mis-matches as a security error because

		// the file could be present in multiple controllers and in multiple install blocks

		// with and without the VerifyOnRestore flag set

		DEBUG_PRINTF2(_L("No match in controller for %S"), &aTarget);

		User::Leave(KErrNotFound);

		}

	// This is where things get really interesting ...

	// The restore machine invokes a restore processor for each controller in turn

	// and as well as checking the exe header the restore processor builds a list of SIDs

	// as it goes.

	// When the files are installed private directories are checked against the list of SIDs.

	// BUT

	// If the exe has been upgraded via a partial upgrade then the application pointer here will

	// refer to the partial upgrade that hasn't been checked yet so the SID isn't known and the processor

	// will reject the restore of files to that private dir.

	// Reversing the order of processing the controllers doesn't help because if the exe

	// hasn't been upgraded but the PU deploys a file to the exe's private dir then again the SID

	// isn't known so the install will be rejected.

	// The work around is to associate all of the files supplied by SBE for PUs with