/*

* 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);