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

#include <http/mhttpdatasupplier.h>

#include <inetprottextutils.h>

#include "mhttpmessagecomposerobserver.h"

#include "thttpmessagepanic.h"

const TInt KDefaultBufferSize	= 128;

// 'this' used in base member initializer list, The 'this' pointer being used is a base class pointer.

#pragma warning( disable : 4355 )

CHttpMessageComposer* CHttpMessageComposer::NewL(MHttpMessageComposerObserver& aObserver)

/**

	Factory constructor. 

	@param		aObserver	The observer for the composer.

	@return		A pointer to a fully constructed and initialised object.

*/

	{

	return new (ELeave) CHttpMessageComposer(aObserver);

	}

CHttpMessageComposer::~CHttpMessageComposer()

/**

	Destructor

*/

	{

	Cancel();

	delete iDataBuffer;

	}

CHttpMessageComposer::CHttpMessageComposer(MHttpMessageComposerObserver& aObserver)

: CActive(CActive::EPriorityStandard + 1), iObserver(aObserver), iDataComposer(*this)

/**

	Constructor.

	We want the request/response to be sent/received and processed as early as possible to avoid the latency by keeping 

	it in the framework. We reduced the scheduling of AOs by 1/6th + 2 when composing and 1/5th + 2 for parsing the header. The value 2 

	indicates the EIdle state and the startline composing/parsing.

*/

	{

	CActiveScheduler::Add(this);

	}

void CHttpMessageComposer::MessageInfoAvailable()

/**

	Notifies the composer that more message info is available. The composer can

	continue composing the message.

	@pre		The composer is waiting for more message info.

	@post		The composer continues composing the message.

	@panic		EHttpMessagePanicBadDataState	The composer was not waiting for

												more info.

*/

	{

	__ASSERT_DEBUG( iDataState == EWaitingForInfo, THttpMessagePanic::Panic(THttpMessagePanic::EHttpMessagePanicBadDataState) ); 

	// Message info available - update data state and continue/start composing.

	iDataState = EGotInfo;

	CompleteSelf();

	}

void CHttpMessageComposer::GetMessageData(TPtrC8& aData)

/**

	Get the current message data.

	@panic		EHttpMessagePanicBadDataState	There is no current data buffer 

												ready.

	@pre		The observer has been notified of available message data.

*/

	{

	__ASSERT_DEBUG( iDataState == EWaitingForRelease, THttpMessagePanic::Panic(THttpMessagePanic::EHttpMessagePanicBadDataState) ); 

	aData.Set(iSendBuffer);

	}

void CHttpMessageComposer::ReleaseMessageData()

/**

	Release the message data. The observer has finished with the current message 

	data buffer. The composer can continue composing the message.

	@panic		EHttpMessagePanicBadDataState	There is no current data buffer 

												ready.

	@pre		The observer has been notified of available message data.

	@post		The composer continues composing the message.

*/

	{

	__ASSERT_DEBUG( iDataState == EWaitingForRelease, THttpMessagePanic::Panic(THttpMessagePanic::EHttpMessagePanicBadDataState) );

	// Is there an entity body?

	if (CheckMessagePendingComplete())

		{

		iObserver.MessageComplete();

		//The composer is done.

		iState = EIdle;

		}

	else

		{

		// Update data state and continue composing.

		iDataState = EGotInfo;

		CompleteSelf();

		}

	}

void CHttpMessageComposer::Reset()

/**

	Composer reset request. As the observer can reset the composer during one of

	the callback functions, the composer must check for re-entrancy to avoid 

	releasing resources that are still required. If the composer is either 

	waiting for more message info, waiting for its data part to be released or 

	is waiting to process its state machine, the composer can safely reset 

	immediately. Otherwise the composer is being reset from within its RunL() 

	and so it must defer resetting itself until a safer point - this is the 

	point in the RunL() where the next step is decided.

	@panic		EHttpMessagePanicDoubleReset	The composer has been reset twice

												in one of the callback functions.

*/

	{

	// Check the data state of the composer - the composer cannot be reset if 

	// the Reset() was called in one of the observer callbacks. It is safe to 

	// reset now if - 

	// 1) the data state is WaitingForInfo

	// 2) the data state is WaitingForRelease

	// 3) the composer is active - waiting to for its RunL() to be called.

	if( iDataState == EWaitingForInfo || iDataState == EWaitingForRelease || IsActive() )

		{

		// Cancel and do the reset.

		Cancel();

		DoReset();

		}

	else

		{

		// Debug check for a double Reset() call...

		__ASSERT_DEBUG( iDataState != EReset, THttpMessagePanic::Panic(THttpMessagePanic::EHttpMessagePanicDoubleReset) );

		// The Reset() was called inside a callback - defer reseting the composer

		// until call stack is back in the composer RunL().

		iDataState = EReset;

		}

	}

void CHttpMessageComposer::CompleteSelf()

/**

	Self-complete function. Ensures that the state machine is processed.

*/

	{

	TRequestStatus* pStat = &iStatus;

	User::RequestComplete(pStat, KErrNone);

	SetActive();

	}

void CHttpMessageComposer::DoReset()

/**

	Resets the composer. The composer moves into the Idle state. Allocated 

	resources are also reset. 

*/

	{

	// Reset the composer - composer state should be Idle and the data state 

	// should be WaitingForInfo.

	iState = EIdle;

	iDataState = EWaitingForInfo;

	iLastChunk = EFalse;

	// Reset the data composer

	iDataComposer.Reset();

	}

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeStartLineL()

/**

	Composes the message start-line. The start-line can be either a Request-Line

	or a Status-Line. Both have three tokens.

		generic-message	=	start-line

							*(message-header CRLF)

							CRLF

							[ message-body ]

		start-line		=	Request-Line | Status-Line

		Request-Line	=	Method SP Request-URI SP HTTP-Version CRLF

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

	The observer supplies these tokens.

	@return		A value of ESectionDone indicating that the start-line has been 

				done.

*/

	{

	__START_PERFORMANCE_LOGGER();

	// Get the start-line tokens from the observer.

	TPtrC8 token1, token2, token3;

	iObserver.StartLineL(token1, token2, token3);

	// Add the tokens to the data buffer.

	iDataComposer.AddTokenL(token1, THttpDataComposer::ESpace);

	iDataComposer.AddTokenL(token2, THttpDataComposer::ESpace);

	iDataComposer.AddTokenL(token3, THttpDataComposer::ECRLF);

	__END_PERFORMANCE_LOGGER(_L(",CHttpMessageComposer::ComposeStartLineL()"));

	return ESectionDone;

	}

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeHeadersL()

    {

    // Compose maximum of 6 headers at one go without AO scheduling

    TComposingStatus status = ComposeSingleHeaderL();

    if(status == ESectionNotDone)

        {

        status = ComposeSingleHeaderL();

        if(status == ESectionNotDone)

            {

            status = ComposeSingleHeaderL();

            if(status == ESectionNotDone)

                {

                status = ComposeSingleHeaderL();                

                if(status == ESectionNotDone)

                    {

                    status = ComposeSingleHeaderL();                

                		if(status == ESectionNotDone)

                    	{

                    	status = ComposeSingleHeaderL();                

                    	}                    

                    }

                }

            }

        }

    return status;

    }

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeSingleHeaderL()

/**

	Composes a header field or the end of headers marker. Each header field is

	delimited by a CRLF end of line marker.

		generic-message	=	start-line

							*(message-header CRLF)

							CRLF

							[ message-body ]

		message-header	=	field-name ":" [ field-value ]

	The observer supplies the field name and value tokens. If there is no more

	header field info then the end of headers marker is added - the composer is

	now ready to send the start-line and headers section of the message. The 

	optional message-body will follow if there is one. The current data buffer

	is set to contain the start-line and message-headers.

	@return		A value of ESectionNotDone indicating that there are more headers

				to add. A value of ESendData indicating that the current message 

				buffer should be sent.

*/

	{

	__START_PERFORMANCE_LOGGER();

	// Get header field info for the next header from the observer - the return

	// value should indicate if there is any more header info.

	TPtrC8 name, value;

	TInt error = iObserver.NextHeaderL(name, value);

	// Was there any header info?

	TComposingStatus status = ESectionNotDone;

	if( error == KErrNone )

		{

		// Add header info to the data buffer - return default status.

		iDataComposer.AddTokenL(name, THttpDataComposer::EColonSpace);

		iDataComposer.AddTokenL(value, THttpDataComposer::ECRLF);

		}

	else

		{

		// No more headers - add an empty line to mark the end of the headers.

		iDataComposer.AddTokenL(KNullDesC8(), THttpDataComposer::ECRLF);

		// Set the send buffer - need to send it so return ESendData status.

		iSendBuffer.Set(*iDataBuffer);

		status = ESendData;

		}

		__END_PERFORMANCE_LOGGER(_L(",CHttpMessageComposer::ComposeSingleHeaderL()"));

	return status;

	}

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeChunkSizeL()

/**

	Compose the chunk-size component. The chunk-size component indicates the 

	size of the subsequent chunk-data component.

		chunk			=	chunk-size [ chunk-extension ] CRLF

							chunk-data CRLF

		chunk-size		=	1*HEX

	The composer is ready to send the chunk-size component before sending the

	chunk-data. Also, an empty line marker from a previous chunk-data component

	is included in the send buffer if this is not the first chunk-size component.

	Note that if the chunk-data component is zero-length it should be ignored

	since a zero value chunk-size indicates the last-chunk component.

	@return		A value of ESendData indicating that the current message buffer

				should be sent. A value	of ESectionDone if the chunk is of zero-

				length.

*/

	{

	__START_PERFORMANCE_LOGGER();

	// Get the current data chunk from the data supplier

	TPtrC8 chunk;

	iBodyData->GetNextDataPart(chunk);

	TComposingStatus status = ESendData;

	TInt chunkSize = chunk.Length();

	if( chunkSize > 0 )

		{

		// Convert the size to its HEX representation.

		HBufC8* hex = NULL;

		InetProtTextUtils::ConvertHexToDescriptorL(chunkSize, hex);

		CleanupStack::PushL(hex);

		// Add the chunk-size componennt.

		iDataComposer.AddTokenL(*hex, THttpDataComposer::ECRLF);

		CleanupStack::PopAndDestroy(hex);

		// Set the send buffer - need to send it so return ESendData status.

		iSendBuffer.Set(*iDataBuffer);

		}

	else

		{

		// The chunk is zero-length - this section is done.

		status = ESectionDone;

		}

	__END_PERFORMANCE_LOGGER(_L(",CHttpMessageComposer::ComposeChunkSizeL()"));

	return status;

	}

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeLastChunkL()

/**

	Composes the last-chunk component. The last-chunk component marks the end

	of the chunked data. 

		last-chunk		=	1*("0") [ chunk-extension ] CRLF

	Optional trailers may follow.

	@return		A value of ESectionDone indicating that the last-chunk component

				has	been added to the message.

*/

	{

	// Add zero to mark the last-chunk.

	_LIT8(KZero, "0");

	iDataComposer.AddTokenL(KZero(), THttpDataComposer::ECRLF);

	// The trailers now follow so this section is done.

	return ESectionDone;

	}

CHttpMessageComposer::TComposingStatus CHttpMessageComposer::ComposeTrailerL()

/**

	Composes a trailer header field. Each trailer header field is delimited by 

	a CRLF end of line marker.

		Chunked-Body	=	*chunk

							last-chunk

							trailer

							CRLF

		trailer			=	*(entity-header CRLF)

		entity-header	=	message-header

		message-header	=	field-name ":" [ field-value ]

	The observer supplies the field name and value tokens. If there is no more

	trailer header field info then the end of headers marker is added - the 

	composer is now ready to send the trailer headers section of the message. 

	The last-chunk section is also included in the send buffer.

	@return		A value of ESectionNotDone indicating that there are more headers

				to add. A value of ESendData indicating that the current message 

				buffer should be sent.

*/

	{

	__START_PERFORMANCE_LOGGER();

	// Get trailer header field info for the next trailer from the observer - the

	// return value should indicate if there is any more trailer info.

	TPtrC8 name, value;

	TInt error = iObserver.NextTrailerL(name, value);

	// Was there any trailer info?

	TComposingStatus status = ESectionNotDone;

	if( error == KErrNone )

		{

		// Add trailer info to the data buffer - return default status.

		iDataComposer.AddTokenL(name, THttpDataComposer::EColonSpace);

		iDataComposer.AddTokenL(value, THttpDataComposer::ECRLF);

		}

	else

		{

		// No more trailers - add an empty line to mark the end of the trailers.

		iDataComposer.AddTokenL(KNullDesC8(), THttpDataComposer::ECRLF);

		// Set the send buffer - need to send it so return ESendData status.

		iSendBuffer.Set(*iDataBuffer);

		status = ESendData;

		}

	__END_PERFORMANCE_LOGGER(_L(",CHttpMessageComposer::ComposeTrailerL()"));

	return status;

	}

/*

 *	Methods from MHttpBufferSupplier

 */

void CHttpMessageComposer::ReAllocBufferL(TInt aRequiredSize, TPtr8& aBuffer)

/**	

	Reallocates the data buffer. The composer supplies the data buffer to the

	data composer. The data composer needs more space to store the current token.

	If the data buffer has not been created then it is created, otherwise it is 

	reallocated to at least the required size.

	@param		aRequiredSize	The minimum size of buffer required.

	@param		aBuffer			An output argument set to the reallocated buffer.

	@panic		EInvariantFalse	The required size was less then the current max

								size of the buffer.

*/

	{

	if( iDataBuffer == NULL )

		{

		// Create the buffer..

		iDataBuffer = HBufC8::NewL(aRequiredSize + KDefaultBufferSize);

		}

	else

		{

		__ASSERT_DEBUG( aRequiredSize > iDataBuffer->Des().MaxLength(), User::Invariant() );

		iDataBuffer = iDataBuffer->ReAllocL(aRequiredSize + KDefaultBufferSize);

		}

	aBuffer.Set(iDataBuffer->Des());

	}

void CHttpMessageComposer::DeleteBuffer()

/**

	Deletes the data buffer.

*/

	{

	delete iDataBuffer;

	iDataBuffer = NULL;

	}

/*

 *	Methods from CActive

 */

void CHttpMessageComposer::RunL()

/**

	Asynchronous request service handler. The composer state machine is processed

	in this function. Behaviour depends on the state. The composer will self-

	complete if it can continue composing the message. The composer informs its

	observer when it has message data ready to send. It will then suspend 

	processing until the observer notifies it that it has finished with the 

	current data. If the composer requires more message info it will stop 

	processing until it is notified that more message info is available.

	If the observer has reset the composer in one of the callback functions then

	the composer will defer resetting itself until it is back in the RunL().

	@leave		KErrCorrupt	The body data supplier indicated that the last data

							part even though it had not supplied all the data it

							specified. Or the body data supplier has supplied 

							all the data it specified but has not indicated a 

							last data part.

	@panic		EHttpMessagePanicBadDataState	The composer has no info to compose

												the message with.

	@panic		EInvarinatFalse	The composer is trying to send entity body data 

								when there is none to send.

	@panic		EHttpMessagePanicBadComposerStata	The composer is in an illegal

													state.

*/

	{

	__ASSERT_DEBUG( iDataState == EGotInfo, THttpMessagePanic::Panic(THttpMessagePanic::EHttpMessagePanicBadDataState) ); 

	TComposingStatus status = ESectionNotDone;

	switch( iState )

		{

	case EIdle:

		{

		status = ESectionDone;

		iState = ECreatingStartLine;

		} 

		//coverity [MISSING_BREAK]

		// Fallthrough is required here as we no longer compose line by line. We compose startline & headers (6) at one go.

	case ECreatingStartLine:

		{

		status = ComposeStartLineL();

		iState = ECreatingHeaders;

        } 

		//coverity [MISSING_BREAK]

		// Fallthrough is required here as we no longer compose line by line. We compose startline & headers (6) at one go.

	case ECreatingHeaders:

		{

		status = ComposeHeadersL();

		// Is the headers section complete?

		if( status != ESectionNotDone )

			{

			iState = EPendingEntityBody;

			// Is there an entity body?

			iBodyData = iObserver.HasBodyL();

			}

		// Stay in this state if there are more headers to compose.

		} break;

	case EPendingEntityBody:

		{

		// Release the current data buffer

		iDataComposer.Release();

		// Set the amount of the entity body data

		if( iBodyData != NULL )

			iDataSizeLeft = iBodyData->OverallDataSize();

		else

			iDataSizeLeft = 0;

		// Determine next action depending on amount of entity data to send.

		if( iDataSizeLeft > 0 )

			{

			// A known amount of data greater than zero. Send entity body with

			// no transfer encoding.