/*

* Copyright (c) 1998-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: 

* tdsasignfb.cpp

*

*/

#include "t_input.h"

#include "t_output.h"

#include <asymmetric.h>

#include "tvectorutils.h"

#include "trsaparams.h"

_LIT8(KModStart, "<modulus>");

_LIT8(KModEnd, "</modulus>");

_LIT8(KPubExpStart, "<publicExponent>");

_LIT8(KPubExpEnd, "</publicExponent>");

_LIT8(KPrivExpStart, "<privateExponent>");

_LIT8(KPrivExpEnd, "</privateExponent>");

_LIT8(KPStart, "<P>");

_LIT8(KPEnd, "</P>");

_LIT8(KQStart, "<Q>");

_LIT8(KQEnd, "</Q>");

_LIT8(KdPStart, "<dP>");

_LIT8(KdPEnd, "</dP>");

_LIT8(KdQStart, "<dQ>");

_LIT8(KdQEnd, "</dQ>");

_LIT8(KqInvStart, "<qInv>");

_LIT8(KqInvEnd, "</qInv>");

_LIT8(KReturnCodeStart, "<return>");

_LIT8(KReturnCodeEnd, "</return>");

_LIT8(KErrArgumentString, "KErrArgument");

CTestAction* CRSATestPublicKey::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CRSATestPublicKey::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop();

	return self;

	}

CTestAction* CRSATestPublicKey::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CRSATestPublicKey* self = new(ELeave) CRSATestPublicKey(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CRSATestPublicKey::~CRSATestPublicKey()

	{

	delete iBody;

	}

CRSATestPublicKey::CRSATestPublicKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

	: CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

void CRSATestPublicKey::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

	iBody->Des().Copy(aTestActionSpec.iActionBody);

	iExpectedReturnValue = KErrNone;

	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

	if(returnValue.Compare(KErrArgumentString) == 0)

		{

		iExpectedReturnValue = KErrArgument;

		}

	}

void CRSATestPublicKey::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EAction;

	}

void CRSATestPublicKey::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	iFinished = ETrue;

	User::RequestComplete(status, KErrNone);

	}

void CRSATestPublicKey::DoReportAction(void)

	{

	}

void CRSATestPublicKey::DoCheckResult(TInt)

	{

	if (iResult)

		iConsole.Printf(_L("."));

	else

		iConsole.Printf(_L("X"));

	}

void CRSATestPublicKey::PerformAction(TRequestStatus& aStatus)

	{

	__UHEAP_MARK;

	TRequestStatus* status = &aStatus;

	iResult = EFalse;

	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

    RInteger mod = VectorUtils::ParseIntegerL(modIn);

	CleanupStack::PushL(mod);

	TPtrC8 expIn = Input::ParseElement(*iBody, KPubExpStart, KPubExpEnd);

    RInteger exp = VectorUtils::ParseIntegerL(expIn);

	CleanupStack::PushL(exp);

	CRSAPublicKey* key = NULL;

	TRAPD(err, key = CRSAPublicKey::NewL(mod, exp));

	if(err == iExpectedReturnValue)

		{

		iResult=ETrue;

		}

	else

		{

		iOut.writeString(_L("CRSAPublicKey construction did not return expected result\n"));

		}

	if(err != KErrNone)

		{

		CleanupStack::PopAndDestroy(2);

		}

	else

		{

		CleanupStack::PushL(key);

		CleanupStack::PopAndDestroy(3);	

		}

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EPostrequisite;

	__UHEAP_MARKEND;

	}

CTestAction* CRSATestPrivateKey::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CRSATestPrivateKey::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop();

	return self;

	}

CTestAction* CRSATestPrivateKey::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CRSATestPrivateKey* self = new(ELeave) CRSATestPrivateKey(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CRSATestPrivateKey::~CRSATestPrivateKey()

	{

	delete iBody;

	}

CRSATestPrivateKey::CRSATestPrivateKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

	: CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

void CRSATestPrivateKey::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

	iBody->Des().Copy(aTestActionSpec.iActionBody);

	iExpectedReturnValue = KErrNone;

	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

	if(returnValue.Compare(KErrArgumentString) == 0)

		{

		iExpectedReturnValue = KErrArgument;

		}

	}

void CRSATestPrivateKey::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EAction;

	}

void CRSATestPrivateKey::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	iFinished = ETrue;

	User::RequestComplete(status, KErrNone);

	}

void CRSATestPrivateKey::DoReportAction(void)

	{

	}

void CRSATestPrivateKey::DoCheckResult(TInt)

	{

	if (iResult)

		iConsole.Printf(_L("."));

	else

		iConsole.Printf(_L("X"));

	}

void CRSATestPrivateKey::PerformAction(TRequestStatus& aStatus)

	{

	__UHEAP_MARK;

	TRequestStatus* status = &aStatus;

	iResult = EFalse;

	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

    RInteger mod = VectorUtils::ParseIntegerL(modIn);

	CleanupStack::PushL(mod);

	TPtrC8 expIn = Input::ParseElement(*iBody, KPrivExpStart, KPrivExpEnd);

    RInteger exp = VectorUtils::ParseIntegerL(expIn);

	CleanupStack::PushL(exp);

	CRSAPrivateKeyStandard* key = NULL;

	TRAPD(err, key = CRSAPrivateKeyStandard::NewL(mod, exp));

	if(err == iExpectedReturnValue)

		{

		iResult=ETrue;

		}

	else

		{

		iOut.writeString(_L("CRSAPrivateKey construction did not return expected result\n"));

		}

	if(err != KErrNone)

		{

		CleanupStack::PopAndDestroy(2);

		}

	else

		{

		CleanupStack::PushL(key);

		CleanupStack::PopAndDestroy(3);	

		}

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EPostrequisite;

	__UHEAP_MARKEND;

	}

CTestAction* CRSATestPrivateKeyCRT::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CRSATestPrivateKeyCRT::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop();

	return self;

	}

CTestAction* CRSATestPrivateKeyCRT::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

	const TTestActionSpec& aTestActionSpec)

	{

	CRSATestPrivateKeyCRT* self = new(ELeave) CRSATestPrivateKeyCRT(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CRSATestPrivateKeyCRT::~CRSATestPrivateKeyCRT()

	{

	delete iBody;

	}

CRSATestPrivateKeyCRT::CRSATestPrivateKeyCRT(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

	: CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

void CRSATestPrivateKeyCRT::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

	iBody->Des().Copy(aTestActionSpec.iActionBody);

	iExpectedReturnValue = KErrNone;

	TPtrC8 returnValue = Input::ParseElement(aTestActionSpec.iActionResult, KReturnCodeStart, KReturnCodeEnd);

	if(returnValue.Compare(KErrArgumentString) == 0)

		{

		iExpectedReturnValue = KErrArgument;

		}

	}

void CRSATestPrivateKeyCRT::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EAction;

	}

void CRSATestPrivateKeyCRT::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	iFinished = ETrue;

	User::RequestComplete(status, KErrNone);

	}

void CRSATestPrivateKeyCRT::DoReportAction(void)

	{

	}

void CRSATestPrivateKeyCRT::DoCheckResult(TInt)

	{

	if (iResult)

		iConsole.Printf(_L("."));

	else

		iConsole.Printf(_L("X"));

	}

void CRSATestPrivateKeyCRT::PerformAction(TRequestStatus& aStatus)

	{

	__UHEAP_MARK;

	TRequestStatus* status = &aStatus;

	iResult = EFalse;

	TPtrC8 modIn = Input::ParseElement(*iBody, KModStart, KModEnd);

    RInteger mod = VectorUtils::ParseIntegerL(modIn);

	CleanupStack::PushL(mod);

	TPtrC8 PIn = Input::ParseElement(*iBody, KPStart, KPEnd);

    RInteger P = VectorUtils::ParseIntegerL(PIn);

	CleanupStack::PushL(P);

	TPtrC8 QIn = Input::ParseElement(*iBody, KQStart, KQEnd);

    RInteger Q = VectorUtils::ParseIntegerL(QIn);

	CleanupStack::PushL(Q);

	TPtrC8 dPIn = Input::ParseElement(*iBody, KdPStart, KdPEnd);

    RInteger dP = VectorUtils::ParseIntegerL(dPIn);

	CleanupStack::PushL(dP);

	TPtrC8 dQIn = Input::ParseElement(*iBody, KdQStart, KdQEnd);

    RInteger dQ = VectorUtils::ParseIntegerL(dQIn);

	CleanupStack::PushL(dQ);

	TPtrC8 QInvIn = Input::ParseElement(*iBody, KqInvStart, KqInvEnd);

    RInteger QInv = VectorUtils::ParseIntegerL(QInvIn);

	CleanupStack::PushL(QInv);

	CRSAPrivateKeyCRT* key = NULL;

	TRAPD(err, key = CRSAPrivateKeyCRT::NewL(mod, P, Q, dP, dQ, QInv));

	if(err == iExpectedReturnValue)

		{

		iResult=ETrue;

		}

	else

		{

		iOut.writeString(_L("CRSAPrivateKeyCRT construction did not return expected result\n"));

		}

	if(err != KErrNone)

		{

		CleanupStack::PopAndDestroy(6);

		}

	else

		{

		CleanupStack::PushL(key);

		CleanupStack::PopAndDestroy(7);	

		}

	User::RequestComplete(status, KErrNone);

	iActionState = CTestAction::EPostrequisite;

	__UHEAP_MARKEND;

	}