// 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:

//

// System includes

#include <http/mhttpdatasupplier.h>

#include <httpstringconstants.h>

#include <wsp/mwspsessionheadersprovider.h>

#include <wsp/mwspcomethodcallback.h>

#include <wsp/mwspcosessioncallback.h>

#include <wsp/mwspcapabilityprovider.h>

#include <wsp/mwspcapabilityviewer.h>

#include <wsp/mwspcapabilitysetter.h>

#include <wsp/mwspaliasaddresses.h>

#include <wsp/mwspextendedmethods.h>

#include <wsp/mwspheadercodepages.h>

#include <wsp/mwspunknowncapabilities.h>

#include <wsp/wsptypes.h>

#include <wsperror.h>

#include <capcodec.h>

#include <uri8.h>

#include <http/framework/logging.h>

// Local includes

#include "tnwsswsptrhndpanic.h"

#include "mconnectioninfoprovider.h"

#include "cnwsswspcoeventdispatcher.h"

#include "cnwsswsptrhnddatasupplier.h"

#include "cnwssconnectguard.h"

#include "cnwsswsptransactioneventfilter.h"

#include "cnwsswspsessioneventfilter.h"

#include "testoom.h"

// Class signature

#include "cnwsswspcosession.h"

// Constants used in this file

const TInt KMaxUriLength = 256;

const TUint KSessDataChunkSize = 256;

const TUint KTransLUTSize = 4;

const TInt KMaxCapabilityDataSize = 256;

const TUint32 KMaxClientSDUSize = 30000;

const TUint32 KMaxServerSDUSize = 30000;

//

_LIT8(KGet, "GET");

_LIT8(KPost, "POST");

_LIT8(KHead, "HEAD");

_LIT8(KTrace, "TRACE");

_LIT8(KOptions, "OPTIONS");

_LIT8(KPut, "PUT");

_LIT8(KDelete, "DELETE");

CNwssWspCOSession* CNwssWspCOSession::NewL(RStringPool& aStringPool,

										   MNwssWapServer& aWapStackProvider,

										   MConnectionInfoProvider& aConnInfoProvider,

										   MSecurityPolicy& aSecurityPolicy,

										   MWspCOSessionCallback& aSessionCB)

	{

	CNwssWspCOSession* me = new(ELeave)CNwssWspCOSession(aStringPool,

														 aWapStackProvider,

														 aConnInfoProvider,

														 aSecurityPolicy,

														 aSessionCB);

	CleanupStack::PushL(me);

	me->ConstructL();

	CleanupStack::Pop(me);

	return me;

	}

CNwssWspCOSession::~CNwssWspCOSession()

	{

	// It is important that the client correctly disconnects sessions before deleting the transport

	// handler.

#ifdef _DEBUG

	if( State() != CNwssWspSession::EDisconnected )

		{

		// WSP session could be suspended

		RWSPCOConn::TSessionState state;

		iWspCOSession.GetSessionState(state);

#ifndef __UNIT_TESTING__

		__ASSERT_DEBUG(state == RWSPCOConn::ESuspended, 

					TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EConnectedUponDestruction));

#endif

		}

#endif

	if( State() != CNwssWspSession::EDisconnected )

		// Ensure everything is closed down.  Since we're destructing, we don't care about

		// errors in this callback.

		(void)SessionDisconnectedCallback();

	if (iConnectGuard)

		iConnectGuard->Cancel();

	if (iTransEventFilter)

		iTransEventFilter->Cancel();

	if( iSessionEventFilter )

		iSessionEventFilter->Cancel();

	// Clean up

	delete iCOTransTable;

	delete iTransEventFilter;

	delete iSessionEventFilter;

	delete iEventDispatcher;

	delete iCapabilityCodec;

	delete iUriBuffer;

	delete iSessDataBuffer;

	delete iConnectGuard;

	delete iOOMCallBack;

	__CLOSELOG

	}

CNwssWspCOSession::CNwssWspCOSession(RStringPool& aStringPool,

								     MNwssWapServer& aWapStackProvider,

								     MConnectionInfoProvider& aConnInfoProvider,

									 MSecurityPolicy& aSecurityPolicy,

									 MWspCOSessionCallback& aSessionCB)

	: CNwssWspSession(aStringPool, aWapStackProvider, aConnInfoProvider, aSecurityPolicy),

	  iSessionCB(aSessionCB)

	{

	__OPENLOG("http", "nwsswsptrhnd.txt")

	__LOG_TITLE("WSP Transport Handler (NWSS bindings) Log")

	}

void CNwssWspCOSession::ConstructL()

	{

	BaseConstructL();

	// Create the transaction look-up table with a default initial size.  Create

	// the event dispatcher and capability codec.

	iCOTransTable = CNwssTransLookUpTable::NewL(KTransLUTSize);

	iTransEventFilter = CNwssWspTransactionEventFilter::NewL(*iCOTransTable, *this, KTransLUTSize);

	iSessionEventFilter = CNwssWspSessionEventFilter::NewL(*iCOTransTable, *this, *this);

	iEventDispatcher = CNwssWspCOEventDispatcher::NewL(iWspCOSession, *iSessionEventFilter, *iTransEventFilter, *this);

	iCapabilityCodec = CCapCodec::NewL();

	// Create scratch buffers

	iUriBuffer = HBufC::NewL(KMaxUriLength);

	iSessDataBuffer = HBufC8::NewL(KSessDataChunkSize);

	// Create the connect guard

	iConnectGuard = CNwssConnectGuard::NewL(*this, iSessionCB);

	// Create the one shot used if OOM occurs during a MethodInvoke or Connect

	iOOMCallBack = new (ELeave)CAsyncCallBack(CActive::EPriorityStandard);

	}

/*

 * Session Invocation API. 

 */

void CNwssWspCOSession::ConnectReq()

	{

	__LOG("Received S-Connect.req primitive")

	// Set connect limbo flag. This indicates that the S-Connect.req has been

	// received but not yet sent to the WAP Stack.

	iInConnectLimbo = ETrue;

	// All this stuff will be broken out, into different states in the parent class

	// This method will just request from its parent that the connection process is

	// started.  The parent, as an AO, will go through the various stages in its RunL.

	// That will involve calls down to this class to allow the connection to be

	// completed.

	InitiateProxyConnection();

	}

TInt CNwssWspCOSession::OpenWspSession(const TDesC8& aRemoteHost,

									   RWAPConn::TPort aRemotePort,

									   RWAPConn::TPort aLocalPort,

									   TBearer aBearer,

									   TBool aSecureConn)

	{

	// Open a WSP CO connection with the WAP stack

	__TESTOOMD(error, iWspCOSession.Open(iWapStackProvider.WapStack(), aRemoteHost, aRemotePort, aLocalPort, aBearer, aSecureConn));

	return error;	  

	}

TInt CNwssWspCOSession::CloseWspSession()

	{

	iEventDispatcher->Cancel();

	iWspCOSession.CancelAll();

	__TESTOOMD(stkErr, iWspCOSession.Close());

	return stkErr;

	}

void CNwssWspCOSession::CompleteProxyConnectionL()

	{

	__LOG("Sending S-Connect.req primitive")

	// Obtain the client headers

	MWspSessionHeadersProvider& prov = iConnInfoProvider.SessionHeadersProvider();

	const TDesC8& cliHdr = prov.ClientHeaders();

	__LOG("--Client session headers are:")

	__DUMP("--", "--", cliHdr)

	// Prepare the client's proposed capabilities

	PrepareClientCapabilities();

	// Request a connection to the proxy

	__TESTOOMD(error, iWspCOSession.Connect(cliHdr, iCapabilityCodec));

	__LOG1("--RWSPCOConn::Connect() returned with %d", error)

	User::LeaveIfError(error);

	// Ensure the event dispatcher is waiting for stack events

	iEventDispatcher->Start();

	// Unset the connect limbo flag - sent S-Connect.req to WAP Stack.

	iInConnectLimbo = EFalse;

	// Send the waiting method invoke (if exists)

	iConnectGuard->SendMethodInvokeReq();

	}

RWTLS CNwssWspCOSession::WtlsHnd()

	{

	return iWspCOSession.Wtls();

	}

void CNwssWspCOSession::DoRunError(TInt aError)

	{

	// Handling from the parent class state machine's RunError.

	// In all cases, this means that a ConnectReq() call in this class has failed.

	// Hence, a connection will never be possible with the gateway, and we should

	// indicate this to the client using DisconnectInd() to ensure their own notion of

	// the session state is correct.  The WTLS failure mode (aError) is indicated

	// using the disconnect reason.

	__ASSERT_DEBUG( iInConnectLimbo, User::Invariant() );

	__LOG("Returning S-Disconnect.ind primitive")

	// Convert the error code to a WSP reason

	TWspReason reason = Wap::EConnectErr;

	switch (aError)

		{

	case KWtlsErrConfigurationFailed:

		__LOG("--reason: KWtlsErrConfigurationFailed")

		reason = Wap::EWtlsConfigurationFailed;

		break;

	case KWtlsErrPhase1HandshakeFailed:

		__LOG("--reason: KWtlsErrPhase1HandshakeFailed")

		reason = Wap::EWtlsPhase1HandshakeFailed;

		break;

	case KWtlsErrPhase2HandshakeFailed:

		__LOG("--reason: KWtlsErrPhase2HandshakeFailed")

		reason = Wap::EWtlsPhase2HandshakeFailed;

		break;

	case KWtlsErrInvalidServerCert:

		__LOG("--reason: KWtlsErrInvalidServerCert")

		reason = Wap::EWtlsInvalidServerCert;

		break;

	case KWtlsErrUntrustedServerCert:

		__LOG("--reason: KWtlsErrUntrustedServerCert")

		reason = Wap::EWtlsUntrustedServerCert;

		break;

	case KWtlsErrNegotiatedConfigRejected:

		__LOG("--reason: KWtlsErrNegotiatedConfigRejected")

		reason = Wap::EWtlsNegotiatedConfigRejected;

		break;

	case KErrNoMemory:

		__LOG("--reason: KErrNoMemory")

		reason = Wap::EOutOfMemory;

		break;

	default:

		;

		}

	// Need to send S-Disconnect.ind - should deal with an invoked method

	// if it exists.

	iConnectGuard->SendDisconnectInd(reason);

	// Unset the connect limbo flag.

	iInConnectLimbo = EFalse;

	}

TBool CNwssWspCOSession::SubDoCancel()

	{

	// Called from the parent class DoCancel().  Cancel the outstanding requests in this class.

	iEventDispatcher->Cancel();

	// We don't want to return to a disconnected state after this.

	return EFalse;

	}

void CNwssWspCOSession::DisconnectReq(TWspReason aReason)

	{

	__ASSERT_DEBUG(State() != CNwssWspSession::EDisconnected,

					TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EInvalidState));

	__LOG("Sending S-Disconnect.req primitive")

	// Check to see if the S-Connect.req has been sent to the WAP Stack

	if( iInConnectLimbo )

		{

		__LOG("---In connect limbo - cannot send S-Disconnect.req.")

		__LOG("---Cancelling proxy connection process.")

		// No, still trying to connect - cancel the proxy connection

		Cancel();

		// Need to send S-Disconnect.ind - should deal with an invoked method

		// if it exists.

		iConnectGuard->SendDisconnectInd(aReason);

		// Unset the connect limbo flag.

		iInConnectLimbo = EFalse;

		return;

		}

	// Request a disconnect

	__ASSERT_DEBUG(State() == CNwssWspSession::EReady,

					TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EInvalidState));

	__TESTOOMD(error, iWspCOSession.Disconnect());	  

	// Handle OOM separately - we can recover from it.

	if (error == KErrNoMemory)

		{

		ScheduleDelayedOomDisconnect(EFalse);

		return;

		}

	__ASSERT_ALWAYS(error == KErrNone, MapToPanic(error));

	// Inform the transaction event filter that S-Disconnect.req has been sent

	iTransEventFilter->SessionDisconnectRequested();

	// Ensure the event dispatcher is waiting for stack events

	iEventDispatcher->Start();

	}

void CNwssWspCOSession::SuspendReq()

	{

	__LOG("Sending S-Suspend.req primitive")

	// Request suspension

	__TESTOOMD(error, iWspCOSession.Suspend());	  

	__ASSERT_ALWAYS(error == KErrNone, MapToPanic(error));

	// Ensure the event dispatcher is waiting for stack events

	iEventDispatcher->Start();

	}

void CNwssWspCOSession::ResumeReq()

	{

	__LOG("Sending S-Resume.req primitive")

	// Obtain the (possibly updated) client headers

	MWspSessionHeadersProvider& prov = iConnInfoProvider.SessionHeadersProvider();

	const TDesC8& cliHdr = prov.ClientHeaders();

	__LOG("--Client session headers are:")

	__DUMP("--", "--", cliHdr)

	// Request session resume.  Needs a blank RWSPCOConn - what to do with this?

	//@todo - this may require considerable work...

	RWSPCOConn blankConn;

	__TESTOOMD(error, iWspCOSession.Resume(blankConn, cliHdr));

	__ASSERT_ALWAYS(error == KErrNone, MapToPanic(error));

	// Ensure the event dispatcher is waiting for stack events

	iEventDispatcher->Start();

	}

/*

 * Method Invocation API. 

 */

void CNwssWspCOSession::MethodInvokeReq(

								MWspCOMethodCallback&		aMethodCallback, 

								RStringF					aMethod, 

								const TUriC8&				aRequestUri, 

								const TDesC8&				aRequestHeaders, 

								const TDesC8&				aRequestBody,

								TBool						aMoreData

								)

	{

	__LOG("Sending T-MethodInvoke.req primitive")

#ifdef __DEBUG

	if( aMoreData )

		{

		__LOG("Attempt to send T-MethodInvoke.req primitive failed because")

		__LOG("Large Data Transfer is not supported in this WAP Stack.")

		}

#endif

	__ASSERT_ALWAYS( !aMoreData, TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::ELargeDataTransferNotSupported) );

	if( iInConnectLimbo )

		{

		__LOG("--In connect limbo - cannot send T-MethodInvoke.req.")

		__LOG("--Save information for later...")

		TRAPD(error, __DEBUGTESTLEAVE \

					  iConnectGuard->ReceivedMethodInvokeReqL(

														 aMethodCallback,

														 aMethod,

														 aRequestUri,

														 aRequestHeaders,

														 aRequestBody

														 ) );

		__ASSERT_ALWAYS( error == KErrNone, TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EDeferedMethodFailed) );

		return;

		}

	__ASSERT_ALWAYS(iWspCOSession.SubSessionHandle() != KNullHandle, TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::ESessionNotConnected));

	RWAPConn::TMethod method = RWAPConn::EGet;

	const TDesC8& methodName = aMethod.DesC();

	__LOG1("--Method is '%S'", &methodName);

	if (methodName.CompareF(KGet) == 0)

		method = RWAPConn::EGet;

	else if (methodName.CompareF(KPost) == 0)

		method = RWAPConn::EPost;

	else if (methodName.CompareF(KHead) == 0)

		method = RWAPConn::EHead;

	else if (methodName.CompareF(KTrace) == 0)

		method = RWAPConn::ETrace;

	else if (methodName.CompareF(KOptions) == 0)

		method = RWAPConn::EOptions;

	else if (methodName.CompareF(KPut) == 0)

		method = RWAPConn::EPut;

	else if (methodName.CompareF(KDelete) == 0)

		method = RWAPConn::EDelete;

	else

		// @todo  -  extension methods?

		TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EUnknownMethod);

	// Convert the URI to Unicode

	__LOG1("--URI is '%S'", &(aRequestUri.UriDes()));

	if (aRequestUri.UriDes().Length() > KMaxUriLength)

		TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EURIOverflow);

	iUriBuffer->Des().Copy(aRequestUri.UriDes());

	// Log headers

	__LOG("--Encoded WSP header is:")

	__DUMP("--", "--", aRequestHeaders)

	// Log body data

	__LOG("--Body data is:")

	__DUMP("--", "--", aRequestBody)

	// Get the next look-up table entry for the new transaction

	CNwssTransLookUpTable::CNwssTransLUTEntry& entry = iCOTransTable->NewEntry();

	entry.iCallback = &aMethodCallback;

	// Create the WSP transaction on the WAP stack, and handle any resulting error

	__TESTOOMD(error, iWspCOSession.CreateTransaction(method, *iUriBuffer, aRequestHeaders, aRequestBody, entry.iStackTrans));

	__LOG1("--RWSPCOConn::CreateTransaction() returned %d", error);

	// Handle OOM separately - we can recover from it.

	if (error == KErrNoMemory)

		{

		ScheduleDelayedOomMethodAbort(*(entry.iCallback), EFalse);

		return;

		}

	else

		// But any other error is due to a client programming error, so panic

		__ASSERT_ALWAYS(error == KErrNone, MapToPanic(error));

	// Get the transaction ID

	error = entry.iStackTrans.Id(entry.iStackTransID);

	__LOG1("--RWSPCOTrans::Id() returned %d", error);

	__ASSERT_ALWAYS(error == KErrNone, MapToPanic(error));

	__LOG1("--Transaction Id is %d", entry.iStackTransID);

	// Ensure the event dispatcher is waiting for stack events

	iEventDispatcher->Start();

	}

void CNwssWspCOSession::MethodInvokeDataReq(

									MWspCOMethodCallback&	/*aTransactionCallback*/,

									const TDesC8&			/*aRequestBody*/,

									const TDesC8&			/*aTrailerHeaders*/,

									TBool					/*aMoreData*/

									)	

	{

	__LOG("Attempt to send T-MethodInvokeData.req primitive failed because")

	__LOG("Large Data Transfer is not supported in this WAP Stack.")

	TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::ELargeDataTransferNotSupported);

	}

void CNwssWspCOSession::MethodAbortReq(MWspCOMethodCallback& aMethodCallback)

	{

	__LOG("Sending T-MethodAbort.req primitive")

	// Check to see if the T-MethodInvoke.req primitive has been sent

	if( iInConnectLimbo )

		{

		__LOG("--In connect limbo - cannot send T-MethodAbort.req.")

		__LOG("--Delete waiting method")

		// Send the T-MethodAbort.ind

		iConnectGuard->SendMethodAbortInd();

		return;

		}

	TBool found = EFalse;

	CNwssTransLookUpTable::CNwssTransLUTEntry& lutEntry = iCOTransTable->LookUpByCallback(aMethodCallback,

																  found);

	if (found)

		{

		__LOG1("--Transaction Id is %d", lutEntry.iStackTransID);

		// Abort the transaction - choose an abort reason from the WSP spec since

		// <wapcli.h> doesn't enumerate it  :(

		// Unfortunately the NWSS stack moves the state to 'Done' prematurely, so

		// check for that now.

		RWSPCOTrans::TState trState = RWSPCOTrans::EInit;

		__TESTOOMD(stkErr, lutEntry.iStackTrans.GetState(trState));

		__LOG1("--Transaction is in state %d", trState);

		__LOG1("--RWSPCOTrans::GetState() returned %d", stkErr);

		if (trState != RWSPCOTrans::EDone)

			{

			__TESTOOM(stkErr, lutEntry.iStackTrans.Abort(EUserReq));

			__LOG1("--RWSPCOTrans::Abort() returned %d", stkErr);

			// Ensure the event dispatcher is waiting for stack events

			iEventDispatcher->Start();

			}

		else

			{