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

#include <authority8.h>

#include <httperr.h>

#include <x509cert.h>

#include <sslerr.h>

#include "msocketfactory.h"

#include "msocketconnector.h"

#include "moutputstream.h"

#include "minputstream.h"

#include "mhttprequest.h"

#include "mhttpresponse.h"

#include "chttpconnectioninfo.h"

#include "chttprequestbatcher.h"

CHttpConnectionManager* CHttpConnectionManager::NewL(MSocketFactory& aSocketFactory, 

													 MHttpBatchingPropertiesCallback& aCallback,

													 CHttpPipelineFallback& aPipelineFallback, 

													 TInt aMaxTransactionsToPipeline,

													 TBool aEnableOptimalPipeline)

	{

	CHttpConnectionManager* self = new (ELeave) CHttpConnectionManager(aSocketFactory, aCallback, aPipelineFallback, aMaxTransactionsToPipeline, aEnableOptimalPipeline);

	return self;

	}

CHttpConnectionManager::~CHttpConnectionManager()

	{

	iPendingRequests.Reset();

	iPendingResponses.Reset();

	// Close down connect, if exists

	if( iSocketConnector )

		{

		iSocketConnector->StopConnect();

		}

	CloseConnection();

	delete iConnectionInfo;

	iTunnelHost.Close();

	delete iRequestBatcher;

	delete iOptimiser;

	}

CHttpConnectionManager::CHttpConnectionManager(MSocketFactory& aSocketFactory, 

											   MHttpBatchingPropertiesCallback& aCallback,

											   CHttpPipelineFallback& aPipelineFallback,

											   TInt aMaxTransactionsToPipeline,

											   TBool aEnableOptimalPipeline): 

	iEnableOptimalPipeline(aEnableOptimalPipeline), iMaxTransactionsToPipeline(aMaxTransactionsToPipeline),

	iSocketFactory(aSocketFactory), iCallback(aCallback), iPipelineFallback(aPipelineFallback)

	{

	}

void CHttpConnectionManager::SubmitL(CHttpConnectionInfo& aConnectionInfo, MHttpRequest& aRequest, MHttpResponse& aResponse)

	{

	// Check state - may need to close connection

	TBool secure = EFalse;

	if( iState == EIdleConnected )

		{

		secure = iConnectionInfo->IsSecure();

		// Can the current connection be re-used?

		if( !iConnectionInfo->HostAndPortMatches(aConnectionInfo) ||

			secure && !aConnectionInfo.IsSecure() )

			{

			__ASSERT_DEBUG( iPendingResponses.Count() == 0, User::Invariant() );

			// Nope - either the current connection is to the wrong host or the

			// current connection is secure and need a non-secure connection.

			CloseConnection();

			}

		}

	else if( iState == EClosing )

		{

		__ASSERT_DEBUG( iConnectionInfo->IsNonPersistent(), User::Invariant() );

		__ASSERT_DEBUG( iPendingResponses.Count() == 0, User::Invariant() );

		// The connection was non-persistent and the remote host has yet to 

		// close the connection - close it now.

		CloseConnection();

		}

	if ( iState == EIdleConnected || iState == EConnected )	

		{

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

		iInputStream->Restart ();			

		}

	// Cleanup old connection info and take ownership of the new connection info.

	delete iConnectionInfo;

	iConnectionInfo = &aConnectionInfo;

	// Store the request and response in appropriate place

	if( iCurrentRequest == NULL )

		{

		// Make this the current request

		iCurrentRequest = &aRequest;

		}

	else

		{

		__ASSERT_DEBUG( !CannotPipeline(), User::Invariant() );

		// Append to the pending request queue

		User::LeaveIfError(iPendingRequests.Append(&aRequest));

		}

	if( iCurrentResponse == NULL )

		{

		// Make this the current response

		iCurrentResponse = &aResponse;

		}

	else

		{

		__ASSERT_DEBUG( !CannotPipeline(), User::Invariant() );

		// Append to the pending response queue		

		TInt err = iPendingResponses.Append( &aResponse );

		// The request is already added into the array. Remove it from the array

		// in case of any error and leave with the error code. 

		// This is required because a checking is going on in CancelSubmission fn.

		// That function expects: if a request object is present in the array there "must" be a 

		// corresponding response object.

		if ( err != KErrNone )

			{

			TInt requestIndex = FindRequest( aRequest );

			if( requestIndex != KErrNotFound )

				{

				iPendingRequests.Remove( requestIndex );

				}

			User::Leave ( err );

			}

		}

	switch( iState )

		{

	case EIdle:

		{

		__FLOG_4(

				_T8("Start connection to host %S, remote port %d (secure : %d, nonpersistent : %d)"), 

				&iConnectionInfo->Host(), 

				iConnectionInfo->Port(), 

				iConnectionInfo->IsSecure(), 

				iConnectionInfo->IsNonPersistent()

				);

		// Need to start connection to the appropriate host

		iSocketConnector = &iSocketFactory.ConnectL(

												   *this, 

												   iConnectionInfo->Host(), 

												   iConnectionInfo->Port()

												   );

		if (!CannotPipeline())

			{

			//  we are pipelining so set this flag

			iFlags.Set(EFirstTransaction);

			}

		// Move to Connecting state

		iState = EConnecting;

		} break;

	case EIdleConnected:

		{

		// A connection is already established with the appropriate host and it

		// is currently not being used by any other transaction. Check to see if

		// an upgrade to a secure connection is required.

		if( iConnectionInfo->IsSecure() && !secure )

			{

			// Upgrade the connection to be secure.

			UpgradeConnectionL();

			}

		else 

			{

			// Move to Connected state and notify the current request to start.

			// Specifies that this transaction is waiting to write its

			// request to the supposedly connected connection. Due timing issues

			// the server may have closed connection but connection manager has

			// not been notified yet.

			iState = EConnected;

			iFlags.Set(EPendingWriteInConnectedState);

			iCurrentRequest->StartRequest();

			}

		} break;

	case EConnecting:

		{

		__ASSERT_DEBUG( !CannotPipeline(), User::Invariant() );

		// Can only submit in this state is a transaction is being pipelined and 

		// pipelining is enabled. A connection is being established with the 

		// appropriate host for an earlier request. Do nothing.

		} break;

	case EConnected:

		{

		__ASSERT_DEBUG( !CannotPipeline(), User::Invariant() );

		// Can only submit in this state is a transaction is being pipelined and 

		// pipelining is enabled. A connection has already been establised with 

		// the appropriate host but is currently being used by other transactions.

		// Check to see if this request is now the current request.

		if( iCurrentRequest == &aRequest )

			{

			// It is - start the request...

			iCurrentRequest->StartRequest();

			}			

		} break;

	case EUpgrading:

		{

		__ASSERT_DEBUG( !CannotPipeline(), User::Invariant() );

		// Can only submit in this state is a transaction is being pipelined and 

		// pipelining is enabled. A connection has already been established with

		// the appropriate host and is currently being upgraded to be secure. Do 

		// nothing. 

		} break;

	default:

		User::Invariant();

		break;

		}

	}

CHttpConnectionManager::TConnectionStatus CHttpConnectionManager::Status() const

	{

	// Check the state for correct status value.

	CHttpConnectionManager::TConnectionStatus status;

	switch( iState )

		{

	case EIdle:

	case EClosing:

		{

		status = ENotConnected;

		} break;

	case EIdleConnected:

		{

		status = EConnectedAndAvailable;

		} break;

	case EConnecting:

	    {

	    if(iEnableOptimalPipeline)

	        {

	        status = EConnectingNotAvailable;

	        break;

	        }

	    }

	case EUpgrading:

	case EConnected:

	default:

		{

		// Number of requests is the number of Pending Responses + the current response

		TInt numberResponses = iPendingResponses.Count();

		if (iCurrentResponse != NULL)

			{

			numberResponses +=1;

			}

		if( (!CannotPipeline() && !iConnectionInfo->IsNonPersistent()) &&

			numberResponses < iMaxTransactionsToPipeline)

			{

			// The connection can be used to pipeline requests - connect and busy.

			status = EConnectedAndBusy;

			}

		else 

			{

			// Other states, connected and not available.

			status = EConnectedNotAvailable;

			}

		}

		break;

		}

	return status;

	}

const CHttpConnectionInfo& CHttpConnectionManager::ConnectionInfo() const

	{

	return *iConnectionInfo;

	}

void CHttpConnectionManager::CancelSubmission(MHttpRequest& aRequest, MHttpResponse& aResponse)

	{

	__FLOG_0(_T8("!! Cancel submission"));

	// If the request has not yet been sent, then just remove the request and

	// response from the pending queues. Everything can carry on as normal. But

	// the request is in the process of being sent or has already been sent and

	// is waiting for a response, then need to close the connection, notifying

	// the other responses of the connection closure.

	TInt requestIndex = FindRequest(aRequest);

	TInt responseIndex = FindResponse(aResponse);

	TBool stopConnection = EFalse;

	if( requestIndex != KErrNotFound )

		{

		__ASSERT_DEBUG( responseIndex != KErrNotFound, User::Invariant() );

		// The request has not been made - just need to remove the request and

		// response objects from the pending queues.

		iPendingRequests.Remove(requestIndex);

		}

	else if( responseIndex != KErrNotFound )

		{

		// The request has been sent but the response has not yet been received

		// and therefore need to stop the connection and remove response from 

		// the pending queue.

		iPendingResponses.Remove(responseIndex);

		stopConnection = ETrue;

		}

	// Is this request/response active?

	if( stopConnection || iCurrentRequest == &aRequest || iCurrentResponse == &aResponse )

		{

		// Yep - need to stop the connection. Check state as could be still

		// trying to connect.

		if( iState == EConnecting )

			{

			__FLOG_4(

					_T8("-> stopping connection to host %S, remote port %d (secure : %d, nonpersistent : %d)"), 

					&iConnectionInfo->Host(), 

					iConnectionInfo->Port(), 

					iConnectionInfo->IsSecure(), 

					iConnectionInfo->IsNonPersistent()

					);

			// Stop the connection - move to Idle state

			iSocketConnector->StopConnect();

			iSocketConnector = NULL;

			SetIdleState();				

			}

		else

			{

			// As the connection had been established, then the request/response 

			// could be in progress - cancel them.

		   if( iCurrentRequest && iCurrentRequest == &aRequest)

				{

				__FLOG_0(_T8("-> cancelling request"));

				iCurrentRequest->CancelRequest();

				}

		   if( iCurrentResponse == NULL && iPendingResponses.Count() == 0 )

				{

				iCurrentResponse = &aResponse;	

				}

		   if( iCurrentResponse && iCurrentResponse == &aResponse )

				{

			   __FLOG_0(_T8("-> completing response"));

				DoResponseCompletion ();

				__FLOG_0(_T8("-> cancelling response"));

				iCurrentResponse->CancelResponse();	

				// Need connection closure?

				if ( stopConnection || 

					( iCurrentResponse && iCurrentResponse == &aResponse && !iCurrentResponse->ResponseCompleted () ) )

					{

					__FLOG_4(

							_T8("-> closing connection to host %S, remote port %d (secure : %d, nonpersistent : %d)"), 

							&iConnectionInfo->Host(), 

							iConnectionInfo->Port(), 

							iConnectionInfo->IsSecure(), 

							iConnectionInfo->IsNonPersistent()

							);

					CloseConnection ();												

					}

				else

					{

					ResponseDataParsed ();						

					}

				}				

			}

			if (  iCurrentResponse && iState == EIdle )

				{

					if ( stopConnection )

						{

						__FLOG_0(_T8("-> Notifying current and pending transactions"));

						// The current transaction was not the one to cancel - need to

						// notify it. This request has already sent and no response has been received.

						// Need to resend the request to maintain the correct request/response state

						// which is needed by the request/response composer/parser.

						iCurrentResponse->ConnectionError(KErrHttpNonPipeliningError);

						}

						NotifyPendingTransactions(KErrHttpNonPipeliningError);

						// Current request and response are no longer valid				

						iCurrentRequest = NULL;

						iCurrentResponse = NULL;				

					return; 				

				}

			if ( iState == EIdle && iPendingRequests.Count() > 0 )

				{				

				// connection is closed explicitly by the connection manager or not active. If we are 

				// having pending requests to be sent need to reconnect here.

				__FLOG_0(_T8("-> Reconnecting and sending the first pending request."));

				// Set the current request & response

				iCurrentRequest = iPendingRequests[0];

				iCurrentResponse = iPendingResponses[0];

				// Remove it from the pending queue

				iPendingRequests.Remove (0);

				iPendingResponses.Remove (0);			

				// Now do a reconnect

				TRAPD ( err, ReconnectSocketL () );

				if ( err != KErrNone )

					{

					ReportSocketError ( err );

					}

				return; 

				}

			if ( iCurrentRequest && iCurrentRequest == &aRequest )					

				{

				iCurrentRequest = NULL;

				}

			if ( iCurrentResponse && iCurrentResponse == &aResponse )					

				{

				iCurrentResponse = NULL;			

				}				

		}

	else if( CannotPipeline() && !iCurrentRequest && !iCurrentResponse )

 	    {

			// Closing the connection since pipelining has been disabled and both the request and 

		    // response have been completed.

	   __FLOG_4(

			   _T8("-> closing connection to host %S, remote port %d (secure : %d, nonpersistent : %d)"), 

			   &iConnectionInfo->Host(), 

			   iConnectionInfo->Port(), 

			   iConnectionInfo->IsSecure(), 

			   iConnectionInfo->IsNonPersistent()

			   );

		 CloseConnection();

		}	

	// Otherwise - do nothing. This submission has already completed.

#if defined (_DEBUG) && defined (_LOGGING)

	__FLOG_0(_T8("-> This submission has already completed. Do nothing"));

#endif

	}

const CX509Certificate* CHttpConnectionManager::ServerCert()

	{

	__ASSERT_DEBUG( iOutputStream != NULL, User::Invariant() );

	return iOutputStream->ServerCert();

	}

TInt CHttpConnectionManager::CipherSuite(TDes8& aCipherSuite)

	{

	__ASSERT_DEBUG( iOutputStream != NULL, User::Invariant() );

	return iOutputStream->CipherSuite(aCipherSuite);

	}

void CHttpConnectionManager::TunnelConnection(RStringF aHost)

	{

	__ASSERT_DEBUG( iState == EConnected, User::Invariant() );

	// Copy the host information (includes port info) for where the tunnel leads.

	iTunnelHost.Close();

	iTunnelHost = aHost.Copy();

	iTunnel = ETrue;

	__FLOG_0(_T8("!! Tunnel establised"));

	__FLOG_5(

			_T8("-> tunnel to %S via host %S, remote port %d (secure : %d, nonpersistent : %d)"),

			&iTunnelHost.DesC(), 

			&iConnectionInfo->Host(), 

			iConnectionInfo->Port(), 

			iConnectionInfo->IsSecure(), 

			iConnectionInfo->IsNonPersistent()

			);

	}

TBool CHttpConnectionManager::TunnelMatches(RStringF aHost) const

	{

	return (iTunnel && iTunnelHost == aHost);

	}

void CHttpConnectionManager::CloseConnection()

	{

	if( iInputStream )

		{

		// Flag that connection

		iState = EClosing;

		// Close the input stream	

		iInputStream->Close();

		iInputStream = NULL;

		}

	// NOTE - there is no need to close the output stream as by closing the

	// input stream it would have been notified and closed anyway. Also, the

	// state should have moved to Idle.

	__ASSERT_DEBUG( iState == EIdle, User::Invariant() );

	}

void CHttpConnectionManager::UpgradeConnectionL()

	{

	__ASSERT_DEBUG( iOutputStream != NULL, User::Invariant() );

	__FLOG_0(_T8("!! Upgrading to secure"));

	// Request upgrade to a secure connection - move to Upgrading state.

	TPtrC8 host;

	if( iTunnel )

		{

		__FLOG_5(