// Copyright (c) 2003-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 "chttpconnectfilter.h"

#include <httpstringconstants.h>
#include <httperr.h>
#include <http/rhttpheaders.h>

_LIT8(KUAProfile, "x-wap-profile");

// 'this' used in base member initializer list, The 'this' pointer being used is a base class pointer.
#pragma warning( disable : 4355 )

CHttpConnectFilter* CHttpConnectFilter::NewL(RHTTPSession aSession)
	{
	CHttpConnectFilter* self = new (ELeave) CHttpConnectFilter(aSession);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CHttpConnectFilter::~CHttpConnectFilter()
	{
	iConnectTransactions.Close();
	iPendingTransactions.Close();

	// If this object has been destroyed from the cleanup stack during creation
	// of the object, it might still be loaded - check. Normally the delete is 
	// initiated by the 'delete this' in MHFUnload.
	if( iLoadCount )
		{
		// As already in a destructor, MHFUnload must not delete this again.
		iLoadCount = -1;
		RStringF filterName = iStringPool.StringF(HTTP::EHttpConnectFilter, iStringTable);
		iSession.FilterCollection().RemoveFilter(filterName);
		}
	}

CHttpConnectFilter::CHttpConnectFilter(RHTTPSession aSession)
: CBase(), iSession(aSession), iStringTable(RHTTPSession::GetTable()), iStringPool(aSession.StringPool()), iCallback(*this)
	{
	}

void CHttpConnectFilter::ConstructL()
	{
	// Register the filter. 
	RStringF filterName = iStringPool.StringF(HTTP::EHttpConnectFilter, iStringTable);
	iSession.FilterCollection().AddFilterL(
										  *this, 
										  THTTPEvent::ENeedTunnel, 
										  MHTTPFilter::EProtocolHandler +20,
										  filterName
										  );
	iSession.FilterCollection().AddFilterL(
										  *this, 
										  THTTPEvent::ECancel, 
										  MHTTPFilter::EProtocolHandler +20,
										  filterName
										  );
	}

TInt CHttpConnectFilter::FindConnectRequest(RStringF aTunnelHost, RStringF aProxy)
	{
	TInt id = KErrNotFound;
	TInt index = iConnectTransactions.Count();
	RStringF tunnelName = iStringPool.StringF(HTTP::ETunnel, iStringTable);
	while( index > 0 && id == KErrNotFound )
		{
		--index;
		RHTTPTransaction trans = iConnectTransactions[index];

		THTTPHdrVal tunnelVal;
#ifdef _DEBUG
		TBool found = 
#endif
		trans.PropertySet().Property(tunnelName, tunnelVal);

		__ASSERT_DEBUG( found, User::Invariant() );

		if( aTunnelHost == tunnelVal.StrF() )
			{
			// Ok the tunnel matches - check to see if a specific proxy is being
			// used.
			THTTPHdrVal proxyVal = RStringF();
			trans.PropertySet().Property(iStringPool.StringF(HTTP::EProxyAddress, iStringTable), proxyVal);

			if( proxyVal.StrF() == aProxy )
				{
				// There already is a CONNECT request for this tunnel - no need to
				// create another.
				id = trans.Id();
				}
			}
		}
	return id;
	}

TInt CHttpConnectFilter::CreateConnectTransactionL(RStringF aTunnelHost, RStringF aProxy, RStringF aUserAgent, RStringF aProfile)
	{
	// The Request-URI for the CONNECT request is in the 'authority' form, as 
	// described in RFC2616, section 5.1.2, but need to pass the request uri as
	// a TUriC8...
	_LIT8(KSchemeString, "https://%S"); // uses more code to use RString EHTTPS than we save by adding the 5 bytes here
	TUriParser8 connectUri;
	HBufC8* uri = HBufC8::NewLC(aTunnelHost.DesC().Length()+8);
	uri->Des().AppendFormat(KSchemeString(), &aTunnelHost.DesC());
	connectUri.Parse(*uri);

	// Open a CONNECT transaction...
	RStringF connectMethod = iStringPool.StringF(HTTP::ECONNECT, iStringTable);
	iNewConnectTransaction = iSession.OpenTransactionL(
													  connectUri,
													  iCallback,
													  connectMethod
													  );
	CleanupStack::PopAndDestroy(uri);
	// As the CONNECT transaction is prepared, submitted and stored, it is 
	// possible to orphan this transaction - it will need to be closed if a 
	// leave occurs.
	iCloseConnectTransaction = ETrue;

	// Set aTunnelHost as the ETunnel property in the transaction.
	RStringF tunnelName = iStringPool.StringF(HTTP::ETunnel, iStringTable);
	THTTPHdrVal tunnelVal(aTunnelHost);
	iNewConnectTransaction.PropertySet().SetPropertyL(tunnelName, tunnelVal);

	if( aProxy.DesC().Length() > 0 )
		{
		// ok need to use a specific proxy - set the appropriate properties in 
		// the transaction.
		RHTTPPropertySet properties = iNewConnectTransaction.PropertySet();
		properties.SetPropertyL(
							   iStringPool.StringF(HTTP::EProxyUsage, iStringTable),
							   iStringPool.StringF(HTTP::EUseProxy, iStringTable)
							   );
		properties.SetPropertyL(
							   iStringPool.StringF(HTTP::EProxyAddress, iStringTable),
							   aProxy
							   );
		}

	// get new transaction headers
	RHTTPHeaders hdr = iNewConnectTransaction.Request().GetHeaderCollection();

	if(aUserAgent.DesC().Length() > 0)
		{
		// add the User-agent header
		hdr.SetFieldL(
					  iStringPool.StringF(HTTP::EUserAgent, iStringTable),
					  THTTPHdrVal(aUserAgent)
					 );
		}

	if(aProfile.DesC().Length() > 0)
		{
		// add the User Agent profile header
//Note: if mmp file defines SRCDBG the next 4 lines cause a compiler bug in thumb udeb builds
// can workaround compiler bug by removing local variable & using this line instead:
//		hdr.SetFieldL(iStringPool.OpenFStringL(KUAProfile), THTTPHdrVal(aProfile));
// but its not leave safe, but could be used for debugging if SRCDBG is really needed

		RStringF profileHeader = iStringPool.OpenFStringL(KUAProfile);
		CleanupClosePushL(profileHeader);

		hdr.SetFieldL(profileHeader, THTTPHdrVal(aProfile));

		CleanupStack::PopAndDestroy(&profileHeader);
		}

	// Submit the CONNECT request...
	iNewConnectTransaction.SubmitL();

	// Store CONNECT transaction...
	User::LeaveIfError(iConnectTransactions.Append(iNewConnectTransaction));

	return iNewConnectTransaction.Id();		
	}

void CHttpConnectFilter::CloseConnectTransaction(TInt aConnectId)
	{
	// Run through connect transaction array, remove and close the one with
	// this id.
	const TInt count = iConnectTransactions.Count();
	for( TInt index = 0; index < count; ++index )
		{
		RHTTPTransaction trans = iConnectTransactions[index];
		if( trans.Id() == aConnectId )
			{
			trans.Close();
			iConnectTransactions.Remove(index);
			return;
			}
		}
	// If no CONNECT transaction found with that id - something has gone wrong.
	User::Invariant();
	}

/*
 *	Methods from MHTTPFilterBase
 */

void CHttpConnectFilter::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
	{
	switch( aEvent.iStatus )
		{
	case THTTPEvent::ENeedTunnel:
		{
		// Transaction needs a tunnel - need to see if a CONNECT request has 
		// been made for this origin server via the same proxy.
		aTransaction.Cancel();

		// The transaction must have the ETunnel property - this contains the
		// host/port of where the tunnel needs to lead to.
		RHTTPPropertySet properties = aTransaction.PropertySet();
		THTTPHdrVal tunnelVal;
#ifdef _DEBUG
		TBool found = 
#endif
		properties.Property(iStringPool.StringF(HTTP::ETunnel, iStringTable), tunnelVal);

		__ASSERT_DEBUG( found, User::Invariant() );
		__ASSERT_DEBUG( tunnelVal.Type() == THTTPHdrVal::KStrFVal, User::Invariant() );

		// Also, check to see if the transaction has a specific proxy to use.
		// NOTE - no need to check HTTP::EUseProxy, only need to see if 
		// the HTTP::EProxyAddress is set/
		THTTPHdrVal proxyVal = RStringF();
		properties.Property(iStringPool.StringF(HTTP::EProxyAddress, iStringTable), proxyVal);

		// See if there already is CONNECT transaction for this tunnel host/port.
		TInt connectId = FindConnectRequest(tunnelVal.StrF(), proxyVal.StrF());

		if( connectId == KErrNotFound )
			{
			// get request headers
			RHTTPHeaders hdr = aTransaction.Request().GetHeaderCollection();

			// extract user-agent header
			THTTPHdrVal userAgent = RStringF();
			hdr.GetField(iStringPool.StringF(HTTP::EUserAgent, iStringTable), 0, userAgent);

			// extract UA profile header
			RStringF profileHeader = iStringPool.OpenFStringL(KUAProfile);
			THTTPHdrVal profile = RStringF();
			hdr.GetField(profileHeader, 0, profile);
			profileHeader.Close();

			// Create a CONNECT transaction for the host/port.
			connectId = CreateConnectTransactionL(tunnelVal.StrF(), proxyVal.StrF(), userAgent.StrF(), profile.StrF());
			}
		
		// Associate this transaction with the CONNECT transaction.
		TPendingTransaction pending = TPendingTransaction(aTransaction, connectId);
		User::LeaveIfError(iPendingTransactions.Append(pending));

		// If a new CONNECT request was created, it is now safe.
		iCloseConnectTransaction = EFalse;
		} break;
	case THTTPEvent::ECancel:
		{
		// Check if this transaction is in the pending queue
		TBool found = EFalse;
		TInt index = iPendingTransactions.Count();
		while( index > 0 && !found )
			{
			--index;
			TPendingTransaction pending = iPendingTransactions[index];

			if( pending.iPendingTransaction == aTransaction )
				{
				// This transaction was waiting for a tunnel - remove it from the
				// queue. Let the CONNECT transaction for the tunnel continue as
				// there could be other pending transactions waiting for that
				// same tunnel.
				iPendingTransactions.Remove(index);
				found = ETrue;
				}
			}
		} break;
	default:
		break;
		}
	}

void CHttpConnectFilter::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)
	{
	}

TInt CHttpConnectFilter::MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& /*aEvent*/)
	{
	// Something has gone a bit wrong - does the connect transaction need to be
	// closed?
	if( iCloseConnectTransaction )
		{
		// Yep, this means that leave occured after the new connect transaction 
		// was opened.
		iNewConnectTransaction.Close();
		}

	// Send the error to the client
	if(aTransaction.SendEvent(aError, THTTPEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::ECurrentFilter)) != KErrNone )
	    {
	    aTransaction.Fail();
	    }

	return KErrNone;
	}

TInt CHttpConnectFilter::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)
	{
	return aError;
	}

/*
 *	Methods from MHTTPFilter
 */

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

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

	delete this;
	}

/*
 *	Methods from MHttpConnectObserver
 */

void CHttpConnectFilter::ConnectCompleteL(TInt aConnectId)
	{
	// Close this CONNECT transaction
	CloseConnectTransaction(aConnectId);

	// Locate the pending transactions that were waiting for this tunnel.
	TInt index = iPendingTransactions.Count();
	while( index > 0 )
		{
		--index;
		TPendingTransaction pending = iPendingTransactions[index];

		if( pending.iConnectId == aConnectId )
			{
			// This transaction was waiting for the tunnel - re-submit it.
			pending.iPendingTransaction.SubmitL();

			// Remove this entry.
			iPendingTransactions.Remove(index);
			}
		}
	}

void CHttpConnectFilter::ConnectErrorL(TInt aConnectId)
	{
	// Close this CONNECT transaction
	CloseConnectTransaction(aConnectId);

	// Locate the pending transactions that were waiting for this tunnel.
	TInt index = iPendingTransactions.Count();
	while( index > 0 )
		{
		--index;
		TPendingTransaction pending = iPendingTransactions[index];

		if( pending.iConnectId == aConnectId )
			{
			// This transaction was waiting for the tunnel - send error. Pretend
			// that the error came from the protocol handler. This ensures all 
			// filters are notified.
			pending.iPendingTransaction.SendEventL(
												  KErrHttpCannotEstablishTunnel,
												  THTTPEvent::EIncoming, 
												  THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler)
												  );

			// Remove this entry.
			iPendingTransactions.Remove(index);
			}
		}
	}

void CHttpConnectFilter::FailPendingTransactions(TInt aConnectId)
	{
	// No need to close the CONNECT transaction - would have closed already.

	// Locate the pending transactions that were waiting for this tunnel.
	TInt index = iPendingTransactions.Count();
	while( index > 0 )
		{
		--index;
		TPendingTransaction pending = iPendingTransactions[index];

		if( pending.iConnectId == aConnectId )
			{
			// This transaction was waiting for the tunnel - fail it!
			pending.iPendingTransaction.Fail();

			// Remove this entry.
			iPendingTransactions.Remove(index);
			}
		}

	}