/*
* 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 "t_retrieve.h"
#include "t_certstoreout.h"
#include "t_input.h"
#include "t_certstoredefs.h"
#include "t_concurrentcertstore.h"
#include <ccertattributefilter.h>

///////////////////////////////////////////////////////////////////////////////
//CRetrieveCertificate
///////////////////////////////////////////////////////////////////////////////

CTestAction* CRetrieveCertificate::NewL(RFs& aFs,
										CConsoleBase& aConsole,
										Output& aOut,
										const TTestActionSpec& aTestActionSpec)
	{
	CRetrieveCertificate* self = new (ELeave) CRetrieveCertificate(aFs, aConsole, aOut);
	CleanupStack::PushL(self);
	self->ConstructL(aTestActionSpec);
	CleanupStack::Pop(self);
	return self;
	}

CRetrieveCertificate::CRetrieveCertificate(RFs& aFs,
										   CConsoleBase& aConsole, 
										   Output& aOut) :
	CCertStoreTestAction(aFs, aConsole, aOut), iDataPtr(NULL, 0),
	iFormat(EUnknownCertificate), iDeletable(EFalse), iTestForDeletable(EFalse)
	{
	}

void CRetrieveCertificate::ConstructL(const TTestActionSpec& aTestActionSpec)
	{
	CCertStoreTestAction::ConstructL(aTestActionSpec);
	
	iFilter = CCertAttributeFilter::NewL();

	HBufC* result = HBufC::NewLC(aTestActionSpec.iActionResult.Length());
	TPtr(result->Des()).Copy(aTestActionSpec.iActionResult);
	Input::GetExpectedResultL(Input::ParseElement(*result, KReturnStart, KReturnEnd), iExpectedResult);
	CleanupStack::PopAndDestroy(result);

	iLabel.Copy(Input::ParseElement(aTestActionSpec.iActionBody, KCertLabelStart));
	if (iLabel.Length() == 0)
		{
		User::Leave(KErrArgument);
		}

	// check for a possible deletable flag value for the certificate
	TInt err = KErrNone;
	TInt pos = 0;
	const TDesC8& deletableStr = Input::ParseElement(aTestActionSpec.iActionResult, 
														KDeletableStart,
														KDeletableEnd,
														pos,
														err);

	// set the deletable attribute if a value was found for the certificate
	if (err == KErrNone)
		{
		SetDeletable(deletableStr);
		
		// if deletable is found then format value must also be present
		SetFormatL(Input::ParseElement(aTestActionSpec.iActionResult, KCertFormatStart));
		}
	}

CRetrieveCertificate::~CRetrieveCertificate()
	{
	Reset();
	delete iFilter;
	}

void CRetrieveCertificate::SetDeletable(const TDesC8& aDeletableString)
	{
	iTestForDeletable = ETrue;
	if (aDeletableString.Compare(KTrue)==0)
		{
		iDeletable = ETrue;
		}
	else
		{
		iDeletable = EFalse;
		}
	}

void CRetrieveCertificate::SetFormatL(const TDesC8& aFormatString)
	{
	if (aFormatString == KNullDesC8)
		{
		User::Leave(KErrArgument);
		}
	if (aFormatString == KWTLS)
		{
		iFormat = EWTLSCertificate;
		}
	else if (aFormatString == KX509)
		{
		iFormat = EX509Certificate;
		}
	else if (aFormatString == KWTLSURL)
		{
		iFormat = EWTLSCertificateUrl;
		}
	else if (aFormatString == KX509URL)
		{
		iFormat = EX509CertificateUrl;
		}
	else
		{
		iOut.write(_L("Unknown cert format: "));
		iOut.writeString(aFormatString);
		iOut.writeNewLine();		   
		User::Leave(KErrNotSupported);
		}
	}

void CRetrieveCertificate::PerformAction(TRequestStatus& aStatus)
	{
	if (aStatus != KErrNone && iState != ECheckRetrieve)
		{
		iState = EFinished;
		}
	
	switch (iState)
		{
		case EList:
			CertStore().List(iCertInfos, *iFilter, aStatus);
			iState = ERetrieveData;
			break;

		case ERetrieveData:
			{
			for (TInt i = 0 ; i < iCertInfos.Count() ; ++i)
				{
				CCTCertInfo* certInfo = iCertInfos[i];
				if (certInfo->Label() == iLabel)
					{
					iCertInfo = certInfo;
					break;
					}
				}
			
			if (!iCertInfo)
				{
				iState = EFinished;			
				TRequestStatus* status = &aStatus;
				User::RequestComplete(status, KErrNotFound);
				}
			else
				{
				TRAPD(err, iData = HBufC8::NewL(iCertInfo->Size()));
				if (err != KErrNone)
					{
					iState = EFinished;
					TRequestStatus* status = &aStatus;
					User::RequestComplete(status, err);
					}
				else
					{
					iState = EParseData;
					// iDataPtr has to be be a member as it's passed to asyc retrieve operation
					iDataPtr.Set(iData->Des());  
					CertStore().Retrieve(*iCertInfo, iDataPtr, aStatus);
					}
				}
			}
			break;

		case EParseData:
			{
			switch (iCertInfo->CertificateFormat())
				{
				case EX509Certificate:
					{
					CX509Certificate* cert = CX509Certificate::NewLC(*iData);
					X509CertWriter writer(iOut);
					writer.WriteCert(*cert);
					CleanupStack::PopAndDestroy();
					iOut.writeNewLine();
					}
					break;

				case EWTLSCertificate:
					{
					CWTLSCertificate* cert = CWTLSCertificate::NewLC(*iData);
					WTLSCertWriter writer(iOut);
					writer.WriteCert(*cert);
					CleanupStack::PopAndDestroy(cert);
					iOut.writeNewLine();
					}
					break;
				
				default:
					break;
				}
			
			iState = ERetrieveCert;
			TRequestStatus* status = &aStatus;
			User::RequestComplete(status, KErrNone);
			}
			break;

		case ERetrieveCert:
			if (CertStoreType() != EUnifiedCertStore)
				{
				iState = EFinished;
				TRequestStatus* status = &aStatus;
				User::RequestComplete(status, KErrNone);
				}
			else
				{
				iState = ECheckRetrieve;
				UnifiedCertStore().Retrieve(*iCertInfo, iCert, aStatus);
				}
			break;

		case ECheckRetrieve:
			{
			TCertificateFormat format = iCertInfo->CertificateFormat();
			TInt expectedErr = KErrNotSupported;
			if (format == EX509Certificate || format == EWTLSCertificate)
				{
				expectedErr = KErrNone;
				}
			TInt err = (aStatus.Int() == expectedErr) ? KErrNone : KErrGeneral;
			iState = EFinished;
			TRequestStatus* status = &aStatus;
			User::RequestComplete(status, err);
			}
			break;

		case EFinished:
			{
			iActionState = EPostrequisite;
			iFinished = ETrue;
			TRequestStatus* status = &aStatus;
			User::RequestComplete(status, aStatus.Int());
			}
			break;
			
		default:
			User::Invariant();
		}
	}

void CRetrieveCertificate::PerformCancel()
	{
	switch (iState)
		{
		case ERetrieveData:
			CertStore().CancelList();
			break;

		case EParseData:
		case ECheckRetrieve:
			CertStore().CancelRetrieve();
			break;

		default:
			break;
		}
	}

void CRetrieveCertificate::Reset()
	{
	iState = EList;
	iCertInfos.Close();
	delete iCert;
	iCert = NULL;
	delete iData;
	iData = NULL;
	}

void CRetrieveCertificate::DoReportAction()
	{
	iOut.write(_L("Retrieving certificate...\n"));
	iOut.write(_L("\tLabel: %S\n"), &iLabel);
	if (iTestForDeletable)
		{
		iOut.writeString(_L("\tDeletable = "));
		iDeletable ? iOut.writeString(KTrue) : iOut.writeString(KFalse);
		iOut.writeNewLine();
		}
	}

void CRetrieveCertificate::DoPerformPostrequisite(TRequestStatus& aStatus)
	{
	iFinished = ETrue;
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, aStatus.Int());
	}

TBool CRetrieveCertificate::ValidCertInfo()
	{
	// check iFormat and deletable flag of the cert info object
	return ((iCertInfo->IsDeletable() == iDeletable) &&
		    (iFormat == iCertInfo->CertificateFormat()));
	}
	
void CRetrieveCertificate::DoCheckResult(TInt aError)
	{
	if (iFinished)
		{
		iResult = (aError == iExpectedResult); 
		
		if (iResult)
			{
			if (iTestForDeletable)
				{
				iResult = iResult && ValidCertInfo();
				
				if (iResult)
					{
					iOut.writeString(_L("\tRetrieved certificate info successfully - \n\n"));
					
					}
				}
			else
				{
				iOut.writeString(_L("\tRetrieved certificate successfully\n\n"));
				}
			}
		else
			{
			iOut.writeString(_L("\tRetrieve certificate failed\n\n"));
			//	If running tests with multiple threads, failure may be expected
			// need to add this back in when we get concurrent tests working
			//CConcurrentTester::SanitizeTestResult(iOut, iResult);
			}
		}
	}