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

	}

/**

@param			aInterfaceUid The unique Id of this interface

@param			aParent A pointer to the parent dll data			

*/

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

	CBase(),

	iInterfaceUid(aInterfaceUid),

	iParent(aParent)

	{

	// Do nothing here

	}

/**

Standard second phase construction function

@pre 			This object is fully constructed.

@post			This object is fully constructed and initialized.

*/

void CRegistryData::CInterfaceData::ConstructL()

	{

	iImplementations = new(ELeave) RPointerArray<CImplementationData>;

	}

//

// CRegistryData::CDllData class

/**

Creates a new CDllData object using aEntry and leaves it on the CleanupStack

@param			aDllName the name of this dll

@param			aDllModTime the modified time of this dll

@param 			aSecondUid Identifies type of the DLL. (PLUGIN or PLUGIN3)

@param  			aThirdUid Identifies a component uniquely. 	

@param			aParent A pointer to the parent drive data

@return			A pointer to the newly created object.

@post			This object is fully constructed and initialized and on the CleanupStack.

*/

CRegistryData::CDllData* CRegistryData::CDllData::NewLC(const TDesC& aDllName,const TTime& aDllModTime,const TUid& aSecondUid,const TUid& aThirdUid,CDriveData* aParent)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aDllName,aDllModTime,aSecondUid,aThirdUid);

	return self;

	}

/**

Creates a new CDllData object using aParent and leaves it on the CleanupStack

@param			aParent A pointer to the parent drive data

@return			A pointer to the newly created object.

@post			This object is fully constructed and initialized and on the CleanupStack.

*/

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CRegistryData::CDllData::~CDllData()

	{

	if(iIfList)

		{

		// Clear the interface list and destroy its objects

		iIfList->ResetAndDestroy();

		delete iIfList;

		iIfList = NULL;

		}

	// Unload this implementation dll.

	delete iDllEntry;

	iDllEntry = NULL;

	iParent = NULL;

	delete iRscFileExtension;

	}

/**

Adds the specified interface to this dll in the registry.

@param			aInterface The interface to add to this dll

@pre 			This object is fully constructed.

@post			aInterface is added to the list of interfaces in this dll.

*/

void CRegistryData::CDllData::AddL(const CInterfaceData* aInterface)

	{

	User::LeaveIfError(iIfList->Append(aInterface));

	}

/**

Sets the resource extension for the plugin. Not set for read only internal drives.

@param			aExt The resource extension to set

@pre 			This object is fully constructed.

@post			aExt is added to the object.

*/

void CRegistryData::CDllData::SetResourceExtL(const TDesC& aExt)

	{

	delete iRscFileExtension;

	iRscFileExtension = NULL;

	iRscFileExtension = aExt.AllocL();

	}

/**

Set the capability,the VID and do the Security check for this DLL.

@pre 			This object is fully constructed.

@return			ETrue if the security check is done successfully. Otherwise EFalse is returned. 

*/

TBool CRegistryData::CDllData::SaveSecurityInfoL()

	{

	iSecurityChecked = EFalse;

	//need to construct the full filename i.e. appending with the

	//preconstructed drivepath name in CDriveData

	TFileName dllFullName;

	dllFullName.Append(iParent->iDrive.Name());

	dllFullName.Append(_L("\\sys\\bin\\"));

	dllFullName.Append(iDllEntry->GetName());

	RLibrary::TInfoBuf infoBuf;

	TInt ret = RLibrary::GetInfo(dllFullName, infoBuf);

	if(ret != KErrNone)

		{

		return EFalse;

		}

	// Set the DLL's capability

	iCapSet = infoBuf().iSecurityInfo.iCaps;

	// Set the DLL's VID

	iVid = infoBuf().iSecurityInfo.iVendorId;

	// Now verify that SID identified in the resource file matches the SID of the Dll file

	TBool match=iDllEntry->GetThirdUid() ==infoBuf().iSecurityInfo.iSecureId;

	if (!match)

		{

#ifdef __ECOM_TRACE 

		__ECOM_TRACE1("ERROR: Plugin SID Mismatch ERROR for %S.", &dllFullName);

#endif

		return EFalse;

		}

	// Now verify the two DLL's second Uid are of the same Uid type (used for distinguising between collection/collection3)

	match=iDllEntry->GetSecondUid() ==infoBuf().iUids[1];

	if (!match)

		{

#ifdef __ECOM_TRACE 

		__ECOM_TRACE1("ERROR: Plugin UID2 Mismatch ERROR for %S.", &iDllEntry->GetName());

#endif

		return EFalse;

		}

	// On the emulator RLoader::CheckLibraryHash() returns KErrNotSupported.

	// Also on the emulator RLoader does no hash checking for DLL's on removable drives.

	// Therefore to be consistent ECOM does not do any hash checking itself on the emulator.

	// Hence code is removed for emulator builds.

#if !defined(__WINSCW__)

	// Verify hash is available

	if(iParent->iParent->iCachedDriveInfo->DriveIsRemovableL(iParent->iDrive))

		{

		RLoader loader;

		TInt err = loader.Connect();

		if(err != KErrNone)

			{

			return EFalse;

			}

		err = loader.CheckLibraryHash(dllFullName, ETrue);

		loader.Close();

		if(err != KErrNone)

			{

#ifdef __ECOM_TRACE 

		__ECOM_TRACE2("INFO: Hash Check Failed for %S with error %d.", &dllFullName, err);

#endif

			return EFalse;

			}

		}

#endif

	iSecurityChecked = ETrue;

	return ETrue;

	}

/**

Check whether security check has been performed if not go retrieve it.

@pre 			This object is fully constructed.

@return			ETrue if the security check is done successfully. Otherwise EFalse is returned. 

*/

TBool CRegistryData::CDllData::ProcessSecurityCheckL()

	{

	if(iSecurityChecked)

		{

		return ETrue;

		}

	return SaveSecurityInfoL();

	}

/**

Writes out the state of this CDllData to aStore.

@param			aStore The stream to store the data in.

@pre 			This object is fully constructed.

*/

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

   	{

 	const CEComEntry& dllEntryData = *iDllEntry;

	TInt size=dllEntryData.GetName().Length()-KDllExtensionLength;

 	aStore.WriteUint32L(size);

	aStore.WriteL(dllEntryData.GetName(),size);

	aStore.WriteInt32L(dllEntryData.GetSecondUid().iUid);	

  	aStore.WriteInt32L(dllEntryData.GetThirdUid().iUid);

    TPckg<TTime> modified(dllEntryData.GetModified());	

 	aStore.WriteL(modified);

	if(!iParent->iParent->iCachedDriveInfo->DriveIsReadOnlyInternalL(iParent->iDrive))

		{

		if(iRscFileExtension)

			{

			size = iRscFileExtension->Length();		

			aStore.WriteUint32L(size);

			aStore.WriteL(iRscFileExtension->Des(),size);

			}

		else

			{

			aStore.WriteUint32L(0);		

			}

		}

   	if(iIfList)

   		{

   		const TInt entryCount = iIfList->Count();

   		aStore.WriteInt32L(entryCount);

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

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

   		}

   	else

   		aStore.WriteInt32L(0);

	}

/**

Restores this CDllData to the state specified in aStore.

@param			aStore The stream to read the data from.

@pre 			This object is fully constructed.

@post			The state of this object is restored to that specified in aStore.

*/

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

 	{	

	TInt size=aStore.ReadUint32L();

    //The next "if" checks if size < 0 not size <= 0 because it seems the ECOM server externalizes

    //the last file name as a string with length 0. If the fix is <= 0, then it makes it

    //incompatible with the existing applications

    if(size < 0 || size > KMaxFileName)

        {

        User::Leave(KErrCorrupt);

        }

	HBufC* name = HBufC::NewLC(size+KDllExtensionLength);

	TPtr ptr=name->Des();

	aStore.ReadL(ptr,size);

	ptr.Append(KDllExtension);

  	TUid secondUid=TUid::Uid(aStore.ReadInt32L());

  	TUid thirdUid=TUid::Uid(aStore.ReadInt32L());

  	TTime dllModifiedTime;  	

   	TPckg<TTime> modified(dllModifiedTime);	

 	aStore.ReadL(modified);

	if(!iParent->iParent->iCachedDriveInfo->DriveIsReadOnlyInternalL(iParent->iDrive))

		{

		size = aStore.ReadUint32L();

		if(size < 0 || size > KMaxFileName)

		        {

       		 User::Leave(KErrCorrupt);

       		 }

		if(size)

			{

			iRscFileExtension = HBufC::NewL(size);

			TPtr extPtr = iRscFileExtension->Des();

			aStore.ReadL(extPtr,size);

			}

		}

   	const TInt entryCount = aStore.ReadInt32L();

	if(entryCount < 0)

		{

		User::Leave(KErrCorrupt);

		}

   	// Security check is deferred until the DLL is needed.

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

	   	{

	   	CInterfaceData* interface = CInterfaceData::NewLC(this);

		interface->InternalizeL(aStore);

		AddL(interface);

	   	CleanupStack::Pop(interface);	// now owned by dll	

		}  	

	iDllEntry = CEComEntry::NewL(*name,secondUid,thirdUid);

	iDllEntry->SetModified(dllModifiedTime);

 	CleanupStack::PopAndDestroy(name);

	}

/**

@param			aParent The parent drive data of this implementation

*/	

CRegistryData::CDllData::CDllData( CDriveData* aParent) :

	CBase(),

	iParent(aParent)	

	{

	// Do nothing here

	//Initialize empty capabilities here

	iCapSet.SetEmpty();

	}

/**

Standard second phase construction function.

@pre 			This object is fully constructed.

@post			This object is fully constructed and initialized.

*/

void CRegistryData::CDllData::ConstructL()

	{

	iIfList = new(ELeave) RInterfaceList(2);

	}

/**

Standard second phase construction function with parameter.

@param			aDllName the name of this dll

@param			aDllModTime the modified time of this dll

@param 			aSecondUid Distinguishes between components having the same UID1 (which distinguishes between EXEs and DLLs) 

				UID2 identifies Interface Implementation Collections (collection and collection 3)

@param			aThirdUid Identifies a component uniquely. In order to ensure that each binary that needs a distinguishing 

				UID is assigned a genuinely unique value. Symbian manages UID allocation through central database.	

@pre 			This object is fully constructed.

@post			This object is fully constructed and initialized.

*/

void CRegistryData::CDllData::ConstructL(const TDesC& aDllName,const TTime& aDllModTime,const TUid& aSecondUid,const TUid& aThirdUid)

	{

	iIfList = new(ELeave) RInterfaceList(2);

	iDllEntry=CEComEntry::NewL(aDllName,aSecondUid,aThirdUid);

	iDllEntry->SetModified(aDllModTime);

	}

/**

Populate a caller-supplied TEntry instance with the data from this dll.

@param			aEntry An entry to be populated (destination)

*/

void CRegistryData::CDllData::PopulateAnEntry(TEntry& aEntry) const

	{

	TPtr bufPtr=aEntry.iName.Des();

	bufPtr.Zero();

	bufPtr.Append(iParent->iDrive.Name());

	bufPtr.Append(_L("\\sys\\bin\\"));

	bufPtr.Append(iDllEntry->GetName());

	aEntry.iType	= TUidType(KDynamicLibraryUid,iDllEntry->GetSecondUid(),iDllEntry->GetThirdUid());

	aEntry.iModified= iDllEntry->GetModified();

	}

//

// CRegistryData::CDriveData class

/**

Creates a new CDriveData object and places it on the CleanupStack

@param			aDrive Information on this drive

@param			aParent A pointer to the parent registry data

@return			A pointer to the newly created class.

@post			This object is fully constructed and initialized and on the CleanupStack.

*/

CRegistryData::CDriveData* CRegistryData::CDriveData::NewLC(TDriveUnit aDrive, CRegistryData* aParent)

	{

	CDriveData* self=new(ELeave) CDriveData(aDrive,aParent);  // calls c'tor

	CleanupStack::PushL(self);	// Make the construction safe by using the cleanup stack

	self->ConstructL(); // Complete the 'construction'.

	return self;

	}

/**

Destructor of CDriveData

*/

CRegistryData::CDriveData::~CDriveData()

	{

	if(iDllList)

		{

		// Clear the interface list and destroy its objects

		iDllList->ResetAndDestroy();

		delete iDllList;

		iDllList = NULL;

		}

	iParent=NULL;

	}

/**

Adds the specified CDllData to this drive data in the registry.

@param			aDll The Dll to add to this drive

@pre 			This object is fully constructed.

@post			aDll is added to the list of dll on this drive.

*/

void CRegistryData::CDriveData::AddL(const CDllData* aDll)

	{

	User::LeaveIfError(iDllList->Append(aDll));

	}

/**

Returns the index of the DLL with this Uid in the Dll list.

@param			aDllUid the UID of to be found DLL.

@return  		The index of this DLL in the DLL list. KErrNotFound if not found.

@pre			This object is fully constructed.

*/

TInt CRegistryData::CDriveData::FindDllIndex(const TUid aDllUid) const

	{

	const TInt dllCount = iDllList->Count();

	for(TInt j = 0; j < dllCount; ++j)

		{

		// For each dll structure check the dll UID

		CDllData* dll = (*iDllList)[j];

		if (aDllUid == dll->iDllEntry->GetThirdUid())

			{

			// it is a match 

 			return j;	 				

			}

		}

	return KErrNotFound;

	}

/**

Writes out the state of this CDriveData to file.

@param			aFs A handle to an open file server session.

@param			aDatFileName the dat file to persist to

@pre 			This object is fully constructed.

*/

void CRegistryData::CDriveData::ExternalizeL(RFs& aFs,const TDesC& aDatFileName) 

	{

	// attempt to create the folders if they don't already exist

	TInt mkDirError = aFs.MkDirAll(aDatFileName);

	if((mkDirError == KErrNone) || (mkDirError == KErrAlreadyExists))

		{

		RFileWriteStream registryStream;

		if(registryStream.Replace(aFs,aDatFileName, EFileWrite) == KErrNone)

			{

			CleanupClosePushL(registryStream);

			// Write the version number as the first thing in the file stream.

			registryStream.WriteInt32L(KRegVersion);				

			if(iDllList)

				{

				TInt entryCount = iDllList->Count();

				registryStream.WriteInt32L(entryCount);

				// Now stream out the data

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

					((*iDllList)[i])->ExternalizeL(registryStream);

				}

			else

				registryStream.WriteInt32L(0);

			CleanupStack::PopAndDestroy();	// registryStream

			}

		}

	else

		{

		User::Leave(mkDirError);

		}

	}

/**

Restores the state of this CDriveData from file.

@param			aFs A handle to an open file server session.

@param			aDatFileName the dat file name to internalize from

@pre 			This object is fully constructed.

@post			The state of this object is restored to that specified

				in the file on this drive.

*/

void CRegistryData::CDriveData::InternalizeL(RFs& aFs,const TDesC& aDatFileName)

	{

	DoInternalizeL(aFs, aDatFileName);  

	}

/**