// 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 <httpstringconstants.h>

#include <httperr.h>

#include <http/thttptable.h>

#include <upnp/tupnptable.h>

#include "httpserverhandler.h"

#include "httpserver.h"

#include "httpevent.h"

#include "upnpserverconstants.h"

#include "upnplog.h"

#include "upnpmemoryutils.h"

const TUint KRecvTimeOutVal = 30000000; // 30secs

__FLOG_STMT(_LIT8(KComponent,"Flow");)

CHttpServerHandler* CHttpServerHandler::NewL ( RInternalSocket& aSocket, RMemChunk& aData, CServiceInfoArray& aServiceInfos, CServerHandlerArray& aServerHandlers, CHeaderCodec& aCodec, RStringPool& aStringPool, CChunkManager* aChunkMgr )

	{

	CHttpServerHandler* self = new ( ELeave ) CHttpServerHandler ( aSocket, aData, aServiceInfos, aServerHandlers, aCodec, aStringPool, aChunkMgr );

	CleanupStack::PushL ( self );

	self->ConstructL ();

	CleanupStack::Pop (); // self

	return self;

	}

void CHttpServerHandler::ConstructL ()

	{

	CProtocolHandler::ConstructL ();

	iRequestParser = CUpnpRequestParser::NewL ( *this );

	iResponseComposer = CUpnpResponseComposer::NewL ( *this );

	StartNewTransactionL ();

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("Created CHttpServerHandler")));

	}

CHttpServerHandler::~CHttpServerHandler ()

	{

	if ( !iReceivedData.IsEmpty() )

		iReceivedData.Free ();

	delete	iRequestParser;

	delete	iResponseComposer;	

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("Destroyed CHttpServerHandler")));

	}

CHttpServerHandler::CHttpServerHandler ( RInternalSocket& aSocket, RMemChunk& aData, CServiceInfoArray& aServiceInfos, CServerHandlerArray& aServerHandlers, CHeaderCodec& aCodec, RStringPool& aStringPool, CChunkManager* aChunkMgr )

: CProtocolHandler (aSocket ),

iServiceInfos ( aServiceInfos ),

iServerHandlers ( aServerHandlers ),

iServerCodec ( aCodec ),

iStringPool ( aStringPool )

	{

	iSocketHandler.Attach ( iSocket );

	iAllocator.SetChunkManager(aChunkMgr);

	iReceivedData.Assign( aData );

	}

// MParserObserver

void CHttpServerHandler::GotHeaders ()

	{

	CServerTransaction& trans = LastTransaction ();

	RRequest request = trans.Request ()->Handle ();

	RStringF hostStr = trans.Request ()->StringPool().StringF(HTTP::EHost, THTTPTable::Table());

	if(!HttpRequestUtils::IsConnectionRequired( *( trans.Request () ) ))

		trans.SetClosing();

	TRAPD ( err, HttpRequestUtils::ValidateL ( *( trans.Request () ) ) );

	if ( err == KErrNone )

		{

		// Notify the flow that the headers are received

		THTTPEvent evt (THTTPEvent::EGotRequestHeaders);

		NotifyEvent ( evt );

		}

	else

		{

		TInt statusCode = KErrNone;;

		switch ( err )

			{

			case KErrNotSupported:

			statusCode = HTTPStatus::ENotImplemented;

			break;

			case KErrCorrupt:

			statusCode = HTTPStatus::EBadRequest;

			break;

			default:

			// Internal server error

			statusCode = HTTPStatus::EInternalServerError;

			break;

			}

		CHttpServerHandler::CreateResponse ( *(trans.Response()), statusCode, this );

		trans.SetReadyToSend ();

		trans.SetClosing ();

		// We have an error and we no longer parse

		iRequestParser->ResetParser ();

		// If this is the only transaction we can compose the response.

		if ( &LastTransaction () == &CurrentTransaction () )

			{

			CurrentTransaction ().SetComposing ( ETrue );

			iResponseComposer->ComposeResponse ( trans.Response () );

			}

		}

	}

void CHttpServerHandler::GotBodyData ()

	{

	THTTPEvent evt( THTTPEvent::EGotRequestBodyData );

	NotifyEvent ( evt );

	}

void CHttpServerHandler::DataParsed ()

	{	

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::DataParsed")));

	// Reset parser on completion one parsing successfully.

	if ( !LastTransaction ().Parsing () )

		{

		iRequestParser->ResetParser ();

		}

	// Handle excess data & start new transaction

	if ( !iReceivedData.IsEmpty() )

		{

		// Start a new transaction with the pending data. We are getting pipelined request

		StartNewTransaction ();

		// Free up the data that we received

		iReceivedData.Free ();

		}

	else

		{

		iSocketHandler.Recv ();

		iTimer->StartTimer ( KRecvTimeOutVal );

		}

	}

void CHttpServerHandler::ParsingComplete ( RMemChunk& aExcessData )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::ParsingComplete")));

	// Notify the flow that our request is complete

	THTTPEvent evt( THTTPEvent::ERequestComplete );

	NotifyEvent ( evt );

	LastTransaction ().SetParsing ( EFalse );

	if ( !aExcessData.IsEmpty () )

		iReceivedData.Append ( aExcessData );

	if ( Error () == KErrNone )

		{

		// Check do we have to send the response for our first transaction. This typically happens

		// in the case of URI not found

		CServerTransaction& currentTrans = CurrentTransaction ();

		if ( currentTrans.ReadyToSend ()

				&& !currentTrans.Composing () )

			{

			CurrentTransaction ().SetComposing ( ETrue );

			iResponseComposer->ComposeResponse ( currentTrans.Response () );

			}

		}

	else if ( Error () != KErrNone && iTransactions.Count () == 0 )

		{

		// We give a chance to send any pending responses

		DestroySelf ();

		}

	}

void CHttpServerHandler::ParserError ( TInt aError )

	{

	// If we got a parser error we should see whether we had more than one transaction.

	// Yes? Then we should wait for the previous transactions completion then

	// close the connection.

	// No? we just cleanup ourself. We will not send any response as we got an invalid request

	// and we have no previous transactions.

	// Note: The above is what we have to do... But for now Cleanup ourself by doing nothing

	SetError ( aError );

	DestroySelf ();	 // ... more

	}

// MComposerObserver

void CHttpServerHandler::MessageDataReadyL ( RBuf8& aData )

	{

	RMBufChain sendData;

	sendData.CreateL(aData);

	iSocketHandler.Send ( sendData );

	}

void CHttpServerHandler::ComposingConcluded ()

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::ComposingConcluded")));

	iResponseComposer->ResetComposer ();

	TBool needToClose = CurrentTransaction ().IsClosing ();

	// Delete the first transaction

	DeleteTransaction ( iTransactions[0] );

	// Check we should close the connection once we sent response to this transaction

	if ( needToClose )

		{

		DestroySelf ();

		return;

		}

	if ( iTransactions.Count () > 0 )

		{

		// Check the next transaction is ready to send

		CServerTransaction& trans = CurrentTransaction ();

		if ( trans.ReadyToSend () )

			{

			CurrentTransaction ().SetComposing ( ETrue );

			iResponseComposer->ComposeResponse ( trans.Response () );

			}

		}

	}

void CHttpServerHandler::ComposerError ( TInt aError )

	{

	// Now we have an error. We just cleanup ourself

	SetError ( aError );

	DestroySelf ();

	}

void CHttpServerHandler::SendComplete ( TInt /* aLength */ )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::SendComplete")));

	CurrentTransaction ().SetComposing ( EFalse );

	iResponseComposer->ResponseDataSent	();

	}

void CHttpServerHandler::RecvComplete ( RMBufChain& aData )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::RecvComplete")));

	iTimer->StopTimer ();

	RMemChunk memChunk;

	TUPnPMemoryUtils::CreateMemChunk(memChunk, aData, iAllocator);

	iReceivedData.Append ( memChunk );	

	// Check we have some transactions to give the received data or should we create a new one

	if ( iTransactions.Count () > 0 && LastTransaction ().Parsing () )

		{

		iRequestParser->ParseRequest ( iReceivedData, LastTransaction ().Request () );

		// parser takes ownership of aData, so it can be cleaned-up

		iReceivedData.Free ();

		return;

		}

	StartNewTransaction ();

	if ( Error () != KErrNone && iTransactions.Count () == 0 )

		{

		// We give a chance to send any pending responses

		DestroySelf ();

		}

	aData.Free();

	}

void CHttpServerHandler::TimeOut ()

	{

	if ( iTransactions.Count () > 0 )		

		{

		CServerTransaction& trans = CurrentTransaction ();

		if ( trans.Parsing () )

			{

			// reset the request parser that is waiting for more data

			iRequestParser->ResetParser ();

			trans.SetParsing ( EFalse );

			//create reponse with 408 status code

			CHttpServerHandler::CreateResponse ( *( trans.Response () ), KRequestTimeoutStatusCode, this );

			trans.SetReadyToSend ();

			trans.SetComplete ();

			// trigger compose self start event for the timed-out transaction

			THTTPEvent evt ( THTTPEvent::ECompleteResponse );

			OnHttpEvent ( iTransactions[0], evt );

			}

		}

	else

		{

		// no transactions are pending,simply make self destroy.

		DestroySelf ();

		}

	}

void CHttpServerHandler::Error ( TOperation /*aOperation*/, TInt aError  )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::Error - %D"), aError));

	// This is a socket error. We cannot do anything here.

	// We just cleanup ourself

	SetError ( aError );

	iResponseComposer->DataSentFailed ();		

	iResponseComposer->ResetComposer ();

	iRequestParser->ResetParser ();

	iSocketHandler.CancelAll ();	

	TInt i = iTransactions.Count () - 1;

	while ( i >= 0 )

		{

		CTransaction* trans = iTransactions[i];

		if ( trans->Complete () )

			{

			iTransactions.Remove ( i );

			delete trans;

			}

		--i;

		}

	DestroySelf ();

	}

CServerTransaction& CHttpServerHandler::CurrentTransaction () const

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::CurrentTransaction")));

	__ASSERT_DEBUG ( iTransactions.Count () > 0, User::Invariant () );

	return static_cast < CServerTransaction& > ( *( iTransactions[0] ) );

	}

CServerTransaction& CHttpServerHandler::LastTransaction () const

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::LastTransaction")));

	TInt count = iTransactions.Count ();

	__ASSERT_DEBUG ( count > 0, User::Invariant () );

	return static_cast < CServerTransaction& > ( *( iTransactions[ count - 1 ]  ) );

	}

void CHttpServerHandler::NotifyEvent ( THTTPEvent& aEvent )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::NotifyEvent")));

	CServerTransaction& trans = LastTransaction ();

	// Ensure that the flow still exists

	CRequest* request = trans.Request ();

	TInt pos = iServiceInfos.MatchServiceUri ( request->Handle ().URI (), HttpRequestUtils::HostStr ( *request ) );

	if ( pos == KErrNotFound )

		{

		if ( !trans.Composing () )

			{

			CHttpServerHandler::CreateResponse ( *( trans.Response () ), HTTPStatus::ENotFound, this );

			trans.SetReadyToSend ();

			}

		}

	else if ( !trans.Complete () ) // Server flow on validation failure, 

								   // completes the transaction after creating error response

								   // so no need to push ERequestComplete Event to ServerFlow.

								   // start composing error response

		{

		CServiceInfo& info = iServiceInfos [ pos ];

		info.Observer ().OnHttpEvent ( &trans, aEvent );

		}

	}

void CHttpServerHandler::CreateResponse ( CResponse& aResponse, TInt aStatusCode, MHttpEventObserver* aServerHandler )

	{

	TRAPD ( err, CHttpServerHandler::CreateResponseL ( aResponse, aStatusCode ) );

	if ( err != KErrNone )

		{

		RResponse response = aResponse.Handle ();

		response.SetStatusCode ( HTTPStatus::EInternalServerError );

		// Should be changed once the status text us moved to te string table

		RStringF responseTextString;

		responseTextString = aResponse.StringPool().StringF ( UPnP::EInternalServerError, TUPnPTable::Table() );

		response.SetStatusText ( responseTextString );

		if ( aServerHandler != NULL )

			{

			CHttpServerHandler& handler = static_cast < CHttpServerHandler& > ( *aServerHandler );

			handler.SetError ( err );

			}

		}

	}

void CHttpServerHandler::CreateResponseL ( CResponse& aResponse, TInt aStatusCode )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::CreateResponse")));

	TVersion version ( KMajorVersion, KMinorVersion, 0 );

	RResponse response = aResponse.Handle ();

	RStringPool sp = aResponse.StringPool ();

	response.SetStatusCode ( aStatusCode );

	response.SetVersion ( version );

	// Add current date header

	RHTTPHeaders hdrs = response.GetHeaderCollection ();

	TTime time;

	time.UniversalTime();

	THTTPHdrVal timeHdrVal ( time.DateTime() );

	hdrs.SetFieldL ( aResponse.StringPool().StringF(HTTP::EDate, THTTPTable::Table() ), timeHdrVal );

	_LIT8 ( KServerName, "Symbian UPnP/1.0 server" );

	RStringF serverStr = sp.OpenFStringL ( KServerName () );

	THTTPHdrVal serverHdrVal ( serverStr );

	hdrs.SetFieldL ( sp.StringF ( HTTP::EServer, THTTPTable::Table() ), serverHdrVal );

	serverStr.Close ();

	if ( aStatusCode != HTTPStatus::EOk )

		{// Content Length

		hdrs.SetFieldL ( sp.StringF( HTTP::EContentLength, THTTPTable::Table() ), THTTPHdrVal ( 0 ) );

		}

	RStringF responseTextString;

	response.SetStatusText ( responseTextString );

	switch ( aStatusCode )

		{

		case HTTPStatus::EOk:

		responseTextString = sp.StringF ( UPnP::EOk, TUPnPTable::Table() );

		break;

		case HTTPStatus::ENotFound:

		responseTextString = sp.StringF ( UPnP::ENotFound, TUPnPTable::Table() );

		break;

		case HTTPStatus::EBadRequest:

		responseTextString = sp.StringF ( UPnP::EBadRequest, TUPnPTable::Table() );

		break;

		case HTTPStatus::EInternalServerError:

		responseTextString = sp.StringF ( UPnP::EInternalServerError, TUPnPTable::Table() );

		break;

		case HTTPStatus::ENotImplemented:

		responseTextString = sp.StringF ( UPnP::ENotImplemented, TUPnPTable::Table() );

		break;

		case HTTPStatus::EPreconditionFailed:

		responseTextString = sp.StringF ( UPnP::EPreconditionFailed, TUPnPTable::Table() );

		break;

		case HTTPStatus::EMethodNotAllowed:

		responseTextString = sp.StringF ( UPnP::EMethodNotAllowed, TUPnPTable::Table() );

		break;

		case HTTPStatus::EUnsupportedMediaType:

		responseTextString = sp.StringF ( UPnP::EUnsupportedMediaType, TUPnPTable::Table() );

		break;

		case KRequestTimeoutStatusCode:

		responseTextString = sp.StringF ( UPnP::ERequestTimeout, TUPnPTable::Table() );

		break;

		case KInvalidSeqStatusCode:

		responseTextString = sp.StringF ( UPnP::EMethodNotAllowed, TUPnPTable::Table() );

		break;

		default:

		ASSERT ( 0 );

		break;

		}

	response.SetStatusText ( responseTextString );

	}

void CHttpServerHandler::StartNewTransactionL ( )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::StartNewTransaction")));

	CServerTransaction* trans = CServerTransaction::NewL ( iServerCodec, iStringPool, *this );

	CleanupStack::PushL ( trans );

	User::LeaveIfError ( iTransactions.Append ( trans ) );

	CleanupStack::Pop (); // trans

	iRequestParser->ParseRequest ( iReceivedData, trans->Request () ); // Needs change

	iReceivedData.Free (); // Free up the data that we received, parser takes ownership

	trans->SetParsing ( ETrue );

	trans->Response()->Handle().SetBody ( *this ); // Set self as the response body supplier

	}

void CHttpServerHandler::StartNewTransaction ()

	{

	TRAPD ( err, StartNewTransactionL () );

	if ( err != KErrNone )

		{

		SetError ( err );

		}

	}

void CHttpServerHandler::DeleteTransaction ( CTransaction* aTrans )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::DeleteTransaction")));

	for ( TInt i = 0; i < iTransactions.Count (); ++i )

		{

		CTransaction* trans = iTransactions[i];

		if ( trans == aTrans )

			{

			iTransactions.Remove ( i );

			delete trans;

			return;

			}

		}

	}

TInt CHttpServerHandler::OnHttpEvent ( CTransaction* aTransaction, THTTPEvent& aEvent )

	{

	LOG(ESockLogExternal::Printf(KSubsysHttpSrvrHndlr, KComponent, _L8("CHttpServerHandler::OnHttpEvent")));

	CServerTransaction& trans = static_cast< CServerTransaction& > (*aTransaction);

	if ( Error ()

		|| aEvent == THTTPEvent::EFailed ) // ControlChannel transaction response is half send, so close it

		{

		if ( &trans == &CurrentTransaction () )

			{

			iResponseComposer->ResetComposer ();

			}

		DeleteTransaction ( aTransaction );

		TInt err = iError;

		DestroySelf ();

		return err;

		}