diff -r 675a964f4eb5 -r 35751d3474b7 cryptoservices/filebasedcertificateandkeystores/source/shared/TokenDataMarshaller.cpp
--- a/cryptoservices/filebasedcertificateandkeystores/source/shared/TokenDataMarshaller.cpp	Tue Jul 21 01:04:32 2009 +0100
+++ b/cryptoservices/filebasedcertificateandkeystores/source/shared/TokenDataMarshaller.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -1,620 +1,620 @@
-/*
-* Copyright (c) 2004-2009 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 "fsmarshaller.h"
-#include "fsdatatypes.h"
-#include "NullStream.h"
-#include <asymmetric.h>
-#include <bigint.h>
-#include <pbedata.h>
-#include <s32mem.h>
-#include <certificateapps.h>
-#include <ccertattributefilter.h>
-
-// Generic externalization stuff ///////////////////////////////////////////////
-
-/**
- * Determine how many bytes are taked up by the externalized representation of
- * an object.
- */
-template <class T>
-TInt Size(const T& aObject)
-	{
-	RNullWriteStream stream;
-	TRAPD(err, stream << aObject);
-	if(err != KErrNone)
-		{
-		_LIT(KPanicCategory, "InValid Size");
-		User::Panic(KPanicCategory,ESerialisationPanic);
-		}
-	stream.Close();
-	return stream.BytesWritten();
-	}
-
-/**
- * Externalize an object to a buffer.  Leaves if an error occurs.
- */
-template <class T>
-void WriteL(const T& aIn, TDes8& aOut)
-	{
-	RDesWriteStream stream(aOut);
-	stream << aIn;
-	stream.Close();
-	}
-
-/**
- * Externalize an object to a buffer.  In debug mode, it will panics if an error
- * occurs - eg buffer is too short.  In release mode, errors are ignored.
- */
-template <class T>
-void Write(const T& aIn, TDes8& aOut)
-	{
-	TRAPD(err, WriteL(aIn, aOut));
-	if(err != KErrNone)
-		{
-		_LIT(KPanicCategory, "Writing Error");
-		User::Panic(KPanicCategory,ESerialisationPanic);
-		}
-	}
-
-/**
- * Implement Externalization selector for RPointerArrays to use a function.
- */
-template <class T>
-EXTERNALIZE_FUNCTION(RPointerArray<T>)
-
-/**
- * Function to externalize RPointerArrays.
- *
- * Although this is generic, it's currently only instantiated for CKeyInfo.
- */
-template <class T>
-void ExternalizeL(const RPointerArray<T>& aIn, RWriteStream& aOut)
-	{
-	TInt count = aIn.Count();
-	aOut.WriteInt32L(count);
-	for (TInt i = 0 ; i < count ; ++i)
-		{
-		T* object = aIn[i];
-		if (object == NULL)
-			{
-			User::Leave(KErrArgument);
-			}
-		aOut << *object;
-		}
-	}
-
-/**
- * Implement Externalization selector for RArrays to use a function.
- */
-template <class T>
-EXTERNALIZE_FUNCTION(RArray<T>)
-
-/**
- * Function to externalize RArrays.
- */
-template <class T>
-void ExternalizeL(const RArray<T>& aIn, RWriteStream& aOut)
-	{
-	TInt count = aIn.Count();
-	aOut.WriteInt32L(count);
-	for (TInt i = 0 ; i < count ; ++i)
-		{
-		aOut << aIn[i];
-		}
-	}
-
-// No-so-generic internalization stuff /////////////////////////////////////////
-
-/**
- * Internalize an object from a descriptor.
- */
-template <class T>
-void ReadL(const TDesC8& aIn, T& aOut)
-	{
-	RDesReadStream stream(aIn);
-	stream >> aOut;
-	stream.Close();
-	}
-
-/**
- * Implement Internalization selector for RArrays to use a function.
- */
-template <class T>
-inline Internalize::Function Internalization(const RArray<T>*)
-	{
-	return Internalize::Function();
-	}
-
-/**
- * Function to internalize an RArray.
- */
-template <class T>
-void InternalizeL(RArray<T>& aOut, RReadStream& aIn)
-	{
-	ASSERT(aOut.Count() == 0);
-	TInt count = aIn.ReadInt32L();
-	for (TInt i = 0 ; i < count ; ++i)
-		{
-		T t;
-		aIn >> t;
-		User::LeaveIfError(aOut.Append(t));
-		}
-	}
-
-/**
- * Internalize an object from a stream.  Creates an instance by calling the
- * class' NewL(RReadStream&) method.
- */
-template <class T>
-inline void CreateL(RReadStream& aIn, T*& aOut)
-	{
-	aOut = T::NewL(aIn);
-	}
-
-/**
- * Internalize an object from a descriptor.  
- */
-template <class T>
-void CreateL(const TDesC8& aIn, T& aOut)
-	{
-	RDesReadStream stream(aIn);
-	CreateL(stream, aOut);
-	stream.Close();
-	}
-
-/**
- * Internalize an object from a descriptor leaving the result on the cleanup
- * stack.  This is generic, but is only instantiated for RInteger.
- */
-template <class T>
-void CreateLC(const TDesC8& aIn, T& aOut)
-	{
-	RDesReadStream stream(aIn);
-	CreateLC(stream, aOut);
-	stream.Close();
-	}
-
-/**
- * Internalize a cryptotokens object from a descriptor.
- */
-template <class T>
-void CreateL(const TDesC8& aIn, MCTToken& aToken, T& aOut)
-	{
-	RDesReadStream stream(aIn);
-	CreateL(stream, aToken, aOut);
-	stream.Close();
-	}
-
-/**
- * Internalize a cryptotoken object from a stream.  Creates an instance by
- * calling the class' NewL(RReadStream&, MCTToken&) method.
- */
-template <class T>
-inline void CreateL(RReadStream& aIn, MCTToken& aToken, T*& aOut)
-	{
-	aOut = T::NewL(aIn, aToken);
-	}
-
-/**
- * Internalize an array of of key info objects from a stream. 
- */
-void CreateL(RReadStream& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
-	{
-	TInt count = aIn.ReadInt32L();
-	for (TInt i = 0 ; i < count ; ++i)
-		{
-		CCTKeyInfo* t;
-		CreateL(aIn, aToken, t);
-		CleanupReleasePushL(*t);
-		User::LeaveIfError(aOut.Append(t));
-		CleanupStack::Pop();
-		}
-	}
-
-// can we combine this with the one above?
-
-/**
- * Internalize an RMPointerArray of cryptotoken objects from a stream.
- */
-template <class T>
-void CreateL(RReadStream& aIn, MCTToken& aToken, RMPointerArray<T>& aOut)
-	{	
-	TInt count = aIn.ReadInt32L();
-	for (TInt i = 0 ; i < count ; ++i)
-		{
-		T* t;
-		CreateL(aIn, aToken, t);
-		CleanupReleasePushL(*t);
-		User::LeaveIfError(aOut.Append(t));
-		CleanupStack::Pop();
-		}
-	}
-
-// Serialization for RIntegers /////////////////////////////////////////////////
-
-// This is exported as it is useful itself in the server
-
-/**
- * Implement a CreateL function for internalizing HBufC8s.
- */
-inline void CreateL(RReadStream& aIn, HBufC8*& aOut)
-	{
-	aOut = HBufC8::NewL(aIn, KMaxIntegerSize);
-	}
-
-/**
- * Implement a CreateLC function for internalizing RIntegers. 
- */
-EXPORT_C void CreateLC(RReadStream& aIn, RInteger& aOut)
-	{	
-	HBufC8* rBuf;
-	CreateL(aIn, rBuf);
-	CleanupStack::PushL(rBuf);
-	TPtr8 rPtr(rBuf->Des());	
-	aOut = RInteger::NewL(rPtr);
-	CleanupStack::PopAndDestroy(rBuf);
-	CleanupStack::PushL(aOut);
-	}
-
-/**
- * Externalize an RInteger.
- */
-EXPORT_C void ExternalizeL(const TInteger& aIn, RWriteStream& aOut)
-	{
-	HBufC8* sBuf = aIn.BufferLC();
-	aOut << *sBuf;
-	CleanupStack::PopAndDestroy(sBuf);	
-	}
-
-// Externalization for signature objects ///////////////////////////////////////
-
-/**
- * Implement Externalization selector for CDSASignature to use a function.
- */
-EXTERNALIZE_FUNCTION(CDSASignature)
-
-/**
- * Externalise a DSA signature object.
- */
-void ExternalizeL(const CDSASignature& aIn, RWriteStream& aOut)
-	{
-	aOut << aIn.R();
-	aOut << aIn.S();
-	}
-
-/**
- * Implement Externalization selector for CRSASignature to use a function.
- */
-EXTERNALIZE_FUNCTION(CRSASignature)
-
-/**
- * Externalize an RSA signature object.
- */
-void ExternalizeL(const CRSASignature& aIn, RWriteStream& aOut)
-	{
-	aOut << aIn.S();
-	}
-
-// Internalization for signature objects ///////////////////////////////////////
-
-/**
- * Specialise CreateL for CRSASignature.
- */
-template <>
-void CreateL(RReadStream& aIn, CRSASignature*& aOut)
-	{
-	RInteger r;
-	CreateLC(aIn, r);
-	aOut = CRSASignature::NewL(r);
-	CleanupStack::Pop(); // r
-	}
-
-/**
- * Specialise CreateL for CDSASignature.
- */
-template <>
-void CreateL(RReadStream& aIn, CDSASignature*& aOut)
-	{
-	RInteger r;
-	CreateLC(aIn, r);
-	RInteger s;
-	CreateLC(aIn, s);
-	aOut = CDSASignature::NewL(r, s);
-	CleanupStack::Pop(2); // s, r
-	}
-
-// Serialization for DH ojects /////////////////////////////////////////////////
-
-/**
- * Implement Externalization selector for CDHParams to use a function.
- */
-EXTERNALIZE_FUNCTION(CDHParams)
-
-/**
- * Externalise a TDHParams object.
- */
-void ExternalizeL(const CDHParams& aIn, RWriteStream& aOut)
-	{
-	aOut << aIn.N();
-	aOut << aIn.G();
-	}
-
-/**
- * Specialise CreateL for CDHParams.
- */
-template <>
-void CreateL(RReadStream& aIn, CDHParams*& aOut)
-	{
-	RInteger n;
-	CreateLC(aIn, n);
-	RInteger g;
-	CreateLC(aIn, g);
-	aOut = CDHParams::NewL(n, g);
-	CleanupStack::PopAndDestroy(2, &n); // g, n
-	}
-
-/**
- * Implement Externalization selector for CDHPublicKey to use a function.
- */
-EXTERNALIZE_FUNCTION(CDHPublicKey)
-
-/**
- * Externalise a CDHPublicKey object.
- */
-void ExternalizeL(const CDHPublicKey& aIn, RWriteStream& aOut)
-	{
-	aOut << aIn.N();
-	aOut << aIn.G();
-	aOut << aIn.X();
-	}
-
-/**
- * Specialise CreateL for CDHPublicKey.
- */
-template <>
-void CreateL(RReadStream& aIn, CDHPublicKey*& aOut)
-	{
-	RInteger n;
-	CreateLC(aIn, n);
-	RInteger g;
-	CreateLC(aIn, g);
-	RInteger X;
-	CreateLC(aIn, X);
-	aOut = CDHPublicKey::NewL(n, g, X);
-	CleanupStack::Pop(3); // X, g, n
-	}
-
-// Common //////////////////////////////////////////////////////////////////////
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TUid>& aOut)
-	{
-	::ReadL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CKeyInfoBase& aIn)
-	{
-	return ::Size(aIn);
-	}
-
-EXPORT_C void TokenDataMarshaller::Write(const CKeyInfoBase& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TUid>& aIn)
-	{
-	return ::Size(aIn);
-	}
-
-EXPORT_C void TokenDataMarshaller::Write(const RArray<TUid>& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const MCertInfo& aIn)
-	{
-	return ::Size(aIn);
-	}
-
-EXPORT_C void TokenDataMarshaller::Write(const MCertInfo& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}
-
-// Client //////////////////////////////////////////////////////////////////////
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
-	{
-	::CreateL(aIn, aToken, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTKeyInfo*& aOut)
-	{
-	::CreateL(aIn, aToken, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDSASignature*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CRSASignature*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CDHParams& aIn)
-	{
-    return Size(aIn.N()) + Size(aIn.G());
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const CDHParams& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CDHPublicKey& aIn)
-	{
-	return Size(aIn.N()) + Size(aIn.G()) + Size(aIn.X());
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const CDHPublicKey& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RInteger& aInteger)
-	{
-	::CreateLC(aIn, aInteger);
-	CleanupStack::Pop();
-	}
-	
-EXPORT_C TInt TokenDataMarshaller::Size(const CPBEncryptParms& aIn)
-	{
-	return ::Size(aIn);
-	}
-	
-EXPORT_C void TokenDataMarshaller::Write(const CPBEncryptParms& aIn,  TDes8& aOut)
-	{
-	::Write(aIn, aOut);	
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, RMPointerArray<CCTCertInfo>& aOut)
-	{
-	::CreateL(aIn, aToken, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTCertInfo*& aOut)
-	{
-	::CreateL(aIn, aToken, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TCertificateAppInfo>& aOut)
-	{
-	::ReadL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CCertAttributeFilter& aIn)
-	{
-	return ::Size(aIn);
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const CCertAttributeFilter& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-// Server //////////////////////////////////////////////////////////////////////
-
-EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CKeyInfo>& aIn)
-	{
-	return ::Size(aIn);
-	}
-	
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CPBEncryptParms*& aOut)
-	{
-	::CreateL(aIn, aOut);	
-	}
-
-EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CKeyInfo>& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CKeyInfo*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-/**
- * Determine the size of an externalized big integer.  This assumes that the
- * size of the buffer returned by TInteger::BufferLC() is the same as the size
- * of the integer as returned by TInteger::ByteCount().  This is done to avoid
- * allocating the buffer just so we can tell how big it is.
- */
-EXPORT_C TInt TokenDataMarshaller::Size(const TInteger& aIn)
-	{
-	// This is an overestimate as the length is encoded with a TCardinality
-	return sizeof(TInt32) + aIn.ByteCount();
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CDSASignature& aIn)
-	{
-	return Size(aIn.R()) + Size(aIn.S());
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const CDSASignature& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const CRSASignature& aIn)
-	{
-	return Size(aIn.S());
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const CRSASignature& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHParams*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHPublicKey*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::WriteL(const TInteger& aIn, TDes8& aOut)
-	{
-	::WriteL(aIn, aOut);
-	}
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertInfo*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CCertInfo>& aIn)
-	{
-	return ::Size(aIn);
-	}
-
-EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CCertInfo>& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}
-
-EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TCertificateAppInfo>& aIn)
-	{
-	return ::Size(aIn);
-	}
-   
-EXPORT_C void TokenDataMarshaller::Write(const RArray<TCertificateAppInfo>& aIn, TDes8& aOut)
-	{
-	::Write(aIn, aOut);
-	}   
-
-EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertAttributeFilter*& aOut)
-	{
-	::CreateL(aIn, aOut);
-	}
+/*
+* Copyright (c) 2004-2009 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 "fsmarshaller.h"
+#include "fsdatatypes.h"
+#include "NullStream.h"
+#include <asymmetric.h>
+#include <bigint.h>
+#include <pbedata.h>
+#include <s32mem.h>
+#include <certificateapps.h>
+#include <ccertattributefilter.h>
+
+// Generic externalization stuff ///////////////////////////////////////////////
+
+/**
+ * Determine how many bytes are taked up by the externalized representation of
+ * an object.
+ */
+template <class T>
+TInt Size(const T& aObject)
+	{
+	RNullWriteStream stream;
+	TRAPD(err, stream << aObject);
+	if(err != KErrNone)
+		{
+		_LIT(KPanicCategory, "InValid Size");
+		User::Panic(KPanicCategory,ESerialisationPanic);
+		}
+	stream.Close();
+	return stream.BytesWritten();
+	}
+
+/**
+ * Externalize an object to a buffer.  Leaves if an error occurs.
+ */
+template <class T>
+void WriteL(const T& aIn, TDes8& aOut)
+	{
+	RDesWriteStream stream(aOut);
+	stream << aIn;
+	stream.Close();
+	}
+
+/**
+ * Externalize an object to a buffer.  In debug mode, it will panics if an error
+ * occurs - eg buffer is too short.  In release mode, errors are ignored.
+ */
+template <class T>
+void Write(const T& aIn, TDes8& aOut)
+	{
+	TRAPD(err, WriteL(aIn, aOut));
+	if(err != KErrNone)
+		{
+		_LIT(KPanicCategory, "Writing Error");
+		User::Panic(KPanicCategory,ESerialisationPanic);
+		}
+	}
+
+/**
+ * Implement Externalization selector for RPointerArrays to use a function.
+ */
+template <class T>
+EXTERNALIZE_FUNCTION(RPointerArray<T>)
+
+/**
+ * Function to externalize RPointerArrays.
+ *
+ * Although this is generic, it's currently only instantiated for CKeyInfo.
+ */
+template <class T>
+void ExternalizeL(const RPointerArray<T>& aIn, RWriteStream& aOut)
+	{
+	TInt count = aIn.Count();
+	aOut.WriteInt32L(count);
+	for (TInt i = 0 ; i < count ; ++i)
+		{
+		T* object = aIn[i];
+		if (object == NULL)
+			{
+			User::Leave(KErrArgument);
+			}
+		aOut << *object;
+		}
+	}
+
+/**
+ * Implement Externalization selector for RArrays to use a function.
+ */
+template <class T>
+EXTERNALIZE_FUNCTION(RArray<T>)
+
+/**
+ * Function to externalize RArrays.
+ */
+template <class T>
+void ExternalizeL(const RArray<T>& aIn, RWriteStream& aOut)
+	{
+	TInt count = aIn.Count();
+	aOut.WriteInt32L(count);
+	for (TInt i = 0 ; i < count ; ++i)
+		{
+		aOut << aIn[i];
+		}
+	}
+
+// No-so-generic internalization stuff /////////////////////////////////////////
+
+/**
+ * Internalize an object from a descriptor.
+ */
+template <class T>
+void ReadL(const TDesC8& aIn, T& aOut)
+	{
+	RDesReadStream stream(aIn);
+	stream >> aOut;
+	stream.Close();
+	}
+
+/**
+ * Implement Internalization selector for RArrays to use a function.
+ */
+template <class T>
+inline Internalize::Function Internalization(const RArray<T>*)
+	{
+	return Internalize::Function();
+	}
+
+/**
+ * Function to internalize an RArray.
+ */
+template <class T>
+void InternalizeL(RArray<T>& aOut, RReadStream& aIn)
+	{
+	ASSERT(aOut.Count() == 0);
+	TInt count = aIn.ReadInt32L();
+	for (TInt i = 0 ; i < count ; ++i)
+		{
+		T t;
+		aIn >> t;
+		User::LeaveIfError(aOut.Append(t));
+		}
+	}
+
+/**
+ * Internalize an object from a stream.  Creates an instance by calling the
+ * class' NewL(RReadStream&) method.
+ */
+template <class T>
+inline void CreateL(RReadStream& aIn, T*& aOut)
+	{
+	aOut = T::NewL(aIn);
+	}
+
+/**
+ * Internalize an object from a descriptor.  
+ */
+template <class T>
+void CreateL(const TDesC8& aIn, T& aOut)
+	{
+	RDesReadStream stream(aIn);
+	CreateL(stream, aOut);
+	stream.Close();
+	}
+
+/**
+ * Internalize an object from a descriptor leaving the result on the cleanup
+ * stack.  This is generic, but is only instantiated for RInteger.
+ */
+template <class T>
+void CreateLC(const TDesC8& aIn, T& aOut)
+	{
+	RDesReadStream stream(aIn);
+	CreateLC(stream, aOut);
+	stream.Close();
+	}
+
+/**
+ * Internalize a cryptotokens object from a descriptor.
+ */
+template <class T>
+void CreateL(const TDesC8& aIn, MCTToken& aToken, T& aOut)
+	{
+	RDesReadStream stream(aIn);
+	CreateL(stream, aToken, aOut);
+	stream.Close();
+	}
+
+/**
+ * Internalize a cryptotoken object from a stream.  Creates an instance by
+ * calling the class' NewL(RReadStream&, MCTToken&) method.
+ */
+template <class T>
+inline void CreateL(RReadStream& aIn, MCTToken& aToken, T*& aOut)
+	{
+	aOut = T::NewL(aIn, aToken);
+	}
+
+/**
+ * Internalize an array of of key info objects from a stream. 
+ */
+void CreateL(RReadStream& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
+	{
+	TInt count = aIn.ReadInt32L();
+	for (TInt i = 0 ; i < count ; ++i)
+		{
+		CCTKeyInfo* t;
+		CreateL(aIn, aToken, t);
+		CleanupReleasePushL(*t);
+		User::LeaveIfError(aOut.Append(t));
+		CleanupStack::Pop();
+		}
+	}
+
+// can we combine this with the one above?
+
+/**
+ * Internalize an RMPointerArray of cryptotoken objects from a stream.
+ */
+template <class T>
+void CreateL(RReadStream& aIn, MCTToken& aToken, RMPointerArray<T>& aOut)
+	{	
+	TInt count = aIn.ReadInt32L();
+	for (TInt i = 0 ; i < count ; ++i)
+		{
+		T* t;
+		CreateL(aIn, aToken, t);
+		CleanupReleasePushL(*t);
+		User::LeaveIfError(aOut.Append(t));
+		CleanupStack::Pop();
+		}
+	}
+
+// Serialization for RIntegers /////////////////////////////////////////////////
+
+// This is exported as it is useful itself in the server
+
+/**
+ * Implement a CreateL function for internalizing HBufC8s.
+ */
+inline void CreateL(RReadStream& aIn, HBufC8*& aOut)
+	{
+	aOut = HBufC8::NewL(aIn, KMaxIntegerSize);
+	}
+
+/**
+ * Implement a CreateLC function for internalizing RIntegers. 
+ */
+EXPORT_C void CreateLC(RReadStream& aIn, RInteger& aOut)
+	{	
+	HBufC8* rBuf;
+	CreateL(aIn, rBuf);
+	CleanupStack::PushL(rBuf);
+	TPtr8 rPtr(rBuf->Des());	
+	aOut = RInteger::NewL(rPtr);
+	CleanupStack::PopAndDestroy(rBuf);
+	CleanupStack::PushL(aOut);
+	}
+
+/**
+ * Externalize an RInteger.
+ */
+EXPORT_C void ExternalizeL(const TInteger& aIn, RWriteStream& aOut)
+	{
+	HBufC8* sBuf = aIn.BufferLC();
+	aOut << *sBuf;
+	CleanupStack::PopAndDestroy(sBuf);	
+	}
+
+// Externalization for signature objects ///////////////////////////////////////
+
+/**
+ * Implement Externalization selector for CDSASignature to use a function.
+ */
+EXTERNALIZE_FUNCTION(CDSASignature)
+
+/**
+ * Externalise a DSA signature object.
+ */
+void ExternalizeL(const CDSASignature& aIn, RWriteStream& aOut)
+	{
+	aOut << aIn.R();
+	aOut << aIn.S();
+	}
+
+/**
+ * Implement Externalization selector for CRSASignature to use a function.
+ */
+EXTERNALIZE_FUNCTION(CRSASignature)
+
+/**
+ * Externalize an RSA signature object.
+ */
+void ExternalizeL(const CRSASignature& aIn, RWriteStream& aOut)
+	{
+	aOut << aIn.S();
+	}
+
+// Internalization for signature objects ///////////////////////////////////////
+
+/**
+ * Specialise CreateL for CRSASignature.
+ */
+template <>
+void CreateL(RReadStream& aIn, CRSASignature*& aOut)
+	{
+	RInteger r;
+	CreateLC(aIn, r);
+	aOut = CRSASignature::NewL(r);
+	CleanupStack::Pop(); // r
+	}
+
+/**
+ * Specialise CreateL for CDSASignature.
+ */
+template <>
+void CreateL(RReadStream& aIn, CDSASignature*& aOut)
+	{
+	RInteger r;
+	CreateLC(aIn, r);
+	RInteger s;
+	CreateLC(aIn, s);
+	aOut = CDSASignature::NewL(r, s);
+	CleanupStack::Pop(2); // s, r
+	}
+
+// Serialization for DH ojects /////////////////////////////////////////////////
+
+/**
+ * Implement Externalization selector for CDHParams to use a function.
+ */
+EXTERNALIZE_FUNCTION(CDHParams)
+
+/**
+ * Externalise a TDHParams object.
+ */
+void ExternalizeL(const CDHParams& aIn, RWriteStream& aOut)
+	{
+	aOut << aIn.N();
+	aOut << aIn.G();
+	}
+
+/**
+ * Specialise CreateL for CDHParams.
+ */
+template <>
+void CreateL(RReadStream& aIn, CDHParams*& aOut)
+	{
+	RInteger n;
+	CreateLC(aIn, n);
+	RInteger g;
+	CreateLC(aIn, g);
+	aOut = CDHParams::NewL(n, g);
+	CleanupStack::PopAndDestroy(2, &n); // g, n
+	}
+
+/**
+ * Implement Externalization selector for CDHPublicKey to use a function.
+ */
+EXTERNALIZE_FUNCTION(CDHPublicKey)
+
+/**
+ * Externalise a CDHPublicKey object.
+ */
+void ExternalizeL(const CDHPublicKey& aIn, RWriteStream& aOut)
+	{
+	aOut << aIn.N();
+	aOut << aIn.G();
+	aOut << aIn.X();
+	}
+
+/**
+ * Specialise CreateL for CDHPublicKey.
+ */
+template <>
+void CreateL(RReadStream& aIn, CDHPublicKey*& aOut)
+	{
+	RInteger n;
+	CreateLC(aIn, n);
+	RInteger g;
+	CreateLC(aIn, g);
+	RInteger X;
+	CreateLC(aIn, X);
+	aOut = CDHPublicKey::NewL(n, g, X);
+	CleanupStack::Pop(3); // X, g, n
+	}
+
+// Common //////////////////////////////////////////////////////////////////////
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TUid>& aOut)
+	{
+	::ReadL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CKeyInfoBase& aIn)
+	{
+	return ::Size(aIn);
+	}
+
+EXPORT_C void TokenDataMarshaller::Write(const CKeyInfoBase& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TUid>& aIn)
+	{
+	return ::Size(aIn);
+	}
+
+EXPORT_C void TokenDataMarshaller::Write(const RArray<TUid>& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const MCertInfo& aIn)
+	{
+	return ::Size(aIn);
+	}
+
+EXPORT_C void TokenDataMarshaller::Write(const MCertInfo& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}
+
+// Client //////////////////////////////////////////////////////////////////////
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
+	{
+	::CreateL(aIn, aToken, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTKeyInfo*& aOut)
+	{
+	::CreateL(aIn, aToken, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDSASignature*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CRSASignature*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CDHParams& aIn)
+	{
+    return Size(aIn.N()) + Size(aIn.G());
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const CDHParams& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CDHPublicKey& aIn)
+	{
+	return Size(aIn.N()) + Size(aIn.G()) + Size(aIn.X());
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const CDHPublicKey& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RInteger& aInteger)
+	{
+	::CreateLC(aIn, aInteger);
+	CleanupStack::Pop();
+	}
+	
+EXPORT_C TInt TokenDataMarshaller::Size(const CPBEncryptParms& aIn)
+	{
+	return ::Size(aIn);
+	}
+	
+EXPORT_C void TokenDataMarshaller::Write(const CPBEncryptParms& aIn,  TDes8& aOut)
+	{
+	::Write(aIn, aOut);	
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, RMPointerArray<CCTCertInfo>& aOut)
+	{
+	::CreateL(aIn, aToken, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTCertInfo*& aOut)
+	{
+	::CreateL(aIn, aToken, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TCertificateAppInfo>& aOut)
+	{
+	::ReadL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CCertAttributeFilter& aIn)
+	{
+	return ::Size(aIn);
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const CCertAttributeFilter& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+// Server //////////////////////////////////////////////////////////////////////
+
+EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CKeyInfo>& aIn)
+	{
+	return ::Size(aIn);
+	}
+	
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CPBEncryptParms*& aOut)
+	{
+	::CreateL(aIn, aOut);	
+	}
+
+EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CKeyInfo>& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CKeyInfo*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+/**
+ * Determine the size of an externalized big integer.  This assumes that the
+ * size of the buffer returned by TInteger::BufferLC() is the same as the size
+ * of the integer as returned by TInteger::ByteCount().  This is done to avoid
+ * allocating the buffer just so we can tell how big it is.
+ */
+EXPORT_C TInt TokenDataMarshaller::Size(const TInteger& aIn)
+	{
+	// This is an overestimate as the length is encoded with a TCardinality
+	return sizeof(TInt32) + aIn.ByteCount();
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CDSASignature& aIn)
+	{
+	return Size(aIn.R()) + Size(aIn.S());
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const CDSASignature& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const CRSASignature& aIn)
+	{
+	return Size(aIn.S());
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const CRSASignature& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHParams*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHPublicKey*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::WriteL(const TInteger& aIn, TDes8& aOut)
+	{
+	::WriteL(aIn, aOut);
+	}
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertInfo*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CCertInfo>& aIn)
+	{
+	return ::Size(aIn);
+	}
+
+EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CCertInfo>& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}
+
+EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TCertificateAppInfo>& aIn)
+	{
+	return ::Size(aIn);
+	}
+   
+EXPORT_C void TokenDataMarshaller::Write(const RArray<TCertificateAppInfo>& aIn, TDes8& aOut)
+	{
+	::Write(aIn, aOut);
+	}   
+
+EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertAttributeFilter*& aOut)
+	{
+	::CreateL(aIn, aOut);
+	}