/*

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

*

*/

#include "restoremachine.h"

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include <usif/sts/sts.h>

#else

#include "integrityservices.h"

#endif

#include "installclientserver.h"

#include "sisregistryentry.h"

#include "restorecontroller.h"

#include "restoreprocessor.h"

#include "sisregistryfiledescription.h"

#include "installationprocessor.h"

#include "sisuihandler.h"

#include "sishash.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "log.h"

#include "swispubsubdefs.h"

#include "securitycheckutil.h"

#include "cleanuputils.h"

#include "sisversion.h"

#include "sisregistrywritablesession.h"

#include <f32file.h>

#include "sisregistrypackage.h"

using namespace Swi;

//

// CRestoreMachine

//

CRestoreMachine* CRestoreMachine::NewL(const RMessage2& aMessage)

	{	

	CRestoreMachine* self = CRestoreMachine::NewLC(aMessage);

	CleanupStack::Pop(self);

	return self;	

	}

CRestoreMachine* CRestoreMachine::NewLC(const RMessage2& aMessage)

	{	

	CRestoreMachine* self = new (ELeave) CRestoreMachine;

	CleanupStack::PushL(self);

	self->ConstructL(aMessage);

	return self;	

	}

void CRestoreMachine::ConstructL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF(_L8("Restore - Starting new restore session"));

	iSystemDriveChar = RFs::GetSystemDriveChar();

	TPckg<TUid> package(iPackageUid);

	TInt err = aMessage.Read(EMessageSlotRestoreUid, package, 0);

	if (err != KErrNone)

		{

		aMessage.Panic(KInstallServerName, KErrBadDescriptor);

		}

	TInt len = aMessage.GetDesLengthL(EMessageSlotRestoreController);

	iBuf = HBufC8::NewL(len);

	TPtr8 bufPtr = iBuf->Des();

	err = aMessage.Read(EMessageSlotRestoreController, bufPtr, 0);

	if (err != KErrNone)

		{

		aMessage.Panic(KInstallServerName, KErrBadDescriptor);

		}

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

  	iSecurityManager = CSecurityManager::NewL();

  	iRestoreController = CRestoreController::NewL(*iBuf, *iSecurityManager, iFs);

	iFileMan = CFileMan::NewL(iFs);

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	// Create an STS transaction

	iStsSession.CreateTransactionL();

	_LIT(KPathFormat, "%c:%S");	

	TPath path;	

	TUint driveCh(iSystemDriveChar); // can't pass TChar to Format

	// Connect to the registry and start a transaction

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

	iRegistrySession.CreateTransactionL();

#else

	// Create an integrity services object

	TTime currentTime;

	currentTime.UniversalTime();

	_LIT(KPathFormat, "%c:%S");	

	TUint driveCh(iSystemDriveChar); // can't pass TChar to Format

	TPath path;	

	path.Format(KPathFormat, driveCh, &KSysInstallPath);

	iIntegrityServices = CIntegrityServices::NewL(currentTime.Int64(), path);

	//Roll back partial, abortive installs before us

	iIntegrityServices->RollBackL(ETrue);

#endif

	path.Format(KPathFormat, driveCh, &KSysInstallTempPath);

	err = iFs.MkDirAll(path);

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

 		{

		User::Leave(err);

 		}

	// Check if it is a valid upgrade

 	if (iSecurityManager->SecurityPolicy().AllowOverwriteOnRestore())    

 		{

 		// Fix PDEF129066: Pre-installed backed up content cannot be restored 

 		PrepareUpgradesL();

 		}

 	else

 		{

 		CheckVersionUpgradeL();

 		}

		//Publish package Uid which is going to be restored.

 	err = SecUtils::PublishPackageUid(iPackageUid, iUidList);

	if (err == KErrNone)

    	{

        DEBUG_PRINTF2(_L("CRestoreMachine::ConstructL published Uid is %x."),iPackageUid);

    	}

	else if (err == KErrOverflow)

	    {

        DEBUG_PRINTF2(_L("CRestoreMachine::ConstructL Failed to publish Uid %x as the array, holding the uids, exceeded its upper limit."),iPackageUid);

	    }

    else if (err == KErrNotFound)

        {

        DEBUG_PRINTF2(_L("CRestoreMachine::ConstructL Failed to publish Uid %x as the property is not defined."),iPackageUid);

        }

	else

		{

        DEBUG_PRINTF3(_L("CRestoreMachine::ConstructL Failed to publish Uid %x with error %d."),iPackageUid, err);

        User::Leave(err);

		}

 #ifdef SYMBIAN_USER_PROMPT_SERVICE

	//connect to the SWI Observer

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

	//Resgister to the SWI Observer

	TRequestStatus status;

	iObserver.Register(status);

	User::WaitForRequest(status);

	RBuf logFileName;

	logFileName.CreateL(KMaxFileName);

	logFileName.CleanupClosePushL();

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

	iObserver.GetFileHandleL(logFileName);

	//Add the log file to the transaction

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	iStsSession.RegisterNewL(logFileName);

#else

	iIntegrityServices->AddL(logFileName);

#endif

	CleanupStack::PopAndDestroy(&logFileName);

#endif

	aMessage.Complete(KErrNone);

	}

void CRestoreMachine::ServiceFileRequestL(const RMessage2& aMessage)

	{

	RFile restoreFile;

	TInt err = restoreFile.AdoptFromClient(aMessage, EMessageSlotRestoreFs, EMessageSlotRestoreFile);

	CleanupClosePushL(restoreFile);

	if (err != KErrNone)

		{

		aMessage.Panic(KInstallServerName, KErrBadDescriptor);

		User::Leave(KErrBadDescriptor);

		}

	TInt len = aMessage.GetDesLengthL(EMessageSlotRestorePath);

	HBufC* buf = HBufC::NewLC(len);

	TPtr filename = buf->Des();

	err = aMessage.Read(EMessageSlotRestorePath, filename, 0);

	if (err != KErrNone)

		{

		aMessage.Panic(KInstallServerName, KErrBadDescriptor);

		User::Leave(KErrBadDescriptor);

		}

	TFileName sbeFileName;

	User::LeaveIfError(restoreFile.FullName(sbeFileName));

	DEBUG_PRINTF3(_L("Restore - Servicing File Request for file '%S' from '%S'"),

		&filename, &sbeFileName);

	if (filename[0] == '!')			// install to user selected rive

		{

		filename[0] = iRestoreController->InstallDrive();

		}

	else if (filename[0] == '$')	// install to system drive

		{

		filename[0] = iFs.GetSystemDriveChar();

		}

	// Check if the disk is in at present

  	TInt drive;

  	User::LeaveIfError(iFs.CharToDrive(filename[0], drive));

  	TVolumeInfo volume;

  	err = iFs.Volume(volume, drive);

  	if (err != KErrNone)

  		{

  		User::Leave(KErrPathNotFound); // error code agreed with the connect team

  		}

	if (!SecurityCheckUtil::CheckFileName(filename,iSystemDriveChar)

		|| SecurityCheckUtil::IsSubstedDriveL(iFs, filename))

		{

		User::Leave(KErrBadName);

		}

	// For TCB protected directories eclipsing checks are required. This is not necessary

	// for public or private directories because SBE can restore these directly and the eclipsing

	// checks do not really improve security.

	TBool requiresHashCheck = EFalse;

	if (SecurityCheckUtil::IsProtectedDirectoryL(filename) && ! SecurityCheckUtil::IsPrivateDirectory(filename))

		{	

		if (! IsUniqueL(filename, requiresHashCheck))

			{

			User::Leave(KErrInvalidEclipsing);

			}

		}

	// Hash checks must be performed for TCB protected files

	requiresHashCheck |= SecurityCheckUtil::IsTargetTcbWriteProtected(filename);

	TFileName tempFileName;

	iRestoreController->AddFileDescriptionL(restoreFile, filename, tempFileName, requiresHashCheck);

	// move the file to it's temporary location and add it to the transaction

	// as a temporary file.

	// format of names is {drive}:\sys\install\temp\file-{uid}-{abs index}-{file index}-{hash of name in hex}

	// this format differs slightly from the install format

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	iStsSession.RegisterTemporaryL(tempFileName);

#else

	iIntegrityServices->TemporaryL(tempFileName);

#endif

 	err = iFs.MkDirAll(tempFileName);

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

 		{

		User::Leave(err);

 		}

 	User::LeaveIfError(iFileMan->Copy(restoreFile, tempFileName));	

	CleanupStack::PopAndDestroy(2, &restoreFile);

	aMessage.Complete(KErrNone);

	}

TBool CRestoreMachine::IsUniqueL(const TDesC& aFileName, TBool& aCheckFileHashOut)

	{	

	aCheckFileHashOut = EFalse;

	if (aFileName.Length() == 0)

		{

		return ETrue;

		}

	TPath path;

	path.Copy(aFileName);

	// Find on which disks (if any) this file exists on	

	TDriveList driveList;

	User::LeaveIfError(iFs.DriveList(driveList));

	TChar disk = 'a' - 1;

	for (TInt i = 0; i < driveList.Length(); i++)

		{

		disk+=1;

		if (driveList[i] == 0)

			{

			continue;

			}

		else if (disk == 'z')

			{

			continue; // eclipsing allowed, checked later

			}

		path[0] = disk;

		TEntry entry;

		if (iFs.Entry(path, entry) == KErrNone)

			{

			if (path.CompareF(aFileName) == KErrNone)

				{

				// If there is already a file here, check its hash

				aCheckFileHashOut = ETrue;

				}

			else

				{

				// names must be unique across drives

				return EFalse;

				}

			}

		}

	return ETrue;	

	}

void CRestoreMachine::CheckVersionUpgradeL()

	{

	const RPointerArray<CPlan>& plans = iRestoreController->Plans();

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	RSisRegistrySession session;

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

	CleanupClosePushL(session);

#endif

    TInt count = plans.Count(); 

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

		{

		// check only the first plan is a valid upgrade

        const Sis::CController& controller = plans[i]->ApplicationL().ControllerL();

		Sis::TInstallType type = controller.Info().InstallType();

		TBool isBase = ((type == EInstInstallation) || (type == EInstPreInstalledApp));

		// ask the registry if the UID already exists.

		RSisRegistryEntry entry;

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		TInt err = entry.Open(iRegistrySession, controller.Info().Uid().Uid());

#else

		TInt err = entry.Open(session, controller.Info().Uid().Uid());

#endif

		if (err == KErrNone)

			{

			CleanupClosePushL(entry);

			TVersion version = entry.VersionL();

			if (isBase && !entry.IsInRomL())

				{

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

				CleanupStack::PopAndDestroy(&entry);

#else

				CleanupStack::PopAndDestroy(2, &session); // entry

#endif

				const CVersion& ctrlVersion = controller.Info().Version();

				if (version.iMajor == ctrlVersion.Major() &&

					version.iMinor == ctrlVersion.Minor() &&

					version.iBuild == ctrlVersion.Build())

					{

					DEBUG_PRINTF(_L8("Restore - Error, attempting to restore an application that is already on device"));

					User::Leave(KErrAlreadyExists);

					}

				else

					{

					DEBUG_PRINTF(_L8("Restore - Error, attempting to restore an application that is not supported on device"));

					User::Leave(KErrNotSupported);

					}

				}

			CleanupStack::PopAndDestroy(&entry);

            // check for Augmentations as well. Need to leave with KErrAlreadyExists, if the same augmentation exists

            if (type == Sis::EInstAugmentation)

                {

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK				

				TBool foundEntryToOverwrite = FindInstalledAugmentationL(iRegistrySession, controller, entry);

#else				

                TBool foundEntryToOverwrite = FindInstalledAugmentationL(session, controller, entry);

#endif				

				entry.Close();

                if ( foundEntryToOverwrite )

                    {

                    DEBUG_PRINTF(_L8("Restore - Error, attempting to restore an augmentation of an application that is already on device"));

                    User::Leave(KErrAlreadyExists);

                    }

                }

			}

		}

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		CleanupStack::PopAndDestroy(&session);

#endif

	}

/**

 Scans the meta-data to restore and identifies any applications or upgrades that are already

 installed and should be overwritten.

 If an overwrite is required then this function removes all of the installed files 

 belonging to application using the current integrity services transaction.

 */

void CRestoreMachine::PrepareUpgradesL()

	{

	const RPointerArray<CPlan>& plans = iRestoreController->Plans();

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	RSisRegistrySession session;

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

	CleanupClosePushL(session);

#endif

	// Loop over the set of applications in the restore meta-data

	// N.B. The set of upgrades in the restore meta-data can be DIFFERENT to 

	// the set of upgrades on the device.

	TInt count = plans.Count();	

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

		{

		const Sis::CController& controller = plans[i]->ApplicationL().ControllerL();

		Sis::TInstallType type = controller.Info().InstallType();

		// Ask the registry if the application already exists.				

		RSisRegistryEntry entryToOverwrite;		

		TBool foundEntryToOverwrite = EFalse;		

		if (type == Sis::EInstAugmentation)

			{

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			foundEntryToOverwrite = FindInstalledAugmentationL(iRegistrySession, controller, entryToOverwrite);

#else

			foundEntryToOverwrite = FindInstalledAugmentationL(session, controller, entryToOverwrite);

#endif

			}

		 else 

			{

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			TInt err = entryToOverwrite.Open(iRegistrySession, controller.Info().Uid().Uid());

#else

			TInt err = entryToOverwrite.Open(session, controller.Info().Uid().Uid());

#endif

			if (err == KErrNone)

				{

				foundEntryToOverwrite = ETrue;

				}

			else if (err != KErrNotFound)

				{

				User::Leave(err);

				}

			}

		CleanupClosePushL(entryToOverwrite);

		if (foundEntryToOverwrite && entryToOverwrite.IsInRomL())

			{

			// Can't overwrite entries in ROM; however, this is not a fatal error

			// because it is still valid to restore upgrades to ROM stubs. Consequently,

			// only the removal of existing files is skipped.

			DEBUG_PRINTF2(_L("Package 0x%08x is in ROM, skipping removal of files."),

					entryToOverwrite.UidL().iUid);		

			}

		else if (foundEntryToOverwrite && ! entryToOverwrite.IsPresentL())

			{

			DEBUG_PRINTF2(_L("Package 0x%08x is registered but not fully present. Skipping restore."), 

					entryToOverwrite.UidL().iUid);

			// Package exists but can't be overwritten. Leaving with KErrAlreadyExists

			// instructs SBE to skip this package but continue with the restore.

			User::Leave(KErrAlreadyExists);	

			}

		else if (foundEntryToOverwrite)

			{						

			// The application in the registry is already installed and is not in the ROM

			// This could be because the system drive has not been reformatted OR a firmware

			// upgrade also flashed the user data area.

			// Identify the package to be overwritten and record this in the package

			// being restored. This is needed by the SIS registry in order to overwrite

			// the controller and .reg files to overwrite. 

			CApplication* application = const_cast<CApplication*>(&plans[i]->ApplicationL());

			// controller must be controller to restore not current controller	

			application->SetUpgrade(controller);				

			CSisRegistryPackage* originalPackage=entryToOverwrite.PackageL();

			CleanupStack::PushL(originalPackage);

			application->SetPackageL(*originalPackage);	

			DEBUG_PRINTF5(_L("Restoring package as upgrade 0x%08x, name=\"%S\" vendor=\"%S\" index=%d"), 

					originalPackage->Uid().iUid, &originalPackage->Name(), 

					&originalPackage->Vendor(), originalPackage->Index());			

			CleanupStack::PopAndDestroy(originalPackage);

			// Remove all files registered for this package if the package is an SA or SP

			// and the version numbers mismatch.

			// If the version numbers are exactly the same then SWI avoids deleting files 

			// to work with applications that don't create full backups 

			// N.B. Files should still be overwritten if they are present in the backup.

			if (type == Sis::EInstInstallation || Sis::EInstAugmentation)

				{

				TVersion vToRestore(0,0,0);

				if (type == Sis::EInstInstallation)

					{

					// The package in the restore image could have been upgrade with a PU

					vToRestore = GetLatestVersionOfPackageToRestore();

					}

				else

					{

					// Augmentation so version number to restore is the one in the current controller

					vToRestore.iMajor = controller.Info().Version().Major();

					vToRestore.iMinor = controller.Info().Version().Minor();

					vToRestore.iBuild = controller.Info().Version().Build();

					}

				TVersion vCurrent(entryToOverwrite.VersionL());