/*

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

* CSisRegistrySubSession class implementation

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#include "sisregistryserversubsession.h"

#include <swi/sistruststatus.h>

#include <scs/ipcstream.h>

#include "swi/siscontroller.h"

#include "sisregistryserversession.h"

#include "sisregistryfiledescription.h"

#include "scrhelperutil.h"

#include "scrdbconstants.h"

#include "log.h"

#include "cleanuputils.h"

#include "sisregistryutil.h"

#include "dessisdataprovider.h"

#include "sisrevocationmanager.h"

#include "sisregistryproperty.h"

#include "controllerinfo.h"

#include "sisinfo.h"

#include "filesisdataprovider.h"

#include "sisregistryserverconst.h"

#include "siscontrollerverifier.h"

#include "sisregistryobject.h"

#include "arrayutils.h"

#include "sisregistrydependency.h"

#include "siscertificatechain.h"

using namespace Swi;

using namespace Usif;

CSisRegistrySubSession::~CSisRegistrySubSession()

	{

	ResetFileAPIData();

	delete iRevocationManager;

	delete iSisControllerVerifier;

	delete iComponentEntry;

	iControllerArray.ResetAndDestroy();

	}

CSisRegistrySubSession::CSisRegistrySubSession(CSisRegistrySession& aSession,

		Usif::TComponentId& aCompId, TUid aCompUid):

		iSession(aSession),

		iComponentId(aCompId),

		iCompUid(aCompUid)

	{

	}

void CSisRegistrySubSession::ResetFileAPIData()

	{

	iNumFilesSent = 0;

	iWildcardFileCount = 0;

	iRegularFileCount = 0;

	delete iSavedFileDesc;

	iSavedFileDesc = NULL;

	if (iScrFileList != NULL)

		{

		iScrFileList->Close();

		delete iScrFileList;

		iScrFileList = NULL;

		}

	}

void CSisRegistrySubSession::RequestVersionRegistryEntryL(const RMessage2& aMessage)

	{

	// the identity of the current entry/subsession is passed in IPC 3!

	// Lookup the component ID for the subsession handle

	CComponentEntry* component = ComponentL();

	const TDesC& verString = component->Version();

	TVersion version;

	StringToVersionL(verString, version);

	DEBUG_PRINTF5(_L8("Sis Registry Server - Version for subsession ID %d is %d.%d.%d"),

		aMessage.Int3(), version.iMajor, version.iMinor, version.iBuild);

	TPckg<TVersion> packageVersion(version);

	aMessage.WriteL(EIpcArgument0, packageVersion);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::RequestPackageNameRegistryEntryL(const RMessage2& aMessage)

	{

	CComponentEntry* component = ComponentL();

	aMessage.WriteL(EIpcArgument0, component->Name());

	aMessage.Complete(KErrNone); 

	}

void CSisRegistrySubSession::RequestLocalizedVendorNameRegistryEntryL(const RMessage2& aMessage)

	{

	// Get the relevant component entry usnig the given Uid - IPC arg 3.

	CComponentEntry* component = ComponentL();

	HBufC* localizedVendorName = component->Vendor().AllocLC();

	DEBUG_PRINTF3(_L("Sis Registry Server - Vendor for subsession ID %d is '%S'"), 

		aMessage.Int3(), localizedVendorName);

	// Write the component name back in to IPC arg 0.

	aMessage.WriteL(EIpcArgument0, *localizedVendorName);

	CleanupStack::PopAndDestroy(localizedVendorName);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::RequestUniqueVendorNameRegistryEntryL(const RMessage2& aMessage)

	{

	// Get the Unique vendor name

	HBufC* uniqueVendorName = GetStrPropertyValueL(iSession.ScrSession(), iComponentId, KCompUniqueVendorName);

	DEBUG_PRINTF3(_L("Sis Registry Server - Unique Vendor for subsession ID %d is '%S'"),

		aMessage.Int3(), uniqueVendorName);

	CleanupStack::PushL(uniqueVendorName);

	aMessage.WriteL(EIpcArgument0, *uniqueVendorName);

	CleanupStack::PopAndDestroy(uniqueVendorName);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::RequestEmbeddedPackageRegistryEntryL(const RMessage2& aMessage)

	{

	RPointerArray<CSisRegistryPackage> embeddedPackages;

	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(embeddedPackages);

	ScrHelperUtil::InternalizeEmbeddedPackageArrayL(iSession.ScrSession(), iComponentId, embeddedPackages);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package for subsession %d has %d embedded packages."),

		aMessage.Int3(), embeddedPackages.Count());

	SisRegistryUtil::SendDataPointerArrayL(aMessage, embeddedPackages, EIpcArgument0);

	CleanupStack::PopAndDestroy(&embeddedPackages);

	}

void CSisRegistrySubSession::RequestHashRegistryEntryL(const RMessage2& aMessage)

	{

	// get file name

	TUint srcLen = aMessage.GetDesLengthL(EIpcArgument0);

	HBufC* fileName = HBufC::NewLC(srcLen);

	TPtr namePtr1 = fileName->Des();

	aMessage.ReadL(EIpcArgument0, namePtr1, 0);

	DEBUG_PRINTF3(_L("Sis Registry Server - Subsession ID %d requested hash for file '%S'."),

		aMessage.Int3(), fileName);

	CHashContainer* hashContainer = NULL;

	ScrHelperUtil::ReadFromScrL(iSession.ScrSession(), iComponentId, hashContainer, *fileName);

	CleanupStack::PushL(hashContainer);

	SisRegistryUtil::SendDataL(aMessage, *hashContainer, EIpcArgument1);

    CleanupStack::PopAndDestroy(2, fileName); // hashContainer and fileName.

	}	

void CSisRegistrySubSession::RequestUidRegistryEntryL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF3(_L8("Sis Registry Server - Subsession ID %d has Package UID 0x%08x."),

		aMessage.Int3(), iCompUid.iUid);

	TPckg<TUid> packageUid(iCompUid);

	aMessage.WriteL(EIpcArgument0, packageUid);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::RequestLanguageRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the language component property 

	TLanguage language = static_cast<TLanguage> (GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompLanguage, EFalse, ELangEnglish));

	DEBUG_PRINTF3(_L8("Sis Registry Server - Subsession ID %d is localised in language %d."),

		aMessage.Int3(), language);

	TPckgC<TLanguage> packageLanguage(language);

	aMessage.WriteL(EIpcArgument0, packageLanguage);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::UidPresentRegistryEntryL(const RMessage2& aMessage)

	{

	TBool isPresent = IsCompletelyPresentL();

	// Update the CompPresence property based on the component presence

	iSession.ScrSession().SetIsComponentPresentL(iComponentId, isPresent);

	TPckgC<TBool> package(isPresent);

	DEBUG_CODE_SECTION(

		if (isPresent)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is completely present."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not completely present."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);		

	}

void CSisRegistrySubSession::SignedRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property 

	TBool isSigned = static_cast<TBool>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompIsSigned, EFalse, KDefaultIsSigned));

	TPckgC<TBool> package(isSigned);

	DEBUG_CODE_SECTION(

		if (isSigned)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is signed."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not signed."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);

	}

void CSisRegistrySubSession::SignedBySuCertRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property

	TBool isSignedBySuCert = GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompSignedBySuCert, EFalse, KDefaultIsSignedBySuCert);

	TPckgC<TBool> package(isSignedBySuCert);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);			

	}

void CSisRegistrySubSession::RegistryEntryTrustL(const RMessage2& aMessage)

	{

	TSisPackageTrust trust = static_cast<TSisPackageTrust>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompTrust, EFalse, KDefaultTrustValue));

	TPckgC<TSisPackageTrust> package(trust);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package trust status for subsession ID %d is %d."),

		aMessage.Int3(), trust);

	aMessage.WriteL(0, package);	

	aMessage.Complete(KErrNone);

	}

void CSisRegistrySubSession::TrustTimeStampL(const RMessage2& aMessage)

	{

	// Retrieve the component property 

	TTime time = TTime(GetInt64PropertyValueL(iSession.ScrSession(), iComponentId, KCompTrustTimeStamp, ETrue));

	TPckgC<TTime> package(time);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Last package trust update time for subsession %d was %Ld"),

		aMessage.Int3(), time.Int64());

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);			

	}

void CSisRegistrySubSession::TrustStatusEntryL(const RMessage2& aMessage)

    {

	// Retrieve the trust status from SCR

	TSisTrustStatus status;

	ScrHelperUtil::ReadFromScrL(iSession.ScrSession(), iComponentId, status);

	DEBUG_PRINTF4(_L8("Sis Registry Server - Package for subsession ID %d has Validation Status: %d, Revocation Status: %d."),

		aMessage.Int3(), status.ValidationStatus(), status.RevocationStatus());

	SisRegistryUtil::SendDataL(aMessage,status,EIpcArgument0);

    }

void CSisRegistrySubSession::RevocationCheckEntryL(const RMessage2& aMessage)

    {

	// Get the OCSP Uri

    TUint uriLen = aMessage.GetDesLengthL(EIpcArgument0);

    HBufC8* ocspUri = HBufC8::NewLC(uriLen);

    TPtr8 ocspPtr(ocspUri->Des());

    aMessage.ReadL(EIpcArgument0, ocspPtr);

    DEBUG_PRINTF3(_L8("Sis Registry Server - Client has requested a revocation check for component id %d with URI '%S'."),

    		iComponentId, ocspUri);

    // Get the controllers for the component 

    // Note that just the first controller is used here

    RPointerArray<HBufC8> controllers;

	CleanupResetAndDestroyPushL(controllers);

	GenerateControllersArrayL(iComponentId, controllers);

	if (controllers.Count() > 0)

		{

		// Get the trust status

		TSisTrustStatus trustStatus;

		ScrHelperUtil::ReadFromScrL(iSession.ScrSession(), iComponentId, trustStatus);

		// Get the install chain indicies

		RArray<TInt> chainIndexArray;

		CleanupClosePushL(chainIndexArray);

		ScrHelperUtil::InternalizeChainIndexArrayL(iSession.ScrSession(), iComponentId, chainIndexArray);

		CDesDataProvider* dataProvider = CDesDataProvider::NewLC(*controllers[0]);

	    Sis::CController* firstController = Sis::CController::NewLC(*dataProvider, Sis::EAssumeType);

	    if (iRevocationManager == NULL)

	    	{

	    	iRevocationManager = CSisRevocationManager::NewL(iSession);

	    	}

	    iRevocationManager->RevocationStatusRequestL(controllers[0], firstController,

	    		trustStatus, chainIndexArray, ocspPtr, aMessage);

	    controllers.Remove(0); // remove the buffer passed to the revocation manager

	    CleanupStack::Pop(firstController); // belongs to revocation manager now

	    CleanupStack::PopAndDestroy(2, &chainIndexArray);	//chainIndexArray and dataProvider.

		}

    CleanupStack::PopAndDestroy(2, ocspUri);	//controllers and ocspUri.

	}

void CSisRegistrySubSession::CancelRevocationCheckEntryL(const RMessage2& aMessage)

    {

    DEBUG_PRINTF(_L8("Sis Registry Server - Cancelling revocation check."));

	if (iRevocationManager != NULL)   	

		{

		iRevocationManager->Cancel();

		}

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::InRomRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property (InRom)

	// Determine if the type is preinstalled

	TBool inRom = static_cast<TBool>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompInRom, EFalse, KDefaultIsInRom));

	TPckgC<TBool> package(inRom);

	DEBUG_CODE_SECTION(

		if (inRom)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is in ROM."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not in ROM."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);		

	}

void CSisRegistrySubSession::PreInstalledRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property (install type)

	// Determine if the type is preinstalled

	Sis::TInstallType instType = static_cast<Sis::TInstallType>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompInstallType, EFalse, KDefaultInstallType));

	TBool preInstalled = CSisRegistryObject::IsPreinstalled(instType);

	TPckgC<TBool> package(preInstalled);

	DEBUG_CODE_SECTION(

		if (preInstalled)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is preinstalled."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not preinstalled."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);

	}

void CSisRegistrySubSession::DeletablePreInstalledRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property

	TBool deletablePreInstalled = static_cast<TBool>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompDeletablePreinstalled, EFalse, KDefaultIsDeletablePreInstalled));

	TPckgC<TBool> package(deletablePreInstalled);

	DEBUG_CODE_SECTION(

		if (deletablePreInstalled)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is a 'deleteable' presinstalled package."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not a 'deleteable' presinstalled package."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);

	}

void CSisRegistrySubSession::AugmentationRegistryEntryL(const RMessage2& aMessage)

	{

	// Retrieve the component property (install type)

	Sis::TInstallType instType = static_cast<Sis::TInstallType>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompInstallType, EFalse, KDefaultInstallType));

	// Determine if the type is an augmentation

	TBool aug = (instType == Sis::EInstAugmentation);

	TPckgC<TBool> package(aug);

	DEBUG_CODE_SECTION(

		if (aug)

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is an augmentation."),

				aMessage.Int3());

			}

		else

			{

			DEBUG_PRINTF2(_L8("Sis Registry Server - Package for subsession ID %d is not an augmentation."),

				aMessage.Int3());

			}

	);

	aMessage.WriteL(EIpcArgument0, package);	

	aMessage.Complete(KErrNone);

	}

// Request the user selected drive

void CSisRegistrySubSession::RequestSelectedDriveRegistryEntryL(const RMessage2& aMessage)	

	{

	// Retrieve the selected drive

	TChar selectedDrive = static_cast<TChar>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompSelectedDrive, EFalse));

	TInt drive = selectedDrive;

	TPckg<TInt> packageDrive(drive);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package for subsession ID %d has selected drive %d"),	

		aMessage.Int3(), drive);

	aMessage.WriteL(EIpcArgument0, packageDrive);

	aMessage.Complete(KErrNone);

	}

// Request the drive bitmask where the files are installed

void CSisRegistrySubSession::RequestInstalledDrivesRegistryEntryL(const RMessage2& aMessage)	

	{

	// Get the list of installed files

	TUint instDrives = InstalledDrivesL();

	TPckg<TUint> installedfilesDrive(instDrives);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package for subsession ID %d has Installed drives bitmask %d"),	

		aMessage.Int3(), instDrives);

	aMessage.WriteL(EIpcArgument0, installedfilesDrive);

	aMessage.Complete(KErrNone);

	}

// Request the install type

void CSisRegistrySubSession::RequestInstallTypeRegistryEntryL(const RMessage2& aMessage)	

	{

	// Retrieve the component property (install type)

	Sis::TInstallType installType = static_cast<Sis::TInstallType>(GetIntPropertyValueL(iSession.ScrSession(), iComponentId, KCompInstallType, EFalse, KDefaultInstallType));

	TPckgC<Sis::TInstallType> packageInstallType(installType);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package for subsession ID %d is of type %d."),

		aMessage.Int3(), installType);

	aMessage.WriteL(EIpcArgument0, packageInstallType);

	aMessage.Complete(KErrNone);	

	}	

// Request the value of property, based on specific property key.

// if not found returns to client KErrNotFound.

void CSisRegistrySubSession::RequestPropertyRegistryEntryL(const RMessage2& aMessage)

	{

	TInt value = 0;	

	TBool propertyFound = EFalse;

	RPointerArray<CSisRegistryProperty> propertiesArray;

	TInt givenPropertyKey = aMessage.Int0();

	// Get the component properties from SCR.

	ScrHelperUtil::InternalizePropertiesArrayL(iSession.ScrSession(), iComponentId, propertiesArray);

	CleanupResetAndDestroyPushL(propertiesArray);

	// Iterate through the properties array and get the value for given property key.

	for (TInt property = 0; property < propertiesArray.Count(); property++)

		{

		if(propertiesArray[property]->Key() == givenPropertyKey)

			{				

			value = propertiesArray[property]->Value();

			propertyFound = ETrue;

			break;

			}

		}

	CleanupStack::PopAndDestroy(&propertiesArray);

	if(!propertyFound)

		{

		value = KErrNotFound;

		}

	DEBUG_PRINTF4(_L8("Sis Registry Server - Value of property %d for subsession ID %d is %d"),

		aMessage.Int0(), aMessage.Int3(), value);

	TPckgC<TInt> packageValue(value);

	aMessage.WriteL(EIpcArgument1, packageValue);

	aMessage.Complete(KErrNone);	

	}

void CSisRegistrySubSession::RequestSizeRegistryEntryL(const RMessage2& aMessage)

	{

	TInt64 size = 0;

	// Lookup the component entry for the subsession handle

	CComponentEntry* componentEntry = ComponentL();

	size = componentEntry->ComponentSize();

	TPckg<TInt64> packageSize(size);

	DEBUG_PRINTF3(_L8("Sis Registry Server - Package for subsession ID %d takes up %Ld bytes."),	

		aMessage.Int3(), size);