// 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 <http/framework/crxdata.h>

#include <http/rhttpheaders.h>

#include <http/thttpevent.h>

#include <httpstringconstants.h>

#include <wsp/wsptypes.h>

#include <wsp/cwsptransporthandler.h>

#include <wsp/mwspcosessioninvoker.h>

#include <wsp/mwspcomethodinvoker.h>

#include <wspstringconstants.h>

#include <wspstdconstants.h>

#include <wsperror.h>

// User includes

#include "cwspcotransaction.h"

#include "cwspcapabilityinfo.h"

#include "cwspproxyinfoprovider.h"

#include "cconnectiontimer.h"

#include "cwspprimitivesender.h"

#include "wsppanic.h"

#include "cwspheaderutils.h"

#include "cwspheadercodec.h"

// Class signature

#include "cwspcoprotocolhandler.h"

const TInt KDefaultConnectionTimeMicroSeconds	= 180000000;		// 3 minutes

/*

 * CWspCOProtocolHandler

 */

CWspCOProtocolHandler* CWspCOProtocolHandler::NewL(TAny* aSession)

	{

	RHTTPSession* session = REINTERPRET_CAST(RHTTPSession*, aSession);

	CWspCOProtocolHandler* self = new (ELeave) CWspCOProtocolHandler(*session);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CWspCOProtocolHandler::~CWspCOProtocolHandler()

	{

	if( iConnectionTimer )

		iConnectionTimer->Cancel();

	delete iConnectionTimer;

	delete iClientSessionHeaders;

	delete iTransportHandler;

	delete iClientCapInfo;

	delete iNegotiatedCapInfo;

	delete iProxyInfoProvider;

	delete iPrimitiveSender;

	delete iHdrUtils;

	}

CWspCOProtocolHandler::CWspCOProtocolHandler(RHTTPSession aSession)

: CProtocolHandler(aSession), /*iSessionState(ENull),*/ iTimedOutValue(KDefaultConnectionTimeMicroSeconds)

	{

	__OPEN_LOG("WspProtocolHandler.txt")

	}

void CWspCOProtocolHandler::ConstructL()

	{

	CProtocolHandler::ConstructL(iSession);

	// Open the WSP header field names table

	iSession.StringPool().OpenL(WSP::Table);

	// Create the proposed client capability object and the negotiated session capability object

	iClientCapInfo = CWspCapabilityInfo::NewL();

	iNegotiatedCapInfo = CWspCapabilityInfo::NewL();

	// Create the proxy info provider

	iProxyInfoProvider = CWspProxyInfoProvider::NewL(iSession);

	// Create the connection timer object

	iConnectionTimer = CConnectionTimer::NewL(*this);

	// Create the primitive sender active object

	iPrimitiveSender = CWspPrimitiveSender::NewL(*this);

	// Create the transport handler

	CreateWspTransportHandlerL();

	// Create the WSP header utilities

	iHdrUtils = CWspHeaderUtils::NewL(*STATIC_CAST(CWspHeaderCodec*, iCodec));

	}

void CWspCOProtocolHandler::CreateWspTransportHandlerL()

	{

	// Assert that the transport handler doesn't already exist

	__ASSERT_DEBUG(iTransportHandler == NULL, Panic(KWspPanicTransportHandlerAlreadyExists));

	// Pass through the session string pool when creating the transport handler

	RStringPool stringPool = iSession.StringPool();

	iTransportHandler = CWspTransportHandler::NewL(

												  stringPool,

												  iSecurityPolicy,

												  *this,				// Session CB

												  *iProxyInfoProvider,	// Proxy info

												  *this,				// Capability info

												  *this					// Session headers info

												  );

	// Check the supported services

	CWspTransportHandler::TWspSupportedServices suppSvc = iTransportHandler->SupportedServices();

	TBool sessionSupport = suppSvc & CWspTransportHandler::ECOSessionService;

	TBool methodSupport  = suppSvc & CWspTransportHandler::ECOMethodInvocationService;

	if( !sessionSupport || !methodSupport )

		{

		__LOG(_L("Session management facility or method invoke facility not supported by transport handler"));

		User::Leave(KWspErrRequiredServicesNotSupported);

		}

	// Configure the session invoker object

	iSessionInvoker = &iTransportHandler->COSessionInvoker();

	}

void CWspCOProtocolHandler::CheckClientCapabilities()

	{

	// Reset the proposed client properties - sets the capabilities to the 

	// default values.

	iClientCapInfo->Reset();

	// Check the session properties...

	RHTTPConnectionInfo	connInfo = iSession.ConnectionInfo();

	RStringPool stringPool = iSession.StringPool();

	// ...client message size...

	THTTPHdrVal clientMessageSize;

	TBool hasClientMessageSize = connInfo.Property(stringPool.StringF(HTTP::EWspCapClientMessageSize, RHTTPSession::GetTable()), clientMessageSize);

	if( hasClientMessageSize )

		{

		// Initial attempt to negotiate message size and SDU size will attempt to go

		// for a single PDU transfers, so set them the same

		__ASSERT_DEBUG( clientMessageSize.Type() == THTTPHdrVal::KTIntVal, Panic(KWspPanicBadClientMessageSize) );

		iClientCapInfo->SetClientMessageSize(clientMessageSize.Int());

		iClientCapInfo->SetClientSDUSize(clientMessageSize.Int());

		}

	// ... server message size...

	THTTPHdrVal serverMessageSize;

	TBool hasServerMessageSize = connInfo.Property(stringPool.StringF(HTTP::EWspCapServerMessageSize, RHTTPSession::GetTable()), serverMessageSize);

	if( hasServerMessageSize )

		{

		// Initial attempt to negotiate message size and SDU size will attempt to go

		// for a single PDU transfers, so set them the same

		__ASSERT_DEBUG( serverMessageSize.Type() == THTTPHdrVal::KTIntVal, Panic(KWspPanicBadServerMessageSize) );

		iClientCapInfo->SetServerMessageSize(serverMessageSize.Int());

		iClientCapInfo->SetServerSDUSize(serverMessageSize.Int());

		}

	// ...method MOR...

	THTTPHdrVal methodMOR;

	TBool hasMethodMOR = connInfo.Property(stringPool.StringF(HTTP::EWspCapMaxOutstandingRequests, RHTTPSession::GetTable()), methodMOR);

	if( hasMethodMOR )

		{

		__ASSERT_DEBUG( methodMOR.Type() == THTTPHdrVal::KTIntVal, Panic(KWspPanicBadMethodMOR) );

		__ASSERT_DEBUG( STATIC_CAST(TUint8, methodMOR.Int()) <= KMaxTUint8, Panic(KWspPanicBadMethodMOR) );

		__ASSERT_DEBUG( STATIC_CAST(TUint8, methodMOR.Int()) > 0, Panic(KWspPanicBadMethodMOR) );

		iClientCapInfo->SetMethodMOR( STATIC_CAST(TUint8, methodMOR.Int()) );

		}

	// Sort out the protocol options - by default try to use Large Data Transfer

	TUint8 protocolOptions = ELargeDataTransfer;

	THTTPHdrVal notUsed;

	// ...use acknowledgements...

	TBool hasUseAcknowledgements = connInfo.Property(stringPool.StringF(HTTP::EWspCapUseAcknowledgements, RHTTPSession::GetTable()), notUsed);

	if( hasUseAcknowledgements )

		{

		protocolOptions |= EAcknowledgementHeaders;

		}

	// ...support suspend resume facilty...

	TBool hasSuspendResume = connInfo.Property(stringPool.StringF(HTTP::EWspCapSupportSuspendResume, RHTTPSession::GetTable()), notUsed);

	if( hasSuspendResume )

		{

		protocolOptions |= ESessionResumeFacility;

		}

	iClientCapInfo->SetProtocolOptions(protocolOptions);

	// Get the connection time-out value

	THTTPHdrVal connectionTimeout;

	TBool hasConnectionTimeout = connInfo.Property(stringPool.StringF(HTTP::EWspProxyConnectionTimeout, RHTTPSession::GetTable()), connectionTimeout);

	if( hasConnectionTimeout )

		{

		__ASSERT_DEBUG((connectionTimeout.Type() == THTTPHdrVal::KTIntVal), Panic(KWspPanicBadConenctionTimeout));

		iTimedOutValue = connectionTimeout.Int();

		}

	else

		{

		// Use the default value

		iTimedOutValue = KDefaultConnectionTimeMicroSeconds;

		}

	}

TBool CWspCOProtocolHandler::UpdateNegotiatedCapabilitiesL()

	{

	// Check the capabilities proposed by the client

	TBool capabilitiesReduced = EFalse;

	RHTTPConnectionInfo	connInfo = iSession.ConnectionInfo();

	RStringPool stringPool = iSession.StringPool();

	// ...client message size...

	TUint32 clientMessageSize = iNegotiatedCapInfo->GetClientMessageSize();

	if( clientMessageSize != iClientCapInfo->GetClientMessageSize() )

		{

		// The server has reduced the client message size - update the return flag...

		capabilitiesReduced = ETrue;

		// ...and the session property...

		THTTPHdrVal clientMessageSizeProperty = clientMessageSize;

		connInfo.SetPropertyL(stringPool.StringF(HTTP::EWspCapClientMessageSize, RHTTPSession::GetTable()), clientMessageSizeProperty);

		}

	// ...server message size...

	TUint32 serverMessageSize = iNegotiatedCapInfo->GetServerMessageSize();

	if( serverMessageSize != iClientCapInfo->GetServerMessageSize() )

		{

		// The server has reduced the server message size - update the return flag...

		capabilitiesReduced = ETrue;

		// ...and the session property...

		THTTPHdrVal serverMessageSizeProperty = serverMessageSize;

		connInfo.SetPropertyL(stringPool.StringF(HTTP::EWspCapServerMessageSize, RHTTPSession::GetTable()), serverMessageSizeProperty);

		}

	// ...method MOR...

	TUint32 methodMOR = iNegotiatedCapInfo->GetMethodMOR();

	if( methodMOR != iClientCapInfo->GetMethodMOR() )

		{

		// The server has reduced the method MOR - update the return flag...

		capabilitiesReduced = ETrue;

		// ...and the session property...

		THTTPHdrVal methodMORProperty = methodMOR;

		connInfo.SetPropertyL(stringPool.StringF(HTTP::EWspCapMaxOutstandingRequests, RHTTPSession::GetTable()), methodMORProperty);

		}

	// Check the protocol options

	TUint8 protocolOptions = iNegotiatedCapInfo->GetProtocolOptions();

	// ...acknowledgements...

	if( (protocolOptions & EAcknowledgementHeaders) != (iClientCapInfo->GetProtocolOptions() & EAcknowledgementHeaders) )

		{

		// The server has cleared the use acknowledgement headers flag - update

		// the return flag...

		capabilitiesReduced = ETrue;

		// ...and the session property...

		THTTPHdrVal notUsed = 0;

		connInfo.SetPropertyL(stringPool.StringF(HTTP::EWspCapUseAcknowledgements, RHTTPSession::GetTable()), notUsed);

		}

	// ...suspend resume facility...

	if( (protocolOptions & ESessionResumeFacility) != (iClientCapInfo->GetProtocolOptions() & ESessionResumeFacility) )

		{

		// The server has cleared the support suspend/resume facility flag - 

		// update the return flag...

		capabilitiesReduced = ETrue;

		// ...and the session property...

		THTTPHdrVal notUsed = 0;

		connInfo.SetPropertyL(stringPool.StringF(HTTP::EWspCapSupportSuspendResume, RHTTPSession::GetTable()), notUsed);

		}

	return capabilitiesReduced;

	}

TBool CWspCOProtocolHandler::SupportSuspendResume() const

	{

	return (iNegotiatedCapInfo->GetProtocolOptions() & ESessionResumeFacility);

	}

TBool CWspCOProtocolHandler::CanResume() const

	{

	TBool canResume = SupportSuspendResume();

	if( canResume && (iSessionState != EConnected && iSessionState != ESuspending && iSessionState != ESuspended) )

		{

		// In the wrong state

		canResume = EFalse;

		}

	return canResume;

	}

TBool CWspCOProtocolHandler::CanSuspend() const

	{

	TBool canSuspend = SupportSuspendResume();

	if( canSuspend && (iSessionState != EConnected && iSessionState != EResuming) )

		{

		// In the wrong state

		canSuspend = EFalse;

		}

	return canSuspend;

	}

#if defined (_DEBUG)

void CWspCOProtocolHandler::ResetAll()

	{

	// Delete helper objects and reset state

	delete iClientSessionHeaders;

	iClientSessionHeaders = NULL;

	// 

	if (iClientCapInfo)

		iClientCapInfo->Reset();

	if (iNegotiatedCapInfo)

		iNegotiatedCapInfo->Reset();

	if (iConnectionTimer)

		iConnectionTimer->Cancel();

	if (iProxyInfoProvider)

		iProxyInfoProvider->ResetProxyInfo();

	//

	iSessionState = ENull; 

	iTimedOutValue = 0;

	iConnectTimedOut = EFalse;

	iWaitingMethod  = EFalse;

	iDisconnectRequested = EFalse;

	iPendingCompletingMethods = 0;

	//

	// Reset the transport handler (stub only)

	iSessionInvoker->DisconnectReq((TWspReason)(-999));

	}

#endif

void CWspCOProtocolHandler::SessionConnectL()

	{

	__ASSERT_DEBUG( iSessionState == ENull, Panic(KWspPanicSessionNotInValidState) );

	__LOG(_L("Initiating a session connect."));

	// Check for any client proposed capabilities

	CheckClientCapabilities();

	// Update the client session headers

	UpdateClientSessionHeadersL();

	// Update the proxy info

	iProxyInfoProvider->UpdateProxyInfoL();

	// Start connection timed-out timer

	iConnectionTimer->Start(iTimedOutValue);

	// Send S-Connect.req primitive to transport handler

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

	iSessionInvoker->ConnectReq();

	// Update session state

	__LOG(_L("---WSP Session in Connecting state."));

	iSessionState = EConnecting;

	// Check to see if there is a method transactions waiting.

	CheckWaitingMethod();

	}

void CWspCOProtocolHandler::SessionResumeL()

	{

	__ASSERT_DEBUG( CanResume(), Panic(KWspPanicSessionNotInValidState) );

	__LOG(_L("Initiating a session resume."));

	// Check to see if the proxy info has not changed.

	if( iProxyInfoProvider->ProxyInfoChangedAndUpdateL() )

		{

		__LOG(_L("---Proxy has changed. Disconnect from the old proxy and connect to the new one."));

		// The client has specified a different - disconnect this session

		SessionDisconnect(EChangedProxyInSuspendedSession);

		}

	else

		{

		// Check for any client proposed capabilities

		CheckClientCapabilities();

		// Update the client session headers

		UpdateClientSessionHeadersL();

		// Start connection timed-out timer

		iConnectionTimer->Start(iTimedOutValue);

		// Send S-Resume.req primitive to transport handler

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

		iSessionInvoker->ResumeReq();

		// Update session state

		__LOG(_L("---WSP Session in Resuming state."));

		iSessionState = EResuming;

		// Check to see if there is a method transactions waiting.

		CheckWaitingMethod();

		}

	}

void CWspCOProtocolHandler::SessionDisconnect(TWspReason aReason)

	{

	__ASSERT_DEBUG( iSessionState != ENull && iSessionState != EClosing, Panic(KWspPanicSessionNotInValidState) );

	// Are there any methods waiting to send their final .res primitive

	if( iPendingCompletingMethods > 0 )

		{

		// Yep, need to wait until there are done.

		iDisconnectRequested = ETrue;

		return;

		}

	__LOG(_L("Disconnecting session."));

	// Need to cancel the connection timer

	iConnectionTimer->Cancel();

	// Send S-Disconnect.req primitive to transport handler

	__LOG1(_L("---Sending S-Disconnect.req primitive. Reason code : %d"), aReason);

	iSessionInvoker->DisconnectReq(aReason);

	// Update session state

	__LOG(_L("---WSP Session in Closing state."));

	iSessionState = EClosing;

	}

void CWspCOProtocolHandler::SessionSuspend()

	{

	__ASSERT_DEBUG( CanSuspend(), Panic(KWspPanicSessionNotInValidState) );

	// Are there any methods waiting to send their final .res primitive

	if( iPendingCompletingMethods > 0 )

		{

		// Yep, need to wait until there are done.

		iDisconnectRequested = ETrue;

		return;

		}

	__LOG(_L("Suspending session."));

	// Need to cancel the connection timer

	iConnectionTimer->Cancel();

	// Send S-Suspend.req primitive to transport handler

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

	iSessionInvoker->SuspendReq();

	// Update session state

	__LOG(_L("---WSP Session in Suspending state."));

	iSessionState = ESuspending;

	}

void CWspCOProtocolHandler::DoSessionConnectedL()

	{

	// Cancel the connection timer

	iConnectionTimer->Cancel();

	// Check for the Encoding-Version header in the server session headers

 	RHTTPHeaders headers = iSession.ResponseSessionHeadersL();

 	THTTPHdrVal negotiatedVersion;

 	TInt err = headers.GetField(

 							   iSession.StringPool().StringF(WSP::EEncodingVersion, WSP::Table),

 							   0,		// Zero index -> first part

 							   negotiatedVersion

 							   );

	// Default version is 1.2 - this is the case if the header is missing.

 	CWspHeaderCodec::TWspVersion version = CWspHeaderCodec::EVersion1_2;

	if( (err != KErrNotFound) && (negotiatedVersion.Type() == THTTPHdrVal::KStrFVal) )

 		{

 		// Check what version the encoding is and set it accordingly in the codec

		switch(negotiatedVersion.StrF().Index(WSPStdConstants::Table) )

			{

			case WSPStdConstants::EWspVersion11:

				version = CWspHeaderCodec::EVersion1_1;

				break;

			case WSPStdConstants::EWspVersion13:

				version = CWspHeaderCodec::EVersion1_3;

				break;

			case WSPStdConstants::EWspVersion14:

				version = CWspHeaderCodec::EVersion1_4;

				break;

			default:

				// If the version is 1.2 or anything else, stay at 1.2

				break;

			}

 		}

	// Set the encoding value in the codec

	STATIC_CAST(CWspHeaderCodec*, iCodec)->SetWspVersion(version);

	// Inform client that the session is connected - check negotiated capabilities

	THTTPSessionEvent connectEvent = THTTPSessionEvent::EConnectedOK;

	// Check the negotiated capabilities

 	TBool capabilitiesReduced = UpdateNegotiatedCapabilitiesL();

	if( capabilitiesReduced )

		{

		// At least one of the proposed client capabilities has been negotiated 

		// down or rejected - need to inform client of this event.

		connectEvent = THTTPSessionEvent::EConnectedWithReducedCapabilities;

		}

	SendSessionEvent(connectEvent);

	// WSP session is connected - update state

	__LOG(_L("---WSP Session in Connected state"));

	iSessionState = EConnected;

	}

void CWspCOProtocolHandler::SendSessionEvent(THTTPSessionEvent aEvent)

	{

	// Send the event to the client - need to TRAPD

	TRAPD(error, iSession.SendSessionEventL(aEvent, THTTPSessionEvent::EIncoming, THTTPFilterHandle::EProtocolHandler));

	if( error != KErrNone )

		{

		__LOG1(_L("Error - Could not send event to the client, error code %d"), error);

		iSession.FailSessionEvent(THTTPFilterHandle::EProtocolHandler);

		}

	}

void CWspCOProtocolHandler::UpdateClientSessionHeadersL()

	{

	// Check for Encoding-Version header

	RStringPool stringPool = iSession.StringPool();