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

#include <httperr.h>

#include <rmemcell.h>

#include "cupnpresponseparser.h"

#include "tupnpmessagepanic.h"

_LIT8(KHeaderSeparator,	"\n");

__FLOG_STMT(_LIT8(KSubsys,"UPnPResParser");)

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

_LIT8(KHTTP, "HTTP");

EXPORT_C CUpnpResponseParser* CUpnpResponseParser::NewL(MParserObserver& aObserver)

	{

	CUpnpResponseParser* self = new(ELeave) CUpnpResponseParser(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CUpnpResponseParser::CUpnpResponseParser(MParserObserver& aObserver)

	:iObserver(aObserver)

	{

	}

EXPORT_C CUpnpResponseParser::~CUpnpResponseParser()

	{

	iMessageParser.Close();

	iBodyParts.Close();

	if(!iMsgBuf.IsEmpty())

		{

		iMsgBuf.Free();	

		}

	iRawDataArray.Close();

	__FLOG(_L8("-> Response parser destroyed"));

	__FLOG_CLOSE;

	}

void CUpnpResponseParser::ConstructL()

	{

	iMessageParser.OpenL(*this);

	__FLOG_OPEN(KSubsys, KComponent);

	__FLOG(_L8("-> Response parser created"));

	}

void CUpnpResponseParser::ResetData()

	{

	iMessageParser.Reset();

	iBodyParts.Reset();

	iOverallDataSize = 0;

	iFlags = 0;

	}

TBool CUpnpResponseParser::GetNextDataPart(TPtrC8& aDataPart)

	{

	__FLOG(_L8("-> Supplying response body part"));

	TInt bodyPartsCount = iBodyParts.Count();

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

	// Provide the first chunk.

	aDataPart.Set(iBodyParts[0]);

	__FLOG_1(_L8("%S"), &aDataPart);

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

	}

void CUpnpResponseParser::ReleaseData()

	{

	__FLOG(_L8("-> Releasing response body part"));

	// Remove the oldest chunk.

	if( iBodyParts.Count() > 0 )

		{

		iBodyParts.Remove(0);

		}

	// Are there any more chunks?

	if(iBodyParts.Count() > 0)	

		{

		// Notify the sender about the presence of the body. He can then call

		// MHTTPDataSupplier::GetNextDataPart() to get the body data.

		iObserver.GotBodyData();

		}

	else

		{

		// Does this data packet need to be released?

		if( NotifyReleaseData() )

			{

			// Notify sender that the current data is no longer needed.

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

			// client.

			iObserver.DataParsed();

			iFlags &= ~ENotifyReleaseData;

			}

		}

	}

TInt CUpnpResponseParser::OverallDataSize()

	{

	return (iOverallDataSize < 0) ? KErrNotFound : iOverallDataSize;

	}

TInt CUpnpResponseParser::Reset()

	{

	return KErrNotSupported;

	}

void CUpnpResponseParser::GetDataPacket(TPtrC8& aData)

	{

	__FLOG(_L8("-> Supplying response data to the HTTP message parser"));

	aData.Set(iRawDataArray[0]);

	iRawDataArray.Remove(0);

	}

void CUpnpResponseParser::ReleaseDataPacket()

	{

	__FLOG(_L8("-> Releasing response data"));

	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.

		ResetData();

		iMessageParser.ReceivedMessageData();		 

		}

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

		{

		if(iRawDataArray.Count() > 0 && !IsExcessData())

			{

			iMessageParser.ReceivedMessageData();

			}

		else

			{

			// Notify sender that the current data is no longer needed.

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

			// client.

			iObserver.DataParsed();

			}

		}

	else

		{

		// Flag that the data needs to be released

		iFlags |= ENotifyReleaseData;

		}

	}

void CUpnpResponseParser::StartLineL(const TDesC8& aStartLine)

	{

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

	// 

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

	//

	// First extract the HTTP-Version

	__FLOG(_L8("-> Got the reponse start line"));

	__FLOG_1(_L8("%S"), &aStartLine);

	TPtrC8 data = aStartLine;

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

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

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

	User::LeaveIfError(consumed);

	if((consumed > KHTTP().Length()) || (consumed < KHTTP().Length()))

		User::Leave(KErrCorrupt);

	TPtrC8 http = data.Left(consumed);

	if( http.CompareF(iResponse->StringPool().StringF(HTTP::EHTTP, THTTPTable::Table()).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);

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

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

	// Extract the minor version number

	TInt minor;

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

	User::LeaveIfError(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));

	// 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 the Status-Line info

	RStringF reason = iResponse->StringPool().OpenFStringL(data);

	RResponse response = iResponse->Handle();

	TVersion version(major, minor, 0);

	response.SetVersion(version);

	response.SetStatusCode(status);

	response.SetStatusText(reason);

	reason.Close();

	// Check to see if a body is expected

	if( HTTPStatus::IsInformational(status) )

		{

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

		iFlags |= EConsumingResponse;

		}

	}

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

	{

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

	__FLOG(_L8("-> Got header value pair"));

	__FLOG_2(_L8("%S: %S"), &aFieldName, &aFieldValue);

	if( !ConsumingResponse() )

		{

		RStringF name = iResponse->StringPool().OpenFStringL(aFieldName);

		CleanupClosePushL(name);

		iResponse->Handle().GetHeaderCollection().SetRawFieldL(name, aFieldValue, KHeaderSeparator);

		CleanupStack::PopAndDestroy(&name);

		}

	}

TInt CUpnpResponseParser::BodySizeL()

	{

	if( !ConsumingResponse() )

		{

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

		iObserver.GotHeaders();

		}

	// Check for a body...

	if( ConsumingResponse() ||	// this implies that the status code was 1xx - no body

		iResponse->Handle().StatusCode() == 204 || 

		iResponse->Handle().StatusCode() == 304 && 

		// if 2xx response...

		( HTTPStatus::IsSuccessful(iResponse->Handle().StatusCode()) ) )

		{

		// No entity body is expected as specified in RFC2616 section 4.4.

		iOverallDataSize = MHttpMessageParserObserver::ENoBody;

		iFlags |= EBodyComplete;

		__FLOG(_L8("-> Response has no body"));

		return iOverallDataSize;

		}

	// A body is expected - find the length. First check for a Transfer-Encoding

	// header field.

	iResponse->Handle().SetBody(*this);

	THTTPHdrVal value;

	RStringF name = iResponse->StringPool().StringF(HTTP::ETransferEncoding, THTTPTable::Table());

	TInt err = iResponse->Handle().GetHeaderCollection().GetField(name, 0, value);

	if( err != KErrNone && err != KErrNotFound )

		User::Leave(err);

	// It exists - what's the value?

	if( err == KErrNone && value.Type() == THTTPHdrVal::KStrFVal &&

		value.StrF().Index(THTTPTable::Table()) == HTTP::EChunked )

		{

		// The Transfer-Encoding header is Chunked and as the chunked

		// encoding is removed, we remove the header.

		iResponse->Handle().GetHeaderCollection().RemoveField(name);

		// As the entity body is chunked the overall data size is unknown.

		iOverallDataSize = MHttpMessageParserObserver::EChunked;

		__FLOG(_L8("-> Response has chunked body"));

		return iOverallDataSize;			

		}

	// Either no Transfer-Encoding header was present - now check for a 

	// Content-Length header.

	err = KErrNone;

	name = iResponse->StringPool().StringF(HTTP::EContentLength, THTTPTable::Table());

	err = iResponse->Handle().GetHeaderCollection().GetField(name, 0, value);

	if( err != KErrNone && err != KErrNotFound )

		User::Leave(err);

	if( err == KErrNone && value.Type() == THTTPHdrVal::KTIntVal )

		{

		// Content-Length header value specified the length of entity in bytes.

		iOverallDataSize = value.Int();

		__FLOG_1(_L8("-> Response body length = %d"), iOverallDataSize);

		return iOverallDataSize;

		}

	// There was no Content-Length header either, so the server will signal the

	// end of the message by closing the connection - overall data size unknown.

	iOverallDataSize = MHttpMessageParserObserver::EUnknown;

	__FLOG(_L8("-> Response body size is unknown"));

	return iOverallDataSize;

	}

void CUpnpResponseParser::BodyChunkL(const TDesC8& aData)

	{

	__FLOG(_L8("-> Got response body chunk"));

	__FLOG_1(_L8("%S"), &aData);

	iFlags |= EBodyPresent;

	if (aData.Length() > 0)

		{

		iBodyParts.Append(aData);

		}

	// Only notify the client that there is a body part if there is one.

	if(iBodyParts.Count() > 0)

		{

		// Notify the sender about the presence of the body. He can then call

		// MHTTPDataSupplier::GetNextDataPart() to get the body data.

		iObserver.GotBodyData();

		}

	}

void CUpnpResponseParser::BodyCompleteL()

	{

	__FLOG(_L8("-> Response body complete"));

	iFlags |= EBodyComplete;

	}

void CUpnpResponseParser::MessageCompleteL(const TPtrC8& aExcessData)

	{

	__FLOG(_L8("-> Message complete"));

	iFlags |= EMessageComplete;

	if ( aExcessData.Length() > 0 || iRawDataArray.Count() > 0 )

		{

		__FLOG(_L8("->Excess Data:"));

		__FLOG_1(_L8("%S"), &aExcessData);

		iFlags |= EExcessData;

		}

	else

		{

		__FLOG(_L8("-> No excess data"));

		}

	TInt excessDataLen = aExcessData.Length();

	TInt count = iRawDataArray.Count();

	while(count > 0)

		{

		excessDataLen += iRawDataArray[count-1].Length();

		count--;

		}

	TInt lenToTrim = iMsgBuf.Length() - excessDataLen;

	iMsgBuf.TrimStart(lenToTrim);

	if( !ConsumingResponse() )

		{

		iObserver.ParsingComplete(iMsgBuf);

		}

	else

		{

		// There could be excess data - this data is for this response and needs

		// to be parsed. Set it as the raw data.

		iRawDataArray.Reset();

		TPtrC8 rMBufPtr;

		RMemCell* rMBuf;

		TMemCellIterator mBufIter(iMsgBuf);

		while((rMBuf = mBufIter++) != NULL)

			{

			rMBufPtr.Set(rMBuf->Ptr(), rMBuf->Length());

			iRawDataArray.AppendL(rMBufPtr);

			}

		}

	}

TInt CUpnpResponseParser::HandleParserError(TInt aError)

	{

	__FLOG_1(_L8("-> HTTP message parser received error: %d"), aError);

	iRawDataArray.Reset();

	iBodyParts.Reset();

	iObserver.ParserError(aError);

	return KErrNone;

	}

EXPORT_C void CUpnpResponseParser::ParseResponse(RMemChunk& aMessage, CResponse* aResponse)

	{

	__FLOG(_L8("-> Parsing response"));

	__ASSERT_DEBUG(aResponse, TUPnPMessagePanic::Panic(TUPnPMessagePanic::EMissingResponse));

	__ASSERT_DEBUG(!aMessage.IsEmpty(), TUPnPMessagePanic::Panic(TUPnPMessagePanic::ENoMessage));

	iResponse = aResponse;

	if(!iMsgBuf.IsEmpty())

		{

		iMsgBuf.Free();	

		}

	iMsgBuf.Assign(aMessage);

	TPtrC8 rMBufPtr;

	RMemCell* rMBuf;

	TMemCellIterator mBufIter(iMsgBuf);

	TInt err = KErrNone;

	while((rMBuf = mBufIter++) != NULL)

		{

		rMBufPtr.Set(rMBuf->Ptr(), rMBuf->Length());

		err = iRawDataArray.Append(rMBufPtr);

		if(err != KErrNone)

			{

			HandleParserError(err);

			break;

			}

		}

	if(err == KErrNone)

		{

		// Initiate the message parser

		iMessageParser.ReceivedMessageData();

		}

	}

EXPORT_C void CUpnpResponseParser::ResetParser()

	{

	__FLOG(_L8("-> Response parser reset"));

	iMessageParser.Reset();

	iRawDataArray.Reset();

	iBodyParts.Reset();

	iOverallDataSize = 0;

	iFlags &= ~EExcessData;

	}