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

#include <httperr.h>

#include <httpstringconstants.h>

#include "cupnprequestparser.h"

#include "tupnpmessagepanic.h"

_LIT8(KHeaderSeparator,	"\n");

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

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

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CUpnpRequestParser::CUpnpRequestParser(MParserObserver& aObserver)

	:iObserver(aObserver)

	{

	}

EXPORT_C CUpnpRequestParser::~CUpnpRequestParser()

	{

	iMessageParser.Close();

	iBodyParts.Close();

	if(!iMsgBuf.IsEmpty())

		{

		iMsgBuf.Free();	

		}

	iRawDataArray.Close();

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

	__FLOG_CLOSE;

	}

void CUpnpRequestParser::ConstructL()

	{

	iMessageParser.OpenL(*this);

	__FLOG_OPEN(KSubsys, KComponent);

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

	}

TBool CUpnpRequestParser::GetNextDataPart(TPtrC8& aDataPart)

	{

	__FLOG(_L8("-> Supplying request 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 CUpnpRequestParser::ReleaseData()

	{

	__FLOG(_L8("-> Releasing request 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 CUpnpRequestParser::OverallDataSize()

	{

	return (iOverallDataSize < 0) ? KErrNotFound : iOverallDataSize;

	}

TInt CUpnpRequestParser::Reset()

	{

	return KErrNotSupported;

	}

void CUpnpRequestParser::GetDataPacket(TPtrC8& aData)

	{

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

	aData.Set(iRawDataArray[0]);

	iRawDataArray.Remove(0);

	}

void CUpnpRequestParser::ReleaseDataPacket()

	{

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

	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 CUpnpRequestParser::StartLineL(const TDesC8& aStartLine)

	{	

	// From RFC 2616 Sec 5.1 Request-Line   = Method SP Request-URI SP HTTP-Version CRLF

	// Request-Line == Start-Line

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

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

	TPtrC8 startLinePtr ( aStartLine );

	// Find the first space.

	TInt pos = startLinePtr.Locate ( ' ' );

	User::LeaveIfError ( pos );

	// Extract the method

	TPtrC8 method ( startLinePtr.Left ( pos ) );

	InetProtTextUtils::RemoveWhiteSpace ( method, InetProtTextUtils::ERemoveBoth );

	// Now move past the space that we located

	startLinePtr.Set ( startLinePtr.Mid ( pos + 1 ) );

	// Locate the next space.

	pos = startLinePtr.Locate ( ' ' );

	User::LeaveIfError ( pos );

	// Extract the request URI

	TPtrC8 requestUri ( startLinePtr.Left ( pos ) );

	InetProtTextUtils::RemoveWhiteSpace ( requestUri, InetProtTextUtils::ERemoveBoth );

	TUriParser8 uriParser;

	User::LeaveIfError ( uriParser.Parse ( requestUri ) );

	// Now move past the space that we located

	startLinePtr.Set ( startLinePtr.Mid ( pos + 1 ) );

	// Extract the version

	TPtrC8 versionPtr ( startLinePtr );

	if ( versionPtr.Length () == 0 )

		User::Leave ( KErrCorrupt );

	InetProtTextUtils::RemoveWhiteSpace ( requestUri, InetProtTextUtils::ERemoveBoth );

	RStringPool sp = iRequest->StringPool();

	pos = versionPtr.Locate('/');

	if( pos == KErrNotFound )

		User::Leave(KErrCorrupt);

	versionPtr.Set(versionPtr.Mid(pos + 1));

	// Extract the major version number

	TInt major;

	pos = InetProtTextUtils::ConvertDescriptorToInt(versionPtr, major);

	User::LeaveIfError(pos);

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

	versionPtr.Set(versionPtr.Mid(pos + 1));

	// Extract the minor version number

	TInt minor;

	pos = InetProtTextUtils::ConvertDescriptorToInt(versionPtr, minor);

	User::LeaveIfError(pos);

	RStringF methodStr = sp.OpenFStringL ( method );

	CleanupClosePushL(methodStr);

	RRequest request = iRequest->Handle ();

	request.SetMethod ( methodStr );

	request.SetURIL ( uriParser );

	TVersion version ( major, minor, 0);	

	request.SetVersion ( version );

	CleanupStack::PopAndDestroy(&methodStr);

	}

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

	{

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

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

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

	CleanupClosePushL(name);

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

	CleanupStack::PopAndDestroy(&name);

	}

TInt CUpnpRequestParser::BodySizeL()

	{

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

	iObserver.GotHeaders();

	//First check for a Transfer-Encoding header field.

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

	THTTPHdrVal value;

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

	if( iRequest->Handle().GetHeaderCollection().GetField(name, 0, value) == KErrNone )

		{

		// It exists - what's the value?

		if( 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.

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

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

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

			iOverallDataSize = MHttpMessageParserObserver::EChunked;

			}

		}

	else

		{

		// Transfer-Encoding header was not present - now check for a 

		// Content-Length header.

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

		TInt err = iRequest->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("-> Request body length = %d"), iOverallDataSize);

			}

		}

	return iOverallDataSize;	

	}

void CUpnpRequestParser::BodyChunkL(const TDesC8& aData)

	{

	__FLOG(_L8("-> Got request 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 CUpnpRequestParser::BodyCompleteL()

	{

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

	iFlags |= EBodyComplete;

	}

void CUpnpRequestParser::MessageCompleteL(const TPtrC8& aExcessData)

	{

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

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

		{

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

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

		iFlags |= EExcessData;

		}

	else

		{

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

		}

	// Post a message to the sender with aExcessData as the payload

	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);	

	iObserver.ParsingComplete(iMsgBuf);

	}

TInt CUpnpRequestParser::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 CUpnpRequestParser::ParseRequest(RMemChunk& aMessage, CRequest* aRequest)

	{

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

	__ASSERT_DEBUG(aRequest, TUPnPMessagePanic::Panic(TUPnPMessagePanic::EMissingRequest));

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

	iRequest = aRequest;

	if(!iMsgBuf.IsEmpty())

		{

		iMsgBuf.Init();	

		}

	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 CUpnpRequestParser::ResetParser()

	{

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

	iMsgBuf.Init();

	iMessageParser.Reset();

	iRawDataArray.Reset();

	iBodyParts.Reset();

	iOverallDataSize = 0;

	iFlags &= ~EExcessData;

	}