// 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 "chttpclienthandler.h"

#include <http.h>

#include <http/framework/crxdata.h>

#include <http/framework/csecuritypolicy.h>

#include <inetprottextutils.h>

#include <uriutilscommon.h>

#include <uriutils.h>

#include <authority8.h>

#include <in_sock.h>

#include <securesocket.h>

#include <x509certext.h>

#include "chttptransportlayer.h"

#include "chttpclientfilter.h"

#include "chttpconnectfilter.h"

#include "chttpclientheadercodec.h"

#include "chttpclienttransaction.h"

#include "chttpconnectioninfo.h"

#include "chttpconnectionmanager.h"

#include "chttprequestcomposer.h"

#include "chttpresponseparser.h"

#include "thttpclientpanic.h"

const TInt KHttpDefaultPort			= 80;

const TInt KHttpDefaultSecurePort	= 443;

const TInt KHttpDefaultProxyPort	= 8080;

const TInt KMaxConnectionManagers	= 4;

const TInt KDefaultBatchingBufSize	= 1400;

const TInt KDefaultMaxNumberTransactionsToPipeline = KMaxTInt;

const TInt KDefaultBufferSize		= 32*1024;

_LIT8(KSecureHttpScheme, "https");

_LIT8(KHttpClientCodecName, "HTTP/client");

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

const TUint KIPv6HostOpenBrace		= '[';

const TUint KIPv6HostCloseBrace		= ']';

class InetProtTextUtils;

CHttpClientHandler* CHttpClientHandler::NewL(TAny* aSession)

	{

	RHTTPSession* httpSession = REINTERPRET_CAST(RHTTPSession*, aSession);

	CHttpClientHandler* self = new (ELeave) CHttpClientHandler(*httpSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CHttpClientHandler::~CHttpClientHandler()

	{

	iProxyAddress.Close();

	iConnectionManagers.ResetAndDestroy();

	delete iTransportLayer;

	delete iPipelineFallback;

	__FLOG_CLOSE;

	}

CHttpClientHandler::CHttpClientHandler(RHTTPSession aSession)

: CProtocolHandler(aSession),

iStringTable(RHTTPSession::GetTable())

	{

	__FLOG_OPEN("http", "httpclienthandler.txt");

	__FLOG(_T8("HTTP Client Protocol Handler Log"));

	}

void CHttpClientHandler::ConstructL()

	{	

	CProtocolHandler::ConstructL(iSession);

	CHttpClientFilter* clientFilter = CHttpClientFilter::NewL(iSession);

	CleanupStack::PushL ( clientFilter );

	CHttpConnectFilter::NewL(iSession);

	CleanupStack::Pop (); // clientFilter

	RHTTPConnectionInfo	connInfo = iSession.ConnectionInfo();

	RStringPool stringPool = iSession.StringPool();

	THTTPHdrVal value;

	TBool hasValue = connInfo.Property(stringPool.StringF(HTTP::ESessionClosing, iStringTable), value);

	if( hasValue && value.Type() == THTTPHdrVal::KTIntVal )  

		{

		iSessionClosingPtr = reinterpret_cast<TBool*>(value.Int());

		}

	else

		{

		__FLOG_0(_T8("!! Session Closing Flag NOT set"));

		User::Leave(KErrNotFound);

		}

	iPipelineFallback = CHttpPipelineFallback::NewL();	

	}

CHttpConnectionInfo* CHttpClientHandler::PrepareTransactionL(RHTTPTransaction aTrans, TBool& aNeedTunnel, TBool& aCanPipeline)

	{

    // Check that filters are not added headers that are not needed for CONNECT method.

    // Remove the unwanted headers. But do only if the property has been set for the 

    // strict CONNECT method.

    EnsureStrictConnectMethodHeaders (aTrans);

	// To prepare the transaction need to create the Request-URI, set the Host

	// header and establish the connection info.

	RStringPool stringPool = iSession.StringPool();

	RHTTPRequest request = aTrans.Request();

	SetupProxyInformation(aTrans);

	// Store the method index from string table

	TInt methodIndex = request.Method().Index(iStringTable); 

	// Check for https scheme.

	const TUriC8& uri = request.URI();

	// secure doesn't count if it's a connect request	

	TBool secure = methodIndex != HTTP::ECONNECT &&

		(uri.Extract(EUriScheme).CompareF(KSecureHttpScheme) == 0);

	// Create the Request-URI for this transaction...

	TInt port = (secure) ? KHttpDefaultSecurePort : KHttpDefaultPort;

	TPtrC8 host;

	CreateRequestUriL(methodIndex, aTrans, host, port);

	// If the host name is empty leave as the URI is not complete - a CONNECT

	// method request has an empty host as it will go to the proxy.

	if( host.Length() == 0 )

		{

		__FLOG_0(_T8("!! Invalid uri"));

		__FLOG_2(_T8("-> Trans %d, Con %d : missing host!"), aTrans.Id(),GetConnectionID(aTrans));

		User::Leave(KErrHttpInvalidUri);

		}

	// Set the Host header...

	TBool isHttp10 = SetHostHeaderL(aTrans, host, port);

	// Create the connection info. Is a proxy being used?

	if( iUseProxy )

		{

		// Need a tunnel if request is going via a proxy and request is using 

		// the https scheme

		if( secure )

			{

			__FLOG_4(_T8("Trans %d, Con %d : tunnel required to host %S, port %d"), aTrans.Id(),GetConnectionID(aTrans), &host, port);

			// This request needs a tunnel to be established to the specified 

			// host/port - add the ETunnel property to the transaction.

			aNeedTunnel = ETrue;

			AddTunnelInfoL(aTrans, host, port);

			}

		// Need to obtain the proxy info.

		const TDesC8& proxy = iProxyAddress.DesC();

		TAuthorityParser8 auth;

		auth.Parse(proxy);

		host.Set(auth.Extract(EAuthorityHost));

		// Read the proxy port if present

		port = KHttpDefaultProxyPort; // Initialise with default proxy port

		if( auth.IsPresent(EAuthorityPort) )

			{

			TPtrC8 portDesc = auth.Extract(EAuthorityPort);

			TInt error = InetProtTextUtils::ConvertDescriptorToInt(portDesc, port);

			if( error != KUriUtilsErrEmptyData )

				{

				// An empty port component is allowed - just ignore it.

				User::LeaveIfError(error);

				}

			}

		}

	// Is a non-persistent connection required? The connection is non-persistent

	// if either it is a HTTP/1.0 request or it is a HTTP/1.1 request and it has

	// a Connection: close header.

	RHTTPHeaders headers = request.GetHeaderCollection();

	CHttpConnectionInfo::THttpPersistent persistentState = isHttp10 ? 

														   CHttpConnectionInfo::ENonPersistent : 

														   CHttpConnectionInfo::EPersistent;

	THTTPHdrVal connVal;

	RStringF connStr = stringPool.StringF(HTTP::EConnection, iStringTable);

	if( headers.GetField(connStr,0,connVal) == KErrNone )

		{

		__ASSERT_DEBUG( !isHttp10, THttpClientPanic::Panic(THttpClientPanic::EInvalidHeaderForHTTP10) ); // no connection headers are allowed in HTTP/1.0

		if( (connVal.Type() == THTTPHdrVal::KStrFVal) && 

			(connVal.StrF() == stringPool.StringF(HTTP::EClose, iStringTable)) )

			{

			// Client has specified a Connection: close header - non-persistent

			// connection.

			persistentState = CHttpConnectionInfo::ENonPersistent;

			}

		}

	// Create the connection info object

	CHttpConnectionInfo* connectionInfo = CHttpConnectionInfo::NewL(stringPool, host, static_cast<TUint16>(port));

	connectionInfo->SetSecureState(secure);

	connectionInfo->SetPersistentState(persistentState);

	// Check to see if this transaction can be pipelined.

	switch(methodIndex)

		{

	case HTTP::EGET:

		{

		// Can only pipeline non-HTTP/1.0 requests...

		if( !isHttp10 )

			{

			// These methods can be pipelined but only if pipelining has not been 

			// specifically disabled for the transaction.

            aCanPipeline = (CheckPipelineSupport(aTrans) && !iPipelineFallback->NeedPipelineFallback(host));

            __FLOG_4(_T8("Pipelining --- enabled: %d Support: %d Fallback: %d  Host %S"), aCanPipeline, CheckPipelineSupport(aTrans), !iPipelineFallback->NeedPipelineFallback(host), &host);

			break;

			}

		// Allow the HTTP/1.0 requests to drop through to default case.

		}

	default:

		// All other methods are not to be pipelined.

		aCanPipeline = EFalse;

		break;

		};

	return connectionInfo;

	} 

void CHttpClientHandler::CreateRequestUriL(TInt aMethodIndex, RHTTPTransaction aTrans, TPtrC8& aHost, TInt& aPort)

	{

	RStringPool stringPool = iSession.StringPool();

	RHTTPRequest request = aTrans.Request();

	const TUriC8& uri = request.URI();

	TBool secure = EFalse;

	RStringF scheme = stringPool.OpenFStringL(uri.Extract(EUriScheme));

	CleanupClosePushL(scheme);

	if( aMethodIndex == HTTP::ECONNECT )

		{

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

		aHost.Set(uri.Extract(EUriHost));

		}

	else if( uri.IsPresent(EUriHost) )

		{

		// The request URI is absolute - check the scheme is http or https

		secure = uri.IsPresent(EUriScheme) && (scheme.Index(iStringTable) == HTTP::EHTTPS);

		if( !uri.IsPresent(EUriScheme) || !secure &&

			scheme.Index(iStringTable) != HTTP::EHTTP)

			{

			__FLOG_0(_T8("!! Invalid uri."));

			__FLOG_3(_T8("-> Trans %d, Con %d: %S scheme is not supported!"), aTrans.Id(),GetConnectionID(aTrans), &scheme.DesC());

			User::Leave(KErrHttpInvalidUri);

			}

		// Get the host and port info from it.

		aHost.Set(uri.Extract(EUriHost));

		// Check to see if a port has been specified	

		if( uri.IsPresent(EUriPort) )

			{

			TPtrC8 port = uri.Extract(EUriPort);

			TInt error = InetProtTextUtils::ConvertDescriptorToInt(port, aPort);

			if( error != KUriUtilsErrEmptyData )

				{

				// An empty port component is allowed - just ignore it.

				User::LeaveIfError(error);

				}

			}

		}

	else

		{

		// The request URI is relative - update the request URI to be absolute.

		// The client MUST have supplied a Host header.

		RHTTPHeaders headers = request.GetHeaderCollection();

		RStringF hostStr = stringPool.StringF(HTTP::EHost, iStringTable);

		THTTPHdrVal hostVal;

		if( headers.GetField(hostStr, 0, hostVal) == KErrNotFound )

			{

			// No Host header - do not know which host to connect to.

			User::Leave(KErrHttpGeneralHeaderMissingHost);

			}

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

		// Set the host output argument

		aHost.Set(hostVal.StrF().DesC());

		// Create the absolute uri

		CUri8* absoluteUri = CUri8::NewLC(uri);

		RStringF httpStr = stringPool.StringF(HTTP::EHTTP, iStringTable);

		absoluteUri->SetComponentL(httpStr.DesC(), EUriScheme);

		absoluteUri->SetComponentL(aHost, EUriHost);

		// Check for port info in the Host header

		RStringF portStr = stringPool.StringF(HTTP::EPort, iStringTable);

		THTTPHdrVal portVal;

		TBool hasPort = (headers.GetParam(hostStr, portStr, portVal) == KErrNone);

		if( hasPort && portVal.Type() == THTTPHdrVal::KTIntVal )

			{

			// Set the port output argument

			aPort = portVal.Int();

			// Convert the int value to its descriptor format

			HBufC8* portBuf = NULL;

			InetProtTextUtils::ConvertIntToDescriptorL(aPort, portBuf);

			CleanupStack::PushL(portBuf);

			absoluteUri->SetComponentL(*portBuf, EUriPort);

			CleanupStack::PopAndDestroy(portBuf);

			}

		// Now set the absolute URI back into the transaction

		request.SetURIL(absoluteUri->Uri());

		CleanupStack::PopAndDestroy(absoluteUri);

		}

	// Create the Request-URI based on the request URI. 

	// NOTE - might have changed from earlier

	const TUriC8 reqURI = request.URI();

	// CONNECT uses authority while everything else uses absoluteURI or absolutePath

	// use absolutePath for direct connections and tunnels, and absoluteURI for proxy

	// note: OPTIONS uses "*" as well, but that should still work

	CAuthority8* authToUse=NULL;

	CUri8* uriToUse = NULL;

	if( aMethodIndex == HTTP::ECONNECT)

		{

		authToUse = CAuthority8::NewLC();

		authToUse->SetComponentL(reqURI.Extract(EUriUserinfo),EAuthorityUserinfo);

		authToUse->SetComponentL(reqURI.Extract(EUriHost),EAuthorityHost);

		authToUse->SetComponentL(reqURI.Extract(EUriPort),EAuthorityPort);	

		}

	else 

		{

		uriToUse = CUri8::NewLC(reqURI);

		if( !iUseProxy || secure ) // if (useproxy and not secure) or (not useproxy) = not useproxy or secure

			{// Not going via a proxy - need to remove the scheme and authority parts

			uriToUse->RemoveComponentL(EUriScheme);

			uriToUse->RemoveComponentL(EUriHost);	// this also removes the userinfo + port

			}

		}

	// Set the Request-URI for the request

	RString uriStr = stringPool.OpenStringL(

		authToUse ? authToUse->Authority().AuthorityDes() : uriToUse->Uri().UriDes());

	CleanupClosePushL(uriStr);

	THTTPHdrVal uriVal(uriStr);

	aTrans.PropertySet().SetPropertyL(stringPool.StringF(HTTP::EUri, iStringTable), uriVal);

	CleanupStack::PopAndDestroy(3, &scheme); // uriToUse or authToUse, uriStr 

	}

TBool CHttpClientHandler::SetHostHeaderL(RHTTPTransaction aTrans, const TDesC8& aHost, TInt aPort)

	{

		__START_PERFORMANCE_LOGGER();

	// Set the Host header only if the request is not an HTTP/1.0 request.

	RStringPool stringPool = iSession.StringPool();

	RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

	THTTPHdrVal httpVersion;

	TBool isHttp10 = EFalse;

	if( connInfo.Property(stringPool.StringF(HTTP::EHTTPVersion,iStringTable), httpVersion) )

		{

		__ASSERT_DEBUG( httpVersion.Type() == THTTPHdrVal::KStrFVal, THttpClientPanic::Panic(THttpClientPanic::EInvalidHeaderValueType) );

		isHttp10 = (httpVersion.StrF() == stringPool.StringF(HTTP::EHttp10, iStringTable));

		}

	// Regardless of proxy settings a Host header based on the URI authority must be added unless

	// this is an HTTP/1.0 request in which case a Host header should not exist.

	RHTTPRequest request = aTrans.Request();

	RHTTPHeaders headers = request.GetHeaderCollection();

	RStringF hostStr = stringPool.StringF(HTTP::EHost, iStringTable);

	if( !isHttp10 )

		{

		// If the Host header does not already exist, add it!

		THTTPHdrVal hostValue;

		if( headers.GetField(hostStr, 0, hostValue) == KErrNotFound )

			{				

			// Set the Host header...

			RStringF hostValStr;

			// Check if its a literal IPV6 address

			UriUtils::TUriHostType aHostsType = UriUtils::HostType( aHost );

			if ( ( aHostsType != UriUtils::ETextHost ) && ( aHostsType != UriUtils::EIPv4Host ) ) // is an IPv6 or other future protocol address

				{

				HBufC8* ipv6LiteralHost = HBufC8::NewLC( aHost.Length() + 2 ); // add 2 for the braces

				TPtr8 ipv6LiteralHostPtr = ipv6LiteralHost->Des();	

				ipv6LiteralHostPtr.Append( KIPv6HostOpenBrace );

				ipv6LiteralHostPtr.Append( aHost );

				ipv6LiteralHostPtr.Append( KIPv6HostCloseBrace );

				hostValStr = stringPool.OpenFStringL( ipv6LiteralHostPtr );

				CleanupStack::PopAndDestroy( ipv6LiteralHost );

				}

			else

				{

				hostValStr = stringPool.OpenFStringL( aHost );

				}

			CleanupClosePushL(hostValStr);

			THTTPHdrVal hostVal(hostValStr);	

			headers.SetFieldL(hostStr, hostVal);

			CleanupStack::PopAndDestroy(&hostValStr);

			// Also set the port number if Host header is not empty and a port 

			// number is not the default.

			if( aPort != KHttpDefaultPort && aPort != KHttpDefaultSecurePort )

				{

				THTTPHdrVal portVal(aPort);

				RStringF portStr = stringPool.StringF(HTTP::EPort,iStringTable);

				headers.SetParamL(hostStr, portStr, portVal, 0);

				}

			}

		// else the Host header already exists, so do nothing

		}

	else // This is an HTTP/1.0 request

		headers.RemoveField(hostStr);

	__END_PERFORMANCE_LOGGER(_L(",CHttpClientHandler::SetHostHeaderL()"));	

	return isHttp10;

	}

void CHttpClientHandler::AddTunnelInfoL(RHTTPTransaction aTrans, const TDesC8& aHost, TInt aPort)

	{

	// Convert the port number into a descriptor...

	HBufC8* port = NULL;

	InetProtTextUtils::ConvertIntToDescriptorL(aPort, port);

	CleanupStack::PushL(port);

	// Create the Request-URI for the CONNECT request - it is in the 'authority'

	// form, as described in RFC2616, section 5.1.2.

	CAuthority8* authority = CAuthority8::NewLC();

	authority->SetComponentL(aHost, EAuthorityHost);

	authority->SetComponentL(*port, EAuthorityPort);

	// Set this as the ETunnel property in the transaction.

	RStringPool stringPool = iSession.StringPool();

	RStringF tunnelStr = stringPool.OpenFStringL(authority->Authority().AuthorityDes());

	CleanupClosePushL(tunnelStr);

	THTTPHdrVal tunnelVal(tunnelStr);

	aTrans.PropertySet().SetPropertyL(stringPool.StringF(HTTP::ETunnel, iStringTable), tunnelVal);

	CleanupStack::PopAndDestroy(3, port); // delete authority and close tunnelStr

	}

TBool CHttpClientHandler::SelectConnectionManagerL(const CHttpConnectionInfo& aConnectionInfo, RHTTPTransaction aTrans, TBool aCanPipeline, CHttpConnectionManager *&aManager )

	{

	// Selecting a connection manager depends on whether the transaction can be

	// pipelined. If so, then the connection manager of choice would be the one

	// that is connected to the correct location and busy with other transactions.

	// If there is no connection manager that fits this criteria, then the 

	// selection process follows that for a transaction that cannot be pipelined.

	// The order of preference for selecting a connection manager - 

	// 1) A manager that is connected to the correct location and is available.

	//	  This is the backup-choice for a transaction that can be pipelined.

	// 2) A manager that is not connected to anywhere.

	// 3) Create a new manager if the limit has not been reached.

	// 4) Use a manager that is connected to a different host (but not being 

	//    used) and will therefore need disconnecting and reconnecting.

	CHttpConnectionManager* backupChoice = NULL;

	CHttpConnectionManager* secondChoice = NULL;

	CHttpConnectionManager* fourthChoice = NULL;

    CHttpConnectionManager* managerConnecting = NULL;	

	TBool newConnection = ETrue;

    TInt numConnectionsToSingleServer = 0;

	TBool connectMethod = aTrans.Request().Method().Index(iStringTable) == HTTP::ECONNECT;

	const TInt numConnMan = iConnectionManagers.Count();

	for( TInt ii=0; (ii < numConnMan && aManager == NULL ); ++ii )

		{

		CHttpConnectionManager::TConnectionStatus status = iConnectionManagers[ii]->Status();

		switch( status )

			{

		case CHttpConnectionManager::ENotConnected:

			{

			// This is a pretty good option because it just needs a connection 

			// to be established

			secondChoice = iConnectionManagers[ii];

			} break;

		case CHttpConnectionManager::EConnectedAndAvailable:

			{

			// This is the ideal situation if the location matches, otherwise it

			// becomes the fourth choice

			const CHttpConnectionInfo& connectionInfo = iConnectionManagers[ii]->ConnectionInfo();

			if( connectionInfo.HostAndPortMatches(aConnectionInfo) )

				{

				if(!connectMethod)

				     {

	                ++numConnectionsToSingleServer;					

				     if( aCanPipeline )

					     {

						  // This is the backup-choice

						  backupChoice = iConnectionManagers[ii];

						 }

				     else

					    {

						// This is the one!

						aManager = iConnectionManagers[ii];

						newConnection = EFalse;

					    }

				     }

				 }

			else

				{

				// Non-matching connection info - fourth choice.

				fourthChoice = iConnectionManagers[ii];

				}

			} break;

		case CHttpConnectionManager::EConnectedAndBusy:

			{