// Copyright (c) 2001-2009 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 for OCSP Transaction object.
// 
//

#include "transaction.h"
#include "requestencoder.h"
#include "responsedecoder.h"
#include "ocsp.h"
#include "panic.h"

#include <x509cert.h>
#include <x509certchain.h>

COCSPTransaction* COCSPTransaction::NewL(const TDesC8& aURI, 
										 MOCSPTransport& aTransport, const TUint aRetryCount, const TInt aTimeout)
	{
	COCSPTransaction* self = new (ELeave) COCSPTransaction(aTransport, aRetryCount, aTimeout);
	CleanupStack::PushL(self);
	self->ConstructL(aURI);
	CleanupStack::Pop(self);
	return self;
	}

COCSPTransaction::COCSPTransaction(MOCSPTransport& aTransport, const TUint aRetryCount, const TInt aTimeout) :
	CActive(EPriorityNormal),
	iTransport(aTransport),
	iRetryCount(aRetryCount),
	iTimeout(aTimeout)
	{
	CActiveScheduler::Add(this);
	}


void COCSPTransaction::ConstructL(const TDesC8& aURI)
	{
	iURI = aURI.AllocL();
	}


COCSPTransaction::~COCSPTransaction()
	{
	Cancel();
	delete iURI;
	delete iRequestEncoder;
	delete iResponseDecoder;
	}


// Create the request, then send it off
void COCSPTransaction::SendRequest(COCSPRequest& aRequest, TRequestStatus& aStatus)
	{
	__ASSERT_ALWAYS(!iRequest, Panic(KErrInUse));
	iClientRequestStatus = &aStatus;
	aStatus = KRequestPending;

	iRequest = &aRequest;
	iState = ESendRequest;
	SetActive();

	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	}


// Safe regardless of whether we have a request outstanding
void COCSPTransaction::CancelRequest()
	{
	Cancel();
	}


COCSPResponse* COCSPTransaction::TakeResponse()
	{
	__ASSERT_ALWAYS(iResponseDecoder, Panic(KErrNotReady));
	return iResponseDecoder->TakeResponse();
	}


void COCSPTransaction::CompleteClient(const TInt aStatus)
	{
	User::RequestComplete(iClientRequestStatus, aStatus);
	}


void COCSPTransaction::RunL()
	{
	TInt err = iStatus.Int();
	switch (iState)
		{
		case ESendRequest:
			__ASSERT_ALWAYS(err == KErrNone, Panic(KErrCorrupt));
			iRequestEncoder = COCSPRequestEncoder::NewL(*iRequest);
			iTransport.SendRequest(*iURI, iRequestEncoder->Encoding(), iTimeout, iStatus);
			iState = EFinished;
			SetActive();			  
			break;

		case EFinished:
			{
			// Depending on the error retry the request
			// Retry if
			// 		- More attempts remaining AND 
			//		- error is OCSP::KErrTransportTimeout OR
			// 		- error is OCSP::KErrTransportFailure (HTTP response malformed) OR
			//		- invalid response received (OCSPReponse malformed) OR 
			//		- OCSPResponseStatus is OCSP::EServerInternalError OR
			//		- OCSPResponseStatus is OCSP::ETryLater
			//
			// We won't retry if 
			//		- error is OCSP::KErrInvalidURI OR
			//		- error is OCSP::KErrServerNotFound

			TBool retryNeeded = EFalse;
			TInt errDecode = KErrNone;
			if ((err == OCSP::KErrTransportTimeout) || (err == OCSP::KErrTransportFailure))
				{
				retryNeeded = ETrue;
				}
			else if (err == KErrNone)
				{
				TRAP(errDecode, iResponseDecoder = COCSPResponseDecoder::NewL(iTransport.GetResponse()));
				if ((errDecode == OCSP::EMalformedResponse) || 
						(errDecode == OCSP::EServerInternalError) || (errDecode == OCSP::ETryLater))
					{
					retryNeeded = ETrue;
					}
				}

			--iRetryCount;
			if (retryNeeded && iRetryCount > 0)
				{
				__ASSERT_ALWAYS(iResponseDecoder == NULL, Panic(KErrCorrupt));
				iTransport.SendRequest(*iURI, iRequestEncoder->Encoding(), iTimeout, iStatus);
				SetActive();
				}
			else
				{
				// If retry is not needed and there was an error (including +ve) then pass it up else complete normally
				if (err != KErrNone)
					{
					User::Leave(err);
					}
				if (errDecode != KErrNone)
					{
					User::Leave(errDecode);
					}
				CompleteClient(KErrNone);
				}
			}
			break;

		default:
			Panic(KErrCorrupt);
		}
	}


TInt COCSPTransaction::RunError(TInt aError)
	{
	CompleteClient(aError);
	return KErrNone;
	}


void COCSPTransaction::DoCancel()
	{
	iTransport.CancelRequest();
	if (iClientRequestStatus)
		{
		CompleteClient(KErrCancel);
		}
	}