diff -r 7333d7932ef7 -r 8b7f4e561641 installationservices/swinstallationfw/source/sifcommon.cpp
--- a/installationservices/swinstallationfw/source/sifcommon.cpp	Tue Aug 31 15:21:33 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1264 +0,0 @@
-/*
-* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of the License "Eclipse Public License v1.0"
-* which accompanies this distribution, and is available
-* at the URL "http://www.eclipse.org/legal/epl-v10.html".
-*
-* Initial Contributors:
-* Nokia Corporation - initial contribution.
-*
-* Contributors:
-*
-* Description: 
-*
-*/
-
-
-#include <f32file.h>
-#include <usif/sif/sifcommon.h>
-#include <s32mem.h>
-#include <scs/cleanuputils.h>
-#include <scs/streamingarray.h>
-#include "sifcommon_internal.h"
-
-using namespace Usif;
-
-/**
-	The COpaqueNamedParams and CComponentInfo containers implement the deferred internalization
-	logic. This mechanism is necessary because these containers may be passed through IPC between
-	the SIF client and server. Hence, they must be externalized and internalized on both sides.
-	However, The SIF client doesn't implement an active object and therefore it cannot internalize
-	parameters returned by the SIF server. This de-serialization is done by the deferred internalization
-	logic when the user accesses them first time.
-	Hence, all the get methods, for example Name(), GetIntByName(), StringByNameL(), call the
-	InternalizeFromExternalBufferL() method which calls ConstInternalizeL() in order to unpack
-	the data recived from the SIF server if there is any. ConstInternalizeL() is a const method despite
-	the fact it modifies class'es members. This is done to keep the get methods const as expected by
-	the users.
- */
-
-// ##########################################################################################
-
-namespace
-	{
-	TInt PackCapabilitySet(const TCapabilitySet& aCapSet)
-		{
-		TInt caps=0;
-		for (TInt c=0; c<ECapability_Limit; ++c)
-			{
-			if (aCapSet.HasCapability(TCapability(c)))
-				{
-				caps += (1<<c);
-				}
-			}
-		return caps;
-		}
-
-	void UnpackCapabilitySet(TInt aPackedCapSet, TCapabilitySet& aCapSet)
-		{
-		for (TInt c=0; c<ECapability_Limit; ++c)
-			{
-			const TInt cap = 1<<c;
-			if (aPackedCapSet&cap)
-				{
-				aCapSet.AddCapability(TCapability(c));
-				}
-			}
-		}
-	}
-
-// ##########################################################################################
- 
-EXPORT_C TSecurityContext::TSecurityContext(const RMessage2& aMessage): iMsg(aMessage)
-	{
-	}
-
-EXPORT_C TBool TSecurityContext::HasCapability(TCapability aCapability) const
-	{
-	return iMsg.HasCapability(aCapability);
-	}
-
-EXPORT_C void TSecurityContext::HasCapabilityL(TCapability aCapability) const
-	{
-	iMsg.HasCapabilityL(aCapability);
-	}
-
-EXPORT_C TSecureId TSecurityContext::SecureId() const
-	{
-	return iMsg.SecureId();
-	}
-
-// ##########################################################################################
-
-CComponentInfo::CApplicationInfo::CApplicationInfo()
-    {
-    }
-
-EXPORT_C CComponentInfo::CApplicationInfo::~CApplicationInfo()
-    {
-    delete iName;
-    delete iGroupName;
-    delete iIconFileName;
-    }
-
-EXPORT_C CComponentInfo::CApplicationInfo* CComponentInfo::CApplicationInfo::NewLC(const TUid& aAppUid, const TDesC& aName, const TDesC& aGroupName, const TDesC& aIconFileName)
-    {
-        _LIT(emptyString,"");
-        // Leave if aName, aGroupName or aIconFileName exceeds KMaxDescriptorLength
-       if ((&aName != NULL && aName.Length() > KMaxDescriptorLength) || 
-               (&aGroupName != NULL && aGroupName.Length() > KMaxDescriptorLength) ||
-               (&aIconFileName != NULL && aIconFileName.Length() > KMaxDescriptorLength))
-            {
-            User::Leave(KErrOverflow);
-            }
-        
-       CComponentInfo::CApplicationInfo* self = new (ELeave) CComponentInfo::CApplicationInfo();
-       CleanupStack::PushL(self);
-
-        self->iAppUid = aAppUid;  
-        if(&aName == NULL)
-            {
-            self->iName = emptyString().AllocL();
-            }
-        else
-            {
-            self->iName = aName.AllocL();
-            }
-   
-        if(&aGroupName == NULL)
-            {
-            self->iGroupName = emptyString().AllocL();
-            }
-        else
-            {
-            self->iGroupName = aGroupName.AllocL();
-            }
-        
-        if(&aIconFileName == NULL)
-            {
-            self->iIconFileName = emptyString().AllocL();
-            }
-        else
-            {
-            self->iIconFileName = aIconFileName.AllocL();
-            }     
-    
-        return self;
-    }
-
-EXPORT_C const TUid& CComponentInfo::CApplicationInfo::AppUid() const
-    {
-    return iAppUid;
-    }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::Name() const
-    {
-    return *iName;
-    }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::GroupName() const
-    {
-    return *iGroupName;
-    }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::IconFileName() const            
-    {
-    return *iIconFileName;
-    }
-
-CComponentInfo::CApplicationInfo* CComponentInfo::CApplicationInfo::NewL(RReadStream& aStream)
-    {    
-    CApplicationInfo* self = new (ELeave) CApplicationInfo();
-    CleanupStack::PushL(self);
-    
-    self->iAppUid = TUid::Uid(aStream.ReadInt32L());
-    self->iName = HBufC::NewL(aStream, KMaxDescriptorLength);
-    self->iGroupName = HBufC::NewL(aStream, KMaxDescriptorLength);
-    self->iIconFileName = HBufC::NewL(aStream, KMaxDescriptorLength);
-    
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-void CComponentInfo::CApplicationInfo::ExternalizeL(RWriteStream& aStream) const
-    {
-    aStream.WriteInt32L(iAppUid.iUid);    
-    aStream << *iName;
-    aStream << *iGroupName;
-    aStream << *iIconFileName;
-    }
-            
-// ##########################################################################################
-
-CComponentInfo::CNode::CNode() : iAuthenticity(ENotAuthenticated)
-	{
-	iUserGrantableCaps.SetEmpty();
-	}
-
-EXPORT_C CComponentInfo::CNode::~CNode()
-	{
-	delete iSoftwareTypeName;
-	delete iComponentName;
-	delete iGlobalComponentId;
-	delete iVersion;
-	delete iVendor;
-
-	iApplications.Close();
-	iChildren.Close();	
-	}
-
-EXPORT_C CComponentInfo::CNode* CComponentInfo::CNode::NewLC(const TDesC& aSoftwareTypeName, const TDesC& aComponentName,
-															const TDesC& aVersion, const TDesC& aVendor, TScomoState aScomoState,
-															TInstallStatus aInstallStatus, TComponentId aComponentId,
-															const TDesC& aGlobalComponentId, TAuthenticity aAuthenticity,
-															const TCapabilitySet& aUserGrantableCaps, TInt aMaxInstalledSize,
-															TBool aHasExe, TBool aIsDriveSelectionRequired,
-															RPointerArray<CApplicationInfo>* aApplications, RPointerArray<CNode>* aChildren)
-	{
-	// We leave if aSoftwareTypeName, aComponentName, aVersion, aVendor or aGlobalComponentId exceeds KMaxDescriptorLength
-	if (aSoftwareTypeName.Length() > KMaxDescriptorLength ||
-		aComponentName.Length() > KMaxDescriptorLength ||
-		aVersion.Length() > KMaxDescriptorLength ||
-		aVendor.Length() > KMaxDescriptorLength ||
-		aGlobalComponentId.Length() > KMaxDescriptorLength)
-		{
-		User::Leave(KErrOverflow);
-		}
-		
-
-	// Since the max heap buffer length is 2K, which is more than (num of parameters * KMaxDescriptorLength), we just assert this condition
-	__ASSERT_ALWAYS(aSoftwareTypeName.Length() + aComponentName.Length() + aVersion.Length() + aVendor.Length() + 
-					aGlobalComponentId.Length() <= KMaxHeapBufLength, User::Leave(KErrOverflow));
-
-	// Create an instance of CNode
-	CNode* self = new (ELeave) CNode();
-	CleanupStack::PushL(self);
-
-	// Copy Software Type Name, Component Name, Version, aVendor, aGlobalComponentId
-	self->iSoftwareTypeName = aSoftwareTypeName.AllocL();
-	self->iComponentName = aComponentName.AllocL();
-	self->iVersion = aVersion.AllocL();
-	self->iVendor = aVendor.AllocL();
-	self->iGlobalComponentId = aGlobalComponentId.AllocL();
-
-	// Others
-	self->iScomoState = aScomoState;
-	self->iInstallStatus = aInstallStatus;
-	self->iComponentId = aComponentId;
-	self->iAuthenticity = aAuthenticity;
-	self->iUserGrantableCaps = aUserGrantableCaps;
-	self->iMaxInstalledSize = aMaxInstalledSize;
-	self->iHasExe = aHasExe;
-	self->iIsDriveSelectionRequired = aIsDriveSelectionRequired;
-
-	if(aApplications != NULL)
-        {
-        for (TInt i=aApplications->Count()-1; i>=0; --i)
-            {
-            self->iApplications.InsertL((*aApplications)[i], 0);
-            aApplications->Remove(i);
-            }
-        }
-	
-	// Embedded Components
-	if(aChildren != NULL)
-		{
-		for (TInt i=aChildren->Count()-1; i>=0; --i)
-			{
-			self->iChildren.InsertL((*aChildren)[i], 0);
-			aChildren->Remove(i);
-			}
-		}
-	
-	return self;
-	}
-
-EXPORT_C void CComponentInfo::CNode::AddChildL(CComponentInfo::CNode* aChild)
-	{
-	if (aChild == NULL)
-		{
-		User::Leave(KErrArgument);
-		}
-
-	iChildren.AppendL(aChild);
-	}
-
-CComponentInfo::CNode* CComponentInfo::CNode::NewL(RReadStream& aStream)
-	{
-	// Create an instance of CNode
-	CNode* self = new (ELeave) CNode();
-	CleanupStack::PushL(self);
-	
-	self->iSoftwareTypeName = HBufC::NewL(aStream, KMaxDescriptorLength);
-	self->iComponentName = HBufC::NewL(aStream, KMaxDescriptorLength);
-	self->iVersion = HBufC::NewL(aStream, KMaxDescriptorLength);
-	self->iVendor = HBufC::NewL(aStream, KMaxDescriptorLength);
-	self->iGlobalComponentId = HBufC::NewL(aStream, KMaxDescriptorLength);
-	self->iScomoState = static_cast<TScomoState>(aStream.ReadInt32L());
-	self->iInstallStatus = static_cast<TInstallStatus>(aStream.ReadInt32L());
-	self->iComponentId = aStream.ReadInt32L();
-	self->iAuthenticity = static_cast<TAuthenticity>(aStream.ReadInt32L());
-	UnpackCapabilitySet(aStream.ReadInt32L(), self->iUserGrantableCaps);
-	self->iMaxInstalledSize = aStream.ReadInt32L();
-	self->iHasExe = aStream.ReadInt32L();
-	self->iIsDriveSelectionRequired = aStream.ReadInt32L();	
-	
-	const TInt numApplications = aStream.ReadInt32L();
-    for (TInt i=0; i<numApplications; ++i)
-        {
-        CApplicationInfo* app = CApplicationInfo::NewL(aStream);
-        CleanupStack::PushL(app);
-        self->iApplications.AppendL(app);
-        CleanupStack::Pop(app);
-        }
-	
-	const TInt numChildren = aStream.ReadInt32L();
-	for (TInt i=0; i<numChildren; ++i)
-		{
-		CNode* node = CNode::NewL(aStream);
-		CleanupStack::PushL(node);
-		self->iChildren.AppendL(node);
-		CleanupStack::Pop(node);
-		}
-	
-	CleanupStack::Pop(self);
-	return self;
-	}
-
-void CComponentInfo::CNode::ExternalizeL(RWriteStream& aStream) const
-	{
-	ASSERT (iSoftwareTypeName!=NULL && iComponentName!=NULL && iVersion!=NULL && iVendor!=NULL && iGlobalComponentId!=NULL);
-
-	aStream << *iSoftwareTypeName;
-	aStream << *iComponentName;
-	aStream << *iVersion;
-	aStream << *iVendor;
-	aStream << *iGlobalComponentId;
-
-	aStream.WriteInt32L(iScomoState);
-	aStream.WriteInt32L(iInstallStatus);
-	aStream.WriteInt32L(iComponentId);
-	aStream.WriteInt32L(static_cast<TInt>(iAuthenticity));
-	aStream.WriteInt32L(PackCapabilitySet(iUserGrantableCaps));
-	aStream.WriteInt32L(iMaxInstalledSize);
-	aStream.WriteInt32L(iHasExe);
-	aStream.WriteInt32L(iIsDriveSelectionRequired);
-	
-	const TInt numApplications = iApplications.Count();
-    aStream.WriteInt32L(numApplications);
-    for (TInt i=0; i<numApplications; ++i)
-        {
-        iApplications[i]->ExternalizeL(aStream);
-        }
-	
-	const TInt numChildren = iChildren.Count();
-	aStream.WriteInt32L(numChildren);
-	for (TInt i=0; i<numChildren; ++i)
-		{
-		iChildren[i]->ExternalizeL(aStream);
-		}
-	}
-
-EXPORT_C const TDesC& CComponentInfo::CNode::SoftwareTypeName() const
-	{
-	return *iSoftwareTypeName;
-	}
-
-EXPORT_C const TDesC& CComponentInfo::CNode::ComponentName() const
-	{
-	return *iComponentName;
-	}
-
-EXPORT_C const TDesC& CComponentInfo::CNode::Version() const
-	{
-	return *iVersion;
-	}
-
-EXPORT_C const TDesC& CComponentInfo::CNode::Vendor() const
-	{
-	return *iVendor;
-	}
-
-EXPORT_C TScomoState CComponentInfo::CNode::ScomoState() const
-	{
-	return iScomoState;
-	}
-
-EXPORT_C TInstallStatus CComponentInfo::CNode::InstallStatus() const
-	{
-	return iInstallStatus;
-	}
-
-EXPORT_C TComponentId CComponentInfo::CNode::ComponentId() const
-	{
-	return iComponentId;
-	}
-
-EXPORT_C const TDesC& CComponentInfo::CNode::GlobalComponentId() const
-	{
-	return *iGlobalComponentId;
-	}
-
-EXPORT_C TAuthenticity CComponentInfo::CNode::Authenticity() const
-	{
-	return iAuthenticity;
-	}
-
-EXPORT_C const TCapabilitySet& CComponentInfo::CNode::UserGrantableCaps() const
-	{
-	return iUserGrantableCaps;
-	}
-
-EXPORT_C TInt CComponentInfo::CNode::MaxInstalledSize() const
-	{
-	return iMaxInstalledSize;
-	}
-
-EXPORT_C TBool CComponentInfo::CNode::HasExecutable() const
-	{
-	return iHasExe;
-	}
-
-EXPORT_C TBool CComponentInfo::CNode::DriveSeletionRequired() const
-    {
-    return iIsDriveSelectionRequired;
-    }
-
-EXPORT_C const RPointerArray<CComponentInfo::CApplicationInfo>& CComponentInfo::CNode::Applications() const
-    {
-    return iApplications;
-    }
-
-EXPORT_C const RPointerArray<CComponentInfo::CNode>& CComponentInfo::CNode::Children() const
-	{
-	return iChildren;
-	}
-
-// ##########################################################################################
-
-CComponentInfo::CComponentInfo() : iExternalBufferPtr(NULL, 0, 0)
-	{
-	}
-
-EXPORT_C CComponentInfo::~CComponentInfo()
-	{
-	delete iRootNode;
-
-	CleanupExternalBuffer();
-	}
-
-EXPORT_C CComponentInfo* CComponentInfo::NewL()
-	{
-	return new (ELeave) CComponentInfo;
-	}
-
-EXPORT_C CComponentInfo* CComponentInfo::NewLC()
-	{
-	CComponentInfo* self = new (ELeave) CComponentInfo;
-	CleanupStack::PushL(self);
-	return self;
-	}
-
-EXPORT_C const CComponentInfo::CNode& CComponentInfo::RootNodeL() const
-	{
-	InternalizeFromExternalBufferL();
-	
-	if (iRootNode == NULL)
-		{
-		User::Leave(KErrNotFound);
-		}
-	
-	return *iRootNode;
-	}
-
-EXPORT_C void CComponentInfo::SetRootNodeL(CNode* aRootNode)
-	{
-	InternalizeFromExternalBufferL();
-	
-	if (aRootNode == NULL)
-		{
-		User::Leave(KErrArgument);
-		}
-	
-	delete iRootNode;
-	iRootNode = aRootNode;
-	}
-
-EXPORT_C void CComponentInfo::SetRootNodeAsChildL(CNode& aParentNode)
-	{
-	InternalizeFromExternalBufferL();
-	
-	if (iRootNode == NULL)
-		{
-		User::Leave(KErrNotFound);
-		}
-	
-	aParentNode.AddChildL(iRootNode);
-	iRootNode = NULL;
-	}
-
-EXPORT_C void CComponentInfo::ExternalizeL(RWriteStream& aStream) const
-	{
-	InternalizeFromExternalBufferL();
-	
-	aStream.WriteInt8L(iRootNode != NULL);
-	
-	if (iRootNode != NULL)
-		{
-		iRootNode->ExternalizeL(aStream);
-		}
-	}
-
-void CComponentInfo::ConstInternalizeL(RReadStream& aStream) const
-	{
-	CNode*& rootNode = const_cast<CNode*&>(iRootNode);
-	delete rootNode;
-	rootNode = NULL;
-	
-	if (aStream.ReadInt8L() != 0)
-		{
-		rootNode = CNode::NewL(aStream);
-		}
-	}
-
-void CComponentInfo::CleanupExternalBuffer() const
-	{
-	delete iExternalBuffer;
-	iExternalBuffer = NULL;
-	iDeferredInternalization = EFalse;
-	}
-
-void CComponentInfo::InternalizeFromExternalBufferL() const
-	{
-	if (iDeferredInternalization)
-		{
-		iDeferredInternalization = EFalse;
-
-		RDesReadStream rs(*iExternalBuffer);
-		CleanupClosePushL(rs);
-		ConstInternalizeL(rs);
-		CleanupStack::PopAndDestroy(&rs);
-
-		CleanupExternalBuffer();
-		}
-	}
-
-EXPORT_C void CComponentInfo::PrepareForIpcL(TIpcArgs& aIpcArgs, TInt aIndex)
-	{
-	delete iExternalBuffer;
-	iExternalBuffer = NULL;
-
-	iExternalBuffer = HBufC8::NewL(KMaxComponentInfoStreamedSize);
-	iExternalBufferPtr.Set(iExternalBuffer->Des());
-	
-	aIpcArgs.Set(aIndex, &iExternalBufferPtr);
-	
-	iDeferredInternalization = ETrue;
-	}
-
-// ##########################################################################################
-
-COpaqueNamedParams::COpaqueNamedParams()
-	: iExternalBuffer(NULL), iExternalBufferPtr(NULL, 0, 0), iDeferredInternalization(EFalse), iExternalizedSize(2*sizeof(TInt))
-	{
-	}
-
-EXPORT_C COpaqueNamedParams::~COpaqueNamedParams()
-	{
-	Cleanup();
-	iParams.Close();
-	CleanupExternalBuffer();
-	}
-
-EXPORT_C COpaqueNamedParams* COpaqueNamedParams::NewL()
-	{
-	return new (ELeave) COpaqueNamedParams;
-	}
-
-EXPORT_C COpaqueNamedParams* COpaqueNamedParams::NewLC()
-	{
-	COpaqueNamedParams* self = new (ELeave) COpaqueNamedParams;
-	CleanupStack::PushL(self);
-	return self;
-	}
-
-void COpaqueNamedParams::VerifyExternalizedSizeForNewParamArrayL(TInt aNameSize, TInt aValueSize) const
-	{
-	const TInt load = 2*sizeof(TInt) + aNameSize + aValueSize;
-	if (aNameSize > KMaxOpaqueParamsDescriptorSize || iExternalizedSize + load > KMaxOpaqueParamsExternalizedSize)
-		{
-		User::Leave(KErrOverflow);
-		}
-	iExternalizedSize += load;
-	}
-
-void COpaqueNamedParams::VerifyExternalizedSizeForExistingParamArrayL(TInt aOldValueSize, TInt aNewValueSize) const
-	{
-	const TInt diff = aNewValueSize - aOldValueSize;
-	if (iExternalizedSize + diff > KMaxOpaqueParamsExternalizedSize)
-		{
-		User::Leave(KErrOverflow);
-		}
-	iExternalizedSize += diff;
-	}
-
-EXPORT_C void COpaqueNamedParams::AddStringL(const TDesC& aName, const TDesC& aValue)
-	{
-	CStringItem* stringItem = CStringItem::NewL(aName, aValue);
-	CleanupStack::PushL(stringItem);
-	
-	AddOpaqueParamL(stringItem);
-    CleanupStack::Pop(stringItem);
-	}
-
-EXPORT_C void COpaqueNamedParams::AddStringArrayL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
-    {
-    CStringArrayItem* stringArray = CStringArrayItem::NewL(aName, aValueArray);
-    CleanupStack::PushL(stringArray);
-    
-    AddOpaqueParamL(stringArray);
-    CleanupStack::Pop(stringArray);
-    }
-
-EXPORT_C void COpaqueNamedParams::AddIntL(const TDesC& aName, TInt aValue)
-	{
-	CIntegerItem* integer = CIntegerItem::NewL(aName, aValue);
-    CleanupStack::PushL(integer);
-    
-    AddOpaqueParamL(integer);
-    CleanupStack::Pop(integer);	
-	}
-
-EXPORT_C void COpaqueNamedParams::AddIntArrayL(const TDesC& aName, const RArray<TInt>& aValueArray)
-    {
-    CIntegerArrayItem* integerArray = CIntegerArrayItem::NewL(aName, aValueArray);
-    CleanupStack::PushL(integerArray);
-    
-    AddOpaqueParamL(integerArray);
-    CleanupStack::Pop(integerArray);     
-    }
-
-void COpaqueNamedParams::AddOpaqueParamL(MOpaqueParam* aItemBase)
-    {
-    const TInt count = iParams.Count();
-        
-    for (TInt i=0; i<count; ++i)
-        {
-        if (iParams[i]->Name().CompareF(aItemBase->Name()) == 0)
-            {
-            VerifyExternalizedSizeForExistingParamArrayL(iParams[i]->ValueSize(), aItemBase->ValueSize());
-            
-            delete iParams[i];
-            iParams[i] = aItemBase;
-            return;
-            }
-        }
-
-    VerifyExternalizedSizeForNewParamArrayL(aItemBase->Name().Size(), aItemBase->ValueSize());
-    iParams.AppendL(aItemBase); 
-    }
-
-EXPORT_C void COpaqueNamedParams::GetNamesL(RPointerArray<HBufC>& aNames) const
-	{
-	InternalizeFromExternalBufferL();
-
-	const TInt len = iParams.Count();
-	for (TInt i=0; i<len; ++i)
-		{
-		HBufC* name = iParams[i]->Name().AllocLC();
-		aNames.AppendL(name);
-		CleanupStack::Pop(name);
-		}
-	}
-	
-EXPORT_C void COpaqueNamedParams::ExternalizeL(RWriteStream& aStream) const
-	{
-	InternalizeFromExternalBufferL();
-
-	TInt count = iParams.Count();
-	aStream.WriteInt32L(count);
-	for (TInt i=0; i<count; ++i)
-		{
-		aStream.WriteInt32L(iParams[i]->Type());
-		iParams[i]->ExternalizeL(aStream);
-		}
-	
-	aStream.WriteInt32L(iExternalizedSize);
-	}
-
-EXPORT_C void COpaqueNamedParams::InternalizeL(RReadStream& aStream)
-	{
-	ConstInternalizeL(aStream);
-	}
-
-void COpaqueNamedParams::ConstInternalizeL(RReadStream& aStream) const
-	{
-    ConstCleanup();
-	RPointerArray<MOpaqueParam>& refParams = const_cast<RPointerArray<MOpaqueParam>& >(iParams);
-	
-	TInt count = aStream.ReadInt32L();
-	for (TInt i=0; i<count; ++i)
-		{
-		MOpaqueParam::TType type = static_cast<MOpaqueParam::TType>(aStream.ReadInt32L());
-	    MOpaqueParam* param(0);
-		switch(type)
-		    {
-		    case MOpaqueParam::EString:
-		        param = CStringItem::NewL(aStream);
-		        break;
-		        
-            case MOpaqueParam::EStringArray:
-                param = CStringArrayItem::NewL(aStream);
-                break;
-                
-            case MOpaqueParam::EInteger:
-                param = CIntegerItem::NewL(aStream);
-                break;     
-                
-            case MOpaqueParam::EIntegerArray:
-                param = CIntegerArrayItem::NewL(aStream);
-                break;     
-                
-            default:
-                User::Leave(KErrCorrupt);
-		    }
-		CleanupStack::PushL(param);
-		refParams.AppendL(param);
-		CleanupStack::Pop(param);
-		}
-		
-	iExternalizedSize = aStream.ReadInt32L();
-	}
-
-EXPORT_C void COpaqueNamedParams::PrepareArgumentsForIpcL(TIpcArgs& aIpcArgs, TInt aIndex) const
-	{
-	delete iExternalBuffer;
-	iExternalBuffer = NULL;
-	iExternalBuffer = HBufC8::NewL(iExternalizedSize);
-	iExternalBufferPtr.Set(iExternalBuffer->Des());
-	
-	RDesWriteStream ws(iExternalBufferPtr);
-	CleanupClosePushL(ws);
-	ExternalizeL(ws);
-	ws.CommitL();
-	CleanupStack::PopAndDestroy(&ws);
-	
-	aIpcArgs.Set(aIndex, &iExternalBufferPtr);
-	}
-
-EXPORT_C void COpaqueNamedParams::PrepareResultsForIpcL(TIpcArgs& aIpcArgs, TInt aIndex)
-	{
-	delete iExternalBuffer;
-	iExternalBuffer = NULL;
-	iExternalBuffer = HBufC8::NewL(KMaxOpaqueParamsExternalizedSize);
-	iExternalBufferPtr.Set(iExternalBuffer->Des());
-	
-	RDesWriteStream ws(iExternalBufferPtr);
-	CleanupClosePushL(ws);
-	ws.WriteInt32L(0); // Write the initial count of results, so that the object will be valid even if no results are added
-	CleanupStack::PopAndDestroy(&ws);
-	
-	aIpcArgs.Set(aIndex, &iExternalBufferPtr);
-	
-	iDeferredInternalization = ETrue;
-	}
-
-void COpaqueNamedParams::InternalizeFromExternalBufferL() const
-	{
-	if (iDeferredInternalization)
-		{
-		iDeferredInternalization = EFalse;
-		
-		RDesReadStream rs(*iExternalBuffer);
-		CleanupClosePushL(rs);
-		ConstInternalizeL(rs);
-		CleanupStack::PopAndDestroy(&rs);
-
-		CleanupExternalBuffer();
-		}
-	}
-
-EXPORT_C const TDesC& COpaqueNamedParams::StringByNameL(const TDesC& aName) const
-	{
-	InternalizeFromExternalBufferL();
-	
-	const TInt count = iParams.Count();
-	for (TInt i=0; i<count; ++i)
-		{
-		if (iParams[i]->Type() == MOpaqueParam::EString && iParams[i]->Name().CompareF(aName) == 0)
-			{
-			CStringItem* string = static_cast<CStringItem*>(iParams[i]);
-			return string->StringValue();
-			}
-		}
-	
-	return KNullDesC;    
-	}
-
-EXPORT_C const RPointerArray<HBufC>& COpaqueNamedParams::StringArrayByNameL(const TDesC& aName) const
-    {
-    InternalizeFromExternalBufferL();
-  
-    const TInt count = iParams.Count();
-    TInt i;
-    for (i=0; i<count; ++i)
-        {
-        if (iParams[i]->Type() == MOpaqueParam::EStringArray && iParams[i]->Name().CompareF(aName) == 0)
-            {
-            break;
-            }
-        }
-    
-    if(i == count)
-        {
-        User::Leave(KErrNotFound); 
-        }
-    CStringArrayItem* stringArray = static_cast<CStringArrayItem*>(iParams[i]);  
-    return stringArray->StringArrayValue();
-    }
-
-EXPORT_C TBool COpaqueNamedParams::GetIntByNameL(const TDesC& aName, TInt& aValue) const
-	{
-	InternalizeFromExternalBufferL();
-	
-    const TInt count = iParams.Count();
-    for (TInt i=0; i<count; ++i)
-        {
-        if (iParams[i]->Type() == MOpaqueParam::EInteger && iParams[i]->Name().CompareF(aName) == 0)
-            {
-            CIntegerItem* integer = static_cast<CIntegerItem*>(iParams[i]); 
-            aValue = integer->IntegerValue();
-            return ETrue;
-            }
-        }
-    
-    return EFalse;
-	}
-
-EXPORT_C TInt COpaqueNamedParams::IntByNameL(const TDesC& aName) const
-	{
-	InternalizeFromExternalBufferL();
-
-	TInt val;
-	if (!GetIntByNameL(aName, val))
-		{
-		User::Leave(KErrNotFound);
-		}
-	return val;
-	}
-
-EXPORT_C  const RArray<TInt>& COpaqueNamedParams::IntArrayByNameL(const TDesC& aName) const
-    {  
-    InternalizeFromExternalBufferL();
-  
-    const TInt count = iParams.Count();
-    TInt i;
-    for (i=0; i<count; ++i)
-        {
-        if (iParams[i]->Type() == MOpaqueParam::EIntegerArray && iParams[i]->Name().CompareF(aName) == 0)
-            {
-            break;
-            }
-        }
-    
-    if(i == count)
-        {
-        User::Leave(KErrNotFound); 
-        }
-    CIntegerArrayItem* integerArray = static_cast<CIntegerArrayItem*>(iParams[i]);      
-    return integerArray->IntegerArrayValue();
-    }
-
-EXPORT_C TInt COpaqueNamedParams::CountL() const
-	{
-	InternalizeFromExternalBufferL();
-	return iParams.Count();
-	}
-	
-EXPORT_C void COpaqueNamedParams::Cleanup()
-	{
-	ConstCleanup();
-	}
-
-void COpaqueNamedParams::ConstCleanup() const
-	{
-	// Cleanup internal params
-	iExternalizedSize = 2*sizeof(TInt);
-	
-	RPointerArray<MOpaqueParam>& refParams = const_cast<RPointerArray<MOpaqueParam>&>(iParams);
-	refParams.ResetAndDestroy();
-	}
-
-	void COpaqueNamedParams::CleanupExternalBuffer() const
-	{
-	delete iExternalBuffer;
-	iExternalBuffer = NULL;
-	iDeferredInternalization = EFalse;
-	}
-	
-
-/*
- * SifCommon internal classes
- */
-
-
-CItemBase::CItemBase(TType aType):
-    iType(aType)
-    {
-    
-    }
-
-CItemBase::TType CItemBase::Type() const
-    {
-    return iType;
-    }
-
-void CItemBase::SetNameL(const TDesC& aName)
-    {
-    delete iName;
-    iName = aName.AllocL();
-    }
-
-
-CItemBase::~CItemBase()
-    {
-    delete iName;
-    }
-
-const HBufC& CItemBase::Name() const
-    {
-    return *iName;
-    }
-
-void CItemBase::SetValueSize(TInt aSize)
-    {
-    iSize = aSize;
-    }
-
-TInt CItemBase::ValueSize() const
-    {
-    return iSize;
-    }
-
-void CItemBase::VerifyExternalizedSizeForParamL(TUint aValueSize) const
-    {
-    if(aValueSize > KMaxOpaqueParamsDescriptorSize)
-        {
-        User::Leave(KErrOverflow);
-        }
-    }
-
-void CItemBase::ExternalizeL(RWriteStream& aStream) const
-    {
-    aStream << Name();
-    aStream.WriteInt32L(iSize);
-    }
-
-void CItemBase::InternalizeL (RReadStream& aStream)
-    {
-    delete iName;
-    iName = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);
-    iSize = aStream.ReadInt32L();
-    }
-    
-/*
- * CStringItem
- */
-CStringItem::CStringItem():
-    CItemBase(EString)
-    {
-    
-    }
-
-CStringItem* CStringItem::NewL(const TDesC& aName, const TDesC& aValue)
-    {
-    CStringItem* self = new(ELeave)CStringItem();
-    CleanupStack::PushL(self);
-    self->ConstructL(aName, aValue);
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-CStringItem* CStringItem::NewL(RReadStream& aStream)
-    {   
-    CStringItem *self = new(ELeave)CStringItem();
-    CleanupStack::PushL(self);
-    self->InternalizeL(aStream);
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-void CStringItem::ConstructL(const TDesC& aName, const TDesC& aValue)
-    {
-    VerifyExternalizedSizeForParamL(aValue.Size());
-    SetNameL(aName);
-    iString = aValue.AllocL();
-    SetValueSize(iString->Size());
-    }
-
-CStringItem::~CStringItem()
-    {
-    delete iString;
-    }
-
-void CStringItem::ExternalizeL(RWriteStream& aStream) const
-    {
-	CItemBase::ExternalizeL(aStream);
-    aStream << *iString;
-    }
-
-void CStringItem::InternalizeL(RReadStream& aStream)
-    {
-    CItemBase::InternalizeL(aStream);
-    DeleteObjectZ(iString);
-    iString = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);
-    }
-
-const TDesC& CStringItem::StringValue() const
-    {
-    return *iString;
-    }
-
-const HBufC& CStringItem::Name() const
-    {
-    return CItemBase::Name(); 
-    }
-
-MOpaqueParam::TType CStringItem::Type() const
-    {
-    return CItemBase::Type();
-    }
-
-TInt CStringItem::ValueSize() const
-    {
-    return CItemBase::ValueSize();
-    }
-/*
- * CStringArrayItem
- */
-
-CStringArrayItem::CStringArrayItem():
-    CItemBase(EStringArray)
-    {
-    
-    }
-
-CStringArrayItem* CStringArrayItem::NewL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
-    {
-    CStringArrayItem* self = new(ELeave)CStringArrayItem();
-    CleanupStack::PushL(self);
-    self->ConstructL(aName, aValueArray);
-    CleanupStack::Pop(self);    
-    return self;
-    }
-
-CStringArrayItem* CStringArrayItem::NewL(RReadStream& aStream)
-    {   
-    CStringArrayItem *self = new(ELeave)CStringArrayItem();
-    CleanupStack::PushL(self);    
-    self->InternalizeL(aStream);
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-void CStringArrayItem::ConstructL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
-    {
-    SetNameL(aName);
-    for(TInt i=0; i< aValueArray.Count(); ++i)
-        {
-        VerifyExternalizedSizeForParamL(aValueArray[i]->Size());
-        HBufC* value = aValueArray[i]->AllocLC();
-        iStringArray.AppendL(value);
-        SetValueSize(ValueSize()+ value->Size());
-        CleanupStack::Pop();
-        }
-    }
-
-void CStringArrayItem::ExternalizeL(RWriteStream& aStream) const
-    {
-    CItemBase::ExternalizeL(aStream);
-    ExternalizePointersArrayL(iStringArray, aStream);
-    }
-
-void CStringArrayItem::InternalizeL(RReadStream& aStream)
-    {
-    CItemBase::InternalizeL(aStream);
-    iStringArray.ResetAndDestroy();
-    InternalizePointersArrayL(iStringArray, aStream);
-    }
-
-const RPointerArray<HBufC>& CStringArrayItem:: StringArrayValue() const
-    {
-    return iStringArray;
-    }
-
-const HBufC& CStringArrayItem::Name() const
-    {
-    return CItemBase::Name(); 
-    }
-
-MOpaqueParam::TType CStringArrayItem::Type() const
-    {
-    return CItemBase::Type();
-    }
-
-TInt CStringArrayItem::ValueSize() const
-    {
-    return CItemBase::ValueSize();
-    }
-
-CStringArrayItem::~CStringArrayItem()
-    {
-    iStringArray.ResetAndDestroy();
-    }
-
-/*
- * CIntegerItem
- */
-
-CIntegerItem::CIntegerItem(TInt aValue):
-    CItemBase(EInteger),
-    iInteger(aValue)
-    {
-    
-    }
-
-CIntegerItem* CIntegerItem::NewL(const TDesC& aName, TInt aValue)
-    {
-    CIntegerItem* self = new(ELeave)CIntegerItem(aValue);
-    CleanupStack::PushL(self);
-    self->ConstructL(aName);
-    CleanupStack::Pop(self);  
-    return self;
-    }
-
-CIntegerItem* CIntegerItem::NewL(RReadStream& aStream)
-    {   
-    CIntegerItem *self = new(ELeave)CIntegerItem(0);
-    CleanupStack::PushL(self);
-    self->InternalizeL(aStream);
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-void CIntegerItem::ConstructL(const TDesC& aName)
-    {
-    SetNameL(aName);
-    SetValueSize(sizeof(TInt));
-    }
-
-void CIntegerItem::ExternalizeL(RWriteStream& aStream) const
-    {
-    CItemBase::ExternalizeL(aStream);
-    aStream.WriteInt32L(iInteger);
-    }
-
-void CIntegerItem::InternalizeL(RReadStream& aStream)
-    {
-    CItemBase::InternalizeL(aStream);
-    iInteger = aStream.ReadInt32L();
-    }
-
-TInt CIntegerItem::IntegerValue() const
-    {
-    return iInteger;
-    }
-
-const HBufC& CIntegerItem::Name() const
-    {
-    return CItemBase::Name(); 
-    }
-
-MOpaqueParam::TType CIntegerItem::Type() const
-    {
-    return CItemBase::Type();
-    }
-
-TInt CIntegerItem::ValueSize() const
-    {
-    return CItemBase::ValueSize();
-    }
-
-CIntegerItem::~CIntegerItem()
-    {
-    }
-
-/*
- * CIntegerArrayItem
- */
-
-CIntegerArrayItem::CIntegerArrayItem():
-    CItemBase(EIntegerArray)
-    {
-    
-    }
-
-CIntegerArrayItem* CIntegerArrayItem::NewL(const TDesC& aName, const RArray<TInt>& aValueArray)
-    {
-    CIntegerArrayItem* self = new(ELeave)CIntegerArrayItem();
-    CleanupStack::PushL(self);
-    self->ConstructL(aName, aValueArray);
-    CleanupStack::Pop(self);    
-    return self;
-    }
-
-CIntegerArrayItem* CIntegerArrayItem::NewL(RReadStream& aStream)
-    {   
-    CIntegerArrayItem *self = new(ELeave)CIntegerArrayItem();
-    CleanupStack::PushL(self);    
-    self->InternalizeL(aStream);
-    CleanupStack::Pop(self);
-    return self;
-    }
-
-
-void CIntegerArrayItem::ConstructL(const TDesC& aName, const RArray<TInt>& aValueArray)
-    {
-    SetNameL(aName);
-    
-    for(TInt i=0; i<aValueArray.Count(); ++i)
-        {
-        iIntegerArray.AppendL(aValueArray[i]);
-        SetValueSize(ValueSize()+sizeof(TInt));
-        }
-    }
-
-void CIntegerArrayItem::ExternalizeL(RWriteStream& aStream) const
-    {
-    CItemBase::ExternalizeL(aStream);
-    ExternalizeFixedLengthArrayL(iIntegerArray, aStream);
-    }
-
-void CIntegerArrayItem::InternalizeL(RReadStream& aStream)
-    {
-    CItemBase::InternalizeL(aStream);
-    iIntegerArray.Reset();
-    InternalizeFixedLengthArrayL(iIntegerArray, aStream);
-    }
-
-const RArray<TInt>& CIntegerArrayItem::IntegerArrayValue() const
-    {
-    return iIntegerArray;
-    }
-
-const HBufC& CIntegerArrayItem::Name() const
-    {
-    return CItemBase::Name(); 
-    }
-
-MOpaqueParam::TType CIntegerArrayItem::Type() const
-    {
-    return CItemBase::Type();
-    }
-
-TInt CIntegerArrayItem::ValueSize() const
-    {
-    return CItemBase::ValueSize();
-    }
-
-CIntegerArrayItem::~CIntegerArrayItem()
-    {
-    iIntegerArray.Close();
-    }