/**
 * Copyright (c) 2010 Sasken Communication Technologies Ltd.
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the "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:
 * Pritam Roy Biswas, Sasken Communication Technologies Ltd - Initial contribution
 *
 * Description:
 *	This source file gives different data classes to be used
 * by Credential Manager Client and Server for data transfer.	
 *
 */

#include "smfcredmgrclientdatastruct.h"
#include "smfutils.h"
#include <f32file.h>

void TSmfAuthToken::ExternalizeL(RWriteStream& aStream)
	{

	TPtr firstArgPtr(iKey->Des());
	SmfUtils::ExternalizeDesL(firstArgPtr, aStream);

	TPtr secondArgPtr(iSecret->Des());
	SmfUtils::ExternalizeDesL(secondArgPtr, aStream);
	}

void TSmfAuthToken::InternalizeL(RReadStream& aStream)
	{

	// Delete the current values
	delete iKey;
	iKey = SmfUtils::InternalizeDesL(aStream);

	delete iSecret;
	iSecret = SmfUtils::InternalizeDesL(aStream);
	}

void CSmfFetchAuthTokenSet::ExternalizeL(RWriteStream& aStream)
	{
	aStream.WriteUint32L(iValidity);

	TPtr tokenPtr(iRegistrationToken->Des());
	SmfUtils::ExternalizeDesL(tokenPtr, aStream);

	TInt32 countTokenSet = iAuthTokenArray.Count();
	aStream.WriteInt32L(countTokenSet);

	for (int i = 0; i < countTokenSet; i++)
		{
		iAuthTokenArray[i].ExternalizeL(aStream);
		}

	}

void CSmfFetchAuthTokenSet::InternalizeL(const RBuf8& aSource)
	{
	// Create stream to read from the given buffer
	RDesReadStream stream(aSource);
	CleanupClosePushL(stream);

	iValidity = stream.ReadUint32L();
	
	// Delete the current values
	delete iRegistrationToken;
	iRegistrationToken = SmfUtils::InternalizeDesL(stream);

	TInt32 countTokenSet = stream.ReadInt32L();
	iAuthTokenArray.Reset();
	for (int i = 0; i < countTokenSet; i++)
		{
		TSmfAuthToken set;
		set.InternalizeL(stream);
		iAuthTokenArray.Insert(set, i);
		}
	CleanupStack::PopAndDestroy(&stream);
	}

void CSmfURLListParams::ExternalizeL(RWriteStream& aStream)
	{
	TInt32 countPlugin = iURLList.Count();
	aStream.WriteInt32L(countPlugin);
	for (int i = 0; i < countPlugin; i++)
		{
		TPtr pluginBufPtr(iURLList[i]->Des());
		SmfUtils::ExternalizeDesL(pluginBufPtr, aStream);
		}

	TPtr tokenPtr(iPluginID->Des());
	SmfUtils::ExternalizeDesL(tokenPtr, aStream);
	}

void CSmfURLListParams::InternalizeL(const TDesC8& aSource)
	{
	// Create stream to read from the given buffer
	RDesReadStream stream(aSource);
	CleanupClosePushL(stream);

	//internalize plugin ids
	TInt32 countPlugin = stream.ReadInt32L();
	iURLList.Reset();
	for (int i = 0; i < countPlugin; i++)
		{
		HBufC* bufPlugin(SmfUtils::InternalizeDesL(stream));
		iURLList.Insert(bufPlugin, i);
		}
	iPluginID = SmfUtils::InternalizeDesL(stream);

	CleanupStack::PopAndDestroy(&stream);
	}

void CSmfPluginIDListParams::ExternalizeL(RWriteStream& aStream)
	{
	TPtr tokenPtr(iRegistrationToken->Des());
	SmfUtils::ExternalizeDesL(tokenPtr, aStream);

	TInt32 countPlugin = iPluginList.Count();
	aStream.WriteInt32L(countPlugin);
	for (int i = 0; i < countPlugin; i++)
		{
		TPtr pluginBufPtr(iPluginList[i]->Des());
		SmfUtils::ExternalizeDesL(pluginBufPtr, aStream);
		}
	}

void CSmfPluginIDListParams::InternalizeL(const RBuf8& aSource)
	{
	// Create stream to use given buffer.
	RDesReadStream stream(aSource);
	CleanupClosePushL(stream);

	// Delete the current values
	delete iRegistrationToken;
	iRegistrationToken = SmfUtils::InternalizeDesL(stream);

	//internalize plugin ids
	TInt32 countPlugin = stream.ReadInt32L();
	iPluginList.Reset();
	for (int i = 0; i < countPlugin; i++)
		{
		HBufC* bufPlugin(SmfUtils::InternalizeDesL(stream));
		iPluginList.Insert(bufPlugin, i);
		}
	CleanupStack::PopAndDestroy(&stream);
	}

void CSmfStoreAuthParams::ExternalizeL(RWriteStream& aStream)
	{
	aStream.WriteInt32L(pluginIDEnabled);

	aStream.WriteUint32L(iValidity);

	TPtr tokenPtr(iRegistrationToken->Des());
	SmfUtils::ExternalizeDesL(tokenPtr, aStream);

	TPtr AuthAppIdPtr(iAuthAppID->Des());
	SmfUtils::ExternalizeDesL(AuthAppIdPtr, aStream);

	TInt32 countTokenSet = iAuthTokenArray.Count();
	aStream.WriteInt32L(countTokenSet);

	for (int i = 0; i < countTokenSet; i++)
		{
		iAuthTokenArray[i].ExternalizeL(aStream);
		}

	TInt32 countPlugin = iPluginIDList.Count();

	aStream.WriteInt32L(countPlugin);

	for (int i = 0; i < countPlugin; i++)
		{

		TPtr pluginBufPtr(iPluginIDList[i]->Des());
		SmfUtils::ExternalizeDesL(pluginBufPtr, aStream);
		}

	TInt32 countUrl = iURLList.Count();
	aStream.WriteInt32L(countUrl);

	for (int i = 0; i < countUrl; i++)
		{
		TPtr urlBufPtr(iURLList[i]->Des());
		SmfUtils::ExternalizeDesL(urlBufPtr, aStream);
		}
	}

void CSmfStoreAuthParams::InternalizeL(const RBuf8& aSource)
	{
	// Create stream to read from the given buffer
	RDesReadStream stream(aSource);
	CleanupClosePushL(stream);

	pluginIDEnabled = stream.ReadInt32L();

	iValidity = stream.ReadUint32L();

	// Delete the current values
	delete iRegistrationToken;
	iRegistrationToken = SmfUtils::InternalizeDesL(stream);

	delete iAuthAppID;
	iAuthAppID = SmfUtils::InternalizeDesL(stream);

	TInt32 countTokenSet = stream.ReadInt32L();
	iAuthTokenArray.Reset();
	for (int i = 0; i < countTokenSet; i++)
		{
		TSmfAuthToken set;
		set.InternalizeL(stream);
		iAuthTokenArray.Insert(set, i);
		}

	//internalize plugin ids
	TInt32 countPlugin = stream.ReadInt32L();
	iPluginIDList.Reset();
	for (int i = 0; i < countPlugin; i++)
		{
		HBufC* bufPlugin = SmfUtils::InternalizeDesL(stream);
		iPluginIDList.Insert(bufPlugin, i);
		}

	//internalize URLs
	TInt32 countURL = stream.ReadInt32L();
	iURLList.Reset();
	for (int i = 0; i < countURL; i++)
		{
		HBufC* bufURL = SmfUtils::InternalizeDesL(stream);
		iURLList.Insert(bufURL, i);
		}
	CleanupStack::PopAndDestroy(&stream);
	}

void CSmfPluginIDUpdate::ExternalizeL(RWriteStream& aStream)
	{
	aStream.WriteInt32L(pluginIDEnabled);

	TPtr newPtr(iNewPluginID->Des());
	SmfUtils::ExternalizeDesL(newPtr, aStream);

	TPtr oldPtr(iOldPluginID->Des());
	SmfUtils::ExternalizeDesL(oldPtr, aStream);
	}

void CSmfPluginIDUpdate::InternalizeL(const RBuf8& aSource)
	{
	// Create stream to read from the given buffer
	RDesReadStream stream(aSource);
	CleanupClosePushL(stream);

	pluginIDEnabled = stream.ReadInt32L();

	// Delete the current values
	delete iNewPluginID;
	iNewPluginID = SmfUtils::InternalizeDesL(stream);

	delete iOldPluginID;
	iOldPluginID = SmfUtils::InternalizeDesL(stream);

	CleanupStack::PopAndDestroy(&stream);
	}

CSmfSignParameters* CSmfSignParameters::NewL(
	const TDesC8& aMessage, const TDesC8& aKey ) 
	{
	CSmfSignParameters* self = new( ELeave ) CSmfSignParameters();
	CleanupStack::PushL( self );
	self->ConstructL( aMessage, aKey );
	CleanupStack::Pop( self );
	return self;
	}

CSmfSignParameters* CSmfSignParameters::NewL( const TDesC8& aData ) 
	{
	CSmfSignParameters* self = new( ELeave ) CSmfSignParameters();
	CleanupStack::PushL( self );
	self->ConstructL( aData );
	CleanupStack::Pop( self );
	return self;
	}

CSmfSignParameters::~CSmfSignParameters() 
	{
	iMessage.Close();
	iKey.Close();
	}

void CSmfSignParameters::ExternalizeL( RWriteStream& aStream ) const
	{
	SmfUtils::ExternalizeDesL( iMessage, aStream );
	SmfUtils::ExternalizeDesL( iKey, aStream );
	}

const TDesC8& CSmfSignParameters::Key() const 
	{
	return iKey;
	}

const TDesC8& CSmfSignParameters::Message() const 
	{
	return iMessage;
	}

CSmfSignParameters::CSmfSignParameters() 
	{
	}

void CSmfSignParameters::ConstructL( const TDesC8& aMessage, const TDesC8& aKey )
	{
	iMessage.CreateL( aMessage );
	iKey.CreateL( aKey );
	}

void CSmfSignParameters::ConstructL( const TDesC8& aData ) 
	{
	RDesReadStream stream( aData );
	CleanupClosePushL( stream );
	SmfUtils::InternalizeDesL( iMessage, stream );
	SmfUtils::InternalizeDesL( iKey, stream );
	CleanupStack::PopAndDestroy( &stream );
	}

CSmfRsaKeyParameters* CSmfRsaKeyParameters::NewL(
		const TDesC& aKeyName, const TTime& startDate,
		const TTime& endDate, const TDesC8& aKeyData )
	{
	CSmfRsaKeyParameters* self = new( ELeave ) CSmfRsaKeyParameters;
	CleanupStack::PushL( self );
	self->ConstructL( aKeyName, startDate, endDate, aKeyData );
	CleanupStack::Pop( self );
	return self;
	}

CSmfRsaKeyParameters* CSmfRsaKeyParameters::NewL( const TDesC8& aData )
	{
	CSmfRsaKeyParameters* self = new( ELeave ) CSmfRsaKeyParameters;
	CleanupStack::PushL( self );
	self->ConstructL( aData );
	CleanupStack::Pop( self );
	return self;
	}

CSmfRsaKeyParameters::~CSmfRsaKeyParameters() 
	{
	iKeyName.Close();
	iKeyData.Close();
	}

void CSmfRsaKeyParameters::ExternalizeL( RWriteStream& aStream ) const
	{
	SmfUtils::ExternalizeDesL( iKeyName, aStream );
	SmfUtils::ExternalizeDesL( iKeyData, aStream );
	SmfUtils::ExternalizeInt64L( iStartDate.Int64(), aStream );
	SmfUtils::ExternalizeInt64L( iEndDate.Int64(), aStream );		
	}

const TDesC& CSmfRsaKeyParameters::KeyName() const
	{
	return iKeyName;
	}

const TDesC8& CSmfRsaKeyParameters::KeyData() const
	{
	return iKeyData;
	}

const TTime& CSmfRsaKeyParameters::StartDate() const
	{
	return iStartDate;
	}

const TTime& CSmfRsaKeyParameters::EndDate() const
	{
	return iEndDate;
	}

void CSmfRsaKeyParameters::ConstructL( 
		const TDesC& aKeyName, const TTime& startDate,
		const TTime& endDate, const TDesC8& aKeyData )
	{
	iKeyName.CreateL( aKeyName );
	iKeyData.CreateL( aKeyData );
	iStartDate = startDate;
	iEndDate = endDate;
	}

void CSmfRsaKeyParameters::ConstructL( const TDesC8& aData )
	{
	RDesReadStream stream( aData );
	CleanupClosePushL( stream );
	SmfUtils::InternalizeDesL( iKeyName, stream );
	SmfUtils::InternalizeDesL( iKeyData, stream );
	TInt64 startDate;
	TInt64 endDate;
	SmfUtils::InternalizeInt64L( startDate, stream );
	SmfUtils::InternalizeInt64L( endDate, stream );
	iStartDate = TTime( startDate );
	iEndDate = TTime( endDate );
	CleanupStack::PopAndDestroy( &stream );	
	}