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

// Implement the transport class for using HTTP GET and POST.

// Links the OCSP module to the HTTP module.

// 

//

#include <http/cecomfilter.h>

#include <escapeutils.h>

#include "securitypolicy.h"

#include "ocsppolicy.h"

#include "ocsptransport.h"

#include "panic.h"

#include <tconvbase64.h>

#include "callbacktimer.h"

_LIT8(KOCSPContentTypeRequest, "application/ocsp-request");

_LIT8(KOCSPContentTypeResponse, "application/ocsp-response");

_LIT8(KSlash, "/");

// Min request size for the use of POST method (else use GET method)

const TInt KMinReqSizeForHTTPPOST = 255;

const TInt KMillSecsToMicroSecs = 1000;

// Default value of timeout means it's disabled

const TInt KTimeoutDisabledValue = KTransportDefaultRequestTimeout;

EXPORT_C COCSPTransportHttp* COCSPTransportHttp::NewL(const TDesC8& aUri, TUint32& aIap)

	{

	COCSPTransportHttp* self = new (ELeave) COCSPTransportHttp(aIap);

	CleanupStack::PushL(self);

	self->ConstructL(aUri);

	CleanupStack::Pop(self);

	return self;

	}

COCSPTransportHttp::COCSPTransportHttp(TUint32& aIap)

	: CActive(CActive::EPriorityStandard), iIap(aIap), 

	  iTimeout(KTimeoutDisabledValue)

	{

	CActiveScheduler::Add(this);

	}

void COCSPTransportHttp::ConstructL(const TDesC8& aUri)

	{

	// Create the timer object

	iTimer = CCallbackTimer::NewL(*this);

	TUriParser8	uri;

	uri.Parse(aUri);

	iHTTPSession.OpenL(uri, iIap, EFalse);

	// Install the HTTP filter (filter UID is specified in swipolicy.ini file)

	InstallHttpFilterL();

	}

COCSPTransportHttp::~COCSPTransportHttp()

	{

	Deque();

	iHTTPTransaction.Close();

	iHTTPSession.Close();

	delete iUri;

	delete iRequest;

	delete iResponseData;

	delete iTimer;

	}

// From MOCSPTransport

void COCSPTransportHttp::SendRequest(const TDesC8& aURI, 

										 const TDesC8& aRequest,

										 const TInt aTimeout,

										 TRequestStatus& aStatus)

	{

	iCallBack = &aStatus;

	aStatus = KRequestPending;

	iServerFound = ETrue;

	delete iUri;

	delete iRequest;

	iTimeout = aTimeout;

	iUri = aURI.Alloc();

	iRequest = aRequest.Alloc();

	// Check for out of memory

	if (iUri == NULL || iRequest == NULL)

		{

		Complete(KErrNoMemory);

		}

	// Take action depending on current state

	if (iState == ETransportConnectingState)

		{

		// Establish a connection

		// Note: Timeout and retries don't apply to this operation

		iState = ETransportConnectingState;

		iHTTPSession.StartConnection(iStatus);

		SetActive();

		}

	else

		{

		// We've connected already, send the request.

		iStatus = KRequestPending;

		TRAPD(err, DoSendRequestL(*iUri, *iRequest));

		if (err == KErrNone)

			{

			// Start the timer (if enabled)

			if (iTimeout > KTimeoutDisabledValue)

				{

				iTimer->After(iTimeout * KMillSecsToMicroSecs);

				}

			SetActive();

			}

		else

			{

			Complete(err);

			}

		}

	}

void COCSPTransportHttp::InstallHttpFilterL()

	{

	// Install filters (if any)

	Swi::RSecPolHandle secPol;

	secPol.OpenLC();

	TUint32 filterId = secPol().OcspHttpHeaderFilter();

	if (filterId != 0)

		{

		TUid headerFilterUid = {filterId};

		CEComFilter::InstallFilterL(iHTTPSession.HTTPSession(), headerFilterUid);

		}

	CleanupStack::PopAndDestroy(&secPol);

	}

void COCSPTransportHttp::DoSendRequestL(const TDesC8& aURI, 

											const TDesC8& aRequest)

	{

	delete iResponseData;

	iResponseData = NULL;

	iOCSPRequest.Set(aRequest);

	// Close previous transaction, if any

	iHTTPTransaction.Close();

	// If the size of the DER encoded request is less than 255 bytes use the GET method (if enabled)

	// else use the POST method

	RBuf8 url8;

	CleanupClosePushL(url8);

	TInt reqSize = aRequest.Length();

	COcspPolicy* ocspPolicy = COcspPolicy::NewL();

	TBool useHTTPGETMethod = ocspPolicy->IsHttpGETMethodEnabled();

	delete ocspPolicy;

	if (useHTTPGETMethod && reqSize < KMinReqSizeForHTTPPOST)

		{

		// Set the OCSP request as part of the url after Base64 and URL encoding

		TBase64 base64;

		TInt destLen = ((iOCSPRequest.Length() - 1 ) / 3 + 1) * 4;

 		HBufC8* encodedBuf = HBufC8::NewMaxLC(destLen); // to get the decoded string

   		TPtr8 encodedPtr = encodedBuf->Des();

 		base64.Encode(iOCSPRequest, encodedPtr);

 		HBufC8* escEncodedReq = EscapeUtils::EscapeEncodeL(encodedPtr, EscapeUtils::EEscapeUrlEncoded);

		CleanupStack::PushL(escEncodedReq);

		url8.CreateL(aURI, aURI.Length() + KSlash().Length() + escEncodedReq->Length());

		// Append a slash only if it's already not present

		if ((aURI.Length() > 0) && (aURI.Right(1) != KSlash))

			{

			url8.Append(KSlash);

			}

		url8.Append(*escEncodedReq);

		CleanupStack::PopAndDestroy(2, encodedBuf);

		if (iURI.Parse(url8))

			{

			User::Leave(OCSP::KErrInvalidURI);

			}

		// Create HTTP transaction, method = GET (default)

		iHTTPTransaction = iHTTPSession().OpenTransactionL(iURI, *this);

		// Add the appropriate Http headers

		AddHttpHeadersL();

		}

	else

		{

		// Use the passed in URL as is

		if (iURI.Parse(aURI))

			{

			User::Leave(OCSP::KErrInvalidURI);

			}

		// Create HTTP transaction, method = POST

		RStringPool stringPool = iHTTPSession().StringPool();

		iHTTPTransaction = iHTTPSession().OpenTransactionL(iURI, *this, stringPool.StringF(HTTP::EPOST,RHTTPSession::GetTable()));

		// Add the appropriate Http headers

		AddHttpHeadersL();

		// Setup the data supplier

		iHTTPTransaction.Request().SetBody(*this);

		}

	// Finally submit the transaction

	iHTTPTransaction.SubmitL();

	CleanupStack::PopAndDestroy(&url8);

	}

void COCSPTransportHttp::AddHttpHeadersL()

	{

	// Get request + it's headers

	RStringPool stringPool = iHTTPSession().StringPool();

	RHTTPRequest request = iHTTPTransaction.Request();

	RHTTPHeaders headers = request.GetHeaderCollection();

	// Host header: done by HTTP module

	// Content-Length header: done by HTTP module

	// Connection:close header:

	headers.SetFieldL(stringPool.StringF(HTTP::EConnection, RHTTPSession::GetTable()), stringPool.StringF(HTTP::EClose, RHTTPSession::GetTable()));

	// Content-Type header:

	RStringF ocspRequest = stringPool.OpenFStringL(KOCSPContentTypeRequest);

	CleanupClosePushL(ocspRequest);

	THTTPHdrVal contentTypeVal(ocspRequest);

	headers.SetFieldL(stringPool.StringF(HTTP::EContentType,RHTTPSession::GetTable()), contentTypeVal);

	CleanupStack::PopAndDestroy(&ocspRequest);

	}

// From MOCSPTransport

void COCSPTransportHttp::CancelRequest()

	{

	Cancel();

	}

// From MOCSPTransport

TPtrC8 COCSPTransportHttp::GetResponse() const

	{

	__ASSERT_ALWAYS(iResponseData, Panic(KErrNotReady));

	return iResponseData->Des();

	}

// From MHTTPDataSupplier

TBool COCSPTransportHttp::GetNextDataPart(TPtrC8& aDataPart)

	{

	aDataPart.Set(iOCSPRequest);

	return ETrue;  // This is the last chunk

	}

// From MHTTPDataSupplier

void COCSPTransportHttp::ReleaseData()

	{

	// Nothing to do - from the OCSP side, ownership of the outgoing data is sorted already

	}

// From MHTTPDataSupplier

TInt COCSPTransportHttp::OverallDataSize()

	{

	return iOCSPRequest.Length();

	}

// From MHTTPDataSupplier

TInt COCSPTransportHttp::Reset()

	{

	return KErrNotSupported;

	}

// From MHTTPTransactionCallback

void COCSPTransportHttp::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

	{

	__ASSERT_ALWAYS(aTransaction == iHTTPTransaction, Panic(KErrArgument));

	// Either ESucceeded or EFailed *will* happen

	switch (aEvent.iStatus)

		{

		case THTTPEvent::EGotResponseHeaders:

			ProcessHeadersL();

			break;

		case THTTPEvent::EGotResponseBodyData:

			ProcessDataL();

			break;

		case THTTPEvent::EResponseComplete:

			CheckDataCompleteL();

			break;

		case THTTPEvent::EFailed:

			{

			// Stop the timer

			iTimer->Cancel();

			TRequestStatus* reqstatus = &iStatus;

			if (iServerFound)

				{

				User::RequestComplete(reqstatus, OCSP::KErrTransportFailure);

				}

			else

				{

				User::RequestComplete(reqstatus, OCSP::KErrServerNotFound);

				}

			}

			break;

		case THTTPEvent::ESucceeded:

			{

			// Stop the timer

			iTimer->Cancel();

			CheckDataCompleteL();

			SetIAPL();

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrNone);

			}

			break;

		case KErrTimedOut:

			// HTTP timed out - this really means it couldn't find the server mentioned in the url

			// Remember this error so we pass it up correctly when we receive "THTTPEvent::EFailed" event

			iServerFound = EFalse;

			break;

		default:

			// Some other event (or error).

			// Do nothing - HTTP module will cause EFailed or ESucceeded to occur

			break;

		}

	}

void COCSPTransportHttp::SetIAPL()

	{

	const RStringPool strPool = iHTTPSession().StringPool();

	RHTTPConnectionInfo connectionInfo = iHTTPSession().ConnectionInfo();

	THTTPHdrVal hdrVal;

	if (connectionInfo.Property(strPool.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()),

			hdrVal)) 

		{

		RConnection* connection =  reinterpret_cast<RConnection*>(hdrVal.Int());

		_LIT(KIapId, "IAP\\Id");

		User::LeaveIfError(connection->GetIntSetting(KIapId, iIap));

		}	

	}

// From MHTTPTransactionCallback

TInt COCSPTransportHttp::MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& /*aEvent*/)

	{

	__ASSERT_ALWAYS(aTransaction == iHTTPTransaction, Panic(KErrArgument));

	// Process error (otherwise, we get a panic)

	AbortTransaction(aError);

	return KErrNone;

	}

// Methods from MCallbackTimer

void COCSPTransportHttp::TimerRun(TInt aError)

	{

	if (aError == KErrNone)

		{

		// Handle the timeout

		iHTTPTransaction.Cancel();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, OCSP::KErrTransportTimeout);

		}

	else

		{

		// Propagate the error upward

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, aError);

		}

	}

// The headers have been received - check them out

void COCSPTransportHttp::ProcessHeadersL()

	{

	RHTTPResponse response = iHTTPTransaction.Response();

	RHTTPHeaders headers = response.GetHeaderCollection();

	RStringPool stringPool = iHTTPSession().StringPool();

	// Check content type

	RStringF ocspResponse = stringPool.OpenFStringL(KOCSPContentTypeResponse);

	CleanupClosePushL(ocspResponse);

	RStringF contentTypeString = stringPool.StringF(HTTP::EContentType,RHTTPSession::GetTable());

	THTTPHdrVal contentTypeVal;

	TInt error = headers.GetField(contentTypeString, 0, contentTypeVal);

	if (error != KErrNone 

		|| contentTypeVal.Type() != THTTPHdrVal::KStrFVal

		|| contentTypeVal.StrF() != ocspResponse)

		{

		User::Leave(OCSP::KErrTransportFailure);

		}

	CleanupStack::PopAndDestroy(); // close ocspResponse

	// Check content length - make descriptor ready to recieve data

	RStringF contentLengthString = stringPool.StringF(HTTP::EContentLength,RHTTPSession::GetTable());

	THTTPHdrVal contentLengthVal;

	error = headers.GetField(contentLengthString, 0, contentLengthVal);

	if (error == KErrNone

		&& contentLengthVal.Type() == THTTPHdrVal::KTIntVal)

		{

		// Make descriptor ready to receive response data

		__ASSERT_ALWAYS(iResponseData == NULL, Panic(KErrAlreadyExists));

		iResponseLength = contentLengthVal.Int();

		iResponseData = HBufC8::NewL(iResponseLength);

		}

	else

		{

		// No Contents-Length field in headers, or wrong data type

		User::Leave(OCSP::KErrTransportFailure);

		}

	}

void COCSPTransportHttp::ProcessDataL()

	{

	if (iResponseData)

		{

		// Some data has come in - copy it into our descriptor

		MHTTPDataSupplier* body = iHTTPTransaction.Response().Body();

		if (!body)

			{

			User::Leave(OCSP::KErrTransportFailure);

			}

		TPtrC8 dataChunk;

		TBool finished = body->GetNextDataPart(dataChunk);

		if (iResponseLength - iResponseData->Length() >= dataChunk.Length())

			{

			iResponseData->Des().Append(dataChunk);			

			body->ReleaseData();

			}

		else

			{

			// Data is longer than Contents-Length header said it would be - error

			body->ReleaseData();

			User::Leave(OCSP::KErrTransportFailure);

			}

		if (finished)

			{

			CheckDataCompleteL();

			}

		}		

	}

void COCSPTransportHttp::CheckDataCompleteL() const

	{

	if (iResponseLength != iResponseData->Length())

		{

		User::Leave(OCSP::KErrTransportFailure);

		}

	}

void COCSPTransportHttp::Complete(TInt aError)

	{

	if (iCallBack)

		{

		// If something went wrong, remove the dodgy response data

		if (aError != KErrNone)

			{

			delete iResponseData;

			iResponseData = NULL;

			}

		// Sets iCallBack back to NULL, so we can only do this once

		User::RequestComplete(iCallBack, aError);

		}

	}

void COCSPTransportHttp::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch(iState)

		{

	case ETransportConnectingState:

		iState = ETransportSendRequestState;

		iStatus = KRequestPending;

		DoSendRequestL(*iUri, *iRequest);

		// Start the timer (if enabled)

		if (iTimeout > KTimeoutDisabledValue)

			{

			iTimer->After(iTimeout * KMillSecsToMicroSecs);

			}

		SetActive();

		break;

	case ETransportSendRequestState:

		// All OK

		Complete(KErrNone);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		};

	}

TInt COCSPTransportHttp::RunError(TInt aError)

	{

	// If we failed in the transport connection state, return a

	// transport error. Otherwise, just propogate the error recieved.

	if (iState == ETransportConnectingState)

		{

		Complete(OCSP::KErrTransportFailure);

		}

	else

		{

		Complete(aError);

		}

	return KErrNone;

	}

void COCSPTransportHttp::DoCancel()

	{