/*

* Copyright (c) 2004-2010 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 <e32property.h>

#include <connect/sbdefs.h>

#include <miscutil.h>

#include <swi/sistruststatus.h>

#include <swi/sisregistrylog.h>

#include <scs/ipcstream.h>

#include <startupdomainpskeys.h>

#include <e32const.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");

_LIT(KApparcRegFileNameFormat, "*10003a3f*");

// 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());

	iIsFirstInit = IsFirstInvocationL();

#ifdef __WINSCW__

	_LIT_SECURE_ID(KAppArcSID, 0x10003A3F);

	if (KAppArcSID.iId == iClientSid.iId)

	    {

        DEBUG_PRINTF(_L8("SIS Registry Server: Init for a connection from AppArc"));

        ProcessRomApplicationsL();

	    }

	else

	    {

        if (iIsFirstInit)

            {

            DEBUG_PRINTF2(_L8("SIS Registry Server: Init for a connection from SID 0x%X"), iClientSid.iId);

            ProcessRomStubsL();

            }

	    }

#else

	TInt res = KErrNone;

	TRAP(res , res = IsFirmwareUpdatedL());

	if (iIsFirstInit || res)

		{

		if (res)

		    {

		    iIsFwUpdated = ETrue;

		    }

		FirstInvocationInitL();

		if (iIsFwUpdated)

		    {

			TRAP(res, UpdateRecentFWVersionL());

			if (res != KErrNone)

                {

                DEBUG_PRINTF2(_L8("Updating recent Firmware Version failed with error code = %d."), res);

                }

		    }		

		}

#endif

	}

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;

	}

void CSisRegistrySession::ProcessRomStubsL()

    {

    DEBUG_PRINTF(_L8("SIS Registry Server - Starting processing of ROM Stub sis files"));

    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

    DEBUG_PRINTF(_L8("SIS Registry Server - Completed processing of ROM Stub sis files"));

    }

void CSisRegistrySession::ProcessRomApplicationsL()

    {

    TComponentId compId = 0;

    DEBUG_PRINTF(_L8("SIS Registry Server - Deleteing all existing ROM applications."));

    ScrHelperUtil::DeleteApplicationEntriesL(iScrSession, compId);

    //Register all apps found in \private\10003a3f\apps

    TDriveUnit romDrive(SisRegistryUtil::SystemRomDrive());

    RBuf romApparcRegFilePath;

    romApparcRegFilePath.CreateL(romDrive.Name(), KMaxPath);

    CleanupClosePushL(romApparcRegFilePath);

    romApparcRegFilePath.Append(KApparcRegFilePath);

    RegisterAllInRomAppL(romApparcRegFilePath);

    //Register all apps found in \private\10003a3f\import\apps

    romApparcRegFilePath = romDrive.Name();

    romApparcRegFilePath.Append(KApparcRegFileImportPath);

    RegisterAllInRomAppL(romApparcRegFilePath);

    CleanupStack::PopAndDestroy(&romApparcRegFilePath);

    DEBUG_PRINTF(_L8("SIS Registry Server - Completed processing of all existing ROM applications."));

    }

// 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 (only in device, NOT in emulator)

// 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

    TInt value(EIdlePhase1NOK);

    RProperty::Get(KPSUidStartup, KPSIdlePhase1Ok, value);

    TBool isFromSWIDaemon = EFalse;

    _LIT_SECURE_ID(KSWIDaemonSID, 0x10202DCE);

    if (KSWIDaemonSID.iId == iClientSid.iId)

        { 

        isFromSWIDaemon = ETrue;

        }

	if ((value == EIdlePhase1Ok || isFromSWIDaemon) && iIsFirstInit)

	    {

        ProcessRomStubsL();

	    }

	if (iIsFwUpdated)

	    {

		// Delete the SisRegistry marker file

        RBuf fileName;

        CleanupClosePushL(fileName);

        fileName.CreateL(KMaxPath);

        TDriveUnit drive(iSystemDrive);

        fileName = drive.Name();

        fileName.Append(KSWIRegFirstInitFile);

        iFs.Delete(fileName);

        CleanupStack::PopAndDestroy(&fileName);

        ProcessRomApplicationsL();

	    }

	}

//

// 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 EAddAppRegEntry:

        AppRegInfoEntryL(aMessage);

        break;

    case EUpdateAppRegEntry:

        AppRegInfoEntryL(aMessage);

        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);

	case EIsFileRegistered:

 		IsFileRegisteredL(aMessage);

 		break;			

	case EComponentIdForUid:

		GetComponentIdForUidL(aMessage);

		break;

	case EComponentIdForPackage:

        GetComponentIdForPackageL(aMessage);

        break;

	case EAppUidsForComponent:

	    GetAppUidsForComponentL(aMessage);

        break;

	case EComponentIdsForPackageUid:	    

        GetComponentIdsForUidL(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;