// Copyright (c) 2001-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:

//

// System includes

#include <e32std.h>

#include <http/mhttptransactioncallback.h>

#include <http/thttpfilterregistration.h>

#include <httpstringconstants.h>

#include <httperr.h>

// Local includes

#include "CHTTPSession.h"

#include "CRequest.h"

#include "CResponse.h"

#include "CHTTPManager.h"

#include "CHeaderField.h"

// Class signature

#include "CTransaction.h"

#define LOGFILE "events.csv"

void CTransaction::CancelTransaction(THTTPFilterHandle aStart)

	{

	// Delete all current events.

	iEventQueue.Reset();

	// Cancel the active object

	Cancel();

	// And send the cancel event

	SynchronousSendEvent(THTTPEvent::ECancel, THTTPEvent::EOutgoing, aStart);

	if (iStatus != EInFilter && iStatus != ECancelled)

		iStatus = EPassive;

	else

		iStatus = ECancelled;

	}

void CTransaction::Close()

	{

	// If the request and the response don't exist yet, the object

	// isn't fully constructed and so shouldn't send any cancel or

	// close messages as its part-constructed state could confuse

	// filters.

	if (!iResponse)

		{

		CHeaderFieldPart::ClosePropertySet(iPropertySet);

		delete iRequest;

		delete this;

		return;

		}

	// If we're currently processing a close event we should stop

	// right now, to prevent infinite loops.

	if (iProcessingSyncEvent && 

		iCurrentSyncEvent.iEvent.iStatus == THTTPEvent::EClosed)

		return;

	// Cancel the transaction

	CancelTransaction(THTTPFilterHandle::EClient);

	// Remember the status

	TInt status = iStatus.Int();

	// And send out the 'close' message.

	SynchronousSendEvent(THTTPEvent(THTTPEvent::EClosed), 

						 THTTPEvent::EOutgoing, THTTPFilterHandle::EClient);

	iStatus = status;

	// The state will now be cancelled if and only if we were in a filter

	iSession.RemoveTransaction(this);

	CHeaderFieldPart::ClosePropertySet(iPropertySet);

	delete iRequest;

	delete iResponse;

	// Cancel the active object

	Cancel();

	if (status == CTransaction::ECancelled)

		{

		// If we're our transaction's RunL (which we probably are),

		// wait until we're back in the CTransaction before we delete it.

		iStatus = CTransaction::EExiting;

		}

	else

		{

		// We can safeley close straight away

		delete this;

		}

	}

void CTransaction::ConstructL(const TUriC8& aURI, RStringF aMethod)

	{

	RStringPool strP = iSession.Manager().StringPool();

	// If the string is the empty string, this means the default value

	// (of GET) should be used.

	if (aMethod == RStringF())

		aMethod = strP.StringF(HTTP::EGET,RHTTPSession::GetTable());

	aMethod.Copy();

	// The 0 header val in the property set has no meaning; the value

	// of the part is not used by property sets.

	CHeaderFieldPart* fieldPart = CHeaderFieldPart::NewL(THTTPHdrVal(0));

	fieldPart->SetPropertySet(iPropertySet);

	iRequest = CRequest::NewL(aMethod, aURI, this);

	iResponse = CResponse::NewL(this);

	iId = iSession.NextTransactionID();

	CActiveScheduler::Add(this);

	iSession.AddTransactionL(this);

	__OPEN_LOG(LOGFILE);

	__LOG(_L(",Transaction ID, Event, Direction, Filter"));

	}

void CTransaction::RunL()

	{

	// If we're in another transaction's RunL (which has called a

	// filter that has in turn run a nested active scheduler) we

	// should block now and try again when that transaction has

	// finished. This is to prevent obscure re-entrancy problems in

	// client code. See the comments on the blocking functions in the

	// session's header file for more details.

	THTTPEvent currentEvent = CurrentEvent().iEvent;	

	if(currentEvent == THTTPEvent::ESuspend)

		{	

		__ASSERT_DEBUG(iStatus != ESuspended, HTTPPanic::Panic(HTTPPanic::EInvalidEvent));				

		iStatus = ESuspended;		

		iSession.TransactionHasBlocked();

		RemoveEvent();

		return;

		}

	if(currentEvent == THTTPEvent::EResume)

		{		

		if(iStatus != ESuspended)

		HTTPPanic::Panic(HTTPPanic::EInvalidEvent);

		RemoveEvent();	

		iSession.Unblock();

		return;

		}	

	if (iSession.IsBlocking())

		{

		if(iStatus.Int() != ESuspended)

			{

			iStatus = EBlocked;

			iSession.TransactionHasBlocked();

			}				

		return;

		}	

	iSession.Block();

	TBool runNext = RunOneFilterL();	

	iSession.Unblock();	

	if (iStatus.Int() == EExiting)

		{

		iStatus = EPassive;

		delete this;

		}

	else if (runNext)

		{

		// Move on to the next filter and find out what to do next.

		Activate(FindNextFilter());

		}

	}

TInt CTransaction::RunError(TInt aError)

	{

	TInt error = KErrNone;

	RHTTPTransaction t;

	t.iImplementation = this;

	switch (iStatus.Int())

		{

	case EInFilter:

	case ECancelled:

		{

		// Get the right event, according to whether it's being sent synchronously or not

		THTTPEvent currentEvent;

		if (iProcessingSyncEvent==1)

			currentEvent = CurrentEvent().iEvent;

		else

			currentEvent = iASyncEvent;

		// Is it a session event

		TBool isSessionEvent = currentEvent.IsSessionEvent();

		// Now, offer to the appropriate handler - MHFRunError for transaction events

		// or MHFSessionRunError for session events

		if (iProcessingSyncEvent==1)

			{

			MHTTPFilter* filter = iSession.FilterQueue()[iNextFilter].iFilter;

			if (isSessionEvent)

				error = filter->MHFSessionRunError(aError, STATIC_CAST(THTTPSessionEvent&, currentEvent));

			else

				error = filter->MHFRunError(aError, t, currentEvent);

			}

		else

			{

			MHTTPFilter* filter = iSession.FilterQueue()[iCurrentASyncFilter].iFilter;

			if (isSessionEvent)

				error = filter->MHFSessionRunError(aError, STATIC_CAST(THTTPSessionEvent&, currentEvent));

			else

				error = filter->MHFRunError(aError, t, currentEvent);

			}

		// Unless we've been deleted, move on to the next filter and

		// find out what to do next.

		if (iStatus.Int() != EExiting)

			Activate(FindNextFilter());

		} break;

	case EExiting:

		break;

	default:

		__ASSERT_DEBUG(EFalse, HTTPPanic::Panic(HTTPPanic::ETransactionUnhandledError));

		}

	if (!iProcessingSyncEvent)

		iSession.Unblock();

	// Panic if MHFRunError hasn't handled the error

	if (error)

		HTTPPanic::Panic(HTTPPanic::ETransactionUnhandledError);

	if (iStatus.Int() == EExiting)

		{

		delete this;

		}

	return KErrNone;

	}

void CTransaction::DoCancel()

	{

	// Nothing to do here. This only happens when the transaction is

	// cancelled or deleted.

	}

#if defined (_DEBUG)

void CTransaction::LogEvent(TInt aTransactionId, const THTTPEvent& aEvent, 

						   TInt aDirection, const TDesC8& aFilterName)

	/* 	creates a single line comma separated list comment of

		Transaction Number, Event, Direction, Filter Name

	*/

	{

	_LIT(KSubmit,"Submit");

	_LIT(KCancel,"Cancel");

	_LIT(KNotifyNewRequestBodyPart,"NotifyNewRequestBodyPart");

	_LIT(KClosed,"Closed");

	_LIT(KGotResponseHeaders,"GotResponseHeaders");

	_LIT(KGotResponseBodyData,"GotResponseBodyData");

	_LIT(KResponseComplete, "ResponseComplete");

	_LIT(KGotResponseTrailerHeaders,"GotResponseTrailerHeaders");

	_LIT(KSucceeded,"Succeeded");

	_LIT(KFailed, "Failed");

	_LIT(KUnrecoverableError, "Unrecoverable Error");

	_LIT(KTooMuchRequestData, "TooMuchRequestData");

	_LIT(KRedirectRequiresConfirmation, "RedirectRequiresConfirmation");

	_LIT(KNeedTunnel, "NeedTunnel");

	_LIT(KGetCipherSuite, "GetCipherSuite");

	_LIT(KUnknownEvent, "UnknownEvent");

	TPtrC event(KNullDesC);

	switch (aEvent.iStatus)

		{

	case THTTPEvent::ESubmit:

		event.Set(KSubmit);

		break;

	case THTTPEvent::ECancel:

		event.Set(KCancel);

		break;

	case THTTPEvent::ENotifyNewRequestBodyPart:

		event.Set(KNotifyNewRequestBodyPart);

		break;

	case THTTPEvent::EClosed:

		event.Set(KClosed);

		break;

	case THTTPEvent::EGotResponseHeaders:

		event.Set(KGotResponseHeaders);

		break;

	case THTTPEvent::EGotResponseBodyData:

		event.Set(KGotResponseBodyData);

		break;

	case THTTPEvent::EResponseComplete:

		event.Set(KResponseComplete);

		break;

	case THTTPEvent::EGotResponseTrailerHeaders:

		event.Set(KGotResponseTrailerHeaders);

		break;

	case THTTPEvent::ESucceeded:

		event.Set(KSucceeded);

		break;

	case THTTPEvent::EFailed:

		event.Set(KFailed);

		break;

	case THTTPEvent::EUnrecoverableError:

		event.Set(KUnrecoverableError);

		break;

	case THTTPEvent::ETooMuchRequestData:

		event.Set(KTooMuchRequestData);

		break;

	case THTTPEvent::ERedirectRequiresConfirmation:

		event.Set(KRedirectRequiresConfirmation);

		break;

	case THTTPEvent::ENeedTunnel:

		event.Set(KNeedTunnel);

		break;

	case THTTPEvent::EGetCipherSuite:

		event.Set(KGetCipherSuite);

		break;

	default:

		event.Set(KUnknownEvent);

	};

	_LIT(KHandled, "Handled");	

	_LIT(KOutgoing,"Outgoing");

	_LIT(KIncoming,"Incoming");

	TPtrC direction(KHandled);

	switch (aDirection)

		{

	case THTTPEvent::EIncoming:

		direction.Set(KIncoming);

		break;

	case THTTPEvent::EOutgoing:

		direction.Set(KOutgoing);

		break;	

		};

	TBuf<64> filterName;

	filterName.Copy(aFilterName);	

	TBuf<256> logBuffer; // if its longer than 256 then http logging code will fall over anyway

	_LIT(KLogFormat, ", Transaction %d, %S, %S, %S");

	logBuffer.AppendFormat(KLogFormat, aTransactionId, &event, &direction, &filterName);

	__LOG(logBuffer);

	}

#endif

TBool CTransaction::RunOneFilterL()

	{

	// The active scheduler is only really used to split up filtering

	// in order to make things more interactive. By now, the next

	// filter to run should have been worked out, so run it and work

	// out what to do next time.

	RHTTPTransaction t;

	t.iImplementation = this;

	TBool processNext = EFalse;

	iCurrentFilter = iNextFilter;

	iStatus = EInFilter;

	__LOGEVENT(iId, CurrentEvent().iEvent,CurrentEvent().iDirection,

		iSession.Manager().StringPool().StringF(

		iSession.FilterQueue()[iNextFilter].iName).DesC());

	// Run it.

	MHTTPFilter* filter = iSession.FilterQueue()[iNextFilter].iFilter;

	THTTPEvent currentEvent = CurrentEvent().iEvent;

	//I need to keep a copy of the event and if the  event is asyncronous I need to keep the event 

	if(iProcessingSyncEvent==0 ) 

		{

		iASyncEvent= iEventQueue[0].iEvent;

		iCurrentASyncFilter=iNextFilter;

		}

	if (currentEvent.IsSessionEvent())

		{

		filter->MHFSessionRunL(STATIC_CAST(THTTPSessionEvent&, currentEvent));

		}

	else

		filter->MHFRunL(t, currentEvent);

	switch (iStatus.Int())

		{

	case EInFilter:

		processNext = ETrue;

		iStatus = EFilter;

		break;

	case ECancelled:

		iStatus = EPassive;

		processNext = ETrue;

		break;

	default:

		break;

		}

	return processNext;

	}

TInt CTransaction::AddEvent(THTTPEvent& aEvent, TInt aDirection,

							  THTTPFilterHandle aStart)

	{

	// API for adding new events to the queue.

	TInt startFilter = 0;

	// Look at the start filter handle to decide where to start the filter.

	switch (aStart.iValue)

		{

	case THTTPFilterHandle::EUndefined:

		HTTPPanic::Panic(HTTPPanic::EInvalidFilterHandle);

		break;

	case THTTPFilterHandle::EClient:

		startFilter = iSession.FilterQueue().Count() - 1;

		__LOGEVENT(iId,aEvent,aDirection,_L8("Client"));

		break;

	case THTTPFilterHandle::EProtocolHandler:

		startFilter = 0;

		__LOGEVENT(iId,aEvent,aDirection,_L8("Protocol Handler"));

		break;

	case THTTPFilterHandle::ECurrentFilter:

		if (iStatus.Int() != EInFilter && iStatus.Int() != ECancelled && iStatus.Int() != ESuspended)

			HTTPPanic::Panic(HTTPPanic::EInvalidFilterHandle);

		startFilter = iCurrentFilter;

		__LOGEVENT(iId,aEvent,aDirection,iSession.Manager().StringPool().StringF(

			iSession.FilterQueue()[iCurrentFilter].iName).DesC());

		break;

	default:

		// Assume any other value is a filter handle.

		{

		TInt i;

		TInt count = iSession.FilterQueue().Count();

		// If there aren't any filters, you shouldn't be specifying a

		// filter handle. Return an error.

		if (count == 0)

			HTTPPanic::Panic(HTTPPanic::EInvalidFilterHandle);

		for (i = 0; i < count; ++i)

			{

			if (iSession.FilterQueue()[i].iHandle == aStart.iValue)

				break;

			}

		if (i == count)

			{

			// We haven't found that filter. We may as well leave

			HTTPPanic::Panic(HTTPPanic::EInvalidFilterHandle);

			}

		startFilter = i;

		__LOGEVENT(iId,aEvent,aDirection,iSession.Manager().StringPool().

			  StringF(iSession.FilterQueue()[i].iName).DesC());

		break;

		}

		}

	TEventRegistration r(aEvent, aDirection, startFilter);

	return AppendEvent(r);

	}

TInt CTransaction::SendEvent(THTTPEvent& aEvent, TInt aDirection, THTTPFilterHandle aStart)

    {

    TInt err = AddEvent(aEvent, aDirection, aStart);

    if(err != KErrNone)

        {

        return err;

        }

    // If necessary, process the event having added it to the

    // queue. It's not necessary if we're inside a MHFRunL (in which

    // case the event will be processed when we return to

    // CTransaction::RunL) or if we've already added an event that

    // hasn't been run yet (in which case we'll be active)

    if (iStatus.Int() == EPassive)

        {

        Activate(FindNextFilter());

        }    

    return err;

    }

void CTransaction::SendEventL(THTTPEvent& aEvent, TInt aDirection,

							  THTTPFilterHandle aStart)

	{

	User::LeaveIfError(SendEvent(aEvent, aDirection, aStart));

	}

void CTransaction::SynchronousSendEvent(THTTPEvent aEvent, TInt aDirection, 

										 THTTPFilterHandle aStart)

	{

	// Remember the current async event, in case this is a nested async event.

	TEventRegistration storedSyncEvent = iCurrentSyncEvent;

	iProcessingSyncEvent = ETrue;

	// As we're in sync mode, this call must succeed.

	AddEvent(aEvent, aDirection, aStart);

	TInt s = iStatus.Int();

	// Remember the current filter so that events fired after a cancel

	// start from the right place.

	TInt rememberedCurrentFilter = iCurrentFilter;

	iStatus = EPassive;

	do 

		{

		iStatus = FindNextFilter();

		if (iStatus.Int() != EPassive)

			{

			TRAPD(error, RunOneFilterL());

			if (error)

				RunError(error);

			}

		}

	while (iStatus.Int() != EPassive && iStatus.Int() != EExiting);

	iCurrentFilter = rememberedCurrentFilter;

	if ( iStatus.Int() != EExiting )

		{

			iStatus = s;

		}

	iProcessingSyncEvent = EFalse;

	iCurrentSyncEvent = storedSyncEvent;

	}

CTransaction::TTransactionStates CTransaction::FindNextFilter()

	{