/*

* 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 <e32property.h>

#include <connect/sbdefs.h>

#include <miscutil.h>

#include <swi/sistruststatus.h>

#include <swi/sisregistrylog.h>

#include <scs/ipcstream.h>

#include "sislauncherclient.h"

#include "swtypereginfo.h"

#include "scrhelperutil.h"

#include "scrdbconstants.h"

#include "log.h"

#include "swi/siscontroller.h"

#include "sisregistryserversession.h"

#include "sisregistryserver.h"

#include "sisregistryserverconst.h"

#include "sisregistryobject.h"

#include "sisregistryfiledescription.h"

#include "sisregistrydependency.h"

#include "controllerinfo.h"

#include "arrayutils.h"

#include "hashcontainer.h"

#include "filesisdataprovider.h"

#include "dessisdataprovider.h"

#include "sisrevocationmanager.h"

#include "siscontroller.h"

#include "siscertificatechain.h"

#include "sisregistryproperty.h"

#include "cleanuputils.h"

#include "sisregistryutil.h"

#include "sisinfo.h"

#include "sisuid.h"

#include "securitymanager.h"

#include "siscontrollerverifier.h"

#include "sisinstallblock.h"

#include "sisregistryfiledescription.h"

#include "sisregistrywritablesession.h"  

using namespace Swi;

using namespace Usif;

const TInt KUidHexLength = 8;

_LIT(KSWIRegFirstInitFile, "\\sys\\install\\sisregistry\\swiregfirstinit.log");

// Function to panic an offending client

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

	{

	aMessage.Panic(KSisRegistryShortName, aPanic);

	}

//

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

//

void CSisRegistrySession::CreateL()

	{

	Server().AddSession();

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

	iSystemDrive = iFs.GetSystemDrive();

	// Create a session with the Software Component Registry

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

	TInt res = KErrNone;

	TRAP(res , res = IsFirmwareUpdatedL());

	if (IsFirstInvocationL() || res )

		{

		isFwUpdated = ETrue;

		FirstInvocationInitL();

		}

	}

CSisRegistrySession::~CSisRegistrySession()

	{

	Server().DropSession();

	iOpenedPackages.ResetAndDestroy();	

	iScrSession.Close();

	iFs.Close();	

	}

// Returns ETrue if this is the first run of SWIRegistry server ever (or after firmware upgrade)

TBool CSisRegistrySession::IsFirstInvocationL()

	{

	TBool firstInvocation = ETrue;

	// Check if the flagging file KSWIRegFirstInitFile exists in on the <systemdrive>

	RBuf fileName;

	CleanupClosePushL(fileName);

	fileName.CreateL(KMaxPath);

	TDriveUnit drive(iSystemDrive);

	fileName = drive.Name();

	fileName.Append(KSWIRegFirstInitFile);

	TEntry entry;

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

		{

		firstInvocation = EFalse;

		}

	CleanupStack::PopAndDestroy(&fileName);

	return firstInvocation;

	}

// Does initialization required when run after very first boot of phone (or after firmware upgrade)

// Method is only invoked when such a state is detected

// Leaves behind a file in <systemdrive>:\sys to mark a successful initialization 

void CSisRegistrySession::FirstInvocationInitL()

	{

	// Add the ROM installed stub details to SCR

	// Create an SCR transaction, so that entries won't be added to the SCR if the function leaves

	iScrSession.CreateTransactionL();

	ProcessRomDriveL();

	iScrSession.CommitTransactionL();

	// Create a file in <systemdrive>:\sys to mark a successful initialization

	// so that we don't come here again (unless firmware is upgraded in which case <systemdrive>:\sys 

	// should be cleaned

	RBuf fileName;

	CleanupClosePushL(fileName);

	fileName.CreateL(KMaxPath);

	TDriveUnit drive(iSystemDrive);

	fileName = drive.Name();

	fileName.Append(KSWIRegFirstInitFile);

	RFile file;

	CleanupClosePushL(file);

	file.Replace(iFs, fileName, EFileWrite | EFileShareAny);

	CleanupStack::PopAndDestroy(2, &fileName);	// file

	}

//

// Handle a client request.

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

// the error code to the client

//

void CSisRegistrySession::ServiceL(const RMessage2& aMessage)

	{

	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:

		SubsessionL(aMessage.Int3()).RequestVersionRegistryEntryL(aMessage);

		break;

	case EPackageName:

		SubsessionL(aMessage.Int3()).RequestPackageNameRegistryEntryL(aMessage);

		break;

	case EUniqueVendorName:

		SubsessionL(aMessage.Int3()).RequestUniqueVendorNameRegistryEntryL(aMessage);

		break;	

	case ELocalizedVendorName:

		SubsessionL(aMessage.Int3()).RequestLocalizedVendorNameRegistryEntryL(aMessage);

		break;

	case EUid:

		SubsessionL(aMessage.Int3()).RequestUidRegistryEntryL(aMessage);

		break;

	case ESids:

		SubsessionL(aMessage.Int3()).RequestSidsRegistryEntryL(aMessage);

		break;

	case ELanguage:

		SubsessionL(aMessage.Int3()).RequestLanguageRegistryEntryL(aMessage);

		break;

	case EUidPresent:

		SubsessionL(aMessage.Int3()).UidPresentRegistryEntryL(aMessage);

		break;

	case ESigned:

		SubsessionL(aMessage.Int3()).SignedRegistryEntryL(aMessage);

		break;

	case EGetTrust:

		SubsessionL(aMessage.Int3()).RegistryEntryTrustL(aMessage);

		break;	

	case ETrustTimeStamp:

		SubsessionL(aMessage.Int3()).TrustTimeStampL(aMessage);

		break;	

	case ETrustStatus:

		SubsessionL(aMessage.Int3()).TrustStatusEntryL(aMessage);

		break; 

	case EIsSidPresent:

		IsSidPresentL(aMessage);

		break;

	case EShutdownAllApps:

		SubsessionL(aMessage.Int3()).ShutdownAllAppsL(aMessage);

		break;

	case ERevocationStatus:

		SubsessionL(aMessage.Int3()).RevocationCheckEntryL(aMessage);

		break;	

	case ECancelRevocationStatus:

		SubsessionL(aMessage.Int3()).CancelRevocationCheckEntryL(aMessage);

		break;			

	case EInRom:

		SubsessionL(aMessage.Int3()).InRomRegistryEntryL(aMessage);

		break;

	case EAugmentation:

		SubsessionL(aMessage.Int3()).AugmentationRegistryEntryL(aMessage);

		break;

	case EControllers:

		SubsessionL(aMessage.Int3()).RequestControllersL(aMessage);

		break;

	case EProperty:

		SubsessionL(aMessage.Int3()).RequestPropertyRegistryEntryL(aMessage);

		break;

	case EFiles:

		SubsessionL(aMessage.Int3()).RequestFileNamesRegistryEntryL(aMessage);

		break;

	case EHashEntry:

		SubsessionL(aMessage.Int3()).RequestHashRegistryEntryL(aMessage);

		break;	

	case EFileDescriptions:

		SubsessionL(aMessage.Int3()).RequestFileDescriptionsRegistryEntryL(aMessage);

		break;	

	case ESelectedDrive:

		SubsessionL(aMessage.Int3()).RequestSelectedDriveRegistryEntryL(aMessage);

		break;

	case EInstalledDrives:

		SubsessionL(aMessage.Int3()).RequestInstalledDrivesRegistryEntryL(aMessage);

		break;			

	case EPreInstalled:

		SubsessionL(aMessage.Int3()).PreInstalledRegistryEntryL(aMessage);

		break;

	case EInstallType:

		SubsessionL(aMessage.Int3()).RequestInstallTypeRegistryEntryL(aMessage);

		break;

	case ECertificateChains:

		SubsessionL(aMessage.Int3()).RequestCertificateChainsRegistryEntryL(aMessage);

		break;

	case EEmbeddedPackages:

		SubsessionL(aMessage.Int3()).RequestEmbeddedPackageRegistryEntryL(aMessage);

	    break; 

	case EEmbeddingPackages:

		SubsessionL(aMessage.Int3()).RequestEmbeddingPackagesRegistryEntryL(aMessage);

	    break; 

	case EPackageAugmentations:

		SubsessionL(aMessage.Int3()).RequestPackageAugmentationsRegistryEntryL(aMessage);

	    break;

	case EPackageAugmentationsNumber:

		SubsessionL(aMessage.Int3()).RequestPackageAugmentationsNumberL(aMessage);

		break;

	case ESize:

		SubsessionL(aMessage.Int3()).RequestSizeRegistryEntryL(aMessage);

	    break;

	case EPackage:

		SubsessionL(aMessage.Int3()).RequestPackageRegistryEntryL(aMessage);

	    break;    

	case EGetMatchingSupportedLanguages:

		SubsessionL(aMessage.Int3()).RequestMatchingSupportedLanguagesL(aMessage);

	    break;

	case ECreateTransaction:

		CreateTransactionL(aMessage);

		break;

	case ECommitTransaction:

		CommitTransactionL(aMessage);

		break;

	case ERollbackTransaction:

		RollbackTransactionL(aMessage);

		break;

	case EAddEntry:

		RegisterEntryL(aMessage, ETrue, EFalse);

		break;

	case EAddSoftwareTypeEntry:

		RegisterEntryL(aMessage, ETrue, ETrue);

		break;

	case EUpdateEntry:

		RegisterEntryL(aMessage, EFalse, EFalse);

		break;

	case EUpdateSoftwareTypeEntry:

		RegisterEntryL(aMessage, EFalse, ETrue);

		break;

	case EDeleteEntry:

		DeleteEntryL(aMessage);

		break;

	case EDependencies:

		SubsessionL(aMessage.Int3()).RequestDependenciesRegistryEntryL(aMessage);

		break; 

	case EDependentPackages:

		SubsessionL(aMessage.Int3()).RequestDependentPackagesRegistryEntryL(aMessage);

		break;

	case EGetEntry:

		RequestRegistryEntryL(aMessage);

		break;

	case EAddDrive:

		AddDriveL(aMessage);

		break;

	case EDeletablePreInstalled:

		SubsessionL(aMessage.Int3()).DeletablePreInstalledRegistryEntryL(aMessage);

		break;

	case EVerifyController:

		{

		SubsessionL(aMessage.Int3()).VerifyControllerL(aMessage);

		break;

		}

	case ERemoveWithLastDependent:

		{

		SubsessionL(aMessage.Int3()).RemoveWithLastDependentL(aMessage);

		break;

		} 

	case ESetRemoveWithLastDependent:

		{

		SubsessionL(aMessage.Int3()).SetRemoveWithLastDependentL(aMessage);

		break;

		} 

	case EloggingFile:

 		LoggingFileInfoL(aMessage);

 		break;

	case ENonRemovable:

		SubsessionL(aMessage.Int3()).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:

		SubsessionL(aMessage.Int3()).SignedBySuCertRegistryEntryL(aMessage);

 		break;	

	case ESetComponentState:

 		SetComponentStateL(aMessage);

 		break;	

	case EIsFileRegistered:

 		IsFileRegisteredL(aMessage);

 		break;			

	case EComponentIdForUid:

		GetComponentIdForUidL(aMessage);

		break;

	default:

		PanicClient(aMessage,EPanicIllegalFunction);

		break;

		}

	}

void CSisRegistrySession::RequestInstalledUidsL(const RMessage2& aMessage)

	{

	RArray<TUid> uids;

	CleanupClosePushL(uids);

	// Retrieve all the components from SCR

	RArray<TComponentId> componentIdList;

	CleanupClosePushL(componentIdList);

	ScrHelperUtil::GetComponentIdListL(iScrSession, componentIdList);

	// Retrieve the UIDs for all the components

	TInt compCount = componentIdList.Count();

	for (TInt index = 0; index < compCount; ++index)

		{

		TComponentId compId = componentIdList[index];

		TUid uid = TUid::Uid(GetIntPropertyValueL(iScrSession, compId, KCompUid, ETrue));

		TInt err = uids.InsertInUnsignedKeyOrder(uid);

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

			{

			CleanupStack::PopAndDestroy(&componentIdList);

			User::Leave(err);

			}

		}

	CleanupStack::PopAndDestroy(&componentIdList);	

	SisRegistryUtil::SendDataArrayL(aMessage, uids, EIpcArgument0);

	CleanupStack::PopAndDestroy(&uids);

	}

void CSisRegistrySession::RequestInstalledPackagesL(const RMessage2& aMessage)

	{

    RPointerArray<CSisRegistryPackage> packages; 

    CleanupResetAndDestroyPushL(packages);

	// Retrieve all the installed components from SCR

	RArray<TComponentId> componentIdList;

	CleanupClosePushL(componentIdList);

	ScrHelperUtil::GetComponentIdListL(iScrSession, componentIdList);

	// Get the components count and iterate through all of them.

	TInt compCount = componentIdList.Count();

	for (TInt index = 0; index < compCount; ++index)

		{

		// Take the component Id.

		TComponentId compId = componentIdList[index];

		// Get the relevant package from SCR.

		CSisRegistryPackage *package = NULL;

		ScrHelperUtil::ReadFromScrL(iScrSession, compId, package);

		CleanupStack::PushL(package);

		packages.AppendL(package);

		CleanupStack::Pop(package);

		}

	CleanupStack::PopAndDestroy(&componentIdList); 

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

    CleanupStack::PopAndDestroy(&packages);

	}

void CSisRegistrySession::UidInstalledL(const RMessage2& aMessage)

	{

	TUid uid; 

	TPckg<TUid> packageUid(uid);

	aMessage.ReadL(EIpcArgument0, packageUid);

	// check whether is registered

	TBool isRegistered = IsRegisteredL(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)

	{