/*

* Copyright (c) 2006 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:   Implementation of DevTokenDataMarshaller

*

*/

#include <asymmetric.h>

#include <bigint.h>

#include <s32mem.h>

#include <certificateapps.h>

#include <ccertattributefilter.h>

#include <s32strm.h>

#include <e32test.h>

#include "DevTokenMarshaller.h"

#include "DevTokenDataTypes.h"

#include "DevTokenNullStream.h"

#include "DevCertKeyEncryptor.h"

#include "DevtokenLog.h"

// ======== LOCAL FUNCTIONS ========

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

// ---------------------------------------------------------------------------

// 

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, MDevTokenKeyInfoArray& aOut)

    {

    //No need to check this

    //ASSERT(aOut.Count() == 0);

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

        }

    }

// ---------------------------------------------------------------------------

// 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();

        }

    }

// ---------------------------------------------------------------------------

// Internalize an RPointerArray from a stream.

// ---------------------------------------------------------------------------

//

template <class T>

void CreateL(RReadStream& aIn, RPointerArray<T>& aOut)

    {

    TInt count = aIn.ReadInt32L();

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

        {

        T* t;

        CreateL(aIn, t);

        CleanupStack::PushL(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 CreateL function for internalizing HBufCs.

// ---------------------------------------------------------------------------

// 

inline void CreateL(RReadStream& aIn, HBufC*& aOut )

    {

    aOut = HBufC::NewL(aIn, KMaxSiteName );

    }

// ---------------------------------------------------------------------------

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

    }

// ---------------------------------------------------------------------------

// Decrypt and create a RInteger

// ---------------------------------------------------------------------------

// 

EXPORT_C void DecryptAndCreateLC(RReadStream& aIn, RInteger& aOut, MKeyEncryptor* aEncryptor)

    {

    TRACE_PRINT( "DecryptAndCreateL   ->>>")

    HBufC8* rBuf;

    HBufC8* decryptedBuf = NULL;

    CreateL(aIn, rBuf);

    CleanupStack::PushL(rBuf);

    TRACE_PRINT( "DecryptAndCreateL encrypted buf:" )

    TRACE_PRINT_RAW(*rBuf);

    if ( aEncryptor )

        {

        decryptedBuf = aEncryptor->DecryptL( *rBuf );

        TRACE_PRINT( "DecryptAndCreateL decrypted buf:" )

        TRACE_PRINT_RAW(*decryptedBuf);

        TPtr8 decryptedPtr(decryptedBuf->Des());

        aOut = RInteger::NewL(decryptedPtr);

        }

    TRACE_PRINT( "DecryptAndCreatL   <<<-")

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

    }

// ---------------------------------------------------------------------------

// Encrypt and Store an RInteger 

// ---------------------------------------------------------------------------

//

EXPORT_C void EncryptAndStoreL(const TInteger& aIn, RWriteStream& aOut, MKeyEncryptor* aEncryptor )

    {

    TRACE_PRINT( "EncryptAndStoreL   ->>>" )

    HBufC8* sBuf = aIn.BufferLC();

    HBufC8* encryptedBuf = NULL;

    TRACE_PRINT( "EncryptAndStoreL plain buf ;")

    TRACE_PRINT_RAW( *sBuf );

    if ( aEncryptor )

        {

        encryptedBuf = aEncryptor->EncryptL( *sBuf ); 

        TRACE_PRINT( "EncryptAndStoreL encrypted buf ;" )

        TRACE_PRINT_RAW( *encryptedBuf );

        aOut << *encryptedBuf;

        }

    TRACE_PRINT( "EncryptAndStoreL   <<<-" )    

    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 CDevTokenDHParams to use a function.

// ---------------------------------------------------------------------------

// 

EXTERNALIZE_FUNCTION(CDevTokenDHParams)

// ---------------------------------------------------------------------------

// Externalise a CDevTokenDHParams object.

// ---------------------------------------------------------------------------

//  

void ExternalizeL(const CDevTokenDHParams& aIn, RWriteStream& aOut)

    {

    aOut << aIn.N();

    aOut << aIn.G();

    }

// ---------------------------------------------------------------------------

// Specialise CreateL for CDevTokenDHParams.

// ---------------------------------------------------------------------------

// 

template <>

void CreateL(RReadStream& aIn, CDevTokenDHParams*& aOut)

    {

    RInteger n;

    CreateLC(aIn, n);

    RInteger g;

    CreateLC(aIn, g);

    aOut = CDevTokenDHParams::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.