// 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:

//

#include "engine.h"

#include "transport.h"

#include "panic.h"

#include "logger.h"

#include "main.h"

#include "requestlogger.h"

#include "testfilterparameters.h"

#include <miscutil.h>

#include <ocsp.h>

#include <x509cert.h>

#include <ocsptransport.h>

#include "ocspsupporttransport.h"

// Log file created by the transport filter

_LIT(KFilterLogFileName, "\\tocsphttpfilter.log");

const TInt KTimeMilliToMicro = 1000;

CTOCSPEngine* CTOCSPEngine::NewL(CTOCSPLogger& aLog)

	{

	CTOCSPEngine* self = new (ELeave) CTOCSPEngine(aLog);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTOCSPEngine::CTOCSPEngine(CTOCSPLogger& aLog) :

	CActive(EPriorityNormal),

	iLog(aLog)

	{

	CActiveScheduler::Add(this);

	}

void CTOCSPEngine::ConstructL()

	{

	// Open file server session

	User::LeaveIfError(iFs.Connect());

	iCertUtils = CCertUtils::NewL(iFs);

	// Create cancellation timer

	iTimer = CCallbackTimer::NewL(*this);

	}

CTOCSPEngine::~CTOCSPEngine()

	{

    Cancel(); // Calls Reset along the way

	Destroy();

	delete iTimer;

	delete iCertUtils;

	delete iUnifiedCertStore;

	iFs.Close();

	}

// Common code between destructor and ResetL()

void CTOCSPEngine::Destroy()

	{

	delete iParams;

	iParams = NULL;

	delete iClient;

	iClient = NULL;

	iSubjectCerts.ResetAndDestroy();

	iIssuerCerts.ResetAndDestroy();

	iSigningCerts.ResetAndDestroy();

	iTransportLog.Close();

	delete iRequestLog;

	iRequestLog = NULL;

	// Not owned

	iTransport = NULL;

	}

void CTOCSPEngine::Reset()

	{

	Destroy();

	// Delete and reset all the filter parameters

	DeleteFilterParameters();

	iUseDirectAuthorisation = EFalse;

	iUseCADelegateAuthorisation = EFalse;

	iUseCADirectAuthorisation = EFalse;

	iUseAllSchemes = EFalse;

	iCancelTime = 0;

	}

void CTOCSPEngine::StartL(TRequestStatus& aStatus)

	{	

	iParams = COCSPParameters::NewL();	

	InitDirectAuthL();

	// Delete the transport filter log file

	TInt err = iFs.Delete(KFilterLogFileName);

	if ((err != KErrNone) && (err != KErrNotFound))

		{

		if (iVerbose)

			{

			iLog.LogL(_L("Failed to delete transport filter log file ("), ETrue);

			iLog.LogL(KFilterLogFileName);

			iLog.LogL(_L("). Error: "), ETrue);

			iLog.LogL(err);

			}

		User::Leave(err);

		}

	iState = EInitCertStore;

	aStatus = KRequestPending;

	iOriginalRequestStatus = &aStatus;

	SetActive();

	// Initialise unified cert store here if it doesn't already exist

	if (!iUnifiedCertStore)

		{

		iUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);

		iUnifiedCertStore->Initialize(iStatus);

		}

	else

		{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	}

void CTOCSPEngine::EndL(TRequestStatus& aStatus)

	{

	Reset();

	CleanUpDirectAuthL(aStatus);

	}

void CTOCSPEngine::SetURIL(const TDesC8& aURI, TBool aUseAIA)

	{

	iParams->SetURIL(aURI, aUseAIA);

	}

void CTOCSPEngine::SetDefaultTransportL()

	{

	iIap = 0;

	MOCSPTransport* trans = COCSPTransportDefault::NewL(iIap);

	CleanupStack::PushL(trans);

	SetTransportL(trans);

	CleanupStack::Pop(trans);

	}

void CTOCSPEngine::SetTestTransportL(const TDesC& aResponseFile, const TDesC* aRequestFile)

	{

	CTOCSPTransport* trans = CTOCSPTransport::NewL(aResponseFile, aRequestFile);

	CleanupStack::PushL(trans);

	SetTransportL(trans);

	CleanupStack::Pop(trans);

	}

void CTOCSPEngine::SetOcspSupportTransportL()

	{

	iIap = 0;

	Swi::COcspSupportTransport* trans = Swi::COcspSupportTransport::NewL(iIap);

	CleanupStack::PushL(trans);

	SetTransportL(trans);

	CleanupStack::Pop(trans);

	}

void CTOCSPEngine::SetTransportRetryCount(TUint aRetryCount)

	{

	__ASSERT_DEBUG(iTransport != NULL, Panic(KErrTOCSPScriptParameterError));

	iParams->SetRetryCount(aRetryCount);

	}

void CTOCSPEngine::SetTransportTimeout(TInt aTimeout)

	{

	__ASSERT_DEBUG(iTransport != NULL, Panic(KErrTOCSPScriptParameterError));

	iParams->SetTimeout(aTimeout);

	}

void CTOCSPEngine::SetTransportL(MOCSPTransport* aTransport)

	{

	// To log the request, we wrap the transport in our request logger transport

	if (iRequestLog)

		{

		aTransport = CTOCSPRequestLogger::NewL(*iRequestLog, aTransport);

		}

	iTransport = aTransport;

	iParams->SetTransport(aTransport);

	}

void CTOCSPEngine::SetFilterParameters(TInt aNumDelayResp, TInt aCountDropResp,

			TInt countCorruptHTTPDataHeader, TInt countCorruptHTTPDataBodySizeLarge, TInt countCorruptHTTPDataBodySizeSmall, 

			TInt aCountCorruptOCSPData, 

			TInt aCountInternalErrorResp, TInt aCountTryLaterResp,

			TInt aCountSigValidateFailure)

	{

	iNumDelayResp = aNumDelayResp;

	iCountDropResp = aCountDropResp;

	iCountCorruptHTTPDataHeader = countCorruptHTTPDataHeader;

	iCountCorruptHTTPDataBodySizeLarge = countCorruptHTTPDataBodySizeLarge;

	iCountCorruptHTTPDataBodySizeSmall = countCorruptHTTPDataBodySizeSmall;

	iCountCorruptOCSPData = aCountCorruptOCSPData;

	iCountInternalErrorResp = aCountInternalErrorResp;

	iCountTryLaterResp = aCountTryLaterResp;

	iCountSigValidateFailure = aCountSigValidateFailure;

	}

void CTOCSPEngine::AddCertL(const TDesC8& aSubject, const TDesC8& aIssuer)

	{

	// Create certificate objects and keep hold of them - these are added

	// to the client later

	CX509Certificate* subject = CX509Certificate::NewLC(aSubject);

	User::LeaveIfError(iSubjectCerts.Append(subject));

	CleanupStack::Pop(subject);  // Now owned through iCerts

	CX509Certificate* issuer = CX509Certificate::NewLC(aIssuer);

	User::LeaveIfError(iIssuerCerts.Append(issuer));

	CleanupStack::Pop(issuer);  // Now owned through iCerts

	// Add certificates to parameter

	iParams->AddCertificateL(*subject, *issuer);

	}

void CTOCSPEngine::ReadTransportLogL()

	{

	// Read and process the transport filter log (if it exists)

	RFile file;

	TInt size;

	if (file.Open(iFs, KFilterLogFileName, EFileShareAny | EFileRead) != KErrNone)

		{

		return;

		}

	CleanupClosePushL(file);

	file.Size(size);

	RFileReadStream fileStream(file);

	CleanupClosePushL(fileStream);

	RBuf8 logBuffer;

	logBuffer.CreateL(size);

	CleanupClosePushL(logBuffer);

	fileStream.ReadL(logBuffer, size);

	TInt readPos = 0;

	TPtrC8 currentLine;

	while (MiscUtil::ReadNonEmptyLineL(logBuffer, readPos, currentLine))

		{

		TLex8 lex(currentLine);

		TPtrC8 methodName = lex.NextToken();

		// Validate and store the entry

		TTransportLog logEntry;

		if (methodName.Length() <= 4)

			{

			logEntry.iHttpMethod.Copy(methodName);

			logEntry.iHttpMethod.UpperCase();

			}

		// Get the timestamps and calculate transaction duration

		TInt64 startTime = 0;

		TInt64 endTime = 0;

		lex.SkipSpaceAndMark(); User::LeaveIfError(lex.Val(startTime));

		lex.SkipSpaceAndMark(); User::LeaveIfError(lex.Val(endTime));

		logEntry.iTransDurationMs = static_cast<TInt64>((endTime - startTime) / KTimeMilliToMicro);

		iTransportLog.AppendL(logEntry);

		}

	CleanupStack::PopAndDestroy(3, &file); // fileStream, logBuffer

	}

TBool CTOCSPEngine::ReadLineL(const TDesC8& aBuffer, TInt& aPos, TPtrC8& aLine) const

	{

	TBool endOfBuffer = EFalse;	

	aLine.Set(NULL, 0);

	TInt bufferLength = aBuffer.Length();	

	__ASSERT_ALWAYS(aPos >=0 && aPos <= bufferLength, User::Leave(KErrArgument));

	// Skip blank lines

	while (aPos < bufferLength) 

		{

		TChar  c = aBuffer[aPos];

		if (c != '\r' && c != '\n')

			{

			break;

			}

		aPos++;

		}

	// Find the position of the next delimter		

	TInt endPos = aPos;	

	while (endPos < bufferLength)

		{

		TChar c = aBuffer[endPos];

		if (c == '\n' || c == '\r') 

			{

			break;

			}	

		++endPos;

		}

	if (endPos != aPos)	

		{

		TInt tokenLen = endPos - aPos;

		aLine.Set(&aBuffer[aPos], tokenLen);

		}

	else 

		{

		return ETrue; // End of buffer

		}			

	aPos = endPos;

	return endOfBuffer;

	}

void CTOCSPEngine::LogResponseDetailsL()

	{

	if (iVerbose)

		{

		_LIT(KDateFormat, "%F%H:%T %D/%M/%Y");

		TBuf<32> timeString;

		iLog.LogL(_L("Response details:\n"));

		TTime timeNow;

		timeNow.UniversalTime();

		timeNow.FormatL(timeString, KDateFormat);

		iLog.LogL(_L("  Response generation time == "));

		iLog.LogL(timeString);

		iLog.LogL(_L("\n"));

		TBuf<10> indexText;

		for (int i = 0 ; i < iClient->TransactionCount() ; ++i)

			{

			const COCSPResponse* response = iClient->Response(i);

			iLog.LogL(_L("  Response "));

			indexText.Zero();

			indexText.Num(i);

			iLog.LogL(indexText);

			iLog.LogL(_L(":\n"));

			if (response)

				{

				response->ProducedAt().FormatL(timeString, KDateFormat);

				iLog.LogL(_L("    producedAt == "));

				iLog.LogL(timeString);

				iLog.NewLineL();

				TInt count = response->CertCount();

				for (TInt index = 0; index < count; ++index)

					{

					const COCSPResponseCertInfo& certInfo = response->CertInfo(index);

					iLog.LogL(_L("    Cert "));

					indexText.Zero();

					indexText.Num(index);

					iLog.LogL(indexText);

					iLog.LogL(_L(" Results:"));

					iLog.LogL(_L("\n      status == "));

					iLog.LogL(TranslateResultL(certInfo.Status()));

					certInfo.ThisUpdate().FormatL(timeString, KDateFormat);

					iLog.LogL(_L("\n      thisUpdate == "));

					iLog.LogL(timeString);

					iLog.NewLineL();

					if (certInfo.NextUpdate())

						{

						timeString.Zero();

						certInfo.NextUpdate()->FormatL(timeString, KDateFormat);

						iLog.LogL(_L("      nextUpdate == "));

						iLog.LogL(timeString);

						iLog.NewLineL();

						}

					if (certInfo.RevocationTime())

						{

						timeString.Zero();

						certInfo.RevocationTime()->FormatL(timeString, KDateFormat);

						iLog.LogL(_L("      revocationTime == "));

						iLog.LogL(timeString);

						iLog.NewLineL();

						}

					}

				}

			else

				{

				iLog.LogL(_L("    missing"));			

				iLog.NewLineL();

				}

			const TOCSPOutcome& outcome = iClient->Outcome(i);

			iLog.LogL(_L("    Validation outcome:"));

			iLog.NewLineL();

			iLog.LogL(_L("      status == "));

			iLog.LogL(TranslateStatusL(outcome.iStatus));

			iLog.NewLineL();

			iLog.LogL(_L("      result == "));

			iLog.LogL(TranslateResultL(outcome.iResult));

			iLog.NewLineL();

			}

		iLog.LogL(_L("  OCSP Summary result == "));

		iLog.LogL(TranslateResultL(iClient->SummaryResult()));

		iLog.NewLineL();

		}

	}

void CTOCSPEngine::RunL()

	{

	TInt err = iStatus.Int();

	if( KErrNotFound != err && KErrNone != err )

		{

		iLog.LogL(_L("Client request completed with code:"));  

		iLog.LogL(err);

		iLog.NewLineL();

		User::LeaveIfError(err);

		}

	if( KErrNotFound == err )

		{

		iLog.LogL(_L("Item not found leave code"));

		iLog.NewLineL();

		// Handle error

		User::Leave(err);

		}

	switch (iState)

		{

		case EInitCertStore:

			// Remove all certificates so we always start from the same state 

			iCertUtils->RemoveCertsL(*iUnifiedCertStore, iStatus);

			iState = ERemovingCerts;

			SetActive();

			break;

		case EAddingCert:

		case ERemovingCerts:

			User::RequestComplete(iOriginalRequestStatus, KErrNone);

			break;

		case EChecking:

			// Cancel the timer

			iTimer->Cancel();

			ReadTransportLogL();

			LogResponseDetailsL();

			User::RequestComplete(iOriginalRequestStatus, KErrNone);

			break;

		default:

            User::Panic(_L("TOCSP"), 1);

			break;

		}

	}

TInt CTOCSPEngine::RunError(TInt aError)

    {

    User::RequestComplete(iOriginalRequestStatus, aError);

    return KErrNone;

    }

void CTOCSPEngine::DoCancel()

	{

    switch (iState)

        {

		case EInitCertStore:

			if (iUnifiedCertStore)

				{

				iUnifiedCertStore->CancelInitialize();

				}

			break;

		case EAddingCert:

		case ERemovingCerts:

            iCertUtils->Cancel();

            break;

		case EChecking:

            iClient->CancelCheck();

            break;

		default:

            User::Panic(_L("TOCSP"), 1);

			break;

        }

	Reset();

    User::RequestComplete(iOriginalRequestStatus, KErrCancel);

	}

// Implementation of MTimerRun

void CTOCSPEngine::TimerRun(TInt /*aError*/)

	{

	// Cancellation timer expired

	this->Cancel();

	}

void CTOCSPEngine::SetValidationTimeL(const TTime& aWhen)

	{

	iParams->SetValidationTimeL(aWhen);

	}

void CTOCSPEngine::SetNonce(const TBool aNonce)