--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httptransportfw/Test/T_HttpIntegration/HttpFrmwrk.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,532 @@
+// 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;
+ User::RequestComplete(pStat, KErrNone);
+
+ return KErrNone;
+ }