/*
* Copyright (c) 2006-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: 
* Generic crypto parameter implementation
* Generic crypto parameter implementation
*
*/


/**
 @file
*/

#include <cryptospi/cryptoparams.h>

using namespace CryptoSpi;

//
//Implementation of the generic crypto parameter
//
CCryptoParam::CCryptoParam(TParamType aType, TUid aUid)
	: iType(aType),
	  iUid(aUid)
	{
	}

EXPORT_C CCryptoParam::~CCryptoParam()
	{
		
	}

EXPORT_C TInt CCryptoParam::Type() const
	{
	return iType;
	}

EXPORT_C TUid CCryptoParam::Uid() const
	{
	return iUid;
	}

//
// Implementation of Descriptor parameters
//
EXPORT_C CCryptoDesC8Param* CCryptoDesC8Param::NewL(const TDesC8& aValue, TUid aUid)
	{
	CCryptoDesC8Param* self=NewLC(aValue, aUid);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CCryptoDesC8Param* CCryptoDesC8Param::NewLC(const TDesC8& aValue, TUid aUid)
	{
	CCryptoDesC8Param* self=new(ELeave) CCryptoDesC8Param(aUid);
	CleanupStack::PushL(self);
	self->ConstructL(aValue);
	return self;
	}

EXPORT_C const TDesC8& CCryptoDesC8Param::Value() const
	{
	return *iValue;
	}

EXPORT_C CCryptoDesC8Param::~CCryptoDesC8Param()
	{
	if (iValue)
		{
		iValue->Des().FillZ();
		}
	delete iValue;
	}

CCryptoDesC8Param::CCryptoDesC8Param(TUid aUid)
	: CCryptoParam(EDesC8, aUid)
	{
	}
	
void CCryptoDesC8Param::ConstructL(const TDesC8& aValue)
	{
	iValue=aValue.AllocL();
	}


//
// Implementation of Descriptor parameters
//
EXPORT_C CCryptoDesC16Param* CCryptoDesC16Param::NewL(const TDesC16& aValue, TUid aUid)
	{
	CCryptoDesC16Param* self=NewLC(aValue, aUid);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CCryptoDesC16Param* CCryptoDesC16Param::NewLC(const TDesC16& aValue, TUid aUid)
	{
	CCryptoDesC16Param* self=new(ELeave) CCryptoDesC16Param(aUid);
	CleanupStack::PushL(self);
	self->ConstructL(aValue);
	return self;
	}

EXPORT_C const TDesC16& CCryptoDesC16Param::Value() const
	{
	return *iValue;
	}

EXPORT_C CCryptoDesC16Param::~CCryptoDesC16Param()
	{
	if (iValue)
		{
		iValue->Des().FillZ();
		}
	delete iValue;
	}

CCryptoDesC16Param::CCryptoDesC16Param(TUid aUid)
	: CCryptoParam(EDesC16, aUid)
	{
	}
	
void CCryptoDesC16Param::ConstructL(const TDesC16& aValue)
	{
	iValue=aValue.AllocL();
	}

//
// Implementation of int parameters
//
EXPORT_C CCryptoIntParam* CCryptoIntParam::NewL(TInt aValue, TUid aUid)
	{
	return new(ELeave) CCryptoIntParam(aValue, aUid);
	}

EXPORT_C CCryptoIntParam* CCryptoIntParam::NewLC(TInt aValue, TUid aUid)
	{
	CCryptoIntParam* self=new(ELeave) CCryptoIntParam(aValue, aUid);
	CleanupStack::PushL(self);
	return self;
	}

EXPORT_C TInt CCryptoIntParam::Value() const
	{
	return iValue;
	}

EXPORT_C CCryptoIntParam::~CCryptoIntParam()
	{
	iValue = 0;
	}

CCryptoIntParam::CCryptoIntParam(TInt aValue, TUid aUid)
	: CCryptoParam(EInt, aUid),
	  iValue(aValue)
	{
		
	}

//	
// Implementation of BigInt parameters
//
EXPORT_C CCryptoBigIntParam* CCryptoBigIntParam::NewL(const TInteger& aValue, TUid aUid)
	{
	CCryptoBigIntParam* self = NewLC(aValue, aUid);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CCryptoBigIntParam* CCryptoBigIntParam::NewLC(const TInteger& aValue, TUid aUid)
	{
	CCryptoBigIntParam* self = new(ELeave) CCryptoBigIntParam(aUid);
	CleanupStack::PushL(self);
	self->ConstructL(aValue);
	return self;
	}

EXPORT_C const TInteger& CCryptoBigIntParam::Value() const
	{
	return iValue;
	}

EXPORT_C CCryptoBigIntParam::~CCryptoBigIntParam()
	{
	// Secure delete, BigInts used for RSA/DSA modulus and exponent
	iValue.Close();
	}

CCryptoBigIntParam::CCryptoBigIntParam(TUid aUid)
	: CCryptoParam(EBigInt, aUid)
	{
	}
	
void CCryptoBigIntParam::ConstructL(const TInteger& aValue)
	{
	iValue = RInteger::NewL(aValue);
	}

/*
 * CCryptoParams implementation
 */
EXPORT_C CCryptoParams* CCryptoParams::NewL(void)
	{
	CCryptoParams* self = NewLC();
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CCryptoParams* CCryptoParams::NewLC(void)
	{
	CCryptoParams* self = new(ELeave) CCryptoParams();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CCryptoParams::CCryptoParams()
	{
	}

void CCryptoParams::ConstructL(void)
	{
	}

EXPORT_C CCryptoParams::~CCryptoParams()
	{
	// delete all contained parameters
	iParams.ResetAndDestroy();
	}

EXPORT_C void CCryptoParams::AddL(const TInteger& aParam, TUid aUid)
	{
	CCryptoBigIntParam* param = CCryptoBigIntParam::NewLC(aParam, aUid);
	iParams.AppendL(param);
	CleanupStack::Pop(param);
	}

EXPORT_C void CCryptoParams::AddL(const TInt aParam, TUid aUid)
	{
	CCryptoIntParam* param = CCryptoIntParam::NewLC(aParam, aUid);
	iParams.AppendL(param);
	CleanupStack::Pop(param);
	}

EXPORT_C void CCryptoParams::AddL(const TDesC8& aParam, TUid aUid)
	{
	CCryptoDesC8Param* param = CCryptoDesC8Param::NewLC(aParam, aUid);
	iParams.AppendL(param);
	CleanupStack::Pop(param);
	}

EXPORT_C void CCryptoParams::AddL(const TDesC16& aParam, TUid aUid)
	{
	CCryptoDesC16Param* param = CCryptoDesC16Param::NewLC(aParam, aUid);
	iParams.AppendL(param);
	CleanupStack::Pop(param);
	}

EXPORT_C const TInteger& CCryptoParams::GetBigIntL(TUid aUid) const
	{
	TInteger* paramValue = NULL;
	CCryptoParam* param = GetCryptoParamL(aUid);
	if (param->Type() == CCryptoParam::EBigInt)
		{
		const CCryptoBigIntParam* typedParam = static_cast<const CCryptoBigIntParam*>(param);
		paramValue = const_cast<TInteger*>(&typedParam->Value());
		}
	else
		{
		User::Leave(KErrArgument);
		}
		return *paramValue;
	}

EXPORT_C TInt CCryptoParams::GetTIntL(TUid aUid) const
	{
	TInt paramValue = 0;
	CCryptoParam* param = GetCryptoParamL(aUid);
	if (param->Type() == CCryptoParam::EInt)
		{
		const CCryptoIntParam* typedParam = static_cast<const CCryptoIntParam*>(param);
		paramValue = typedParam->Value();
		}
	else
		{
		User::Leave(KErrArgument);
		}
		return paramValue;
	}

EXPORT_C const TDesC8& CCryptoParams::GetTDesC8L(TUid aUid) const
	{
	TDesC8* paramValue = NULL;
	CCryptoParam* param = GetCryptoParamL(aUid);
	if (param->Type() == CCryptoParam::EDesC8)
		{
		const CCryptoDesC8Param* typedParam = static_cast<const CCryptoDesC8Param*>(param);
		paramValue = const_cast<TDesC8*>(&typedParam->Value());
		}
	else
		{
		User::Leave(KErrArgument);
		}
		return *paramValue;
	}

EXPORT_C const TDesC16& CCryptoParams::GetTDesC16L(TUid aUid) const
	{
	TDesC16* paramValue = NULL;
	CCryptoParam* param = GetCryptoParamL(aUid);
	if (param->Type() == CCryptoParam::EDesC16)
		{
		const CCryptoDesC16Param* typedParam = static_cast<const CCryptoDesC16Param*>(param);
		paramValue = const_cast<TDesC16*>(&typedParam->Value());
		}
	else
		{
		User::Leave(KErrArgument);
		}
		return *paramValue;
	}

EXPORT_C TBool CCryptoParams::IsPresent(TUid aUid) const
	{
	TBool ret = EFalse;
	if (GetCryptoParam(aUid))
		{
		ret = ETrue;
		}
	return ret;
	}

CCryptoParam* CCryptoParams::GetCryptoParam(TUid aUid) const
	{
	CCryptoParam* paramPtr = NULL;
	TInt count = iParams.Count();
	for (TInt i = 0 ;i < count; i++)
		{
		if (iParams[i]->Uid() == aUid)
			{
			paramPtr = iParams[i];
			break;
			}
		}
	return paramPtr;
	}
	
CCryptoParam* CCryptoParams::GetCryptoParamL(TUid aUid) const
	{
	CCryptoParam* paramPtr = GetCryptoParam(aUid);
	// leave if requested uid was not found
	if (!paramPtr)
		{
		User::Leave(KErrArgument);
		}
	return paramPtr;
	}

EXPORT_C CCryptoParams& CCryptoParams::CopyL(const CCryptoParams& aParams)
	{
	iParams.Close();
	TUint count = aParams.iParams.Count();
	for (TUint num = 0; num < count; num++)
		{
		CCryptoParam* item = aParams.iParams[num];

		// Stop armv5 compiler warning about init through switch statement
		CCryptoBigIntParam *b = 0;
		CCryptoDesC8Param *d = 0;
		CCryptoDesC16Param *d16 = 0;
		CCryptoIntParam *i = 0;

		// For each type of cryptoparam, duplicate it, and append to RPtrArray
		switch (item->Type())
			{
			case CCryptoParam::EBigInt:
				b = CCryptoBigIntParam::NewL(((CCryptoBigIntParam*) item)->Value(), ((CCryptoBigIntParam*) item)->Uid());
				CleanupStack::PushL(b);
				iParams.AppendL(b);
				CleanupStack::Pop(b);
				break;
				
			case CCryptoParam::EInt:
				i = CCryptoIntParam::NewL(((CCryptoIntParam*) item)->Value(), ((CCryptoBigIntParam*) item)->Uid());
				CleanupStack::PushL(i);
				iParams.AppendL(i);
				CleanupStack::Pop(i);
				break;
				
			case CCryptoParam::EDesC8:
				d = CCryptoDesC8Param::NewL(((CCryptoDesC8Param*) item)->Value(), ((CCryptoBigIntParam*) item)->Uid());
				CleanupStack::PushL(d);
				iParams.AppendL(d);
				CleanupStack::Pop(d);
				break;
				
			case CCryptoParam::EDesC16:
				d16 = CCryptoDesC16Param::NewL(((CCryptoDesC16Param*) item)->Value(), ((CCryptoBigIntParam*) item)->Uid());
				CleanupStack::PushL(d16);
				iParams.AppendL(d16);
				CleanupStack::Pop(d16);
				break;
				
			default:
				break;
			}
		}
		return *this;
	}

EXPORT_C TInt CCryptoParams::Count(void) const
	{
	return iParams.Count();
	}

EXPORT_C const RPointerArray<CCryptoParam>& CCryptoParams::GetParams() const
	{
	return iParams;
	}