/*

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

* CSisRegistrySession class implementation

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#include <s32mem.h>

#include <f32file.h>

#include <s32file.h>

#include "log.h"

#include <swi/sistruststatus.h>

#include <scs/ipcstream.h>

#include "swi/siscontroller.h"

#include "sisregistryserversession.h"

#include "sisregistryserver.h"

#include "sisregistrypackage.h"

#include "sisregistryserverconst.h"

#include "sisregistryobject.h"

#include "sisregistrycache.h"

#include "sisregistryfiledescription.h"

#include "sisregistrydependency.h"

#include "controllerinfo.h"

#include "arrayutils.h"

#include "integrityservices.h"

#include "hashcontainer.h"

#include "filesisdataprovider.h"

#include "dessisdataprovider.h"

#include "sisrevocationmanager.h"

#include "siscontroller.h"

#include "siscertificatechain.h"

#include "cleanuputils.h"

#include "sisregistryutil.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "securitymanager.h"

#include "siscontrollerverifier.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "swi/sisregistrylogversion.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include <swi/sisregistrylog.h>

#include "sisinstallblock.h"

#include "sisregistryfiledescription.h"

#include "sisregistrywritablesession.h"

using namespace Swi;

template<class T> 

void SendDataL(const RMessage2& aMessage, const T& aProvider, TInt aIpcIndx);

template<class T> 

void SendDataArrayL(const RMessage2& aMessage, const RArray<T> aProvider, TInt aIpcIndx);

template<class T> 

void SendDataPointerArrayL(const RMessage2& aMessage, const RPointerArray<T> aProvider, TInt aIpcIndx);

/**

 * Function to panic an offending client

 * @internalTechnology

 * @released

 */

 void CSisRegistrySession::PanicClient(const RMessagePtr2& aMessage, Swi::TSisRegistryPanic aPanic)

	{

	aMessage.Panic(KSisRegistryShortName, aPanic);

	}

void CSisRegistrySession::CreateL()

//

// 2nd phase construct for sessions - called by the CServer framework

//

	{

	Server().AddSession();

	iRevocationManager =

      CSisRevocationManager::NewL(*this);

	// Just obtain a handle reference to use 

	iFs = Server().Cache().RFsHandle();

	}

CSisRegistrySession::~CSisRegistrySession()

	{

	Server().DropSession();

	delete iRevocationManager;

	delete iSisControllerVerifier;

	iControllerArray.ResetAndDestroy();

	}

void CSisRegistrySession::ServiceL(const RMessage2& aMessage)

//

// Handle a client request.

// Leaving is handled by CSisRegistry::ServiceError() which reports

// the error code to the client

//

	{

	DEBUG_PRINTF2(_L8("SIS Registry Server - ServiceL (function %d)"), aMessage.Function());

	switch (aMessage.Function())

		{	

	// general registry	

	case EInstalledUids:

		RequestInstalledUidsL(aMessage);

		break;

	case EInstalledPackages:

		RequestInstalledPackagesL(aMessage);

		break;

	case EUidInstalled:

	    UidInstalledL(aMessage);

	    break;

	case EControllerInstalled:

	    ControllerInstalledL(aMessage);

	    break;

	case ESidToPackage:

		RequestSidToPackageL(aMessage);

	    break;

	case ESidToFileName:

		RequestSidToFileNameL(aMessage);

		break;

	case EModifiable:

		RequestModifiableL(aMessage);

		break;

	case EHash:

		RequestHashL(aMessage);

		break;		

	// general entry 	

	case EOpenRegistryUid:

		OpenRegistryUidEntryL(aMessage);

		break;

	case EOpenRegistryPackage:

		OpenRegistryPackageEntryL(aMessage);

		break;

	case EOpenRegistryNames:

		OpenRegistryNamesEntryL(aMessage);

		break;

	case ECloseRegistryEntry:

		CloseRegistryEntryL(aMessage);

		break;

	case EVersion:

	    RequestVersionRegistryEntryL(aMessage);

		break;

	case EPackageName:

		RequestPackageNameRegistryEntryL(aMessage);

		break;

	case EUniqueVendorName:

		RequestUniqueVendorNameRegistryEntryL(aMessage);

		break;	

	case ELocalizedVendorName:

		RequestLocalizedVendorNameRegistryEntryL(aMessage);

		break;

	case EUid:

		RequestUidRegistryEntryL(aMessage);

		break;

	case ESids:

		RequestSidsRegistryEntryL(aMessage);

		break;

	case ELanguage:

		RequestLanguageRegistryEntryL(aMessage);

		break;

	case EUidPresent:

		UidPresentRegistryEntryL(aMessage);

		break;

	case ESigned:

	    SignedRegistryEntryL(aMessage);

		break;

	case EGetTrust:

		RegistryEntryTrustL(aMessage);

		break;	

	case ETrustTimeStamp:

		TrustTimeStampL(aMessage);

		break;	

	case ETrustStatus:

		TrustStatusEntryL(aMessage);

		break; 

	case EIsSidPresent:

		IsSidPresentL(aMessage);

		break;

	case EShutdownAllApps:

		ShutdownAllAppsL(aMessage);

		break;

	case ERevocationStatus:

		RevocationCheckEntryL(aMessage);

		break;	

	case ECancelRevocationStatus:

		CancelRevocationCheckEntryL(aMessage);

		break;			

	case EInRom:

		InRomRegistryEntryL(aMessage);

		break;

	case EAugmentation:

		AugmentationRegistryEntryL(aMessage);

		break;

	case EControllers:

		RequestControllersL(aMessage);

		break;

	case EProperty:

		RequestPropertyRegistryEntryL(aMessage);

		break;

	case EFiles:

		RequestFileNamesRegistryEntryL(aMessage);

		break;

	case EHashEntry:

		RequestHashRegistryEntryL(aMessage);

		break;	

	case EFileDescriptions:

		RequestFileDescriptionsRegistryEntryL(aMessage);

		break;	

	case ESelectedDrive:

		RequestSelectedDriveRegistryEntryL(aMessage);

		break;

	case EInstalledDrives:

		RequestInstalledDrivesRegistryEntryL(aMessage);

		break;			

	case EPreInstalled:

		PreInstalledRegistryEntryL(aMessage);

		break;

	case EInstallType:

		RequestInstallTypeRegistryEntryL(aMessage);

		break;

	case ECertificateChains:

		RequestCertificateChainsRegistryEntryL(aMessage);

		break;

	case EEmbeddedPackages:

	    RequestEmbeddedPackageRegistryEntryL(aMessage);

	    break; 

	case EEmbeddingPackages:

		RequestEmbeddingPackagesRegistryEntryL(aMessage);

	    break; 

	case EPackageAugmentations:

	    RequestPackageAugmentationsRegistryEntryL(aMessage);

	    break;

	case EPackageAugmentationsNumber:

		RequestPackageAugmentationsNumberL(aMessage);

		break;

	case ESize:

		RequestSizeRegistryEntryL(aMessage);

	    break;

	case EPackage:

		RequestPackageRegistryEntryL(aMessage);

	    break;

	case EAddEntry:

		RegisterEntryL(aMessage, ETrue);

		break;

	case EUpdateEntry:

		RegisterEntryL(aMessage, EFalse);

		break;

	case EDeleteEntry:

		DeleteEntryL(aMessage);

		break;

	case EDependencies:

		RequestDependenciesRegistryEntryL(aMessage);

		break; 

	case EDependentPackages:

		RequestDependentPackagesRegistryEntryL(aMessage);

		break;

	case EGetEntry:

		RequestRegistryEntryL(aMessage);

		break;

	case EAddDrive:

		AddDriveL(aMessage);

		break;

	case ERemoveDrive:

		RemoveDriveL(aMessage);

		break;

 	case ERegenerateCache:

 		RegenerateCacheL(aMessage);	

 		break;

	case EDeletablePreInstalled:

		DeletablePreInstalledRegistryEntryL(aMessage);

		break;

	case EVerifyController:

		{

		VerifyControllerL(aMessage);

		break;

		}

	case ERemoveWithLastDependent:

		{

		RemoveWithLastDependentL(aMessage);

		break;

		} 

	case ESetRemoveWithLastDependent:

		{

		SetRemoveWithLastDependentL(aMessage);

		break;

		} 

	case EloggingFile:

 		LoggingFileInfoL(aMessage);

 		break;

	case ENonRemovable:

		IsRemovableL(aMessage);

		break;

	case ERemovablePackages:

		RequestRemovablePackagesL(aMessage);

		break;

	case EPackageExistsInRom:

		PackageExistsInRomL(aMessage);

		break;	

	case EInitRecovery:

		RecoverL(aMessage);

		break;

	case EStubFileEntries:

		RequestStubFileEntriesL(aMessage);

		break;

	case ESignedBySuCert:

 		SignedBySuCertRegistryEntryL(aMessage);

 		break;

	case EGetMatchingSupportedLanguages:

		RequestMatchingSupportedLanguagesL(aMessage);

	    break;	

	default:

		PanicClient(aMessage,EPanicIllegalFunction);

		break;

		}

	}

void CSisRegistrySession::VerifyControllerL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF(_L("CSisRegistry::VerifyControllerSignature"));

	CSisRegistryObject& object = Server().Cache().EntryObjectL(aMessage.Int3());

	RPointerArray<HBufC8> controllers;

	iControllerArray.ResetAndDestroy();

	Server().Cache().GenerateControllersArrayL(object, iControllerArray);

	delete iSisControllerVerifier;

	iSisControllerVerifier = CSisControllerVerifier::NewL(aMessage);

	iSisControllerVerifier->VerifyControllerL(iControllerArray); 

	}

void CSisRegistrySession::RequestInstalledUidsL(const RMessage2& aMessage)

	{

	RArray<TUid> uids;

	CleanupClosePushL(uids);

	Server().Cache().UidListL(uids);

	SendDataArrayL(aMessage, uids, EIpcArgument0);

	CleanupStack::PopAndDestroy(&uids);

	}

void CSisRegistrySession::RequestInstalledPackagesL(const RMessage2& aMessage)

	{

    RPointerArray<CSisRegistryPackage> packages; 

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

    Server().Cache().PackageListL(packages); 

    SendDataPointerArrayL(aMessage, packages, EIpcArgument0);

    CleanupStack::PopAndDestroy(&packages);

	}

void CSisRegistrySession::UidInstalledL(const RMessage2& aMessage)

	{

	TBool isRegistered;

	TUid uid; 

	TPckg<TUid> packageUid(uid);

	aMessage.ReadL(EIpcArgument0, packageUid);

	// check whether is registered

	isRegistered = Server().Cache().IsRegistered(uid); 

	DEBUG_CODE_SECTION(

		if (isRegistered)

			{

			DEBUG_PRINTF2(_L8("SIS Registry Server - UID 0x%08x is registered."), uid);

			}

		else

			{

			DEBUG_PRINTF2(_L8("SIS Registry Server - UID 0x%08x is not registered."), uid);

			}

	);

	// return the data back

    TPckgC<TBool> packageBool(isRegistered);

	aMessage.WriteL(EIpcArgument1, packageBool);

	aMessage.Complete(KErrNone);

	}

void CSisRegistrySession::ControllerInstalledL(const RMessage2& aMessage)

	{

	TBool installed;

	TInt srcLen = aMessage.GetDesLengthL(EIpcArgument0);

	HBufC8* buffer = HBufC8::NewLC(srcLen);

	TPtr8 dest = buffer->Des();

	// read data in the buffer

	aMessage.ReadL(EIpcArgument0, dest, 0);

	// lets store all in a stream

	RDesReadStream stream(dest);

    CleanupClosePushL(stream);

	// now create the hash object to look for

	CHashContainer* hash = CHashContainer::NewLC(stream);

  	// is the entry present already?

	installed = Server().Cache().IsRegistered(*hash);

	DEBUG_CODE_SECTION(

		if (installed)

			{

			DEBUG_PRINTF(_L8("SIS Registry Server - Controller is installed."));

			}

		else

			{

			DEBUG_PRINTF(_L8("SIS Registry Server - Controller is not installed."));

			}

	);

	// return the data back

	TPckgC<TBool> isInstalled(installed);

	aMessage.WriteL(EIpcArgument1, isInstalled);

	aMessage.Complete(KErrNone);

	// reclaim memory back

	CleanupStack::PopAndDestroy(3, buffer); // buffer, stream, hash  

	}

void CSisRegistrySession::RegisterEntryL(const RMessage2& aMessage, TBool aNewEntry)

	// register/update new/existing registry entry 

	{

	// get the registry object from client space

	// get the size of the descriptor in client space

	// and allocate sufficient buffer 

	TInt srcLen = aMessage.GetDesLengthL(EIpcArgument0);

	HBufC8* buffer = HBufC8::NewLC(srcLen);

	TPtr8 dest = buffer->Des();

	// read data in the buffer

	aMessage.ReadL(EIpcArgument0, dest, 0);

	// lets store all in a stream

	RDesReadStream stream(dest);

    CleanupClosePushL(stream);   

	// now create a registry entry from the stream

	CSisRegistryObject* object = CSisRegistryObject::NewL(stream);	

	CleanupStack::PopAndDestroy(2, buffer); // buffer, stream 

	CleanupStack::PushL(object);

	buffer = NULL;

	DEBUG_CODE_SECTION(

		if (aNewEntry)

			{

			DEBUG_PRINTF4(_L("Sis Registry Server - registering entry for object with UID: 0x%08x, Name: %S, Vendor: %S."),

				object->Uid().iUid, &(object->Name()), &(object->Vendor()));

			}

		else

			{

			DEBUG_PRINTF4(_L("Sis Registry Server - updating entry for object with UID: 0x%08x, Name: %S, Vendor: %S."),

				object->Uid().iUid, &(object->Name()), &(object->Vendor()));

			}

	);

	TBool isRegistered;

	if(aNewEntry)

		{

		isRegistered = Server().Cache().IsRegistered(*object);

		}

	else

		{

		// We're upgrading an existing entry, if it's not an augmentation upgrade,

		// check for the existance of the base package. Otherwise, check by package

		if (object->InstallType() != Sis::EInstAugmentation)

			{

			isRegistered = Server().Cache().IsRegistered(object->Uid());

			}

		else

			{

			isRegistered = Server().Cache().IsRegistered(*object);

			}

		}

  	// the entry should not be existing - new or

  	// the entry should be existing - upgrade

	if (isRegistered == (!aNewEntry))	

		{			 

		// get this transaction ID from client space, using packaging

		TInt64 transactionID;

		TPckg<TInt64> pkgTransactionID(transactionID);

		aMessage.ReadL(EIpcArgument1, pkgTransactionID);

		CIntegrityServices* integrityService = CIntegrityServices::NewLC(transactionID, KIntegrityServicesPath);

		if (!aNewEntry)

			{

			CSisRegistryObject* existingObject = NULL;

			existingObject = Server().Cache().ObjectL(object->Uid(), object->Index());

			CleanupStack::PushL(existingObject);

			// DEF085506 fix. remove control files (Previous SA and any of PUs) also while SA upgrading.

			if (object->InstallType() == Sis::EInstInstallation)

				{

				Server().Cache().RemoveRegistryEntryL(*existingObject, *integrityService);	

				}

			else // PartialUpgarde case remove only registry file.

				{

				// Essentially, this is an uninstall except we leave the controller file intact.

				Server().Cache().RemoveRegistryFilesL(*existingObject, *integrityService);	

				}	

			CleanupStack::PopAndDestroy(existingObject);

			}

		// get the current controller from client space

		// check the size of the descriptor in client space

		// and allocate accordingly

		TInt srcLenCtrl = aMessage.GetDesLengthL(EIpcArgument2);

		HBufC8* bufferCtrl = HBufC8::NewLC(srcLenCtrl);

		TPtr8 destCtrl = bufferCtrl->Des();