/*

* Copyright (c) 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 "refnativeplugin.h"

#include "usiflog.h"

#include <usif/sif/sif.h>

#include <usif/sif/sifcommon.h>

#include <usif/usiferror.h>

#include <usif/sif/sifplugin.h>

#include <usif/scr/screntries.h>

#include <usif/scr/scr.h>

#include <swi/msisuihandlers.h>

#include <swi/asynclauncher.h>

#include <swi/sisinstallerrors.h>

#include <e32property.h>

#include <sacls.h>

#include "sisregistrywritablesession.h"

#include "sisregistrysession.h"

using namespace Usif;

static const TInt KRefNativePluginImpId = 0x10285BC4;

static const TImplementationProxy ImplementationTable[] = 

	{

	IMPLEMENTATION_PROXY_ENTRY(KRefNativePluginImpId, CRefNativePlugin::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}

CRefNativePlugin* CRefNativePlugin::NewL()

	{

	DEBUG_PRINTF(_L8("Constructing CRefNativePlugin"));

	CRefNativePlugin *self = new (ELeave) CRefNativePlugin();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CRefNativePlugin::ConstructL()

	{

	iImpl = CRefNativePluginActiveImpl::NewL();

	}

CRefNativePlugin::~CRefNativePlugin()

	{

	delete iImpl;

	}

void CRefNativePlugin::CancelOperation()

	{

	DEBUG_PRINTF(_L8("Reference native plugin - Cancel"));

	iImpl->Cancel();

	}

void CRefNativePlugin::GetComponentInfo(const TDesC& aFileName, const TSecurityContext& /*aSecurityContext*/,

										 CComponentInfo& aComponentInfo, TRequestStatus& aStatus)

	{

	iImpl->GetComponentInfo(aFileName, aComponentInfo, aStatus);

	}

void CRefNativePlugin::GetComponentInfo(RFile& aFileHandle, const TSecurityContext& /*aSecurityContext*/,

						 				CComponentInfo& aComponentInfo, TRequestStatus& aStatus)

	{

	iImpl->GetComponentInfo(aFileHandle, aComponentInfo, aStatus);

	}

void CRefNativePlugin::Install(const TDesC& aFileName, const TSecurityContext& aSecurityContext,

								const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,

								TRequestStatus& aStatus)

	{

	iImpl->Install(aFileName, aSecurityContext, aInputParams, aOutputParams, aStatus);

	}

void CRefNativePlugin::Install(RFile& aFileHandle, const TSecurityContext& aSecurityContext,

								const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,

								TRequestStatus& aStatus)

	{

	iImpl->Install(aFileHandle, aSecurityContext, aInputParams, aOutputParams, aStatus);

	}

void CRefNativePlugin::Uninstall(TComponentId aComponentId, const TSecurityContext& aSecurityContext,

								const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)

	{

	iImpl->Uninstall(aComponentId, aSecurityContext, aInputParams, aOutputParams, aStatus);

	}

void CRefNativePlugin::Activate(TComponentId aComponentId, const TSecurityContext& aSecurityContext, TRequestStatus& aStatus)

	{

	DEBUG_PRINTF(_L8("Reference native plugin - Activate"));

	iImpl->Activate(aComponentId, aSecurityContext, aStatus);

	}

void CRefNativePlugin::Deactivate(TComponentId aComponentId, const TSecurityContext& aSecurityContext, TRequestStatus& aStatus)

	{

	DEBUG_PRINTF(_L8("Reference native plugin - Deactivate"));

	iImpl->Deactivate(aComponentId, aSecurityContext, aStatus);

	}

//------------------CRefNativePluginActiveImpl---------------------

CRefNativePluginActiveImpl* CRefNativePluginActiveImpl::NewL()

	{

	DEBUG_PRINTF(_L8("Reference native plugin - Constructing CRefNativePluginActiveImpl"));

	CRefNativePluginActiveImpl *self = new (ELeave) CRefNativePluginActiveImpl();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(1, self);

	return self;

	}

void CRefNativePluginActiveImpl::ConstructL()

	{

	iInstallPrefs = Swi::CInstallPrefs::NewL();

	iAsyncLauncher = Swi::CAsyncLauncher::NewL();

	iComponentInfo = CComponentInfo::NewL();

	CActiveScheduler::Add(this);

	}

CRefNativePluginActiveImpl::~CRefNativePluginActiveImpl()

	{

	delete iAsyncLauncher;

	delete iInstallPrefs;

	delete iComponentInfo;

	}

const TInt KSystemWideErrorsBoundary = -100;

TInt ConvertToSifErrorCode(TInt aSwiErrorCode)

	{

	if (aSwiErrorCode > KSystemWideErrorsBoundary)

		return aSwiErrorCode; 

	switch (aSwiErrorCode)

		{

		case KErrSISFieldIdMissing:

		case KErrSISFieldLengthMissing:

		case KErrSISFieldLengthInvalid:

		case KErrSISStringInvalidLength:

		case KErrSISSignedControllerSISControllerMissing:

		case KErrSISControllerSISInfoMissing:

		case KErrSISInfoSISUidMissing:

		case KErrSISInfoSISNamesMissing:

		case KErrSISFieldBufferTooShort:

		case KErrSISStringArrayInvalidElement:

		case KErrSISInfoSISVendorNamesMissing:

		case KErrSISInfoSISVersionMissing:

		case KErrSISControllerSISSupportedLanguagesMissing:

		case KErrSISSupportedLanguagesInvalidElement:

		case KErrSISLanguageInvalidLength:

		case KErrSISContentsSISSignedControllerMissing:

		case KErrSISContentsSISDataMissing:

		case KErrSISDataSISFileDataUnitMissing:

		case KErrSISFileDataUnitTargetMissing:

		case KErrSISFileOptionsMissing:

		case KErrSISFileDataUnitDescriptorMissing:

		case KErrSISFileDataDescriptionMissing:

		case KErrSISContentsMissing:

		case KErrSISEmbeddedControllersMissing:

		case KErrSISEmbeddedDataUnitsMissing:

		case KErrSISControllerOptionsMissing:

		case KErrSISExpressionMissing:

		case KErrSISExpressionStringValueMissing:

		case KErrSISOptionsStringMissing:

		case KErrSISFileOptionsExpressionMissing:

		case KErrSISExpressionHeadValueMissing:

		case KErrSISEmbeddedSISOptionsMissing:

		case KErrSISInfoSISUpgradeRangeMissing:

		case KErrSISDependencyMissingUid:

		case KErrSISDependencyMissingVersion:

		case KErrSISDependencyMissingNames:

		case KErrSISControllerMissingPrerequisites:

		case KErrSISUpgradeRangeMissingVersion:

		case KErrSISUnexpectedFieldType:

		case KErrSISExpressionUnknownOperator:

		case KErrSISArrayReadError:

		case KErrSISArrayTypeMismatch:

		case KErrSISInvalidStringLength:

		case KErrSISCompressionNotSupported:

		case KErrSISTooDeeplyEmbedded:

		case KErrWrongHeaderFormat:

		case KErrExpressionToComplex:

		case KErrInvalidExpression:

		case KErrInvalidType:

			return KErrSifCorruptedPackage;

		case KErrBadUsage:

		case KErrInstallerLeave:

			return KErrSifUnknown;

		case KErrSISPrerequisitesMissingDependency:

			return KErrSifMissingDependencies;

		case KErrMissingBasePackage:

			return KErrSifMissingBasePackage;

		case KErrCapabilitiesMismatch:

		case KErrInvalidEclipsing:

		case KErrSecurityError:

		case KErrBadHash:

		case KErrDigestNotSupported:

		case KErrSignatureSchemeNotSupported:

		case KErrSISWouldOverWrite:

		case KErrSISInvalidTargetFile:

			return KErrPermissionDenied;

		case KErrPolicyFileCorrupt:

			return KErrSifBadInstallerConfiguration;

		case KErrInvalidUpgrade:

		case KErrLegacySisFile:

			return KErrSifPackageCannotBeInstalledOnThisDevice;

		case KErrSISNotEnoughSpaceToInstall:

			return KErrSifNotEnoughSpace;

		default:

			return KErrSifUnknown;

		}

	}

TBool CRefNativePluginActiveImpl::NeedUserCapabilityL()

	{

	// Silent install is not allowed when the package requires additional capabilities

	// than what it is signed for (Pakage may request for some capability that is not 

	// granted by the certificate used to sign it).

	for(TInt cap=0; cap<ECapability_Limit; ++cap)

		{

		if (iComponentInfo->RootNodeL().UserGrantableCaps().HasCapability(TCapability(cap)))

			{

			DEBUG_PRINTF2(_L("Package requires additional capability - %d"), cap);

			return ETrue;

			}

		}

	return EFalse;

	}

void CRefNativePluginActiveImpl::RunL()

	{

	if (iSilentInstall)

		{

		DEBUG_PRINTF(_L("Silent install  - CRefNativePluginActiveImpl::RunL"));

		ProcessSilentInstallL();

		}

	else

		{

		TInt res = iStatus.Int();

		DEBUG_PRINTF2(_L8("Reference native plugin - Operation finished with result %d"), res);

		// Output options

		if (iOutputParams != NULL)

			{

			iOutputParams->AddIntL(KSifOutParam_ExtendedErrCode, res);

			if (iInstallRequest && res == KErrNone)

				{

				TComponentId resultComponentId = 0;

				TRAPD(getLastIdErr, resultComponentId = GetLastInstalledComponentIdL());

				if (getLastIdErr == KErrNone)

					iOutputParams->AddIntL(KSifOutParam_ComponentId, resultComponentId);

				}

			}

		User::RequestComplete(iClientStatus, ConvertToSifErrorCode(res));

		iClientStatus = NULL;

		}

	}

void CRefNativePluginActiveImpl::ProcessSilentInstallL()

	{

	// We need to do this only once per installation request

	iSilentInstall = EFalse;

	iInstallRequest = ETrue;

	TBool isNotAuthenticated = (ENotAuthenticated == iComponentInfo->RootNodeL().Authenticity());

	TBool reqUserCap = NeedUserCapabilityL();

	if (isNotAuthenticated || reqUserCap)

		{

		if (isNotAuthenticated)

			{

				DEBUG_PRINTF(_L("Silent Install is not allowed on unsigned or self-signed packages"));

			}

		if (reqUserCap)

			{

				DEBUG_PRINTF(_L("Silent Install is not allowed when user capabilities are required"));

			}

		User::RequestComplete(iClientStatus, KErrNotSupported);

		iClientStatus = NULL;

		}		

	else

		{

		TInt err;

		if (iFileHandle)

			{

			TRAP(err, iAsyncLauncher->InstallL(*this, *iFileHandle, *iInstallPrefs, iStatus));

			}

		else

			{

			//DEBUG_PRINTF2(_L("!!!Silent install for %S"), iFileName);

			TRAP(err, iAsyncLauncher->InstallL(*this, iFileName, *iInstallPrefs, iStatus));

			}

		if (err != KErrNone)

			{

			User::RequestComplete(iClientStatus, err);

			iClientStatus = NULL;			

			}

		SetActive();

		}

	}

void CRefNativePluginActiveImpl::DoCancel()

	{

	if (iClientStatus)

		{

		iAsyncLauncher->CancelOperation();

		delete iAsyncLauncher;

		iAsyncLauncher = NULL;

		User::RequestComplete(iClientStatus, KErrCancel);

		iClientStatus = NULL;

		}

	}

void CRefNativePluginActiveImpl::CommonRequestPreamble(const TSecurityContext& aSecurityContext, const COpaqueNamedParams& aInputParams, 

				COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)

	{

	aStatus = KRequestPending;

	iClientStatus = &aStatus;

	iInputParams = &aInputParams;

	iOutputParams = &aOutputParams;

	TInt declineOperation = 0;

	TRAPD(err, aInputParams.GetIntByNameL(KDeclineOperationOptionName, declineOperation));

	if(err == KErrNone && declineOperation)

		{

		iDeclineOperation = ETrue;

		}

	// Check to see if we have the opaque input argument - InstallSilently 

	TInt silentInstall = 0;

	TRAP_IGNORE(aInputParams.GetIntByNameL(KSifInParam_InstallSilently, silentInstall));

	if (silentInstall)

		{

		iSilentInstall = ETrue;

		if (!aSecurityContext.HasCapability(ECapabilityTrustedUI))

			{

			User::RequestComplete(iClientStatus, KErrPermissionDenied);

			iClientStatus = NULL;			

			}

		}	

	}

TComponentId CRefNativePluginActiveImpl::GetLastInstalledComponentIdL()

  	{

  	ASSERT(iInstallRequest);

  	// Find the id of the last installed component and return it

  	TInt uid;

  	User::LeaveIfError(RProperty::Get(KUidSystemCategory, KUidSwiLatestInstallation, uid));

	Swi::RSisRegistrySession sisRegistrySession;

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

	CleanupClosePushL(sisRegistrySession);

	TUid tuid(TUid::Uid(uid));

	TComponentId componentId = sisRegistrySession.GetComponentIdForUidL(tuid);

	CleanupStack::PopAndDestroy(&sisRegistrySession);

	return componentId;

  	}

void CRefNativePluginActiveImpl::GetComponentInfo(const TDesC& aFileName, CComponentInfo& aComponentInfo, TRequestStatus& aStatus)

	{

	DEBUG_PRINTF2(_L("Reference native plugin - retrieving component info for %S"), &aFileName);

	aStatus = KRequestPending;

	iClientStatus = &aStatus;

	TRAPD(err, iAsyncLauncher->GetComponentInfoL(*this, aFileName, *iInstallPrefs, aComponentInfo, iStatus));

	if (err != KErrNone)

		{

		TRequestStatus *statusPtr(&aStatus);

		User::RequestComplete(statusPtr, err);

		return;

		}

	SetActive();

	}

void CRefNativePluginActiveImpl::GetComponentInfo(RFile& aFileHandle, CComponentInfo& aComponentInfo, TRequestStatus& aStatus)

	{

	DEBUG_PRINTF(_L8("Reference native plugin - getting component info by file handle"));

	aStatus = KRequestPending;

	iClientStatus = &aStatus;	

	TRAPD(err, iAsyncLauncher->GetComponentInfoL(*this, aFileHandle, *iInstallPrefs, aComponentInfo, iStatus));

	if (err != KErrNone)

		{

		TRequestStatus *statusPtr(&aStatus);

		User::RequestComplete(statusPtr, err);

		return;

		}

	SetActive();

	}	

void CRefNativePluginActiveImpl::Install(const TDesC& aFileName, const TSecurityContext& aSecurityContext,

											const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,

											TRequestStatus& aStatus)

	{

	DEBUG_PRINTF2(_L("Reference native plugin - install for %S"), &aFileName);

	CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);

	TInt err;

	if (iSilentInstall)

		{

		// Silent install does a few addtional checks on the package to see if is 

		// signed and had the required capabilities. So we need to the get the 

		// package component information with out installing it.

		DEBUG_PRINTF2(_L("Silent install  - Get the ComponentInfo for %S"), &aFileName);

		iFileName = aFileName;

		TRAP(err, iAsyncLauncher->GetComponentInfoL(*this, aFileName, *iInstallPrefs, *iComponentInfo, iStatus));

		}

	else

		{

		// Proceed with the normal installation.

		TRAP(err, iAsyncLauncher->InstallL(*this, aFileName, *iInstallPrefs, iStatus));

		iInstallRequest = ETrue;

		}

	if (err != KErrNone)

		{

		TRequestStatus *statusPtr(&aStatus);

		User::RequestComplete(statusPtr, err);

		return;

		}

	SetActive();

	}

void CRefNativePluginActiveImpl::Install(RFile& aFileHandle, const TSecurityContext& aSecurityContext,

											const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,

											TRequestStatus& aStatus)

	{

	DEBUG_PRINTF(_L8("Reference native plugin - install by file handle"));

	CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);

	TInt err;

	if (iSilentInstall)

		{

		// Silent install does a few addtional checks on the package to see if is 

		// signed and had the required capabilities. So we need to the get the 

		// package component information with out installing it.

		iFileHandle = &aFileHandle;

		TRAP(err, iAsyncLauncher->GetComponentInfoL(*this, aFileHandle, *iInstallPrefs, *iComponentInfo, iStatus));

		}

	else

		{

		// Proceed with the normal installation.

		TRAP(err, iAsyncLauncher->InstallL(*this, aFileHandle, *iInstallPrefs, iStatus));

		iInstallRequest = ETrue;

		}

	if (err != KErrNone)

		{

		TRequestStatus *statusPtr(&aStatus);

		User::RequestComplete(statusPtr, err);

		return;

		}

	SetActive();

	}

void CRefNativePluginActiveImpl::Uninstall(TComponentId aComponentId, const TSecurityContext& aSecurityContext,

		  const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)

	{

	TRAPD(err, UninstallL(aComponentId, aSecurityContext, aInputParams, aOutputParams, aStatus));

	if (err != KErrNone)

		{

		TRequestStatus *statusPtr(&aStatus);

		User::RequestComplete(statusPtr, err);

		return;

		}

	SetActive();

	}

void CRefNativePluginActiveImpl::UninstallL(TComponentId aComponentId, const TSecurityContext& aSecurityContext,

		  const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)

	{

	DEBUG_PRINTF(_L8("Reference native plugin - uninstall"));

	CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);

    // Get UID for given component id