// Copyright (c) 2002-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 "cmessageparserdriver.h"

#include "mdriverobserver.h"

#include "cmessagedatasupplier.h"

CMessageParserDriver* CMessageParserDriver::NewL(MDriverObserver& aObserver)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CMessageParserDriver::~CMessageParserDriver()

	{

	Cancel();

	delete iDataSupplier;

	iHeaders.Close();

	iTrailers.Close();

	iMessageParser.Close();

	}

CMessageParserDriver::CMessageParserDriver(MDriverObserver& aObserver)

: CActive(CActive::EPriorityStandard), iObserver(aObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMessageParserDriver::ConstructL()

	{

	iMessageParser.OpenL(*this);

	}

void CMessageParserDriver::SetMessageData(const TDesC8& aMessageData)

	{

	iMessageData.Set(aMessageData);

	}

void CMessageParserDriver::SetStartLine(const TDesC8& aStartLine)

	{

	iStartLine.Set(aStartLine);

	}

void CMessageParserDriver::SetHeaderL(const TDesC8& aFieldName, const TDesC8& aFieldValue)

	{

	User::LeaveIfError(iHeaders.Append(THeaderField(aFieldName, aFieldValue)));

	}

void CMessageParserDriver::SetBodyData(const TDesC8& aBodyData, TBool aIsChunked, TBool aIsUnknownLength)

	{

	iEntityBody.Set(aBodyData);

	iIsUnknownLength = aIsUnknownLength;

	// Set the entity body info

	if( iEntityBody.Length() > 0 )

		{

		if( aIsChunked )

			{

			iExpectBodyState = EChunkEncodedBody;

			}

		else

			{

			if( iIsUnknownLength )

				iExpectBodyState = EUnknownBodyLength;

			else

				iExpectBodyState = ENonEncodedBody;

			}

		}

	else

		{

		iExpectBodyState = ENoEntityBody;

		}

	}

void CMessageParserDriver::SetTrailerL(const TDesC8& aFieldName, const TDesC8& aFieldValue)

	{

	User::LeaveIfError(iTrailers.Append(THeaderField(aFieldName, aFieldValue)));

	}

void CMessageParserDriver::Start(TInt aExpectedError, TBool aTestReset)

	{

	iExpectedError	= aExpectedError;

	iDoReset		= aTestReset;

	// Inform the observer that the test has started

	iObserver.NotifyStart();

	// Initially set the buffer size to the length of the message unless doing

	// reset test - use a buffer size of an eighth of the message size

	if( iDoReset )

		{

		iBufferSize = iMessageData.Length()/8;

		if( iBufferSize < 1 )

			iBufferSize = 1;

		}

	else

		iBufferSize = iMessageData.Length();

	// Set the reset state to initial state - PendingStartLine.

	iResetState = EPendingStartLine;

	// Self-complete to kick-off the test.

	CompleteSelf();

	}

void CMessageParserDriver::CompleteSelf()

	{

	TRequestStatus* pStat = &iStatus;

	User::RequestComplete(pStat, KErrNone);

	SetActive();

	}

void CMessageParserDriver::DoReset()

	{

	// Reset the parser and update the reset state.

	iMessageParser.Reset();

	iResetState = iState;

	iObserver.Log(_L("RESET - starting test again!!"));

	// Reset the data supplier

	delete iDataSupplier;

	iDataSupplier = NULL;

	if( iState == EPendingHeaders )

		iResetIndex = iHeaderIndex;

	else if( iState == EPendingTrailers )

		iResetIndex = iTrailerIndex;

	else if( iState == EPendingBodySize )

		iResetIndex = 0;

	else if( iState == EPendingBody )

		iResetIndex = iBodyIndex;

	// Start the test over...

	CompleteSelf();

	}

/*

 *	Methods from CActive

 */

void CMessageParserDriver::RunL()

	{

	// Reset the test case data

	iHeaderIndex	= 0;

	iTrailerIndex	= 0;

	iExpectBodyData.Set(iEntityBody);

	// Set the reset flags

	iReset		= EFalse;

	iBodyIndex	= 0;

	iChunkCount	= 0;

	// Reset the data supplier

	delete iDataSupplier;

	iDataSupplier = NULL;

	iDataSupplier = CMessageDataSupplier::NewL(*this, iMessageData, iBufferSize);

	TBuf<64> comment;

	comment.Format(_L("STARTING PARSING -> buffer size : %d"), iBufferSize);

	iObserver.Log(comment);

	// Start the parser...

	iMessageParser.ReceivedMessageData();

	// Move to PendingStartLine state...

	iState = EPendingStartLine;

	}

void CMessageParserDriver::DoCancel()

	{

	// Do nothing...

	}

TInt CMessageParserDriver::RunError(TInt aError)

	{

	// Inform the observer of the error

	iObserver.NotifyError(aError);

	return KErrNone;

	}

/*

 *	Methods from MHttpMessageParserObserver

 */

void CMessageParserDriver::GetDataPacket(TPtrC8& aData)

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	if( iReset )

		{

		// Not expecting a header. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting GetDataPacket"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	iDataSupplier->GetData(aData);

	}

void CMessageParserDriver::ReleaseDataPacket()

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	if( iReset )

		{

		// Not expecting a header. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting ReleaseDataPacket"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	iDataSupplier->ReleaseData();

	// If we have recieved all the data and we were doing a 1.0 request of unknown length

	// tell the parser the data is complete and we are waiting for the body to be complete.

	if( iExpectBodyData.Length() == 0 && iIsUnknownLength && iState==EPendingBodyComplete)

		{

		TRAPD(err, iMessageParser.CompletedBodyDataL() );

		if( err != KErrNone )

			{

			// Not expecting a header. Test has failed - notify the observer.

			iObserver.Log(_L("FAIL - not expecting ReleaseDataPacket"));

			iObserver.NotifyError(err);

			iTestFailed = ETrue;

			}

		}

	}

void CMessageParserDriver::StartLineL(const TDesC8& aStartLine)

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	iObserver.Log(_L("Start-line received"));

	TBuf<256> comment;

	comment.Copy(aStartLine);

	iObserver.Log(comment);

	// Was start-line expected?

	if( iState != EPendingStartLine || iReset )

		{

		// Not expecting start-line. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting start-line"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	else

		{

		// Check that the start-line is correct.

		if( aStartLine.Compare(iStartLine) == 0 )

			{

			// Should a reset occur here?

			if( iDoReset && iResetState == iState )

				iReset = ETrue;

			// Match - what is next?

			if( iHeaders.Count() == 0 )

				iState = EPendingBodySize;

			else

				iState = EPendingHeaders;

            // We no longer parse line by line. We parse startline & headers (5) at one go.

            // We cannot reset here

            iReset = EFalse;

			// Reset?

			if( iDoReset && iReset )

				DoReset();

			}

		else

			{

			// The start-line does not match. Test has failed - notify the observer.

			iObserver.Log(_L("FAIL - received incorrect start-line"));

			iObserver.NotifyError(KErrNotFound);

			iTestFailed = ETrue;

			}

		}

	}

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

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	iObserver.Log(_L("HeaderL received"));

	// Was a header expected? NOTE - this can be a trailer header...

	if( (iState != EPendingHeaders && iState != EPendingTrailers) || iReset )

		{

		// Not expecting a header. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting HeaderL"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	else

		{

		// Yep - log the parsed header...

		TBuf<64> name;

		name.Copy(aFieldName);

		TBuf<256> value;

		value.Copy(aFieldValue);

		TBuf<322> comment;

		comment.Format(_L("%S: %S"), &name, &value);

		iObserver.Log(comment);

		// Get the expected header info...

		THeaderField header;

		if( iState == EPendingHeaders )

			{

			// Should a reset occur here?

			if( iDoReset && (iResetState == iState && iResetIndex == iHeaderIndex) )

				iReset = ETrue;

			// Get the current header info...

			header = iHeaders[iHeaderIndex];

			// Loop to next header...

			++iHeaderIndex;

			// Set next state...

			if( iHeaderIndex < iHeaders.Count() )

				iState = EPendingHeaders;

			else

				iState = EPendingBodySize;

			}

		else

			{

			// Should a reset occur here?

			if( iDoReset && (iResetState == iState && iResetIndex == iTrailerIndex) )

				iReset = ETrue;

			// Get the current trailer info...

			header = iTrailers[iTrailerIndex];

			// Loop to next header...

			++iTrailerIndex;

			// Set next state...

			if( iTrailerIndex < iTrailers.Count() )

				iState = EPendingTrailers;

			else

				iState = EPendingMessageComplete;

			}

		TPtrC8 expectedName		= header.iName;

		TPtrC8 expectedValue	= header.iValue;

		// Check that the parsed header info matches expected

		if( expectedName.Compare(aFieldName) != 0 || expectedValue.Compare(aFieldValue) != 0 )

			{

			// The header info does not match. Test has failed - notify the observer.

			iObserver.Log(_L("FAIL - received incorrect header info"));

			iObserver.NotifyError(KErrNotFound);

			iTestFailed = ETrue;

			}

		else if( iDoReset && iReset )

			DoReset();

		}

	}

TInt CMessageParserDriver::BodySizeL()

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	// Log the headers complete event

	iObserver.Log(_L("BodySizeL received"));

	// Was this expected?

	TInt size = MHttpMessageParserObserver::ENoBody;

	if( iState != EPendingBodySize || iReset )

		{

		// Not expected! Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting BodySizeL"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	else

		{

		// Should a reset occur here?

		if( iDoReset && iResetState == iState )

			iReset = ETrue;

		// Yep - workout what is next...

		switch( iExpectBodyState )

			{

		case ENoEntityBody:

			{

			// No body - use default value of size

			iState = EPendingMessageComplete;

			} break;

		case EChunkEncodedBody:

			{

			// There is a body that is chunk encoded.

			size = MHttpMessageParserObserver::EChunked;

			iState = EPendingBody;

			} break;

		case ENonEncodedBody:

			{

			// There is a body that is not encoded.

			size = iExpectBodyData.Length();

			iState = EPendingBody;

			} break;

		case EUnknownBodyLength:

			{

			// There is a body of unknown length

			size = MHttpMessageParserObserver::EUnknown;

			iState = EPendingBody;

			} break;

		default:

			User::Invariant();

			break;

			}

		// Reset?

		if( iDoReset && iReset )

			DoReset();

		}

	return size;

	}

void CMessageParserDriver::BodyChunkL(const TDesC8& aData)

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	iObserver.Log(_L("BodyChunkL received"));

	// Was this expected?

	if( iExpectBodyState != EChunkEncodedBody && (iState != EPendingBody || iReset ))

		{

		// No body data expected. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting BodyChunkL"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	else

		{

		// Dump the body data...

		iObserver.Dump(aData);

		// Check to see if it matches the expected data.

		TBool match = EFalse;

		if( aData.Length() <= iExpectBodyData.Length() )

			{

			// Is the content the same

			if( aData.Compare(iExpectBodyData.Left(aData.Length())) == 0 )

				{

				// Data is the same - update the expected data

				iExpectBodyData.Set(iExpectBodyData.Mid(aData.Length()));

				match = ETrue;

				}

			}

		if( match )

			{

			// Should a reset occur here?

			if( iDoReset && (iResetState == iState && iResetIndex == iBodyIndex) )

				iReset = ETrue;

			++iBodyIndex;

			// Has all the data been received?

			if( iExpectBodyData.Length() == 0 )

				iState = EPendingBodyComplete;

			// Reset?

			if( iDoReset && iReset )

				DoReset();

			}

		else

			{

			// The body data does not match. Test has failed - notify the observer.

			iObserver.Log(_L("FAIL - received incorrect body data"));

			iObserver.NotifyError(KErrNotFound);

			iTestFailed = ETrue;

			}

		}

	}

void CMessageParserDriver::BodyCompleteL()

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	iObserver.Log(_L("BodyCompleteL received"));

	// Was this expected?

	if( iState != EPendingBodyComplete || iReset )

		{

		// Not expecting body complete. Test has failed - notify the observer.

		iObserver.Log(_L("FAIL - not expecting BodyCompleteL"));

		iObserver.NotifyError(KErrNotFound);

		iTestFailed = ETrue;

		}

	else

		{

		// Should a reset occur here?

		if( iDoReset && iResetState == iState )

			iReset = ETrue;

		// What's next?

		if( iExpectBodyState == EChunkEncodedBody && iTrailers.Count() > 0 )

			iState = EPendingTrailers;

		else

			iState = EPendingMessageComplete;

		// Reset?

		if( iDoReset && iReset )

			DoReset();

		}

	}

void CMessageParserDriver::MessageCompleteL(const TPtrC8& /*aExcessData*/)

	{

	__ASSERT_DEBUG( iTestFailed == EFalse, User::Invariant() );

	// Log the message complete event