// Copyright (c) 2008-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 "ocsphttpfilter.h"
#include <e32cmn.h>
#include <e32std.h>
#include <e32property.h>
#include <http/rhttptransaction.h>
#include <http/rhttpheaders.h>
#include <http/thttphdrval.h>
#include <httpstringconstants.h>
#include "testfilterparameters.h"

// Filter name used to register the filter
_LIT8(KFilterName,"tocsphttpfilter");

// Filter log file read by the test code
_LIT(KFilterLogFileName, "\\tocsphttpfilter.log");

// HTTPMethod StartTimeInMicroseconds
_LIT8(KFilterLogFormat1, "%S %Ld");
// StopTimeInMicroseconds
_LIT8(KFilterLogFormat2, " %Ld\n"); 

// Canned responses
_LIT8(KCannedResponseInteralError, "\x30\x03\x0a\x01\x02");
_LIT8(KCannedResponseTryLater, "\x30\x03\x0a\x01\x03");
_LIT8(KCannedResponseCorruptOCSPData, "\x30\x03\x0a\x01\xf0");

// A non-existent ocsp responder. Redirect requests to this
// responder to simulate a missing response
_LIT8(KNonExistentServer, "http://42.042.042.042:0420/");

// HTTP response header for content-type (canned corrupted)
_LIT8(KOCSPContentTypeResponseCorrupted, "application/ocsp-reponse");

// Byte offset (+1) of Responder ID field of OCSPResponse
const TInt KOCSPResponderIDOffset = 42;

const TInt KTimeMilliToMicro = 1000;

COCSPHTTPFilter::COCSPHTTPFilter()
		: iLogLineCompleted(ETrue)
	{
	}

CEComFilter* COCSPHTTPFilter::InstallFilterL(TAny* aSession)
	{
	RHTTPSession* session = reinterpret_cast<RHTTPSession*>(aSession);
	COCSPHTTPFilter* filter = new (ELeave) COCSPHTTPFilter();
	CleanupStack::PushL(filter);
	filter->ConstructL(*session);
	CleanupStack::Pop(filter);
	return filter;
	}

void COCSPHTTPFilter::ConstructL(const RHTTPSession& aSession)
	{
	iStringPool = aSession.StringPool();
	iFilterName = iStringPool.OpenFStringL(KFilterName);
	// Register the filter for submit events
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EAnyTransactionEvent, MHTTPFilter::EClientFilters, iFilterName);
	User::LeaveIfError(iFs.Connect());
	User::LeaveIfError(iLogFile.Replace(iFs, KFilterLogFileName, EFileShareAny|EFileWrite));
	}

COCSPHTTPFilter::~COCSPHTTPFilter()
	{
	iFilterName.Close();
	iLogFile.Close();
	iFs.Close();
	delete iCustomDataSupplier;
	}

void COCSPHTTPFilter::MHFLoad(RHTTPSession, THTTPFilterHandle)
	{
	++iLoadCount;
	}

void COCSPHTTPFilter::MHFUnload(RHTTPSession /*aSession*/, THTTPFilterHandle)
	{
	if (--iLoadCount)
		return;

	delete this;
	}

void COCSPHTTPFilter::MHFRunL(RHTTPTransaction aTransaction,
									const THTTPEvent& aEvent)
	{
	// Read test parameters
	TInt countDropResp, numDelayResp;
	TInt countCorruptHTTPDataHeader, countCorruptHTTPDataBodySizeLarge, countCorruptHTTPDataBodySizeSmall;
	TInt countCorruptOCSPData;
	TInt countInternalErrorResp, countTryLaterResp;
	TInt countSigValidateFailure;
	ReadTestParameters(numDelayResp, countDropResp,
			countCorruptHTTPDataHeader, countCorruptHTTPDataBodySizeLarge, countCorruptHTTPDataBodySizeSmall,
			countCorruptOCSPData,
			countInternalErrorResp, countTryLaterResp, 
			countSigValidateFailure);

	switch (aEvent.iStatus)
		{
	case THTTPEvent::ESubmit:
		// Start of the HTTP transaction
		iDataSupplied = EFalse;
		iLogLineCompleted = EFalse;
		LogTransactionStartL(aTransaction);
		
		if (countDropResp > 0)
			{
			// Drop the request
			--countDropResp;
			TUriParser8 uri;
			uri.Parse(KNonExistentServer);
			aTransaction.Request().SetURIL(uri);
			}
		break;
	case THTTPEvent::EGotResponseHeaders:
		{
		RHTTPResponse response = aTransaction.Response();
		RHTTPHeaders headers = response.GetHeaderCollection();
		RStringPool stringPool = aTransaction.Session().StringPool();

		// Modify http body size if we plan to modify the body (response data) later
		if (countInternalErrorResp > 0 || countTryLaterResp > 0 || countCorruptOCSPData > 0) // Common code since size is same for all canned responses
			{
			// Create the data supplier
			delete iCustomDataSupplier;
			iCustomDataSupplier = NULL;
			TPtrC8 ptr(KCannedResponseInteralError);
			RStringF contentLengthString = stringPool.StringF(HTTP::EContentLength, RHTTPSession::GetTable());
			if (countTryLaterResp > 0)
				{
				ptr.Set(KCannedResponseTryLater);
				}
			else if (countCorruptOCSPData > 0)
				{
				ptr.Set(KCannedResponseCorruptOCSPData);
				}
			iCustomDataSupplier = new (ELeave) TCustomDataSupplier(ptr, aTransaction);
			THTTPHdrVal contentLengthVal;
			TInt size = iCustomDataSupplier->OverallDataSize();
			contentLengthVal.SetInt(size);
			headers.RemoveFieldPart(contentLengthString, 0);
			headers.SetFieldL(contentLengthString, contentLengthVal);
			}
		// Create and keep a data supplier if we plan to corrupt the data leading to a signature validation failure
		if (countSigValidateFailure > 0)
			{
			// Create the data supplier
			delete iCustomDataSupplier;
			iCustomDataSupplier = NULL;
			TPtrC8 ptr(KNullDesC8);
			iCustomDataSupplier = new (ELeave) TCustomDataSupplier(ptr, aTransaction);
			}
		if (countCorruptHTTPDataHeader > 0)
			{
			// Corrupt the header
			RStringF ocspResponse = stringPool.OpenFStringL(KOCSPContentTypeResponseCorrupted);
			CleanupClosePushL(ocspResponse); 
			RStringF contentTypeString = stringPool.StringF(HTTP::EContentType, RHTTPSession::GetTable());
			THTTPHdrVal contentTypeVal;
			contentTypeVal.SetStrF(ocspResponse);
			headers.RemoveFieldPart(contentTypeString, 0);
			headers.SetFieldL(contentTypeString, contentTypeVal);
			CleanupStack::PopAndDestroy(&ocspResponse);
			--countCorruptHTTPDataHeader;
			}
		if (countCorruptHTTPDataBodySizeLarge > 0 || countCorruptHTTPDataBodySizeSmall > 0)
			{
			// Corrupt the body size recorded in the header
			RStringF contentLengthString = stringPool.StringF(HTTP::EContentLength, RHTTPSession::GetTable());
			THTTPHdrVal contentLengthVal;
			TInt err = headers.GetField(contentLengthString, 0, contentLengthVal);
			if ((err == KErrNone) && (contentLengthVal.Type() == THTTPHdrVal::KTIntVal))
				{
				TInt bodySize = contentLengthVal.Int();
				if (countCorruptHTTPDataBodySizeLarge > 0)
					{
					--bodySize;
					--countCorruptHTTPDataBodySizeLarge;
					}
				else
					{
					++bodySize;
					--countCorruptHTTPDataBodySizeSmall;
					}
				contentLengthVal.SetInt(bodySize);
				headers.RemoveFieldPart(contentLengthString, 0);
				headers.SetFieldL(contentLengthString, contentLengthVal);
				}
			}
		}
		break;
	case THTTPEvent::EGotResponseBodyData:
		if (iCustomDataSupplier && (countInternalErrorResp > 0 || countTryLaterResp > 0 || countCorruptOCSPData > 0 || countSigValidateFailure > 0))
			{
			aTransaction.Response().RemoveBody();
			aTransaction.Response().SetBody(*iCustomDataSupplier);
			// Make sure state machine goes on
			aTransaction.Response().SetStatusCode(THTTPEvent::EResponseComplete);
			}
		break;
	case THTTPEvent::ESucceeded:
	case THTTPEvent::EFailed:
		// Delay response (numDelayResp is in milliseconds)
		if (numDelayResp > 0)
			{
			User::After(numDelayResp * KTimeMilliToMicro);
			}
	// Deliberate fall through case
	case THTTPEvent::ECancel:
		if (!iLogLineCompleted)
			{
			// End of the HTTP transaction
			iLogLineCompleted = ETrue;
			LogTransactionEndL(aTransaction);
			}
		// Since EGotResponseBodyData event can happen more than once per transaction ensure to decrement
		// counters only once
		if (!iDataSupplied)
			{
			if (countInternalErrorResp > 0)
				{
				--countInternalErrorResp;
				}
			if (countTryLaterResp > 0)
				{
				--countTryLaterResp;
				}
			if (countCorruptOCSPData > 0)
				{
				--countCorruptOCSPData;
				}
			if (countSigValidateFailure > 0)
				{
				--countSigValidateFailure;
				}
			iDataSupplied = ETrue;
			}
		break;
	default:
		break;
		}

	// Write the parameters back to keep them persistent between retries
	WriteTestParameters(countDropResp, 
			countCorruptHTTPDataHeader, countCorruptHTTPDataBodySizeLarge, countCorruptHTTPDataBodySizeSmall, 
			countCorruptOCSPData, 
			countInternalErrorResp, countTryLaterResp,
			countSigValidateFailure);
	}

TInt COCSPHTTPFilter::MHFRunError(TInt /*aError*/,
										RHTTPTransaction aTransaction,
										const THTTPEvent& /*aEvent*/)
	{
	// If anything left, we've run out of memory or something
	// similarly catastrophic has gone wrong.
	aTransaction.Fail();
	return KErrNone;
	}

// Logs the transaction method used and the current (start) time
void COCSPHTTPFilter::LogTransactionStartL(const RHTTPTransaction& aTransaction)
	{
	// Get the transaction method being used (GET/POST) and log it
	RHTTPRequest request = aTransaction.Request();
	RStringF method = request.Method();
	TTime time;
	time.HomeTime();
	TInt64 intTime = time.Int64();
	RBuf8 logText;
	logText.CreateL(255);
	CleanupClosePushL(logText);
	logText.Format(KFilterLogFormat1, &method.DesC(), intTime);
	User::LeaveIfError(iLogFile.Write(logText));
	CleanupStack::PopAndDestroy(&logText);
	}

// Logs the current (end) time
void COCSPHTTPFilter::LogTransactionEndL(const RHTTPTransaction& /*aTransaction*/)
	{
	TTime time;
	time.HomeTime();
	TInt64 intTime = time.Int64();
	RBuf8 logText;
	logText.CreateL(255);
	CleanupClosePushL(logText);
	logText.Format(KFilterLogFormat2, intTime);
	User::LeaveIfError(iLogFile.Write(logText));
	CleanupStack::PopAndDestroy(&logText);
	}

// Read test parameters using Publish & Subscribe method
void COCSPHTTPFilter::ReadTestParameters(TInt& aNumDelayResp, TInt& aCountDropResp,
		TInt& aCountCorruptHTTPDataHeader, TInt& aCountCorruptHTTPDataBodySizeLarge, TInt& aCountCorruptHTTPDataBodySizeSmall,
		TInt& aCountCorruptOCSPData, 
		TInt& aCountInternalErrorResp, TInt& aCountTryLaterResp,
		TInt& aCountSigValidateFailure)
	{
	// Set default values which will be used if P&S doesn't exist
	aNumDelayResp = aCountDropResp = 
	aCountCorruptHTTPDataHeader = aCountCorruptHTTPDataBodySizeLarge = aCountCorruptHTTPDataBodySizeSmall = 
		aCountCorruptOCSPData = 
		aCountInternalErrorResp = aCountTryLaterResp = 
		aCountSigValidateFailure = 0;

	TUid categoryUid = TUid::Uid(KFilterParametersCategoryUID);
	RProperty::Get(categoryUid, KFilterParameterNumDelayResp, aNumDelayResp);
	RProperty::Get(categoryUid, KFilterParameterCountDropResp, aCountDropResp);
	RProperty::Get(categoryUid, KFilterParameterCountCorruptHTTPDataHeader, aCountCorruptHTTPDataHeader);
	RProperty::Get(categoryUid, KFilterParameterCountCorruptHTTPDataBodySizeLarge, aCountCorruptHTTPDataBodySizeLarge);
	RProperty::Get(categoryUid, KFilterParameterCountCorruptHTTPDataBodySizeSmall, aCountCorruptHTTPDataBodySizeSmall);
	RProperty::Get(categoryUid, KFilterParameterCountCorruptOCSPData, aCountCorruptOCSPData);
	RProperty::Get(categoryUid, KFilterParameterCountInternalErrorResp, aCountInternalErrorResp);
	RProperty::Get(categoryUid, KFilterParameterCountTryLaterResp, aCountTryLaterResp);
	RProperty::Get(categoryUid, KFilterParameterCountSigValidateFailure, aCountSigValidateFailure);
	}

// To maintain persistence between retry attempts store the updated counts back
void COCSPHTTPFilter::WriteTestParameters(TInt aCountDropResp,
		TInt aCountCorruptHTTPDataHeader, TInt aCountCorruptHTTPDataBodySizeLarge, TInt aCountCorruptHTTPDataBodySizeSmall,
		TInt aCountCorruptOCSPData, 
		TInt aCountInternalErrorResp, TInt aCountTryLaterResp,
		TInt aCountSigValidateFailure)
	{
	TUid categoryUid = TUid::Uid(KFilterParametersCategoryUID);
	RProperty::Set(categoryUid, KFilterParameterCountDropResp, aCountDropResp);
	RProperty::Set(categoryUid, KFilterParameterCountCorruptHTTPDataHeader, aCountCorruptHTTPDataHeader);
	RProperty::Set(categoryUid, KFilterParameterCountCorruptHTTPDataBodySizeLarge, aCountCorruptHTTPDataBodySizeLarge);
	RProperty::Set(categoryUid, KFilterParameterCountCorruptHTTPDataBodySizeSmall, aCountCorruptHTTPDataBodySizeSmall);
	RProperty::Set(categoryUid, KFilterParameterCountCorruptOCSPData, aCountCorruptOCSPData);
	RProperty::Set(categoryUid, KFilterParameterCountInternalErrorResp, aCountInternalErrorResp);
	RProperty::Set(categoryUid, KFilterParameterCountTryLaterResp, aCountTryLaterResp);
	RProperty::Set(categoryUid, KFilterParameterCountSigValidateFailure, aCountSigValidateFailure);
	}

TCustomDataSupplier::TCustomDataSupplier(TPtrC8& aData, RHTTPTransaction& aTransaction)
	{
	iData.Set(aData);
	iTransaction = &aTransaction;
	iDataSupplied = EFalse;
	iOriginalSupplier = aTransaction.Response().Body();
	}

// Methods from MHTTPDataSupplier
TBool TCustomDataSupplier::GetNextDataPart(TPtrC8& aDataPart)
	{
	// Check if we need to simulate a signature validation failure
	if (iData == KNullDesC8)
		{
		// Get the original data
		iOriginalSupplier->GetNextDataPart(aDataPart);
		iCorruptData.Create(aDataPart);
		// Corrupt it (byte is part of ResponderID field)
		--iCorruptData[KOCSPResponderIDOffset];
		// Send it along
		aDataPart.Set(iCorruptData);
		}
	else
		{
		// Consume the original data and pass back canned response
		iOriginalSupplier->GetNextDataPart(aDataPart);
		if (!iDataSupplied)
			{
			aDataPart.Set(iData);
			iDataSupplied = ETrue;
			}
		else
			{
			// no data
			aDataPart.Set(KNullDesC8);
			}
		}
	return ETrue;
	}

void TCustomDataSupplier::ReleaseData()
	{
	iCorruptData.Close();
	// Call original method to ensure it does it's work to let the state machine go on
	iOriginalSupplier->ReleaseData();
	// We are done supplying canned response so restore original supplier
	iTransaction->Response().SetBody(*iOriginalSupplier);
	}

TInt TCustomDataSupplier::OverallDataSize()
	{
	return iData.Length();
	}

TInt TCustomDataSupplier::Reset()
	{
	return KErrNotSupported;
	}