// 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);
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);
}
/**
The method internalizes the data from aRegistryStream.
@param aFileName The ECOM registry file name.
@leave KErrNoMemory
@leave Some other system-wide error codes as well.
*/
void CRegistryData::CDriveData::DoInternalizeL(RFs& aFs, const TDesC& aFileName)
{
RFileReadStream registryStream;
User::LeaveIfError(registryStream.Open(aFs, aFileName, EFileRead));
CleanupClosePushL(registryStream);
// Read in version number. If its not what expected - the file is treated as corrupted.
const TInt version = registryStream.ReadInt32L();
if(version != KRegVersion)
{
User::Leave(KErrCorrupt);
}
const TInt entryCount = registryStream.ReadInt32L();
if(entryCount < 0)
{
User::Leave(KErrCorrupt);
}
for(TInt i = 0; i < entryCount; ++i)
{
CDllData* dll = CDllData::NewLC(this);
dll->InternalizeL(registryStream);
// always add the DLL, DLL security check will be deferred
// until the DLL is needed.
AddL(dll);
CleanupStack::Pop(dll); // now owned by drive
}
CleanupStack::PopAndDestroy();//registryStream
}
/**
Constructor for CDriveData
@param aDrive Information on this drive
@param aParent A pointer to the parent registry data
*/
CRegistryData::CDriveData::CDriveData(TDriveUnit aDrive, CRegistryData* aParent) :
CBase(),
iDrive(aDrive),
iParent(aParent),
iDriveChanged(ETrue),
iRegistryChanged(EFalse)
{
}
/**
Standard second phase construction function.
@pre This object is fully constructed.
@post This object is fully constructed and initialized.
*/
void CRegistryData::CDriveData::ConstructL()
{
iDllList = new(ELeave)TDll;
}
//
// CRegistryData class
/**
Standardized safe construction which leaves nothing on the cleanup stack.
This overload is used by CEComImplIndexPerfTest which plots
discovery time vs. granularity settings.
@leave KErrNoMemory.
@param aFs The open file session.
@param aInterfaceImplIndexGranularity granularity of main index.
@param aImplIndexGranularity granularity of auxiliary index.
@return The newly created instance of the registry data.
@post CRegistryData is fully constructed, and initialized.
*/
CRegistryData* CRegistryData::NewL(RFs& aFs, TInt aInterfaceImplIndexGranularity, TInt aImplIndexGranularity)
{
CRegistryData* self=new(ELeave) CRegistryData(aFs, aInterfaceImplIndexGranularity, aImplIndexGranularity); // calls c'tor
CleanupStack::PushL(self); // Make the construction safe by using the cleanup stack
self->ConstructL(); // Complete the 'construction'.
CleanupStack::Pop(self);
return self;
}
/**
Standardized safe construction which leaves nothing on the cleanup stack.
This overload uses default granularities for the two indexes. These
default values were found to provide reasonably good performance at
the time of testing.
@leave KErrNoMemory.
@param aFs The open file session.
@return The newly created instance of the registry data.
@post CRegistryData is fully constructed, and initialized.
*/
CRegistryData* CRegistryData::NewL(RFs& aFs)
{
return NewL(aFs, KDefaultInterfaceImplIndexGranularity, KDefaultImplIndexGranularity);
}
CRegistryData::~CRegistryData()
{
for(TInt index = 0; index < iInterfaceImplIndex.Count(); ++index)
{
iInterfaceImplIndex[index].Reset();
}
iInterfaceImplIndex.Reset();
// Reset only. It does not own the pointers!
iImplIndex.Reset();
if(iRegistrations)
{
iRegistrations->ResetAndDestroy();
delete iRegistrations;
iRegistrations = NULL;
}
// reset the cached language settings
RDowngradePath::Reset();
delete iCachedDriveInfo;
}
/**
Lists the implementations given the interface UID. The filtered list is returned in the client provided
RImplDataArray parameter.
@param aInterfaceUid The Uid of the interface which the implementations should provide
@param aImplementationData Return value. The filtered list.
*/
void CRegistryData::ListImplementationsL(TUid aInterfaceUid,
RImplDataArray& aImplementationData) const
{
// If discoveries are taking place then the index is invalid so we cannot do
// this request
if(iCurrentlyDiscovering)
User::Leave(KEComErrListCurrentlyUnavailable);
TBool securityPassed = EFalse;
//Do the security check
TInt index = 0;
while (!securityPassed)
{
aImplementationData.Reset();
index = IndexedFind(aInterfaceUid);
if(index == KErrNotFound)
{
User::Leave(KEComErrNoInterfaceIdentified);
}
User::LeaveIfError(index);
TImplContainerArray& implementationList = iInterfaceImplIndex[index].iImpData;
for (TInt j = 0; j < implementationList.Count(); j++)
{
CImplementationData* currentImplementation = implementationList[j].iCurrentImpl;
CDllData* dll = currentImplementation->iParent->iParent;
securityPassed = dll->ProcessSecurityCheckL();
if(!securityPassed)
{
// remove the implementations of the DLL from iInterfaceImplIndex
// and remove the DLL from its parent DLL list.
DeleteDllL(dll);
delete dll;
dll = NULL;
// don't continue processing implementations after we have deleted the DLL
// because the implementations list will have changed, so we need to
// re-do the IndexedFind
break;
}
else
{
User::LeaveIfError(aImplementationData.Append(currentImplementation));
}
}
}
}
/**
Enables or disables the specified interface implementation within the registry.
@param aImplementationUid The interface implementation to change.
@param aState ETrue to enable the implementation, EFalse to disable it
@return KErrNone, KEComErrEnableFailed or KEComErrDisableFailed
@pre CRegistry is fully constructed,
@post The implementation is now enabled or disabled as described
by aState.
*/
TInt CRegistryData::SetEnabledState(TUid aImplementationUid, TBool aState)
{
CImplementationData* impData = NULL;
TUid dummy={0x00000000};
(void)FindImplementation(aImplementationUid, dummy, impData);
if(impData != NULL)
{
impData->iImplInfo->SetDisabled((aState) ? EFalse : ETrue);
return KErrNone;
}
return (aState) ? KEComErrEnableFailed : KEComErrDisableFailed;
}
/**
Temporarily uninstalls the interface implementation groups upon the specified drive.
(ie this can be undone later).
@param aDrive The identifier of the drive to uninstall.
@pre CRegistry is fully constructed
@post The registered implementation groupings
stored upon the specified drive are no
longer available for use.
*/
void CRegistryData::TemporaryUninstallL(const TDriveUnit& aDrive)
{
// Find the appropriate drive entry and remove it...
// Note : the drive may have already been taken offline, so no save is possible!
CDriveData* drive = NULL;
TInt driveIndex = FindDriveL(aDrive, drive);
if(driveIndex != KErrNotFound)
{
TInt dllIndex = drive->iDllList->Count();
while(dllIndex > 0)
{
--dllIndex;
RemoveFromIndexL((*drive->iDllList)[dllIndex]);
}
iRegistrations->Remove(driveIndex);
delete drive;
DriveChanged(aDrive, ETrue);
}
// The flag iRegistryChanged has been moved to each drive.
}
/**
Undoes a temporary uninstall of the interface
implementation groups upon the specified drive.
(ie this can be undone later).
@leave KErrNoMemory, KErrReinstallFailed.
@param aDrive The identifier of the drive to reinstate.
@pre CRegistry is fully constructed
@post The registered implementation groupings
stored upon the specified drive are again
made available for use.
*/
void CRegistryData::UndoTemporaryUninstallL(const TDriveUnit& aDrive)
{
CDriveData* driveData = NULL;
// If the drive was not found then install it, otherwise do nothing because it
// is already there. NB. We could leave here but the problem with that is the
// use case where the drive has been mounted during registry load but the registrar
// is started afterwards, and makes calls to this method as it discovers drives
// for the first time.
if(FindDriveL(aDrive, driveData) == KErrNotFound)
{
// Add the drive entry
CDriveData* drive = CDriveData::NewLC(aDrive,this);
AddImplDataL(drive);
User::LeaveIfError(iRegistrations->Append(drive));
CleanupStack::Pop(drive); // now owned by iRegistrations
DriveChanged(aDrive, EFalse);
// NB We DO need to set iRegistryChanged = ETrue because the idx file needs to be
// rewritten to include the reinstalled drive
}
}
/**
Update the staus of drives in the system
@param aDrive The drive that has changed
@param aDriveRemoved Indicates whether a drive has been removed or added
@pre CRegistry is fully constructed.
@post The state of the drive has been stored
*/
void CRegistryData::DriveChanged(const TDriveUnit& aDrive, TBool aDriveRemoved)
{
if(aDriveRemoved)
{
iRemovedDrives |= (0x1 << aDrive);
}
else
{
iRemovedDrives &= ~(0x1 << aDrive);
}
}
/**
Find if any Dll is regsitered in the drive unit.
@param aDrive The identifier of the drive to find if any Dll is registered.
@return ETrue if any Dll is registered in the drive, otherwise EFalse.
@pre CRegistry is fully constructed.
@post If any Dll is registered in the drive is returned if successfully.
*/
TBool CRegistryData::IsAnyDllRegisteredWithDriveL(const TDriveUnit& aDrive)const
{
CDriveData* driveData = NULL;
if(FindDriveL(aDrive, driveData) == KErrNotFound)
{
User::Leave(KEComErrDriveNotFound);
}
return driveData->iDllList->Count() > 0;
}
/**
Determine if the specified implementation grouping already registered, but needs an update.
@param aDllUid The interface implementation collection data to add.
CRegistryData takes ownership of this object
so it should not be on the CleanupStack.
@param aModified The date of the last modification of the Interface
Implementation Collection.
@param aUpdate An output to indicate if the registry entry requires an update.
(Only valid if the return is ETrue).
@param aDriveData The drive data used to find DLL.
@return ETrue if the Interface Implementation Collection already has a registry entry.
EFalse otherwise.
@pre This object is fully constructed and there is also a valid drive entry
in the registry for aDrive
@post The new data is added to the registry
*/
TBool CRegistryData::IsRegisteredWithDate (TUid aDllUid,
const TTime& aModified,
TBool& aUpdate,
CDriveData* aDriveData)
{
// Find the appropriate drive entry for this
// Interface Implementation Collection
TBool found = EFalse;
TInt index = aDriveData->FindDllIndex(aDllUid);
if(index != KErrNotFound)
{
TDll* dllList = aDriveData->iDllList;
CDllData* dll = (*dllList)[index];
const CEComEntry& dllEntry =*(dll->iDllEntry);
aUpdate = dllEntry.GetModified().Int64() < aModified.Int64();
found = ETrue;
}
return found;
}
/**
Adds data on a specific dll to the registry. The data to be added
is parsed by CRegistryParser.
@leave KErrNoMemory If the item could not be appended to the registry
@leave KEComErrDriveNotFound If aDrive is not a valid drive
@param aDrive The drive the registry data has been found on
@param aFoundDriveIndex The index of the registry data for the drive
the interface implementation collection data has been found on.
@param aDllData The dll data to add. CRegistryData takes ownership of this object
so it should not be on the CleanupStack.
@pre This object is fully constructed and there is also a valid drive entry
in the registry for aDrive
@post The new data is added to the registry
*/
void CRegistryData::AddDllDataL(const TDriveUnit& aDrive, TInt aFoundDriveIndex, CRegistryData::CDllData* aDllData)
{
const TInt regCount = iRegistrations->Count();
if(regCount == 0)
User::Leave(KEComErrDriveNotFound);
// Find the appropriate drive entry
CDriveData* drive = NULL;
if(aFoundDriveIndex == KErrNotFound)
{
if(FindDriveL(aDrive, drive) == KErrNotFound)
User::Leave(KEComErrDriveNotFound);
}
else
drive = (*iRegistrations)[aFoundDriveIndex];
// Append the new data to the list
TDll* dllList = drive->iDllList;
// NOTE : This function MUST NOT leave after the following line because
// aDllData will potentially be 'owned' in two places (dllList and the caller)
// until we return and the caller can Pop.
TBool checkNeeded = ETrue;
TInt ifListCount=aDllData->iIfList->Count();
for(TInt ifListCounter=0; ifListCounter < ifListCount; ifListCounter++)
{
// For each interface structure
CInterfaceData* interface = (*aDllData->iIfList)[ifListCounter];
for(TInt impNum = 0; impNum < interface->iImplementations->Count(); ++impNum)
{
CImplementationData* implData = (*interface->iImplementations)[impNum];
if(!InsertIntoIndexL(implData,checkNeeded))
{
interface->iImplementations->Remove(impNum); //remove from implementation array
delete implData; //delete object
}
}
}
//add filtered list for legitimate implementations into registry
User::LeaveIfError(dllList->Append(aDllData));
drive->iRegistryChanged = ETrue;
}
/**
Updates the data for a dll in the registry.
@leave KErrNoMemory If the indexes cannot be rebuilt
@param aFoundDriveIndex The index of the registry data for the drive
the interface implementation collection data has been found on.
@param aDllData The updated interface implementation collection data.
CRegistryData takes ownership of this object
so it should not be on the CleanupStack.
@pre This object is fully constructed
@post The dll data is updated in the registry
*/
void CRegistryData::UpdateDllDataL(const TDriveUnit& aDrive,TInt aFoundDriveIndex, CDllData* aDllData)
{
const TInt regCount = iRegistrations->Count();
if(regCount == 0)
User::Leave(KEComErrDriveNotFound);
// Find the appropriate drive entry
CDriveData* drive = (*iRegistrations)[aFoundDriveIndex];
TInt index = drive->FindDllIndex(aDllData->iDllEntry->GetThirdUid());
// find the dll entry and clear that too
if(index != KErrNotFound)
{
// Ok its a match, so remove this registry entry and call AddDllData()
//to add the new dll
TDll* dllList = drive->iDllList;
CDllData* olddll = (*dllList)[index];
//remove 'old'implementations from iInterfaceImplIndex
RemoveFromIndexL(olddll);
//now remove old dll from the array and registry
dllList->Remove(index);
delete olddll;
AddDllDataL(aDrive,aFoundDriveIndex,aDllData);
drive->iRegistryChanged = ETrue;
}
if (index == KErrNotFound)
{
__ECOM_TRACE("ECOM: PANIC in CRegistryData::UpdateDllDataL(), expected DLL data missing from ECOM registry");
__ASSERT_DEBUG(EFalse, User::Panic (KEComServerPanicCategory, EEComPanic_CRegistryData_UpdateDllDataL_DllRegistrationMissing));
}
}
/**
The cue that newly discovered Dlls are about to be registered,
and, therefore, the registry index will be out of date until
DiscoveriesCompleteL is called.
@pre CRegistrar is fully constructed
@post iCurrentlyDiscovering is set and the index list is cleared.
*/
void CRegistryData::DiscoveriesBeginning() const
{
iCurrentlyDiscovering = ETrue;
// The registry is about to start changing so the index is now invalid
}
/**
The cue to rebuild the registry indexes
@leave KErrNoMemory
@see CStore
@param aSuccessful Indicates whether discovery completed fully or not
@param aProcessingType indicates the type of processing for plugins
for ensuring that plugins are not processed multiple times
during start-up phase
@param aHasRegistryChanged The flag to indicate whether registry data has been changed
@pre CRegistrar is fully constructed
@post The internal access indexes have been rebuilt
*/
void CRegistryData::DiscoveriesCompleteL(TBool aSuccessful, TPluginProcessingTypeIdentifier aProcessingType, TBool& aHasRegistryChanged)
{
iCurrentlyDiscovering = EFalse;
if (!aSuccessful)
{
return;
}
//if the rediscovery is a result of iLanguageChanged, we should reset it to false
iLanguageChanged=EFalse;
// Warning: this method may be called from the CEComServer destructor.
// E.g. ecomservertest running OOM test on CEComServer::NewLC.
// The call stack:
// ~CEComServer delete iRegistrar, ~CRegistrar delete iDiscoverer,
// ~CDiscoverer calls CRegistrar::DiscoveriesComplete,
// then here.
// Hence if ! aSuccessful do not validate.
if(aProcessingType != EPluginProcessingTypeCriticalOnly)
{
ValidateRegistryL();
}
if(aProcessingType==EPluginProcessingTypeNonCriticalOnly || aProcessingType==EPluginProcessingTypeAll)
{
//first find whether there is any registry data changed
TInt regCount=iRegistrations->Count();
for(TInt i = 0; i <regCount; i++)
{
if ((*iRegistrations)[i]->iRegistryChanged)
{
aHasRegistryChanged = ETrue;
//now having cached that the registry has changed we need
//to reset this flag in ALL the CDriveData, note that it is
//possible that more than one drive will have the flag set
(*iRegistrations)[i]->iRegistryChanged=EFalse;
}
}
//Also indicate registry change if any drives have been removed
aHasRegistryChanged |= (iRemovedDrives != 0);
iRemovedDrives = 0;
}
}
/**
@fn SetDiscoveryFlag(const TDriveUnit aDrive)
Intended Usage : Set the flag to indicate the drive has change(s)
Error Condition : None.
@param aDrive The identifier of the drive changed.
@pre The CRegistrar must be fully constructed
@post The flag is set.
*/
void CRegistryData::SetDiscoveryFlagL(const TDriveUnit& aDriveUnit)
{
CDriveData* drive = NULL;
TInt driveIndex = FindDriveL(aDriveUnit, drive);
if(driveIndex != KErrNotFound)
{
drive->iDriveChanged = ETrue;
}
}
/**
Indicates whether the registry index is currently valid. The
index will not be valid if discoveries are currently taking place.
If the index is not currently valid then calls to
ListImplementationsL() cannot be serviced.
@return ETrue if the index is currently valid, EFalse otherwise.
@pre CRegistrar is fully constructed
*/
TBool CRegistryData::IndexValid() const
{
return !iCurrentlyDiscovering;
}
/**
@param aCapabilitySet A capability set
@param aImplUid The Uid of the implementation for which info is required
@param aInterfaceUid The uid of the interface associated with aImplUid to find or less than
0 if uid is unknown.
@param aEntry Output parameter which will contain the dll information
@param aImplInfo An output parameter. If the call succeeds it will point to the found implementation information,
NULL otherwise.
@param aIsOnRWDrive an output parameter. If the call is successful, this will
be set to ETrue if the implementation is on RW drive. EFalse if the
implementation is on ReadOnly drive.
@return KErrNone if the call succeeds, KErrNotFound - no implementation found,
KErrPermissionDenied - the caller has not enough capabilities to load the plugin.
@pre CRegistrar is fully constructed
*/
TInt CRegistryData::GetImplementationDllInfoForServer(
const TCapabilitySet& /*aCapabilitySet*/,
const TUid aImplUid,
const TUid aInterfaceUid,
TEntry& aEntry,
CImplementationInformation*& aImplInfo,
TBool& aIsOnRWDrive) const
{
aImplInfo = NULL;
CImplementationData* implData;
TInt res = FindImplementation(aImplUid, aInterfaceUid, implData);
if (KErrNone != res)
{
return res;
}
aImplInfo = implData->iImplInfo;
const CDllData* dll = implData->iParent->iParent;
dll->PopulateAnEntry(aEntry);
TEComCachedDriveInfoIterator iter(*iCachedDriveInfo);
if (! iter.SetPos(dll->iParent->iDrive))
{
res = KErrNotFound;
}
else
{
aIsOnRWDrive = iter.DriveIsWritable();
}
return res;
}
/**
@param aClientRequest A client request
@param aImplUid The Uid of the implementation for which info is required
@param aInterfaceUid The uid of the interface associated with aImplUid to find or less than
0 if uid is unknown.
@param aEntry Output parameter which will contain the dll information
@param aImplInfo An output parameter. If the call succeeds it will point to the found implementation information,
NULL otherwise.
@param aSecurityCheckNeeded The bool value to identify whether the security check is needed here. The default value is false.
@return KErrNone if the call succeeds, KErrNotFound - no implementation found,
KErrPermissionDenied - the caller has not enough capabilities to load the plugin.
@pre CRegistrar is fully constructed
*/
TInt CRegistryData::GetImplementationDllInfoForClientL(
const TClientRequest& aClientRequest,
const TUid aImplUid,
const TUid aInterfaceUid,
TEntry& aEntry,
CImplementationInformation*& aImplInfo,
TBool aSecurityCheckNeeded)const
{
aImplInfo = NULL;
TInt res = KErrNotFound;
CImplementationData* implData;
if (!aSecurityCheckNeeded)
{
//The security check has been done already. All the invalid dll have been removed.
res = FindImplementation(aImplUid, aInterfaceUid, implData);
if (KErrNone != res)
{
return res;
}
CDllData* dll = implData->iParent->iParent;
dll->PopulateAnEntry(aEntry);
aImplInfo = implData->iImplInfo;
}
else
{
TBool securityPassed = EFalse;
while(!securityPassed) // go out of this loop either Security check is passed or no DLL found.
{
res = FindImplementation(aImplUid, aInterfaceUid, implData);
if (KErrNone != res)
{
return res;
}
CDllData* dll = implData->iParent->iParent;
// security check is deferred to here.
securityPassed = dll->ProcessSecurityCheckL();
if(securityPassed)
{
if (!aClientRequest.CheckCapability(dll->iCapSet, *(implData->iImplInfo)))
{
return KErrPermissionDenied;
}
dll->PopulateAnEntry(aEntry);
aImplInfo = implData->iImplInfo;
}
else
{
// remove the implementations of the DLL from iInterfaceImplIndex
// and remove the DLL from its parent DLL list.
DeleteDllL(dll);
delete dll;
dll = NULL;
}
}
}
return res;
}
/**
This method removes all implementations of This Dll from the iInterfaceImplIndex,
then delete this Dll from its parent Dll list.
@param aDllData the Dll to be cleaned.
@pre CRegistrar is fully constructed
*/
void CRegistryData::DeleteDllL(CDllData* aDllData) const
{
// find the index of the passed aDllData in its parent's Dll list.
TInt index = aDllData->iParent->FindDllIndex(aDllData->iDllEntry->GetThirdUid());
//removes all implementations of This Dll from the iInterfaceImplIndex
RemoveFromIndexL(aDllData);
if(index != KErrNotFound)
{
//now remove the dll from the array and registry
TDll* dllList = aDllData->iParent->iDllList;
dllList->Remove(index);
}
}
/**
Indicates whether the language downgrade path has changed.
This means we need to call NearestLanguageFile again
@return ETrue if the language downgrade path has changed, EFalse otherwise.
@pre CRegistrar is fully constructed
*/
TBool CRegistryData::HasLanguageChanged() const
{
return iLanguageChanged;
}
/**
@param aFs A handle to a connected file server.
*/
CRegistryData::CRegistryData(RFs& aFs,
TInt aInterfaceImplIndexGranularity,
TInt aImplIndexGranularity) :
CBase(),
iFs(aFs),
iInterfaceImplIndex(aInterfaceImplIndexGranularity),
iImplIndex(aImplIndexGranularity)
{
}
/**
Completes the safe construction of the CRegistryData object.
@leave KErrNoMemory.
@pre This object is constructed
@post This object is fully initialized
*/
void CRegistryData::ConstructL()
{
iCachedDriveInfo = CEComCachedDriveInfo::NewL(iFs);
// Construction of the empty registration data structure here
iRegistrations = new(ELeave)TRegistration;
iSystemDrive=iFs.GetSystemDrive();
// during construction we always need to call this function in
// order to initialise and store the language settings at boot time
TRAPD(err,iLanguageChanged=RDowngradePath::HasChangedL(iFs))
if (err==KErrNoMemory)
{
User::LeaveNoMemory();
}
}
/**
To find the index entry for aImplementationUid.
@return The index of the item or KErrIndexEntryNotFound.
@pre This object is fully constructed
*/
TInt CRegistryData::IndexedFind(TUid aInterfaceUid) const
{
// Find the correct implementation
TInterfaceIndex key;
key.iInterfaceUid = aInterfaceUid;
return iInterfaceImplIndex.FindInOrder(key,TLinearOrder<TInterfaceIndex>(TInterfaceStruct::CompareInfUid));
}
/**
Used by a TIdentityRelation to decide if two CDriveData match.
@return ETrue if the TDriveUnit inside the indexes match.
@param aIndexOne The first CDriveData to compare
@param aIndexTwo The second CDriveData to compare
*/
TBool CRegistryData::MatchOnDrive(const CRegistryData::CDriveData& aIndexOne,
const CRegistryData::CDriveData& aIndexTwo)
{
return aIndexOne.iDrive == aIndexTwo.iDrive;
}
TInt CRegistryData::FindDriveL(const TDriveUnit& aDrive,
CRegistryData::CDriveData*& aDriveData)const
{
TInt index = KErrNotFound;
// Set up the find parameters
TIdentityRelation<CRegistryData::CDriveData> identity(MatchOnDrive);
CDriveData* driveToMatch = CDriveData::NewLC(aDrive,const_cast<CRegistryData*>(this));
index = iRegistrations->Find(driveToMatch, identity);
CleanupStack::PopAndDestroy(driveToMatch);
if(index != KErrNotFound)
aDriveData = (*iRegistrations)[index];
else
aDriveData = NULL;
return index;
}
/**
Finds the instance of CImplementationData for given impl uid and interface uid if known.
@return KErrNone if impl found, otherwise KErrNotFound.
@param aImplUid The uid of the impl to find
@param aInterfaceUid The uid of the interface associated with the impl to find or less than
0 if uid is unknown
@param aImplData Set to the instance CImplementationData found in the index or if
not found set to NULL. This argument is always overwritten.
*/
TInt CRegistryData::FindImplementation(const TUid aImplUid, const TUid aInterfaceUid,
CImplementationData*& aImplData) const
{
aImplData = NULL;
TInt i;
// Index is kept up to date even when discoveries are occurring
// therefore always search index for implementation
// if aInterfaceUid is non zero use it to find position in index list
if(aInterfaceUid.iUid != 0)
{
i = IndexedFind(aInterfaceUid);
if(i == KErrNotFound)
{
return KErrNotFound;
}
TInterfaceIndex listItem = iInterfaceImplIndex[i];
i = listItem.iImpData.FindInOrder(aImplUid,
TImplStruct::CompareUidAgainstImplStruct);
if (i >= 0)
{
aImplData = listItem.iImpData[i].iCurrentImpl;
return KErrNone;
}
}
else // not given I/F UID. Use the iImplIndex.
{
// NB: 1. Impl UID should be globally unique. It is an error if impls
// have same Impl UID but different i/f UIDs. It means one of the
// plug-in supplier made an error in the .RSS file or it could be a
// deliberate attach. But to maintain backward compatibility, ECOM
// allows this error.
// (Multiple impls can have same i/f UID and same Impl UID. That is
// the upgrade situation and only one of them get stored in iImplIndex.)
// 2. Entries in iImplIndex are ordered by Impl UID, and if duplicated,
// ordered by i/f UID. Here i/f UID is wild card. The situation is
// analogous to the array was built with InsertInOrderAllowRepeats.
// RPointerArray::SpecificFindInOrder is for ordered search in array
// with duplicates. Note: it is very expensive to instantiate
// a CImplementationData* just for binary search. Hence reinterpret
// cast the TUid* as CImplementationData*. CompareUidAgainstImplData
// knows to cast the first argument back to TUid.
i = iImplIndex.SpecificFindInOrder(
reinterpret_cast<const CImplementationData*>(&aImplUid),
TLinearOrder<CImplementationData>(CImplementationData::CompareUidAgainstImplData),
EArrayFindMode_First);
if (i == KErrNotFound)
{
return KErrNotFound;
}
aImplData = iImplIndex[i];
// If duplicates exist, they are sorted according to i/f UID
// but we cannot take advantage of this order. To miniize risk
// of malware using duplicate Impl UID as DOS attack, ECOM applies
// the rule that ROMBased plug-in preferred over non-ROMBased,
// higher drive letter preferred over lower drive letter, and
// lastly lower i/f UID preferred over higher i/f UID. Must visit
// every duplicate to compare their ROMBasedness and driver letter
TInt count = iImplIndex.Count();
for (TInt j = i + 1; j < count; j++)
{
if ( iImplIndex[j]->iImplInfo->ImplementationUid().iUid != aImplUid.iUid )
{
break;
}
aImplData = SelectDuplicatedImpl(aImplData, iImplIndex[j]);
}
return KErrNone;
}
return KErrNotFound;
}
/**
This function helps FindImplementation() to decide which of two
implementations with duplicated implementation UID to choose.
The selection rules are:
1. ROM based plugins > non-ROM based.
2. Higher drive letter > lower drive letter
3. Lower I/F UID > Higher I/F UID (for backward compatibility reason)
@param aImpl1 - one of the two implementations to compare.
@param aImpl2 - the other implementation to compare.
@return the preferred implementation.
*/
CRegistryData::CImplementationData* CRegistryData::SelectDuplicatedImpl(
const CImplementationData* aImpl1,
const CImplementationData* aImpl2) const
{
#ifdef ECOM_TRACE
TPtrC oldName = aImpl1->iImplInfo->DisplayName().Left(60);
TPtrC newName = aImpl2->iImplInfo->DisplayName().Left(60);
TPtrC oldDll = aImpl1->iParent->iParent->iDllEntry->GetName();
TPtrC newDll = aImpl2->iParent->iParent->iDllEntry->GetName();
#endif
const TInt KRomBasedFactor = 0x100;
TInt drive1 = aImpl1->iImplInfo->Drive();
if (aImpl1->iImplInfo->RomBased())
{
drive1 |= KRomBasedFactor;
}
TInt drive2 = aImpl2->iImplInfo->Drive();
if (aImpl2->iImplInfo->RomBased())
{
drive2 |= KRomBasedFactor;
}
if (drive1 > drive2)
{
#ifdef ECOM_TRACE
if ((drive1 & KRomBasedFactor) && !(drive2 & KRomBasedFactor))
{
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select ROM based %S over R/W %S", &newName, aImpl2->iParent->iInterfaceUid.iUid, aImpl2->iImplInfo->ImplementationUid().iUid, &oldDll, &newDll);
}
else
{
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select higher drive %S over %S", &newName, aImpl2->iParent->iInterfaceUid.iUid, aImpl2->iImplInfo->ImplementationUid().iUid, &oldDll, &newDll);
}
#endif
return const_cast<CImplementationData*>(aImpl1);
}
else if (drive1 < drive2)
{
#ifdef ECOM_TRACE
if ((drive2 & KRomBasedFactor) && !(drive1 & KRomBasedFactor))
{
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select ROM based %S over R/W %S", &oldName, aImpl1->iParent->iInterfaceUid.iUid, aImpl1->iImplInfo->ImplementationUid().iUid, &newDll, &oldDll);
}
else
{
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select higher drive %S over %S", &oldName, aImpl1->iParent->iInterfaceUid.iUid, aImpl1->iImplInfo->ImplementationUid().iUid, &newDll, &oldDll);
}
#endif
return const_cast<CImplementationData*>(aImpl2);
}
// They are on the same drive. Choose the one with lower I/F UID.
else if (aImpl2->iParent->iInterfaceUid.iUid < aImpl1->iParent->iInterfaceUid.iUid)
{
#ifdef ECOM_TRACE
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select %S with lower i/f UID 0x%X", &oldName, aImpl1->iParent->iInterfaceUid.iUid, aImpl1->iImplInfo->ImplementationUid().iUid, &newDll, aImpl2->iParent->iInterfaceUid.iUid);
#endif
return const_cast<CImplementationData*>(aImpl2);
}
#ifdef ECOM_TRACE
__ECOM_TRACE5("ECOM dup impl UID resolution: rejected \"%S\" i/f UID 0x%X impl UID 0x%X, select %S with lower i/f UID 0x%X", &newName, aImpl2->iParent->iInterfaceUid.iUid, aImpl2->iImplInfo->ImplementationUid().iUid, &oldDll, aImpl1->iParent->iInterfaceUid.iUid);
#endif
return const_cast<CImplementationData*>(aImpl1);
}
/**
Checks each entry in the registry to ensure that both the RSC file and the
corresponding dll exist. If not the dll branch is removed
from the tree. If a drive branch is found which contains no dlls
it is also removed.
@pre This object is fully constructed.
@post Any out of date registry entries are removed from the tree.
*/
void CRegistryData::ValidateRegistryL()
{
TInt driveIndex = iRegistrations->Count();
TFileName rscFileName;
while(driveIndex > 0)
{
--driveIndex;
CDriveData* drive = (*iRegistrations)[driveIndex];
if( !iCachedDriveInfo->DriveIsReadOnlyInternalL(drive->iDrive) &&
drive->iDriveChanged)
{
TInt dllIndex = drive->iDllList->Count();
while(dllIndex > 0)
{
--dllIndex;
CDllData* dll = (*drive->iDllList)[dllIndex];
//reset the buffer first
rscFileName.Zero();
rscFileName.Append(dll->iParent->iDrive.Name());
rscFileName.Append(KEComResourceFilePath);
rscFileName.Append(dll->iDllEntry->GetName().Left(dll->iDllEntry->GetName().Length()-4));
if(dll->iRscFileExtension)
{
rscFileName.Append(dll->iRscFileExtension->Des());
}
// check the existence of RSC file in resource\plugins\ directory.
// RSC filename is already a full name here.
TBool rscFileExistence = BaflUtils::FileExists(iFs, rscFileName);
//save the security info, this will both check existence of the dll
//and cache the information for future use
TBool success=dll->SaveSecurityInfoL();
// If this dll is not found or the corresponding RSC file is not found, then remove it from the registry
if(!success || !rscFileExistence)
{
//remove all implementations of this dll from iInterfaceImplIndex
RemoveFromIndexL(dll);
drive->iDllList->Remove(dllIndex);
//set flag to indicate registry data has been changed
drive->iRegistryChanged = ETrue;
delete dll;
}
}
}
}
}
/**
Determines whether the new implmentation should be preferred over the existing implementation.
Validates later version implementations from R/W drives.
@param aOldImpl The array to append to
@param aNewImpl The item to append
@param aLegitimateImpl Flag, indicating whether current implementation is secure
@return The preferred implementation
@pre This object is fully constructed.
*/
CRegistryData::CImplementationData* CRegistryData::SelectPreferredImplL(CImplementationData* aOldImpl,
CImplementationData* aNewImpl,
TBool& aLegitimateImpl,
TBool aCheckIsNeeded) const
{
aLegitimateImpl = ETrue;
TBool newIsRomOnly = aNewImpl->iImplInfo->RomOnly();
TBool oldIsRomOnly = aOldImpl->iImplInfo->RomOnly();
/* In addition to selecting the highest version of an
implementation this check takes care of the following special
cases:
1. Ensure that a higher-versioned RAM-based implementation
cannot override a ROM-based version
2. Allows for the case where there are two versions of the
same ROM-only implementation on ROM, thus ensuring the
higher of the two versions is used.
*/
if(newIsRomOnly && !oldIsRomOnly)
{
return aNewImpl;
}
else if((newIsRomOnly && oldIsRomOnly))
{
if(aNewImpl->iImplInfo->Version() > aOldImpl->iImplInfo->Version())
{
return aNewImpl;
}
else if(aNewImpl->iImplInfo->Version() == aOldImpl->iImplInfo->Version())
{
//any drive from Y-A has higher priority than Z drive
//any drive with a letter alphabetically greater has higher priority
if((aNewImpl->iImplInfo->Drive() != EDriveZ) &&
(aOldImpl->iImplInfo->Drive() == EDriveZ || aNewImpl->iImplInfo->Drive() > aOldImpl->iImplInfo->Drive()))
{
return aNewImpl;
}
}
}
//all new implementations which are not flagged'RomOnly'
else if(!newIsRomOnly && !oldIsRomOnly)
{
TBool newIsReadOnly = iCachedDriveInfo->DriveIsReadOnlyInternalL(aNewImpl->iParent->iParent->iParent->iDrive);
TBool oldIsReadOnly = iCachedDriveInfo->DriveIsReadOnlyInternalL(aOldImpl->iParent->iParent->iParent->iDrive);
if(aNewImpl->iImplInfo->Version() > aOldImpl->iImplInfo->Version())
{
//filter for implementations on R/W drive trying to upgrade implementations on R/O drive
if((!newIsReadOnly && oldIsReadOnly) && aCheckIsNeeded)
{
//test if a later implementation version on R/W drive has the same filename as the current one before upgrading.
//If not,...
if(aOldImpl->iParent->iParent->iDllEntry->GetName().CompareF(aNewImpl->iParent->iParent->iDllEntry->GetName()) == 0)
{
return aNewImpl;
}
else
{
aLegitimateImpl = EFalse; //not secure
return aOldImpl;
}
}
else
{
return aNewImpl;
}
}
else if(aNewImpl->iImplInfo->Version() == aOldImpl->iImplInfo->Version())
{
//any drive from Y-A has higher priority than Z drive OR
//any drive with a letter alphabetically greater has higher priority
if((aNewImpl->iImplInfo->Drive() != EDriveZ) &&
(aOldImpl->iImplInfo->Drive() == EDriveZ || aNewImpl->iImplInfo->Drive() > aOldImpl->iImplInfo->Drive()))
{
//filename check needs to performed on implementation from R/W drives, trying to
//upgrade implementations on R/O drive
if((!newIsReadOnly && oldIsReadOnly) && aCheckIsNeeded)
{
//test if a later implementation version on R/W drive has the same filename as the current one before upgrading.
//If not,...
if(aOldImpl->iParent->iParent->iDllEntry->GetName().CompareF(aNewImpl->iParent->iParent->iDllEntry->GetName()) == 0)
{
return aNewImpl;
}
else
{
aLegitimateImpl = EFalse; //not secure
return aOldImpl;
}
}
else
{
return aNewImpl;
}
}
}
}
return aOldImpl;
}
/**
This functions checks if a given implementation already exists in
the indexes. If it does exist, determine if the given implementation
should replace the existing one or not.
@param aIdxArray The container array of the interface to hold the implementation.
@param aNewImpl The implementation to filter.
@param aInsertMode whether aNewIMpl is a newcomer of the interface, or an
update of an existing implementation, or a older version of an
existing implementation.
@param aPosOfImplInArray return the index of aNewImpl in aIdxArray,
@param aLegitimateImpl Flag,indicating whether current implementation is secure
@pre This object is fully constructed.
@post none
*/
void
CRegistryData::FilterForLatestLegitimateImplL(TImplContainerArray& aIdxArray,
CImplementationData* aNewImpl,
TInsertImplMode& aInsertMode,
TInt& aPosOfImplInArray,
TBool& aLegitimateImpl,
TBool aCheckIsNeeded)
{
aInsertMode = EInsertImplUndefinedMode;
aLegitimateImpl = ETrue;
TImplStruct newImplStruct;
newImplStruct.iCurrentImpl = aNewImpl;
TInt idxPos = aIdxArray.FindInOrder(newImplStruct, TLinearOrder<TImplStruct> (TImplStruct::CompareImplStructUid));
aPosOfImplInArray = idxPos;
if(idxPos != KErrNotFound)
{
if(aNewImpl != SelectPreferredImplL(aIdxArray[idxPos].iCurrentImpl,
aNewImpl,
aLegitimateImpl,
aCheckIsNeeded))
{
aInsertMode = EInsertImplAsUnusedImpl;
}
else
{
aInsertMode = EInsertImplAsUpgradeOfExistingImpl;
}
}
else
{
aInsertMode = EInsertImplAsNewcomerOfInterface;
}
}
void CRegistryData::ResetTInterfaceIndex(TAny* aObject)
{
TInterfaceIndex* index=reinterpret_cast<TInterfaceIndex*>(aObject);
index->Reset();
}
void CRegistryData::RemoveImplFromImplIndexCleanUp(TAny* aPtr)
{
TCleanupImplIndexEntry *aCleanup = (TCleanupImplIndexEntry*)aPtr;
aCleanup->iRegistryData->RemoveImplByAddrFromImplIndex(aCleanup->iImplEntry);
}
/**
This method retrieves the data for security checks from the iInterfaceImplIndex
@param aImplPtr The new item to be checked
@param aCheckIsNeeded Boolean indicating, whether a filename check is needed
@pre This object is fully constructed.
@post aImplPtr has been checked and added to the index, or not, depending on the
outcome of the checks.
*/
TBool CRegistryData::InsertIntoIndexL(CImplementationData* aImplPtr, TBool aCheckIsNeeded)
{
TBool legitimateImpl = ETrue;
TInterfaceIndex newIndexEl;
TInterfaceIndex* newElPtr;
//initialise
newIndexEl.iInterfaceUid = aImplPtr->iParent->iInterfaceUid;
CleanupStack::PushL(TCleanupItem(ResetTInterfaceIndex,&newIndexEl));
TInt indexPos = iInterfaceImplIndex.FindInOrder(newIndexEl,TLinearOrder<TInterfaceIndex>(TInterfaceStruct::CompareInfUid));
if(indexPos!=KErrNotFound)
newElPtr = &(iInterfaceImplIndex[indexPos]);
else
newElPtr = &newIndexEl;
// For each implementation make sure we only have the latest version
TInt implIdxInContainerArray(KErrNotFound);
TInsertImplMode insertMode;
FilterForLatestLegitimateImplL(newElPtr->iImpData,
aImplPtr,
insertMode,
implIdxInContainerArray,
legitimateImpl,
aCheckIsNeeded);
InsertImplInIndexesL(insertMode,
indexPos,
*newElPtr,
implIdxInContainerArray,
aImplPtr,
legitimateImpl);
CleanupStack::Pop();
if (insertMode == EInsertImplAsUpgradeOfExistingImpl)
{
TUid ImplUid = aImplPtr->iImplInfo->ImplementationUid();
iImplUpgradeCallBack.CallBack(ECallBackId_ImplUpgrade, &ImplUid);
}
return legitimateImpl;
}
/** Handle inserting a CImplementationData in iInterfaceImplIndex and
iImplIndex.
@param aNewImpl the implementation to add to the indexes.
@param aInsertMode indicates whether the implementation is a newcover
of the interface, or is an update of existing implementation
or is an older version of an existing implementation.
@param aIfPosInInterfaceImplIndex is the index of the interface in
iInterfaceImplIndex.
@param aNewIfIndexEl the TInterfaceIndex object containing the implementation.
@param aImplPosInContainerArray is the index of the implementation in
the iImpData member of aNewIfIndexEl.
@param aLegitimateImpl indicate if the implementation passed security check or not.
@leave KErrNoMemory operation fails because the system is out of memory.
@leave KErrGeneral any non-specific programming error.
@leave KErrAlreadyExists the indexes already have an entry with the same
Impl. UID and Interface UID.
*/
void CRegistryData::InsertImplInIndexesL(TInsertImplMode aInsertMode,
TInt aIfPosInInterfaceImplIndex,
TInterfaceIndex& aNewIfIndexEl,
TInt aImplPosInContainerArray,
CImplementationData* aNewImpl,
TBool aLegitimateImpl)
{
if(aInsertMode == EInsertImplUndefinedMode)
{
// Will not happen because if FilterForLatestLegitimateImplL
// does not leave then insertMode is set to one of the valid
// values. If FilterForLatestLegitimateImplL leaves ecomserver exits.
User::Leave(KErrGeneral);
}
// If not a legitimate implementation, aNewImpl will be deleted.
// Do not add it to the two indexes.
if (!aLegitimateImpl)
{
return;
}
TImplContainerArray& implContainerArray = aNewIfIndexEl.iImpData;
if(aInsertMode == EInsertImplAsNewcomerOfInterface)
{
TImplStruct newImplStruct;
newImplStruct.iCurrentImpl = aNewImpl;
implContainerArray.InsertInOrderL(newImplStruct, TLinearOrder<TImplStruct> (TImplStruct::CompareImplStructUid));
#ifdef _DEBUG
// on debug build, check for duplicated implementation UID
// owned by different interfaces.
TInt ii = iImplIndex.SpecificFindInOrder(
aNewImpl,
CImplementationData::CompareImplUidIgnoreIfUid,
EArrayFindMode_Any);
if (ii != KErrNotFound)
{
CImplementationData* otherImpl = iImplIndex[ii];
TPtrC oldName = otherImpl->iImplInfo->DisplayName().Left(60);
TPtrC newName = aNewImpl->iImplInfo->DisplayName().Left(60);
__ECOM_TRACE5("** ECOM: error Impl UID %X, I/F UID %X DLL %S duplicating I/F %X DLL %S",\\
aNewImpl->iImplInfo->ImplementationUid().iUid, \\
aNewImpl->iParent->iInterfaceUid.iUid, &newName,\\
otherImpl->iParent->iInterfaceUid.iUid, &oldName);
}
#endif
}
else if(aInsertMode == EInsertImplAsUpgradeOfExistingImpl)
{
TImplContainer& implContainer = implContainerArray[aImplPosInContainerArray];
CImplementationData* oldImpl = implContainer.iCurrentImpl;
implContainer.iUnusedImpls.AppendL(oldImpl);
RemoveImplByAddrFromImplIndex(oldImpl); // ignore return code
implContainer.iCurrentImpl = aNewImpl;
// We are replacing existing impl with aNewImpl. If existing
// corresponds to a ROM-based plug-in then aNewImpl is an
// update and qualifies as ROM-based under current policy.
if(oldImpl->iImplInfo->RomBased())
{
aNewImpl->iImplInfo->SetRomBased(ETrue);
}
__ECOM_TRACE5("ECOM: Removed old implementation: UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", oldImpl->iImplInfo->ImplementationUid().iUid, oldImpl->iParent->iInterfaceUid.iUid, oldImpl->iImplInfo->Version(), (TInt)(oldImpl->iImplInfo->Drive()), &(oldImpl->iImplInfo->DisplayName()));
__ECOM_TRACE5("ECOM: Loaded new implementation: UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", aNewImpl->iImplInfo->ImplementationUid().iUid, aNewImpl->iParent->iInterfaceUid.iUid, aNewImpl->iImplInfo->Version(), (TInt)(aNewImpl->iImplInfo->Drive()), &(aNewImpl->iImplInfo->DisplayName()));
}
else if (aInsertMode == EInsertImplAsUnusedImpl)
{
TImplContainer& implContainer = implContainerArray[aImplPosInContainerArray];
implContainer.iUnusedImpls.AppendL(aNewImpl);
CImplementationData* currImpl = implContainer.iCurrentImpl;
__ECOM_TRACE5("ECOM: Kept old implementation: UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", currImpl->iImplInfo->ImplementationUid().iUid, currImpl->iParent->iInterfaceUid.iUid, currImpl->iImplInfo->Version(), (TInt)(currImpl->iImplInfo->Drive()), &(currImpl->iImplInfo->DisplayName()));
__ECOM_TRACE5("ECOM: Not loaded new implementation: UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", aNewImpl->iImplInfo->ImplementationUid().iUid, aNewImpl->iParent->iInterfaceUid.iUid, aNewImpl->iImplInfo->Version(), (TInt)(aNewImpl->iImplInfo->Drive()), &(aNewImpl->iImplInfo->DisplayName()));
// We are not replacing existing with aNewImpl. However,
// if aNewImpl corresponds to a ROM-based plug-in then the
// existing impl is an update and qualifies as ROM-based
// under current policy.
if(aNewImpl->iImplInfo->RomBased())
{
currImpl->iImplInfo->SetRomBased(ETrue);
}
return; // the trailing steps not applicable to downgrade situation
}
User::LeaveIfError( InsertImplIntoImplIndex(aNewImpl) );
if(aIfPosInInterfaceImplIndex==KErrNotFound)
{
TCleanupImplIndexEntry aCleanup(this, aNewImpl);
CleanupStack::PushL(TCleanupItem(RemoveImplFromImplIndexCleanUp,&aCleanup));
iInterfaceImplIndex.InsertInOrderL(aNewIfIndexEl, TLinearOrder<TInterfaceIndex>(TInterfaceStruct::CompareInfUid));
CleanupStack::Pop();
}
}
/**
This method takes removes all implementations of a plugin from the iInterfaceImplIndex
@param aDllData Reference to a fully constructed CDllData object
@pre This object is constructed
@post All implementations of the CDllData object, have been removed from the index
*/
void CRegistryData::RemoveFromIndexL(CDllData* aDllData) const
{
//remove 'old' implementations from iInterfaceImplIndex
TInt counter=0;
TImplStruct implStruct;
TInt ifListCount=aDllData->iIfList->Count();
while(counter < ifListCount)
{
CInterfaceData* interface = (*aDllData->iIfList)[counter];
TInterfaceIndex index;
index.iInterfaceUid = interface->iInterfaceUid;
TInt indexPos = iInterfaceImplIndex.FindInOrder(index,TLinearOrder<TInterfaceIndex>(TInterfaceStruct::CompareInfUid));
TImplContainerArray* impDataArray = NULL;
TInt implCount=0;
if(indexPos!=KErrNotFound)
{
impDataArray = &(iInterfaceImplIndex[indexPos].iImpData);
implCount=interface->iImplementations->Count();
for(TInt i=0; i<implCount; i++)
{
implStruct.iCurrentImpl = (*interface->iImplementations)[i];
TInt impPos = impDataArray->FindInOrder(implStruct, TLinearOrder<CRegistryData::TImplStruct> (TImplStruct::CompareImplStructUid));
if(impPos!=KErrNotFound)
{
TImplContainer& implContainer = (*impDataArray)[impPos];
// remove from unused list if exists
TInt count = implContainer.iUnusedImpls.Count();
while(count > 0)
{
--count;
if(implContainer.iUnusedImpls[count]->iParent->iParent == aDllData)
{
implContainer.iUnusedImpls.Remove(count);
}
}
// update current entry
if(implContainer.iCurrentImpl->iParent->iParent == aDllData)
{
// do not care about the return code.
RemoveImplByAddrFromImplIndex(implContainer.iCurrentImpl);
TInt implContainerUnusedImplCount=implContainer.iUnusedImpls.Count();
// no unused impl's therefore no rollback and remove entry
if(implContainerUnusedImplCount == 0)
{
implContainer.Reset();
impDataArray->Remove(impPos);
}
else
{
// Rollback to implementation from unused array
// copy first from unused array
TInt selectedPos = 0;
implContainer.iCurrentImpl = implContainer.iUnusedImpls[selectedPos];
// now check if any others in list should be preferred
for(count = 1;count < implContainerUnusedImplCount; count++)
{
// determine which implementation should be used.
// no security check required as this will have already been done when impl was
// first added to unused list.
TBool dummLegitimateImpl;
implContainer.iCurrentImpl = SelectPreferredImplL(implContainer.iCurrentImpl,
implContainer.iUnusedImpls[count],
dummLegitimateImpl,
EFalse);
if(implContainer.iCurrentImpl == implContainer.iUnusedImpls[count])
{
selectedPos = count;
}
}
implContainer.iUnusedImpls.Remove(selectedPos);
User::LeaveIfError(InsertImplIntoImplIndex(implContainer.iCurrentImpl));
#ifdef ECOM_TRACE
{
CImplementationData* p = implContainer.iCurrentImpl;
__ECOM_TRACE5("ECOM: unused implementation restored UID:0x%X interfaceUID:0x%X version:%d on drive:%d \"%S\"", p->iImplInfo->ImplementationUid().iUid, p->iParent->iInterfaceUid.iUid, p->iImplInfo->Version(), (TInt)(p->iImplInfo->Drive()), &(p->iImplInfo->DisplayName()));
}
#endif
}
}
}
//To make sure it is removed from the implIndex no matter what and that the return code is ignored.
//The previous removal is still required so that a subsequent InsertImplIntoImplIndex is possible
//for an implementation. e.g. an implementaion is on different drives and only one of htem was removed.
// The other one should now make it to the iImplIndex through InsertImplIntoImplIndex. If it wasn't
// removed, before the insert operation, it will fail since both the implementations hav the same
// impl UID.
RemoveImplByAddrFromImplIndex((*interface->iImplementations)[i]);
}
if(impDataArray->Count() == 0)
{
iInterfaceImplIndex[indexPos].Reset();
iInterfaceImplIndex.Remove(indexPos);
}
}
counter++;
}
}
/**
This method inserts implementations into the index
@param aDriveData Drive data in which we are searching the implementations
@pre This object is fully constructed.
@post all implemementations found, have been inserted into the index.
*/
void CRegistryData::AddImplDataL(CDriveData* aDriveData)
{
TBool checkIsNeeded = EFalse;
TInt dllCount=aDriveData->iDllList->Count();
for(TInt dllCounter=0; dllCounter < dllCount;dllCounter++)
{
CDllData* aDllData = (*aDriveData->iDllList)[dllCounter];
TInt interfaceCount=aDllData->iIfList->Count();
for(TInt ifListCounter=0; ifListCounter < interfaceCount; ifListCounter++)
{
// For each interface structure
CInterfaceData* interface = (*aDllData->iIfList)[ifListCounter];
TInt implementationCount=interface->iImplementations->Count();
for(TInt impNum = 0; impNum < implementationCount; ++impNum)
{
CImplementationData* implData = (*interface->iImplementations)[impNum];
TInt retValue = InsertIntoIndexL(implData, checkIsNeeded);
//we know that during internalize, all implementations are legitimate,
//as the check was already performed during discovery. No check is
//performed at this stage, therefore ignore return value, as it will always
//KErrNone
}
}
}
}
/** This method does a search by address and removes the specified entry from iImplIndex.
@param aPtr is the entry to remove
@return True if aPtr is removed from iImplIndex. False if aPtr is not
in iImplIndex, i.e. nothing is removed.
*/
TBool CRegistryData::RemoveImplByAddrFromImplIndex(CImplementationData* aPtr) const
{
TInt aIdx = iImplIndex.Find(aPtr);
if (aIdx != KErrNotFound)
{
// This linear pointer search ensures a safe removal of the impl from iImplIndex so that it is free from a dead object.
// The array does not own the pointer. Do not delete!
iImplIndex.Remove(aIdx);
return ETrue;
}
return EFalse;
}
/** This method inserts the entry aNewImpl into iImplIndex.
@param aNewImpl the item to add to iImplIndex.
@return KErrNone aNewImpl is successfully added to the index.
KErrAlreadyExists iImplIndex has an entry with the same
implementation UID and same parent Interface UID.
KErrNoMemory fail to insert due to out of memory.
Other system wide errors.
@pre aNewImpl is fully constructed.
*/
TInt CRegistryData::InsertImplIntoImplIndex(CImplementationData* aNewImpl) const
{
TLinearOrder<CImplementationData> ImplUidComparator(CImplementationData::CompareImplUid);
return iImplIndex.InsertInOrder(aNewImpl, ImplUidComparator);
}
/** This method checks whether the language downgrade path has been changed.
If it is, save language downgrade path information and set related flag true.
@param aLanguageChanged the returned value to indicate language changed.
*/
void CRegistryData::LanguageChangedL(TBool& aLanguageChanged)
{
iLanguageChanged = RDowngradePath::HasChangedL(iFs);
aLanguageChanged = iLanguageChanged;
}
/** setter
If need to unset the callback, use a TCallBackWithArg constructed with no
arguments.
*/
void CRegistryData::SetImplUpgradeCallBack(const TCallBackWithArg& aCallBack)
{
iImplUpgradeCallBack = aCallBack;
}
#ifdef __ECOM_SERVER_PERFORMANCE__
/**
This method calculates the drive, plugins, interfaces, implementations counts for the drive
type set
@param aType The drive type for which the counts should be calculated
@param aCounts Holds the calculated counts
@pre This object is constructed
*/
void CRegistryData::GetRegistryCountsL(TInt aType, RegistryCounts::TRegistryCounts& aCounts) const
{
aCounts.iDrives = 0;
aCounts.iImplementations = 0;
aCounts.iInterfaces = 0;
aCounts.iDlls = 0;
for(TInt driveIndex = 0; driveIndex< iRegistrations->Count(); driveIndex++)
{
CDriveData* drive = (*iRegistrations)[driveIndex];
TBool isReadOnly = iCachedDriveInfo->DriveIsReadOnlyInternalL(drive->iDrive);
if((aType == RegistryCounts::TRegistryCounts::EAll) ||
(aType == RegistryCounts::TRegistryCounts::ERoInternal && isReadOnly) ||
(aType == RegistryCounts::TRegistryCounts::ENonRoInternal && !isReadOnly))
{
aCounts.iDrives++;
aCounts.iDlls += drive->iDllList->Count();
for(TInt dllIndex = 0; dllIndex < drive->iDllList->Count(); dllIndex++)
{
CDllData* dllList = (*drive->iDllList)[dllIndex];
aCounts.iInterfaces += dllList->iIfList->Count();
for(TInt ifIndex = 0; ifIndex < dllList->iIfList->Count(); ifIndex++)
{
CInterfaceData* ifList = (*dllList->iIfList)[ifIndex];
aCounts.iImplementations += ifList->iImplementations->Count();
}
}
}
}
}
#endif // __ECOM_SERVER_PERFORMANCE__