// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// This file contains the implementations of the classes

// which manage the internal structure of the registry.

// 

//

#include <e32base.h>

#include <e32uid.h>

#include <s32stor.h>

#include <s32file.h>

#include <startup.hrh> // for EStartupStateNonCritical

#include <e32ldr.h> // for hash checking

#include <e32ldr_private.h> // for RLoader

#include <bautils.h> // for BaflUtils::FileExists

#include "EComDebug.h"

#include <ecom/ecom.h>

#include <ecom/ecomerrorcodes.h>

#include <ecom/ecomresolverparams.h>

#include <ecom/implementationinformation.h>

#include "RegistryData.h"

#include "DowngradePath.h"

#include "DriveInfo.h"

#include "FileUtils.h"

#include "EComUidCodes.h"

#include "EComInternalErrorCodes.h"

#define UNUSED_VAR(a) a = a

const TInt KRegVersion = -9999;

const TInt KDllExtensionLength=4;

_LIT(KDllExtension,".dll");

//

//CRegistryData::TInterfaceStruct

/**

Constructor for TInterfaceStruct

@post			Its member variable is granulated as (1)

*/

CRegistryData::TInterfaceStruct::TInterfaceStruct():

	iImpData(1)

	{

	// Do nothing here

	}

/**

This method determins the order of two TInterfaceIndex objects

@param			indexEntry1 first TInterfaceIndex object

@param			indexEntry2 second TInterfaceIndex object

@return			integer indicating the order of these two

@pre			This object is fully constructed

*/

TInt CRegistryData::TInterfaceStruct::CompareInfUid(const TInterfaceIndex& indexEntry1,

													const TInterfaceIndex& indexEntry2)

	{

	return CompareTUidValues(indexEntry1.iInterfaceUid.iUid,indexEntry2.iInterfaceUid.iUid);

	}

//

//CRegistryData::TImplStruct

/**

Constructor for TImplStruct

@post			Its member variables are initialised

*/

CRegistryData::TImplStruct::TImplStruct():

	iCurrentImpl(NULL),

	iUnusedImpls(1)

	{

	// Do nothing here

	}

/**

This method determins the order of two TImplStruct objects

@param			aEntry1 first TImplStruct object

@param			aEntry2 second TImplStruct object

@return			integer indicating the order of these two

@pre			This object is fully constructed

*/

 TInt CRegistryData::TImplStruct::CompareImplStructUid(const TImplStruct& aEntry1,

													const TImplStruct& aEntry2)

	{

	return CompareTUidValues(aEntry1.iCurrentImpl->iImplInfo->ImplementationUid().iUid,

						aEntry2.iCurrentImpl->iImplInfo->ImplementationUid().iUid);

	}

/** Comparer to determine the order of a TUid object (implementation UID) in relation to and a TImplStruct object.

@param aUid the Implementation UID to compare with.

@param aEntry the TImplStruct object to compare aUid against.

@return integer indicating the order of the two.

*/

TInt CRegistryData::TImplStruct::CompareUidAgainstImplStruct(

	const TUid* aUid,

	const TImplStruct& aEntry)

	{

	return CompareTUidValues(aUid->iUid,aEntry.iCurrentImpl->iImplInfo->ImplementationUid().iUid);

	}

//

// CRegistryData::CImplementationData class

/**

Creates a new CImplemenatationData object. Note that CImplementationInformation needs to be constructed too,

for this object to be fully constructed.

@param			aParent A pointer to the parent instance of CInterfaceData

@return			A pointer to the newly created object.

@post			This object is partly constructed and initialized and is on 

				the CleanupStack.

*/

CRegistryData::CImplementationData* CRegistryData::CImplementationData::NewLC(CInterfaceData* aParent)

	{

	CImplementationData* self=new(ELeave) CImplementationData(aParent);

	CleanupStack::PushL(self);

	return self;

	}

/**

Creates a new CImplemenatationData object. It takes parameters to create a CImplementationInformation object,

during 2nd phase construction and initializes iImplInfo to reference to this CImplementationInformation object.

@param			aParent A pointer to the parent instance of CInterfaceData

@param			aUid The unique Id of the new implementation

@param			aVersion The version number of the new implementation

@param			aName The display name of the new implementation

@param			aDataType The data type supported by the new implementation

@param			aOpaqueData Data for the new implementation which is not used by the ECom framework

@param			aDrive The drive that the new implementation is on

@param			aRomOnly The flag recording whether the new implementation may be loaded from ROM only

@param			aRomBased The flag recording whether the new implementation is on ROM or is a later version of one on ROM

@return			A pointer to the newly created object

@post			This object is fully constructed and initialized.

*/

CRegistryData::CImplementationData* CRegistryData::CImplementationData::NewL(CInterfaceData* aParent,

																				TUid	aUid,

																				TInt	aVersion, 

																				HBufC*  aName,

																				HBufC8* aDataType,

																				HBufC8* aOpaqueData,

																				TDriveUnit aDrive,

																				TBool aRomOnly,

																				TBool aRomBased)

	{

	CImplementationData* self=new(ELeave) CImplementationData(aParent);

	CleanupStack::PushL(self);

	self->ConstructL(aUid,

					aVersion,

					aName,

					aDataType,

					aOpaqueData,

					aDrive,

					aRomOnly,

					aRomBased);

	CleanupStack::Pop(self);

	return self;

	}

/**

Creates a new CImplemenatationData object. It takes parameters to create a CImplementationInformation object,

during 2nd phase construction and initializes iImplInfo to reference to this CImplementationInformation object.

@param			aParent A pointer to the parent instance of CInterfaceData

@param			aUid The unique Id of the new implementation

@param			aVersion The version number of the new implementation

@param			aName The display name of the new implementation

@param			aDataType The data type supported by the new implementation

@param			aOpaqueData Data for the new implementation which is not used by the ECom framework

@param			aDrive The drive that the new implementation is on

@param			aRomOnly The flag recording whether the new implementation may be loaded from ROM only

@param			aRomBased The flag recording whether the new implementation is on ROM or is a later version of one on ROM

@param			aExtendedInterfaces The pointer to the array recording the extended interfaces supported by this implementation.

				NULL is available for PLUGIN without extended interfaces support.

@return			A pointer to the newly created object

@post			This object is fully constructed and initialized.

*/

CRegistryData::CImplementationData* CRegistryData::CImplementationData::NewL(CInterfaceData* aParent,

																				TUid	aUid,

																				TInt	aVersion, 

																				HBufC*  aName,

																				HBufC8* aDataType,

																				HBufC8* aOpaqueData,

																				TDriveUnit aDrive,

																				TBool aRomOnly,

																				TBool aRomBased,

																				RExtendedInterfacesArray* aExtendedInterfaces)

	{

	CImplementationData* self=new(ELeave) CImplementationData(aParent);

	CleanupStack::PushL(self);

	self->ConstructL(aUid,

					aVersion,

					aName,

					aDataType,

					aOpaqueData,

					aDrive,

					aRomOnly,

					aRomBased,

					aExtendedInterfaces);

	CleanupStack::Pop(self);

	return self;

	}

/**

Constructor for CImplementationData

@param			aParent The parent interface data of this implementation

@post			Its member variables are initialised

*/

CRegistryData::CImplementationData::CImplementationData( CInterfaceData* aParent):

	CBase(),

	iImplInfo(NULL),

	iParent(aParent)

	{

	// Do nothing here

	}

/**

Destructor of CImplementationData

*/	

CRegistryData::CImplementationData::~CImplementationData()

	{

	if(iImplInfo)

		{

		delete iImplInfo;

		iImplInfo = NULL;	

		}	

	iParent = NULL;		

	}

/**

The object's memory has been allocated.

@param			aUid The unique Id of the new implementation

@param			aVersion The version number of the new implementation

@param			aName The display name of the new implementation

@param			aDataType The data type supported by the new implementation

@param			aOpaqueData Data for the new implementation which is not used by the ECom framework

@param			aDrive The drive that the new implementation is on

@param			aRomOnly The flag recording whether the new implementation may be loaded from ROM only

@param			aRomBased The flag recording whether the new implementation is on ROM or is a later version of one on ROM

@pre 			This object is fully constructed.

@post			This object is fully constructed and initialized.

*/

void CRegistryData::CImplementationData::ConstructL(TUid	aUid,

													TInt	aVersion, 

													HBufC*  aName,

													HBufC8* aDataType,

													HBufC8* aOpaqueData,

													TDriveUnit aDrive,

													TBool aRomOnly,

													TBool aRomBased)

	{

	CImplementationInformation* newImpl = CImplementationInformation::NewL(aUid, 

													 						aVersion, 

													 						aName, 

															 				aDataType,

																			aOpaqueData,

														 					aDrive,

														 					aRomOnly,

													 						aRomBased);

	this->iImplInfo = newImpl;

	}

/**

The object's memory has been allocated.

@param			aUid The unique Id of the new implementation

@param			aVersion The version number of the new implementation

@param			aName The display name of the new implementation

@param			aDataType The data type supported by the new implementation

@param			aOpaqueData Data for the new implementation which is not used by the ECom framework

@param			aDrive The drive that the new implementation is on

@param			aRomOnly The flag recording whether the new implementation may be loaded from ROM only

@param			aRomBased The flag recording whether the new implementation is on ROM or is a later version of one on ROM

@param			aExtendedInterfaces The pointer to the array recording the extended interfaces supported by this implementation.

				NULL is available for PLUGIN without extended interfaces support.

@pre 			This object is fully constructed.

@post			This object is fully constructed and initialized.

*/

void CRegistryData::CImplementationData::ConstructL(TUid	aUid,

													TInt	aVersion, 

													HBufC*  aName,

													HBufC8* aDataType,

													HBufC8* aOpaqueData,

													TDriveUnit aDrive,

													TBool aRomOnly,

													TBool aRomBased,

													RExtendedInterfacesArray* aExtendedInterfaces)

	{

	CImplementationInformation* newImpl = CImplementationInformation::NewL(aUid, 

													 						aVersion, 

													 						aName, 

															 				aDataType,

																			aOpaqueData,

														 					aDrive,

														 					aRomOnly,

													 						aRomBased,

													 						aExtendedInterfaces);

	this->iImplInfo = newImpl;

	}

/**

Initialises member variable with the CImplementationInformation state specified in aStore.

@param			aStore The stream to read the data from.

@pre 			This object is full constructed.

@post			This object is set to the state specified in aStore.

*/

void CRegistryData::CImplementationData::InternalizeL(RReadStream& aStore)

	{

	if (iImplInfo)

		{

		delete iImplInfo;

		iImplInfo = NULL;

		}

	CImplementationInformation* implInfo = 0;

	implInfo=CImplementationInformation::NewLC(EFalse,aStore);

	//as we never store the drive name we need to get this from the parent

	implInfo->SetDrive(iParent->iParent->iParent->iDrive);

	CleanupStack::Pop(1);

	iImplInfo = implInfo;

	implInfo = 0;

	}

/**

Writes out the state of this member variable of type CImplementationInformation to aStore.

@param			aStore The stream to store the data in.

@pre 			This object is fully constructed.

*/

void CRegistryData::CImplementationData::ExternalizeL(RWriteStream& aStore) const

	{

	iImplInfo->ExternalizeL(EFalse,aStore);

	}

/**

This method determines the order of two CImplementationData objects.

For backward compatibility reason, ECom allows different I/Fs using

the same implementation UID for when the device has an implementation UID

that is not unique. Although this is not a valid or supported situation ECOM 

server should be robust.

@see FindImplementation

@see CompareTUidValues

@param			aImpl1 first reference to CImplementationData object 

@param			aImpl2 second reference to CImplementationData object

@return			integer indicating the order of these two

@pre			This object is fully constructed

*/	

TInt CRegistryData::CImplementationData::CompareImplUid(const CImplementationData& aImpl1,

													const CImplementationData& aImpl2)

	{

	TInt ret = CompareTUidValues(aImpl1.iImplInfo->ImplementationUid().iUid, aImpl2.iImplInfo->ImplementationUid().iUid);

	if (ret != 0)

		{

		return ret;

		}

	// Implementation UIDs are equal, use I/F UID as tie breaker

	return CompareTUidValues(aImpl1.iParent->iInterfaceUid.iUid, aImpl2.iParent->iInterfaceUid.iUid);

	}

/**

Similar to CompareImplUid above. This comparer only compare the Impl UID

and ignore the I/F UID part.

@param			aImpl1 first reference to CImplementationData object 

@param			aImpl2 second reference to CImplementationData object

@return			integer indicating the order of these two

@pre			This object is fully constructed

*/	

TInt CRegistryData::CImplementationData::CompareImplUidIgnoreIfUid(const CImplementationData& aImpl1,

													const CImplementationData& aImpl2)

	{

	return CompareTUidValues(aImpl1.iImplInfo->ImplementationUid().iUid,

						aImpl2.iImplInfo->ImplementationUid().iUid);

	}

/**

This method determines the order of an CImplementationData object in relation

to aUid.

@param	aUid is really TUid. Cast it back before compare.

@param	aImplData reference to CImplementationData object

@return	integer indicating the order of the two.

*/	

TInt CRegistryData::CImplementationData::CompareUidAgainstImplData(

											const CImplementationData& aUid,

											const CImplementationData& aImplData)

	{

	// The first argument aUid is really TUid.

	const TUid* ImplUid = reinterpret_cast<const TUid*>(&aUid);

	return CompareTUidValues(ImplUid->iUid,

						aImplData.iImplInfo->ImplementationUid().iUid);

	}

//

// CRegistryData::CInterfaceData class

/**

Creates a new CInterfaceData object and leave it on the CleanupStack

@param			aInterface The unique Id of this interface.

@param			aParent A pointer to the parent dll data 

@return			A pointer to the newly created class.

@post			This object is fully constructed and initialized and is on 

				the CleanupStack.

*/

CRegistryData::CInterfaceData* CRegistryData::CInterfaceData::NewLC(TUid aInterfaceUid,CDllData* aParent)

	{

	CInterfaceData* self=new(ELeave) CInterfaceData(aInterfaceUid,aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

Creates a new CInterfaceData object using the supplied interface id 

and leave it on the CleanupStack

@param			aParent A pointer to the parent dll data

@return			A pointer to the newly created class.

@post			This object is fully constructed and initialized and is on 

				the CleanupStack.

*/

CRegistryData::CInterfaceData* CRegistryData::CInterfaceData::NewLC(CDllData* aParent)

	{

	CInterfaceData* self=new(ELeave) CInterfaceData(aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CRegistryData::CInterfaceData::~CInterfaceData()

	{

	if(iImplementations)

		{

		iImplementations->ResetAndDestroy();

		delete iImplementations;

		iImplementations = NULL;

		}

	iParent = NULL;

	}

/**

Adds the specified implementation to this interface in the registry.

@param			aImplementation The implementation to add to this interface.

@pre			This object is fully constructed.

@post			aImplementation is added to the list of implementations for this interface.

*/

void CRegistryData::CInterfaceData::AddL(const CImplementationData* aImplementation)

	{

#ifdef ECOM_TRACE

	static int counter = 0; counter++;

	__ECOM_TRACE6("ECOM: Implementation discovered (%04d) UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", counter, aImplementation->iImplInfo->ImplementationUid().iUid, aImplementation->iParent->iInterfaceUid.iUid, aImplementation->iImplInfo->Version(), (TInt)(aImplementation->iImplInfo->Drive()), &(aImplementation->iImplInfo->DisplayName()));

#endif

	User::LeaveIfError(iImplementations->Append(aImplementation));

	}

/**

Sets the uid of this interface to aInterfaceUid.

@param			aInterfaceUid The Uid which this object should take.

@pre			This object is fully constructed.

@post			The Uid of this interface is set to aInterfaceUid

*/

void CRegistryData::CInterfaceData::SetInterfaceUid(TUid aInterfaceUid)

	{

	iInterfaceUid = aInterfaceUid;

	}

/**

Writes out this CInterfaceData to aStore.

@param			aStore The stream to store the data in.

@pre 			The state of this object is stored in the stream aStore.

*/

void CRegistryData::CInterfaceData::ExternalizeL(RWriteStream& aStore) const

	{

	aStore.WriteInt32L(iInterfaceUid.iUid);

	if(iImplementations)

		{

		const TInt entryCount = iImplementations->Count();

		aStore.WriteInt32L(entryCount);

		for(TInt i = 0; i < entryCount; ++i)

			((*iImplementations)[i])->ExternalizeL(aStore);

		}

	else

		aStore.WriteInt32L(0);

	}

/**

Restores this CInterfaceData to the state specified in aStore.

@param			aStore The stream to read the data from.

@param			aPresent A boolean indicating whether the dll is still present

@pre 			This object is full constructed.

@post			This object is set to the state specified in aStore.

*/

void CRegistryData::CInterfaceData::InternalizeL(RReadStream& aStore)

	{

	iInterfaceUid.iUid = aStore.ReadInt32L();

	const TInt entryCount = aStore.ReadInt32L();

    if(entryCount < 0)

        {

        User::Leave(KErrCorrupt);

        }

	for(TInt i = 0; i < entryCount; ++i)

		{

		CImplementationData* implementation = CImplementationData::NewLC(this);

		implementation->InternalizeL(aStore);

		AddL(implementation);

		CleanupStack::Pop(implementation);		//now owned by this interface

		}

	}

/**

@param			aParent A pointer to the parent dll data

*/

CRegistryData::CInterfaceData::CInterfaceData(CDllData* aParent) :

	CBase(),

	iParent(aParent)

	{

	// Do nothing here

	}