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

// $Header$

// This module implements the HTTP Framework clas

// by:		irees, December 2002

// for:	Typhoon (7.0s) & JetStream (8.0)

// Include Files  

// 

//

#include <commdbconnpref.h>

#include "CHTTPFamily.h"

#include "HttpFrmwrk.h"

#include "CWspEventDispatcher.h"

//-----------------------------------------------------------------------------

_LIT(KITHIAP, "IAP");				//	Integration Test Harness $$ var name

// Proxy information properties

_LIT(KITHWspProxyAddress, "ProxyAddress");

_LIT(KITHWspBearer,"Bearer");

_LIT(KITHWspLocalPort, "LocalPort");

_LIT(KITHWspRemotePort, "RemotePort");

_LIT(KITHWspServiceNumber, "ServiceNumber");

_LIT(KITHWspSessionType, "SessionType");

_LIT(KITHWspSecurity, "Security");

_LIT(KITHWspBearerSMS, "SMS");

_LIT(KITHWspSessionTypeCL, "ConnectionLess");

_LIT(KITHWspSecurityUseWTLS, "UseWTLS");

// Capability properties

_LIT(KITHWspClientMsgSize, "ClientMsgSize");

_LIT(KITHWspServerMsgSize, "ServerMsgSize");

_LIT(KITHWspUseAcknowledgements, "UseAcknowldegements");

_LIT(KITHWspSupportSuspendResume, "SupportSuspendResume");

_LIT(KITHWspMaxOutstandingRequests, "MaxOutstandingRq");

CFrmwrkSession *CFrmwrkSession::NewL(const TDesC& aName,

									 const TDesC& aFramework, 

									 CTEngine *aTestMachine)

	{

	CFrmwrkSession *self = NewLC( aName, aFramework, aTestMachine );

	CleanupStack::Pop();

	return self; 

	}

//-----------------------------------------------------------------------------

CFrmwrkSession *CFrmwrkSession::NewLC(const TDesC& aName,

									  const TDesC& aFramework, 

									  CTEngine *aTestMachine)

	{

	CFrmwrkSession *self = new (ELeave) CFrmwrkSession();

	CleanupStack::PushL(self);

	self->ConstructL(aName, aFramework, aTestMachine);

	return self;

	}

//-----------------------------------------------------------------------------

void CFrmwrkSession::ConstructL(const TDesC& aName,

								const TDesC& aFramework,

								CTEngine *aTestMachine)

	{

	iEngine = aTestMachine ;

	iName = aName.AllocLC();

	CleanupStack::Pop();

	iState = ENormal;

	iuseWSPProtocol = (aFramework.CompareF(THA_KTxtFrameworkWSP) == 0);

	}

//-----------------------------------------------------------------------------

CFrmwrkSession::~CFrmwrkSession(void)

	{

	delete iName;

	}

void CFrmwrkSession::Log(TRefByValue<const TDesC> aFmt, ... )

	{

	VA_LIST list;

	VA_START(list, aFmt);

	Machine()->MsgPrintfln(aFmt, list);

	}

TInt CFrmwrkSession::OpenL()

	{

	if (iuseWSPProtocol)

		{

		iSession.OpenL(_L8("WSP/WSP"));

		}

	else

	{

		iSession.OpenL();

	}

	iSession.SetSessionEventCallback(this);

	return 0 ;

	}

TInt CFrmwrkSession::Close()

	{

	iSession.Close(); 

	iConnection.Close() ;

	return 0 ;

	}

TInt CFrmwrkSession::DisconnectL()

	{

	TPtrC myName = Name() ;

	Log(_L("Disconnecting %S"), &myName);

	iState = EWSPDisconnecting;

	iSession.DisconnectL();

	return 0 ;

	}

//-----------------------------------------------------------------------------

void CFrmwrkSession::SetWspProxyPropertiesL(RHTTPSession & aSession, RStringPool &aStrPool)

	{

	RHTTPConnectionInfo connInfo = aSession.ConnectionInfo();

	TPtrC valuePtr; 

	valuePtr.Set (Machine()->GetDefine(KITHWspProxyAddress));

	if (valuePtr.Length() != 0)

		{

		HBufC8* valueBuff8 = HBufC8::NewLC(valuePtr.Length());

		TPtr8 valuePtr8 = valueBuff8->Des();

		valuePtr8.Copy(valuePtr);

		RStringF value = aStrPool.OpenFStringL(valuePtr8);

		CleanupClosePushL(value);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspProxyAddress, RHTTPSession::GetTable()), value);

		CleanupStack::PopAndDestroy(2); 

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspBearer));

	if (valuePtr.Length() != 0)

		{

		RStringF bearer;

		if (valuePtr.CompareF(KITHWspBearerSMS)==0)

			bearer = aStrPool.StringF(HTTP::EWspSMS, RHTTPSession::GetTable());

		else

			bearer = aStrPool.StringF(HTTP::EWspIp, RHTTPSession::GetTable());

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspBearer, RHTTPSession::GetTable()), bearer);

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspLocalPort));

	if (valuePtr.Length() != 0)

		{

		TLex lex(valuePtr);

		TInt localPort = 0;

		lex.Val(localPort);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspLocalPort, RHTTPSession::GetTable()), localPort);

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspRemotePort));

	if (valuePtr.Length() != 0)

		{

		TLex lex(valuePtr);

		TInt remotePort = 0;

		lex.Val(remotePort);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspRemotePort, RHTTPSession::GetTable()), remotePort);

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspServiceNumber));

	if (valuePtr.Length() != 0)

		{

		HBufC8* valueBuff8 = HBufC8::NewLC(valuePtr.Length());

		TPtr8 valuePtr8 = valueBuff8->Des();

		valuePtr8.Copy(valuePtr);

		RStringF value = aStrPool.OpenFStringL(valuePtr8);

		CleanupClosePushL(value);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspServiceNumber, RHTTPSession::GetTable()), value);

		CleanupStack::PopAndDestroy(2); 

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspSessionType));

	if (valuePtr.Length() != 0)

		{

		RStringF sessionType;

		if (valuePtr.CompareF(KITHWspSessionTypeCL)==0)

			sessionType = aStrPool.StringF(HTTP::EWspConnectionLess, RHTTPSession::GetTable());

		else

			sessionType = aStrPool.StringF(HTTP::EWspConnectionOriented, RHTTPSession::GetTable());

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspSessionType, RHTTPSession::GetTable()), sessionType);

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspSecurity));

	if (valuePtr.Length() != 0)

		{

		RStringF security;

		if (valuePtr.CompareF(KITHWspSecurityUseWTLS)==0)

			security = aStrPool.StringF(HTTP::EWspUseWtls, RHTTPSession::GetTable());

		else

			security = aStrPool.StringF(HTTP::EWspDoNotUseWtls, RHTTPSession::GetTable());

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspSecurity, RHTTPSession::GetTable()), security);

		}

}

void CFrmwrkSession::SetWspCapabilityPropertiesL(RHTTPSession & aSession, RStringPool &aStrPool)

	{

	RHTTPConnectionInfo connInfo = aSession.ConnectionInfo();

	TPtrC valuePtr; 

	valuePtr.Set (Machine()->GetDefine(KITHWspClientMsgSize));

	if (valuePtr.Length() != 0)

		{

		TLex lex(valuePtr);

		TInt cliMsgSize = 0;

		lex.Val(cliMsgSize);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspCapClientMessageSize, RHTTPSession::GetTable()), cliMsgSize);

		}

	valuePtr.Set (Machine()->GetDefine(KITHWspServerMsgSize));

	if (valuePtr.Length() != 0)

		{

		TLex lex(valuePtr);

		TInt srvMsgSize = 0;

		lex.Val(srvMsgSize);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspCapServerMessageSize, RHTTPSession::GetTable()), srvMsgSize);

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspUseAcknowledgements));

	if (valuePtr.Length() != 0)

		{

		if (valuePtr.CompareF(KTxtTrue)==0)

			connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspCapUseAcknowledgements, RHTTPSession::GetTable()), THTTPHdrVal(1));

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspSupportSuspendResume));

	if (valuePtr.Length() != 0)

		{

		if (valuePtr.CompareF(KTxtTrue)==0)

			connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspCapSupportSuspendResume, RHTTPSession::GetTable()), THTTPHdrVal(1));

		}

	valuePtr.Set(Machine()->GetDefine(KITHWspMaxOutstandingRequests));

	if (valuePtr.Length() != 0)

		{

		TLex lex(valuePtr);

		TInt maxOutReqs = 0;

		lex.Val(maxOutReqs);

		connInfo.SetPropertyL(aStrPool.StringF(HTTP::EWspCapMaxOutstandingRequests, RHTTPSession::GetTable()), maxOutReqs);

		}

	}

TPtrC CFrmwrkSession::Name() const

	{

	TPtrC name(iName->Des());

	return name;

	}

TInt CFrmwrkSession::SetPropertiesL()

	{	

	if (iuseWSPProtocol)

		{

		RStringPool strPool = iSession.StringPool();

		SetWspProxyPropertiesL(iSession, strPool);

		SetWspCapabilityPropertiesL(iSession, strPool);

		}

	return 0 ;

	}

TInt CFrmwrkSession::ConnectL()

	{

	iState = EWSPConnecting;

	iSession.ConnectL();

	TBuf8<16> bufCommDbId;

	TInt commDbId = 0 ;

	bufCommDbId.Copy(iEngine->GetDefine(KITHIAP));

	if (bufCommDbId.Length())

		{	

		TLex8 lexer(bufCommDbId);

		if ((lexer.Val(commDbId) != KErrNone) || (commDbId < 0) || (commDbId > 8))

			{

			Log(THA_KFmtErrIAPVal, &bufCommDbId);

			return (KErrArgument) ;

			}

		}

	if (commDbId)

		{

		RSocketServ sock;

		User::LeaveIfError(sock.Connect());

		TCommDbConnPref prefs1;

		prefs1.SetIapId(commDbId);

		//Start Connection1

		User::LeaveIfError(iConnection.Open(sock));

		User::LeaveIfError(iConnection.Start(prefs1));

		//Set properties for mySession

		RStringPool strPool = iSession.StringPool();

		RHTTPConnectionInfo connInfo1 = iSession.ConnectionInfo();

		connInfo1.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketServ, 

								 RHTTPSession::GetTable() ), 

								 THTTPHdrVal (sock.Handle()) );

		TInt connPtr = REINTERPRET_CAST(TInt, &iConnection);

		connInfo1.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketConnection, 

								 RHTTPSession::GetTable() ), 

								 THTTPHdrVal (connPtr) );

		}

	InstallAuthenticationL(iSession);

	return 0 ;

	}

//-----------------------------------------------------------------------------

//	Called when a authenticated page is requested

//	Asks the user for a username and password that would be appropriate for the url that was

//	supplied.

TBool CFrmwrkSession::GetCredentialsL(	const TUriC8& aURI, 

										RString aRealm, 

										RStringF aAuthenticationType,

										RString& aUsername, 

										RString& aPassword)

	{

	TBuf<80> scratch;

	TBuf8<80> scratch8;

	scratch8.Format(_L8("Enter credentials for URL %S, realm %S"), &aURI.UriDes(), &aRealm.DesC());

	scratch.Copy(scratch8);

	Log(_L("%S"), &scratch);

	scratch.Copy(aAuthenticationType.DesC());

	Log(_L("Using %S authentication"), &scratch);

	Machine()->GetUserInput(_L("Username (or QUIT to give up): "), scratch);

	scratch8.Copy(scratch);

	if (scratch8.CompareF(_L8("quit")))

		{

		TRAPD(err, aUsername = aRealm.Pool().OpenStringL(scratch8));

		if (!err)

			{

			Machine()->GetUserInput(_L("Password: "), scratch);

			scratch8.Copy(scratch);

			TRAP(err, aPassword = aRealm.Pool().OpenStringL(scratch8));

			if (!err)

				return ETrue;

			}

		}

	return EFalse;

	}

void CFrmwrkSession::MHFSessionRunL(const THTTPSessionEvent& aEvent)

	{

	TPtrC name = Name() ;

	switch (aEvent.iStatus)

		{

		case THTTPSessionEvent::EConnect:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, event EConnect, Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EConnectedOK:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, The session has been connected, , Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EDisconnect:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, EDisconnect - shouldnt get this because it is an outgoing event, Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EConnectedWithReducedCapabilities:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, Session connected with reduced capabilities, , Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EDisconnected:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, Session %S has been disconnected"), 

				&name);

			} 

			break;

		case THTTPSessionEvent::EAuthenticatedOK:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, the authentication handshake succeeded, Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EAuthenticationFailure:

			{

			Log(_L("CFrmwrkSession::MHFSessionRunL, the authentication handshake failed, Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::EConnectionTimedOut:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, the connection attempt to the proxy timed out, Session %S"),

				&name);

			} break;

		case THTTPSessionEvent::ENotConnected:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, ENotConnected, Session %S"),

				&name);

			}

			break;

		case THTTPSessionEvent::EExceptionInfo: 

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, EExceptionInfo, Session %S"),

				&name);

			}

			break;

		case THTTPSessionEvent::ERedirected:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, ERedirected, Session %S"),

				&name);

			} 

			break;

		case THTTPSessionEvent::EAlreadyConnecting:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, EAlreadyConnecting, Session %S"),

				&name);

			} 

			break;

		case THTTPSessionEvent::EAlreadyConnected:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, EAlreadyConnected, Session %S"),

				&name);

			} 

			break;

		case THTTPSessionEvent::EAlreadyDisconnecting:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, EAlreadyDisconnecting, Session %S"),

				&name);

			} 

			break;

		case THTTPSessionEvent::EAlreadyDisconnected:

			{

			iState = EWSPDisconnected;

			Log(_L("CFrmwrkSession::MHFSessionRunL, EAlreadyDisconnected, Session %S"),

				&name);

			} 

			break;

		default:

			{

			iState = EWSPDisconnected;

		    Log(_L("CFrmwrkSession::MHFSessionRunL, Unrecognised session event [%d], Session %S[%d]"), 

				aEvent.iStatus, &name);

			}

			break;

		}

	TRequestStatus* pStat = &iEventDispatcher->iStatus;

	User::RequestComplete(pStat,aEvent.iStatus);

}

TInt CFrmwrkSession::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)

	{

	iEngine->LogPrintf(_L("CFrmwrkSession::MHFSessionRunError, error code %d"), aError);

	TRequestStatus* pStat = &iEventDispatcher->iStatus;