/*

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

* Application Processor

*

*/

/**

 @file

 @released

 @internalTechnology 

*/

#include <hash.h>

#include "processor.h"

#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include "integrityservices.h"

#endif

#include "sishelperclient.h"

#include "sisregistryfiledescription.h"

#include "sisregistryentry.h"

#include "sisstring.h"

#include "hashcontainer.h"

#include "siscontroller.h"

#include "application.h"

#include "log.h"

#include "secutils.h"

#include "sisuihandler.h"

#include "filesisdataprovider.h"

#include "securitymanager.h"

#include "sislauncherclient.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "plan.h"

#include "securitycheckutil.h"

#include "progressbar.h"

#include "sidcache.h"

#include "planner.h"

#include "sisregistrypackage.h"

#include <f32file.h>

#include <e32property.h>

#include <swi/swispubsubdefs.h>

using namespace Swi;

const TChar KRomDrive = 'z';

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

CProcessor::CProcessor(const CPlan& aPlan, RUiHandler& aUiHandler,

		Usif::RStsSession& aStsSession, CRegistryWrapper& aRegistryWrapper, 

		RSwiObserverSession& aObserver)

	: CActive(EPriorityStandard), 

	iSystemDriveChar(RFs::GetSystemDriveChar()),

	iRegistryWrapper(aRegistryWrapper),

	iPlan(aPlan),	

	iUiHandler(aUiHandler),

	iStsSession(aStsSession),

	iObserver(aObserver)

	{

	CActiveScheduler::Add(this);

	}

#else

CProcessor::CProcessor(const CPlan& aPlan, RUiHandler& aUiHandler, CIntegrityServices& aIntegrityServices, RSwiObserverSession& aObserver)

	: CActive(EPriorityStandard),

	iSystemDriveChar(RFs::GetSystemDriveChar()),

	iPlan(aPlan),	

	iUiHandler(aUiHandler),

	iIntegrityServices(aIntegrityServices),

	iObserver(aObserver)

	{

	CActiveScheduler::Add(this);

	}

#endif

CProcessor::~CProcessor()

	{

	Cancel();

	iFs.Close();

	iSidsAdded.Close();

	iSidsRemoved.Close();

	iSidsToShutdown.Close();

	}

void CProcessor::ConstructL()

	{

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

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

	}

void CProcessor::ProcessApplicationL(const CApplication& aApplication, TRequestStatus& aClientStatus)

	{

	iApplication = &aApplication;

	iClientStatus = &aClientStatus;

	aClientStatus = KRequestPending;

	iErrorCode = 0;

	// We only get the validation status of the package for uninstallation here 	

	if (ApplicationL().IsUninstall())

		{

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		RSisRegistryEntry entry;		

		User::LeaveIfError(entry.OpenL(iRegistryWrapper.RegistrySession(), ApplicationL().PackageL()));			

		CleanupClosePushL(entry);

		iValidationStatus=entry.TrustStatusL().ValidationStatus();

		CleanupStack::PopAndDestroy(&entry);

#else

		RSisRegistrySession session;

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

		CleanupClosePushL(session);		

		RSisRegistryEntry entry;		

		User::LeaveIfError(entry.OpenL(session, ApplicationL().PackageL()));			

		CleanupClosePushL(entry);

		iValidationStatus=entry.TrustStatusL().ValidationStatus();

		CleanupStack::PopAndDestroy(&entry);

		CleanupStack::PopAndDestroy(&session);

#endif

		}

	else

		{

		iValidationStatus =	ApplicationL().ControllerL().TrustStatus().ValidationStatus();

		}

	iSidsAdded.Reset();

	iSidsRemoved.Reset();

	iSidsToShutdown.Reset();

	SwitchState(EInitialize);

	}

void CProcessor::ProcessPlanL(TRequestStatus& aClientStatus)

	{

	ProcessApplicationL(iPlan.ApplicationL(), aClientStatus);

	}

void CProcessor::Reset()

	{

	}

void CProcessor::DoCancel()

	{

	iCancelled=ETrue;

	User::RequestComplete(iClientStatus, KErrCancel);

	}

void CProcessor::RunL()

	{

	DEBUG_PRINTF3(_L8("Install Server - Processor State Machine, State: %d, Status: %d"),

		iState, iStatus.Int());

	// Leave if there has been an error

	User::LeaveIfError(iStatus.Int());

	if (iCancelled)

		{

		User::Leave(KErrCancel);

		}

	switch(iState)

		{

	case EInitialize:

		if (DoStateInitializeL())

			{

			SwitchState(EProcessEmbedded);

			}

		break;

	case EProcessEmbedded:

		if (DoStateProcessEmbeddedL())

			{

			SwitchState(EShutdownAllApps);

			}

		break;

	case EShutdownAllApps:

		if (DoStateShutdownAllAppsL())

			{

			SwitchState(ECheckApplicationInUse);

			}

		break;

	case ECheckApplicationInUse:

		if (DoStateCheckApplicationInUseL())

			{

			SwitchState(EShutdownExe);

			}

		break;

	case EShutdownExe:

		if (DoStateShutdownExeL())

			{

			SwitchState(EDisplayFiles);

			}

		break;

	case EDisplayFiles:

		if (DoStateDisplayFilesL())

			{

			SwitchState(EProcessSkipFiles);

			}

		break;

	case EProcessSkipFiles:

		if (DoStateProcessSkipFilesL())

			{

			SwitchState(EExtractFiles);

			}

		break;

	case EExtractFiles:

		if (DoStateExtractFilesL())

			{

			SwitchState(EProcessFiles);

			}

		break;

	case EProcessFiles:

		if (DoStateProcessFilesL())

			{

			SwitchState(EVerifyPaths);

			}

		break;

	case EVerifyPaths:

		if (DoStateVerifyPathsL())

			{

			SwitchState(ERemoveFiles);

			}

		break;

	case ERemoveFiles:

		if (DoStateRemoveFilesL())

			{

			SwitchState(ERemovePrivateDirectories);

			}

		break;

	case ERemovePrivateDirectories:

		if (DoStateRemovePrivateDirectoriesL())

			{

			SwitchState(EInstallFiles);

			}

		break;

	case EInstallFiles:

		if (DoStateInstallFilesL())

			{

			SwitchState(EUpdateRegistry);

			}

		break;

	case EUpdateRegistry:

		if (DoStateUpdateRegistryL())

			{

			SwitchState(EFinished);

			}

		break;

	case EFinished:

		DoStateFinishedL();

		break;

	default:

		User::Leave(KErrGeneral);

		break;

		}

	}

void CProcessor::SwitchState(TProcessingState aNextState)

	{

	if (aNextState!=ECurrentState)

		{

		iState=aNextState;

		}

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

void CProcessor::WaitState(TProcessingState aNextState)

	{

	if (aNextState!=ECurrentState)

		{

		iState=aNextState;

		}

	SetActive();

	}

TInt CProcessor::RunError(TInt aError)

	{

	DEBUG_PRINTF2(_L8("Install Server - Processor State Machine RunError, Error code %d"), aError);

	User::RequestComplete(iClientStatus, aError);

	return KErrNone;

	}

// implementations of the states provided

void CProcessor::DoStateFinishedL()

	{

	User::RequestComplete(iClientStatus, iErrorCode);

	}

// common state functions

TBool CProcessor::DoStateShutdownAllAppsL()

	{

	if(ApplicationL().ShutdownAllApps())

		{

		iUiState = EShutdownAllApps;

		// Signal to UI apps are being shut down

		CHandleCancellableInstallEvent* cmd = CHandleCancellableInstallEvent::NewLC(Plan().AppInfoL(), EEventShuttingDownApps, 0, KNullDesC);

		UiHandler().ExecuteL(*cmd);

		CleanupStack::PopAndDestroy(cmd);

		RSisLauncherSession launcher;

		CleanupClosePushL(launcher);

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

		launcher.ShutdownAllL();

		CleanupStack::PopAndDestroy(&launcher);

		}

	//Here is the first point where a package is actually being started to install.

	//Hence, the package header is logged at that point.

	TUid pkgUid;

	TPackageType pkgType;

	TOperationType opType;

	if(ApplicationL().IsUninstall())

		{

		pkgUid = ApplicationL().PackageL().Uid();

		//It is assumed that we don not need pkg type during uninstallation

		pkgType = EUnknownPackage; 

		opType = EOpUninstall;

		}

	else

		{

		pkgUid = ApplicationL().ControllerL().Info().Uid().Uid();

		pkgType = static_cast<TPackageType>(ApplicationL().ControllerL().Info().InstallType());

		opType = EOpInstall;

		}

	CObservationHeader *header = CObservationHeader::NewLC(pkgUid, pkgType, opType);

	Observer().AddHeaderL(*header);

	CleanupStack::PopAndDestroy(header);

	return ETrue;

	}

TBool CProcessor::DoStateCheckApplicationInUseL()

	{

	const RPointerArray<CSisRegistryFileDescription>& filesToRemove = ApplicationL().FilesToRemove();

	TInt fileCount = filesToRemove.Count();

	if (fileCount > 0)

		{		

		// Find Sids corresponding to Exes we are removing.			

		RArray<TAppInUse> sidsArray;

		CleanupClosePushL(sidsArray);

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

			{

			TEntry entry;

			TInt err = Fs().Entry(filesToRemove[i]->Target(), entry);

			// if this is an EXE.

			if (err == KErrNone && entry.IsTypeValid() &&

				SecUtils::IsExe(entry))

				{

				//Add it the check array

				TAppInUse temp;

				temp.iAppUid=filesToRemove[i]->Sid();

				temp.iInUse=EFalse;

				sidsArray.AppendL(temp);				

				}

			}			

		// If there are any executables, check if they are in use.

		TInt exeCount=sidsArray.Count();

		if (exeCount>0)

			{

			RSisLauncherSession launcher;

			CleanupClosePushL(launcher);

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

			//check if they are running	

			TRAPD(err,launcher.CheckApplicationInUseL(sidsArray));

			if(err == KErrNone)

				{

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

					{

					if (sidsArray[i].iInUse)

						{

						iSidsToShutdown.AppendL(sidsArray[i].iAppUid);												

						}

					}

				}

			else

				{

				User::LeaveIfError(err);

				}

			CleanupStack::PopAndDestroy(&launcher);				

			}

		CleanupStack::PopAndDestroy(&sidsArray);

		}

	// If any Sids are in use, display dialog for applications in use

	// which offers the chance to cancel.

	if(iSidsToShutdown.Count() > 0)

		{

		if(!DisplayApplicationInUseL())

			{

			User::Leave(KErrCancel);	

			}

		else 

			{

			// User has chosen to shut down apps.  Set shutdown timeout from

			// software install security policy.

			CSecurityPolicy* secPolicy = CSecurityPolicy::GetSecurityPolicyL();

			iShutdownTimeout = secPolicy->ApplicationShutdownTimeout();

			}

		}

	return ETrue;

	}

TBool CProcessor::DoStateShutdownExeL()

	{

	if (iSidsToShutdown.Count()>0)

		{

		// If this is the first app to shut down, signal to UI apps are

		// being shut down.

		if(iUiState != EShutdownExe)

			{

			iUiState = EShutdownExe;

			CHandleCancellableInstallEvent* cmd = CHandleCancellableInstallEvent::NewLC(Plan().AppInfoL(), EEventShuttingDownApps, 0, KNullDesC);

			UiHandler().ExecuteL(*cmd);

			CleanupStack::PopAndDestroy(cmd);

			}

		RSisLauncherSession launcher;

		CleanupClosePushL(launcher);

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

		launcher.ShutdownL(iSidsToShutdown, iShutdownTimeout);

		CleanupStack::PopAndDestroy(&launcher);		

		}	

	return ETrue;

	}

TBool CProcessor::DoStateRemoveFilesL()

	{

	if (iCurrent < ApplicationL().FilesToRemove().Count())

		{

		if (iUiState != ERemoveFiles)

			{

			iUiState = ERemoveFiles;

			// Signal to UI we are removing files

			CHandleCancellableInstallEvent* cmd = CHandleCancellableInstallEvent::NewLC(Plan().AppInfoL(), EEventRemovingFiles, 0, KNullDesC);

			UiHandler().ExecuteL(*cmd);

			CleanupStack::PopAndDestroy(cmd);

			}

		RemoveFileL(*ApplicationL().FilesToRemove()[iCurrent++]);					

		SwitchState(ECurrentState);

		return EFalse;		

		}

	else

		{

		iCurrent = 0;

		return ETrue;

		}

	}

TBool CProcessor::DoStateRemovePrivateDirectoriesL()

	{

	if (iCurrent < iSidsRemoved.Count())

		{

		// Remove the private directory if the sid is not being replaced

		// and it is not in ROM too (we could be removing an exe which

		// eclipsed one in ROM.)

		if(iSidsAdded.Find(iSidsRemoved[iCurrent]) == KErrNotFound)

			{

			CSidCache* sidCache;

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			sidCache = CSidCache::NewLC(iStsSession);

#else

			sidCache = CSidCache::NewLC(iIntegrityServices);

#endif

			if (!sidCache->IsCachedL(iSidsRemoved[iCurrent]))

				{

				RemovePrivateDirectoryL(iSidsRemoved[iCurrent]);

				}

			CleanupStack::PopAndDestroy(sidCache);

			}

		iCurrent++;

		SwitchState(ECurrentState);

		return EFalse;

		}

	else

		{

		iCurrent = 0;

		return ETrue;

		}

	}

TBool CProcessor::DoStateProcessFilesL()

	{

	return ETrue;

	}

// utility functions

void CProcessor::RunFileL(const TDesC& aFileName, const TDesC& aMimeType, Sis::TSISFileOperationOptions aFileOperationOption)

	{

	CSecurityPolicy* secPolicy = CSecurityPolicy::GetSecurityPolicyL();