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

#include <inetprottextutils.h>

#include <httpstringconstants.h>

#include <http/rhttpheaders.h>

#include <http/framework/mrxdataobserver.h>

#include <httperr.h>

#include "chttpclienttransaction.h"

#include "chttpconnectionmanager.h"

#include "chttprequestcomposer.h"

#include "mhttpresponseobserver.h"

#include "thttpclientpanic.h"

#include "chttpconnectioninfo.h"

_LIT8(KHeaderSeparator,	"\n");

CHttpResponseParser* CHttpResponseParser::NewL(CProtTransaction& aProtTrans, MRxDataObserver& aObserver, MHttpResponseObserver& aResponseObserver)

	{

	CHttpResponseParser* self = new (ELeave) CHttpResponseParser(aProtTrans, aObserver, aResponseObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

CHttpResponseParser::~CHttpResponseParser()

	{

	iBodyParts.Reset();

	iMessageParser.Close();

//	__FLOG_CLOSE;

	}

CHttpResponseParser::CHttpResponseParser(CProtTransaction& aProtTrans, MRxDataObserver& aObserver, MHttpResponseObserver& aResponseObserver)

: CRxData(aProtTrans, aObserver), iStringTable(RHTTPSession::GetTable()), iResponseObserver(aResponseObserver)

	{

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

	}

void CHttpResponseParser::ConstructL()

	{

	iMessageParser.OpenL(*this);

	}

TInt CHttpResponseParser::CancelTransaction(TInt aError)

	{

	__FLOG_0(_T8("!! Cancelling transaction - internal error"));

	// Tell the connection manager to cancel this submission.

	CHttpClientTransaction& trans = static_cast<CHttpClientTransaction&>(*iProtTrans);

	CHttpConnectionManager* manager = trans.ConnectionManager();

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

	__FLOG_1(_T8("-> Trans %d : cancelling its connection manager"), iProtTrans->Transaction().Id());

	// Transaction is still alive - ask its connection manager to cancel it.

	MHttpRequest& request = static_cast<CHttpRequestComposer&>(iProtTrans->TxData());

	MHttpResponse& response = *this;

	manager->CancelSubmission(request, response);

	// Connection is now cancelled - remove the connection manager from the

	// transaction.

	trans.RemoveConnectionManager();		

	// Notify the rx-data observer that an error has occurred

	NotifyObserverError(aError);

	return KErrNone;

	}

void CHttpResponseParser::NotifyObserverError(TInt aError)

	{

	TRAPD( err, iObserver->SetStatusL(*this, aError) );

	if(err != KErrNone)

		{

		// Something has gone seriously wrong - fail the transaction

		iProtTrans->Transaction().Fail(THTTPFilterHandle::EProtocolHandler);

		}

	}

/*

 *	Methods from CRxData

 */

void CHttpResponseParser::ResetRxData()

	{

	iMessageParser.Reset();

	iBodyParts.Reset();

	iOverallDataSize = 0;

	iFlags = 0;

	}

/*

 *	Methods from MHTTPDataSupplier via CRxData

 */

TBool CHttpResponseParser::GetNextDataPart(TPtrC8& aDataPart)

	{

	TInt bodyPartsCount = iBodyParts.Count();

	__ASSERT_ALWAYS(bodyPartsCount > 0, THttpClientPanic::Panic(THttpClientPanic::ENoBodyPartInDataSupplier));

	// Provide the first chunk.

	aDataPart.Set(iBodyParts[0]);

	return (BodyComplete() && bodyPartsCount == 1);

	}

void CHttpResponseParser::ReleaseData()

	{

	// Remove the oldest chunk.

	if( iBodyParts.Count() > 0 )

		{

		iBodyParts.Remove(0);

		}

	// Are there any more chunks?

	if( iBodyParts.Count() > 0 )

		{

		// Yep - notify the client of more body data

		RHTTPTransaction trans = iProtTrans->Transaction();

		if(trans.SendEvent(THTTPEvent::EGotResponseBodyData, THTTPEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler)) != KErrNone)

			trans.Fail(THTTPFilterHandle::EProtocolHandler);

		}

	else

		{

		// Does this data packet need to be released?

		if( NotifyReleaseData() )

			{

			iResponseObserver.ResponseDataParsed();

			iFlags &= ~ENotifyReleaseData;

			}

		// Is the message complete?

		if( MessageComplete() )

			{

			// All the body data has been read by the client - this transaction 

			// is complete.			

			TRAPD(err, iObserver->SetStatusL(*this, THTTPEvent::EResponseComplete));

			if(err != KErrNone)

				iProtTrans->Transaction().Fail(THTTPFilterHandle::EProtocolHandler);

			}

		}

	}

TInt CHttpResponseParser::OverallDataSize()

	{

	return (iOverallDataSize < 0) ? KErrNotFound : iOverallDataSize;

	}

TInt CHttpResponseParser::Reset()

	{

	return KErrNotSupported;

	}

void CHttpResponseParser::OnResponseReceiveTimeOut ()

	{

	// Notify the client of Response Receive TimeOut.

	RHTTPTransaction trans = iProtTrans->Transaction();

	if(trans.SendEvent(THTTPEvent::EReceiveTimeOut, THTTPEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler)) != KErrNone)

		{

		trans.Fail(THTTPFilterHandle::EProtocolHandler);

		}

	else

		{

		// Notify the client that Transaction Failed.

	    if(trans.SendEvent(THTTPEvent::EFailed, THTTPEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler)) != KErrNone)

	        {

			trans.Fail(THTTPFilterHandle::EProtocolHandler);

	        }

		}

	}

TInt CHttpResponseParser::ReceiveTimeOutValue ()

	{

	RHTTPTransaction trans = iProtTrans->Transaction();

	RStringPool stringPool = trans.Session().StringPool();

	RStringF receiveTimeOut = stringPool.StringF(HTTP::EReceiveTimeOutValue, iStringTable);

	THTTPHdrVal receiveTimeOutVal;

	TBool ret = trans.PropertySet().Property(receiveTimeOut,receiveTimeOutVal); 

	if(ret && (receiveTimeOutVal.Type() == THTTPHdrVal::KTIntVal))

		{

		return receiveTimeOutVal.Int();

		}

	return 0;

	}

TBool CHttpResponseParser::ResponseInformational ()

	{

	return (HTTPStatus::IsInformational(iProtTrans->Transaction().Response().StatusCode()));

	}

/*

 *	Methods from MHttpResponse

 */	

void CHttpResponseParser::ResponseDataReceived(const TDesC8& aData)

	{

	__FLOG_2(_T8("Trans %d : parsing %d bytes of data"), iProtTrans->Transaction().Id(), aData.Length());

	iRawData.Set(aData);

	iMessageParser.ReceivedMessageData();		

	}

void CHttpResponseParser::CancelResponse()

	{

	__FLOG_1(_T8("-> Trans %d : response cancelled"), iProtTrans->Transaction().Id());

	iCancellingResponse = ETrue;

	RHTTPTransaction trans = iProtTrans->Transaction();

	RHTTPResponse response = trans.Response();

	iMessageParser.Flush ();		

	iMessageParser.Reset();

	iCancellingResponse = EFalse;	

	}

void CHttpResponseParser::ConnectionError(TInt aError)

	{

	// Check whether we need to resubmit this request once again.	

	CHttpClientTransaction* clientTrans = static_cast<CHttpClientTransaction*>(iProtTrans);

	if ( !clientTrans->NeedDisconnectNotification() && (iOverallDataSize != MHttpMessageParserObserver::EUnknown) 

			&& (clientTrans->RetryNeeded ()	&& ( aError == KErrEof || aError == KErrCancel || aError == KErrDisconnected ) ) )

		{

		if ( !clientTrans->ConnectionManager()->ConnectionInfo().IsNonPersistent () )

			aError = KErrHttpNonPipeliningError;

		}

	RHTTPTransaction trans = iProtTrans->Transaction();

	RHTTPResponse response = trans.Response();

	// Check there is a status code, no body and error status ( KErrEof & KErrDisconnected )

	if ( response.StatusCode() && !response.HasBody() && ( aError == KErrEof || aError == KErrDisconnected ) )

		{

		// Notify the client that all the response headers have been parsed.

		trans.SendEvent(THTTPEvent::EGotResponseHeaders, THTTPEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler));

		}

// Is the server closing the connection been expected?

	if( iOverallDataSize == MHttpMessageParserObserver::EUnknown && !BodyComplete() && 

				(aError == KErrEof || aError == KErrDisconnected) )

	{

	     __FLOG_1(_T8("Trans %d : waiting for connection close to mark end of response body"), iProtTrans->Transaction().Id());

			if (BodyPresent())

				{

				iFlags |= ( EMessageComplete | EBodyComplete ) ;

				// Append NULL to the body chunk 

				RHTTPTransaction trans = iProtTrans->Transaction();

				TInt err = iBodyParts.Append(TPtrC8());

                if ( err!=KErrNone ) 

                trans.Fail(THTTPFilterHandle::EProtocolHandler);

				// Notify the client that there is a body part 

				if(iProtTrans->Transaction().SendEvent(THTTPEvent::EGotResponseBodyData, 

                                                        THTTPEvent::EIncoming,

                                                        THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler)) != KErrNone)

				    {

				    trans.Fail (THTTPFilterHandle::EProtocolHandler);

				    }

		}

			else

				{

				// Yep, since from RFC2616 section 4.4 Message Length, the end of a 

				// response body can be determined by the server closing the connection

				// Notify the parser that the connection close has happened.

				TRAPD( err, iMessageParser.CompletedBodyDataL() );

				if( err != KErrNone )

					{

					// Something has gone seriously wrong - fail the transaction

					iProtTrans->Transaction().Fail(THTTPFilterHandle::EProtocolHandler);

					}

				}

			}

		else

			if ( clientTrans->NeedDisconnectNotification() )

				{

				CHttpRequestComposer& request = static_cast<CHttpRequestComposer&>(iProtTrans->TxData());

				// if we are consuming response then the request has been not sent fully.

				if ( ConsumingResponse () || !request.RequestSent() )

					aError = KErrHttpRequestNotSent;

				// Check if we received some response

				// Check for status code that means we received something as response

				// for this transaction				

				else if ( response.StatusCode () )					

					aError = KErrHttpPartialResponseReceived;

				else

					aError = KErrHttpResponseNotReceived;

				}

			// Notify the rx-data observer that an error has occurred

			   NotifyObserverError(aError);				

			}

		  }

/*

 *	Methods from MHttpMessageParserObserver

 */

void CHttpResponseParser::GetDataPacket(TPtrC8& aData)

	{

	aData.Set(iRawData);

	}

void CHttpResponseParser::ReleaseDataPacket()

	{

	if( ConsumingResponse() && MessageComplete() )

		{

		// Ok, the response was a 1xx message which has been consumed. Reset the

		// this object and continue parsing the next part of the response.

		ResetRxData();

		iMessageParser.ReceivedMessageData();		 

		}		

	else if( iBodyParts.Count() == 0 )

		{

		// Can release as there are no body chunks waiting to be passed to the

		// client.

		iResponseObserver.ResponseDataParsed();		

		}

	else

		{

		// Flag that the data needs to be released

		iFlags |= ENotifyReleaseData;

		}

	}

void CHttpResponseParser::StartLineL(const TDesC8& aStartLine)

	{

	__START_PERFORMANCE_LOGGER();

	// The RFC2616 defines the Status-Line as follows - 

	// 

	// Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF

	//

	// First extract the HTTP-Version

	TPtrC8 data = aStartLine;

	User::LeaveIfError(InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft));

	// HTTP-Version = "HTTP" "/" 1*DIGIT "." 1*DIGIT

	TInt consumed = data.Locate('/');

	User::LeaveIfError(consumed);

	RHTTPTransaction trans = iProtTrans->Transaction();

	RStringPool stringPool = trans.Session().StringPool();

	TPtrC8 http = data.Left(consumed);

	if( http.CompareF(stringPool.StringF(HTTP::EHTTP, iStringTable).DesC()) != 0 )

		User::Leave(KErrCorrupt);

	// Skip past the HTTP and "/"

	data.Set(data.Mid(consumed + 1));

	// Extract the major version number

	TInt major;

	consumed = InetProtTextUtils::ConvertDescriptorToInt(data, major);

	User::LeaveIfError(consumed);

    if( data.Length() > consumed )

		{

	    // Skip past major version number and the "."

	    data.Set(data.Mid(consumed + 1));

		}

	else

		{

		User::Leave(KErrCorrupt); 

		}

	// Extract the minor version number

	TInt minor;

	consumed = InetProtTextUtils::ConvertDescriptorToInt(data, minor);

	User::LeaveIfError(consumed);

	if( data.Length() > consumed )

		{

	    // Skip past minor version number and the SP

	    data.Set(data.Mid(consumed + 1));

	    // Clear any extra surrounding whitespace

	    User::LeaveIfError(InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveBoth));

		}

	else

		{

		 User::Leave(KErrCorrupt);

		}

	// Extract the status code

	TInt status;

	consumed = InetProtTextUtils::ConvertDescriptorToInt(data, status);

	User::LeaveIfError(consumed);

	if( data.Length() > consumed )

		{

		// Skip past status code and the SP

		data.Set(data.Mid(consumed + 1));

		// Remaining data is the status reason - trim any leading whitespace as right side already trimmed

		User::LeaveIfError(InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft));

		}

	else

		{

		// No reason phrase following the status code

		data.Set(KNullDesC8());

		}

	// Populate transaction with Status-Line info

	RStringF reason = stringPool.OpenFStringL(data);

	RHTTPResponse response = trans.Response();

	TVersion version(major, minor, 0);

	response.SetVersion(version);

	response.SetStatusCode(status);

	response.SetStatusText(reason);

	reason.Close();

	__FLOG_5(_T8("Trans %d : status-line -> HTTP/%d.%d %d %S"), iProtTrans->Transaction().Id(), major, minor, status, &response.StatusText().DesC());

	// Check to see if a body is expected

	if( HTTPStatus::IsInformational(status) )

		{

		// 1xx status - no body and need to consume this respons

		iFlags |= EConsumingResponse;

		__FLOG_1(_T8("Trans %d : informational 1xx status - consuming response"), iProtTrans->Transaction().Id());

		}	

		__END_PERFORMANCE_LOGGER(_L(",CHttpResponseParser::StartLineL()"));	

	}

void CHttpResponseParser::HeaderL(const TDesC8& aFieldName, TDesC8& aFieldValue)

	{

	// Only set the headers if we are not consuming the response.

	if( !ConsumingResponse() )

		{

		// Add the header to the response header collection

		RHTTPTransaction trans = iProtTrans->Transaction();

		RStringPool stringPool = trans.Session().StringPool();

		RStringF name = stringPool.OpenFStringL(aFieldName);

		CleanupClosePushL(name);

		RHTTPHeaders headers = trans.Response().GetHeaderCollection();

		headers.SetRawFieldL(name, aFieldValue, KHeaderSeparator);

		/**************************************************************************************

 		* DEF143319   - HTTPS page stops downloading between ~25 and 50 KBytes    

 		* When multiple requests are concatenated in ONE buffer and sent to the server,

 		* the WebLogic server does not process all requests.

 		* So pipelining feature has to be disabled.

 		* This fix enhances the robustness of HTTP stack to interoperate with different servers.

 		***************************************************************************************/

 		if (name.DesC().CompareF(stringPool.StringF(HTTP::EServer,RHTTPSession::GetTable()).DesC()) == KErrNone)

 		    {

             _LIT8(KWebLogicServerName,"WebLogic");

             if (aFieldValue.FindF(KWebLogicServerName)!= KErrNotFound)

                 {

                 RHTTPHeaders headReq = trans.Request().GetHeaderCollection();

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

                 THTTPHdrVal hostVal;

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

                     {

                     // No Host header

                     User::Leave(KErrHttpGeneralHeaderMissingHost);

                     }

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

                 CHttpClientTransaction& protTran = static_cast<CHttpClientTransaction&>(*iProtTrans);

                 CHttpConnectionManager* manager = protTran.ConnectionManager();

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

                     __FLOG_0(_T8("Pipelining is disabled for WebLogic Server- \n"));

                 #endif

                 manager->AppendPipelineFailedHost(hostVal.StrF().DesC());

                 }

		}