--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/idwsfplugin/src/idwsfservicesession.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,1488 @@
+/*
+* Copyright (c) 2002-2005 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:
+*
+*/
+
+
+
+
+
+
+
+
+// INCLUDE
+#include <SenServiceConnection.h> // error code definitions
+#include <SenDateUtils.h>
+#include <SenSoapFault.h>
+#include <SenWsSecurityHeader.h>
+#include <SenTransportProperties.h>
+#include <SenSoapConstants.h> // SOAPAction constants, like KSenSoapActionHeaderName
+
+#include "sendebug.h"
+#include "senlogger.h"
+
+#include "msencoreservicemanager.h"
+#include "senservicemanagerdefines.h"
+#include "senserviceinvocationframework.h"
+
+#include "midwsfsessionvalidator.h"
+#include "idwsfservicesession.h"
+#include "idwsfsessionconsumer.h"
+#include "idwsfserviceinstance.h"
+#include "seninternalcredential.h"
+#include <SenXmlReader.h>
+
+namespace
+ {
+ _LIT8(KSAML, "SAML");
+ _LIT8(KBEARER, "Bearer");
+
+ _LIT8(KProviderID, "<ProviderID>");
+ _LIT8(KProviderIDEnd, "</ProviderID>");
+ _LIT8(KResourceID, "<ResourceID>");
+ _LIT8(KResourceIDEnd, "</ResourceID>");
+ _LIT8(KTrustAnchor, "<TrustAnchor>");
+ _LIT8(KTrustAnchorEnd, "</TrustAnchor>");
+ _LIT8(KServiceInterval, "<ServiceInterval>");
+ _LIT8(KServiceIntervalEnd, "</ServiceInterval>");
+
+ _LIT8(KProviderIdElementLocalName, "ProviderID");
+ _LIT8(KResourceIDElementLocalName, "ResourceID");
+ _LIT8(TrustAnchorElementLocalName, "TrustAnchor");
+ //_LIT8(KServiceIntervalElementLocalName, "ServiceInterval");
+
+ const TInt KSubmitStateOK = 1;
+ const TInt KSubmitStateInvalidCredentials = 2;
+ const TInt KSubmitStateRevalidationAttempted = 3;
+ const TInt KSubmitStateRevalidationFailed = 4;
+ //const TInt KSubmitSateResend = 5;
+ //const TInt KSubmitSateResendFailed = 6;
+ }
+
+CIdWsfServiceSession* CIdWsfServiceSession::NewL(MSIF& aFramework)
+ {
+ CIdWsfServiceSession* self = CIdWsfServiceSession::NewLC(aFramework);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CIdWsfServiceSession* CIdWsfServiceSession::NewLC(MSIF& aFramework)
+ {
+ CIdWsfServiceSession* self = new (ELeave) CIdWsfServiceSession(
+ MSenServiceDescription::EIdWSFServiceSession, aFramework);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CIdWsfServiceSession::CIdWsfServiceSession(TDescriptionClassType aType,
+ MSIF& aSIF)
+ : CSenWebServiceSession(aType, aSIF),
+ iProvider(NULL),
+ ipResourceId(NULL),
+ ipTrustAnchor(NULL),
+ ipReceivedMessageId(NULL),
+ ipSenSecurityMechanism(NULL),
+ iMessageThread(EFalse),
+ ipValidator(NULL),
+ iSubmitState(KSubmitStateOK)
+ {
+ }
+
+CIdWsfServiceSession::~CIdWsfServiceSession()
+ {
+ delete iProvider;
+ delete ipResourceId;
+ delete ipTrustAnchor;
+ delete ipReceivedMessageId;
+ delete ipSenSecurityMechanism;
+
+ TInt count(iConsumerList.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ // we can assume that every remote consumer
+ // has been wrapped inside IdWsfSessionConsumer
+ // -wrapperclass. Cast and destroy:
+ CIdWsfSessionConsumer* pConsumer
+ = (CIdWsfSessionConsumer*) iConsumerList[i];
+
+ // this destroys the wrapper, but the remote
+ // consumer objects ownership remains in either
+ // XMLDao or ClientSession (etc)
+ delete pConsumer;
+ }
+ }
+
+void CIdWsfServiceSession::ConstructL()
+ {
+ // sets local name to "ServiceDescription" and
+ // initiates the inner ipElement
+ CSenWebServiceSession::ConstructL();
+ }
+
+TInt CIdWsfServiceSession::AddConsumerL(MSenRemoteServiceConsumer& aConsumer)
+ {
+ const TInt consumerCount(iConsumerList.Count());
+ for(TInt i=0; i<consumerCount; i++)
+ {
+ if(iConsumerList[i]->Id() == aConsumer.Id())
+ return KErrAlreadyExists; // already added, nothing to do
+ }
+
+ CIdWsfSessionConsumer* pSessionConsumer =
+ CIdWsfSessionConsumer::NewL(aConsumer, *Log());
+
+ iConsumerList.Append(pSessionConsumer);
+
+ // clears the array and inserts item as the only one..
+ // remove next line, when NEW routing is in use:
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceSession::RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer)
+ {
+ const TInt consumerCount(iConsumerList.Count());
+ for(TInt i=0; i<consumerCount; i++)
+ {
+ if(iConsumerList[i]->Id() == aConsumer.Id())
+ {
+ CIdWsfSessionConsumer* pConsumer
+ = (CIdWsfSessionConsumer*) iConsumerList[i];
+ delete pConsumer;
+ iConsumerList.Remove(i);
+ break;
+ }
+ }
+ return CSenServiceSession::RemoveConsumerL(aConsumer);
+ }
+
+TPtrC8 CIdWsfServiceSession::FrameworkId()
+ {
+ return iFramework.Id();
+ }
+
+TInt CIdWsfServiceSession::MessageForSendingL(const TDesC8& aBody,
+ const TDesC8& aSenderID,
+ CSenSoapMessage*& aMessage)
+ {
+ CIdWsfSessionConsumer* pConsumer = NULL;
+ TInt retVal = SessionConsumerL(aSenderID, pConsumer);
+ if (retVal != KErrNone)
+ {
+ return retVal;
+ }
+ if(ipReceivedMessageId)
+ {
+ retVal = pConsumer->MessageForSendingL(aBody,
+ *ipReceivedMessageId,
+ (CIdWsfMessage*&)aMessage);
+ }
+ else
+ {
+ retVal = pConsumer->MessageForSendingL( aBody,
+ KNullDesC8(),
+ (CIdWsfMessage*&)aMessage);
+ }
+ if (retVal != KErrNone)
+ {
+ return retVal;
+ }
+
+ SetFrameworkHeadersL(*aMessage);
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceSession::NewMessageL(CSenSoapMessage*& aMessage)
+ {
+ aMessage = CIdWsfMessage::NewL();
+ return KErrNone;
+ }
+
+// from XML service description
+TInt CIdWsfServiceSession::InitializeFromL(
+ MSenServiceDescription& aDescription)
+ {
+ CSenWebServiceSession::SetSecurityL(KNullDesC8);
+ CSenWebServiceSession::InitializeFromL(aDescription);
+
+ if ( StatusL() != KSenConnectionStatusReady )
+ {
+ if ( TryToSearchValidCredentialL() == KErrNone ) //codescannerwarnings
+ {
+ SetStatusL();
+ }
+ }
+
+ aDescription.HasFacetL(KMessageThread,iMessageThread);
+
+ TDescriptionClassType classType = aDescription.DescriptionClassType();
+ if( classType == MSenServiceDescription::EWSDescription
+ ||
+ classType == MSenServiceDescription::EWSPattern
+ ||
+ classType == MSenServiceDescription::EIdentityProvider
+ )
+ {
+ MSenElement& xmlSdAsElement = (
+ (CSenWSDescription*)&aDescription)->AsElement();
+
+
+ MSenElement* pElement =
+ xmlSdAsElement.Element(KProviderIdElementLocalName);
+ if(pElement)
+ {
+ TPtrC8 providerId = pElement->Content();
+ TPtrC8 endPoint = aDescription.Endpoint();
+
+ CIdWsfServiceProvider* pNewProvider =
+ CIdWsfServiceProvider::NewL(providerId, endPoint);
+ // now it is safe to free & re-assign
+ delete iProvider;
+ iProvider = pNewProvider;
+ }
+
+ pElement = xmlSdAsElement.Element(KResourceIDElementLocalName);
+ if(pElement)
+ {
+ HBufC8* pNewResourceId = (pElement->Content()).AllocL();
+ // now it is safe to free & re-assign
+ delete ipResourceId;
+ ipResourceId = pNewResourceId;
+ }
+
+ pElement = xmlSdAsElement.Element(TrustAnchorElementLocalName);
+ if(pElement)
+ {
+ HBufC8* pNewTrustAnchor = (pElement->Content()).AllocL();
+ delete ipTrustAnchor;
+ ipTrustAnchor = pNewTrustAnchor;
+ }
+ }
+ TPtrC8 contract = Contract();
+ if (contract == KNullDesC8)
+ {
+ return KErrSenNoContract;
+ }
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceSession::ParseMessageL(CSenSoapMessage& aSOAPMessage)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::ParseMessageL");
+
+ if (iMessageThread)
+ {
+ delete ipReceivedMessageId;
+ ipReceivedMessageId =
+ ((CIdWsfMessage&)aSOAPMessage).MessageId().Alloc();
+ if (!ipReceivedMessageId)
+ return KErrNoMemory;
+ }
+
+ TInt error = CSenWebServiceSession::ParseMessageL(aSOAPMessage);
+ if (error != KErrNone)
+ {
+ return error;
+ }
+
+ CIdWsfMessage& message = (CIdWsfMessage&)aSOAPMessage;
+
+ TTime serverTime;
+ if (message.Timestamp().Length() > 0)
+ {
+ serverTime = SenDateUtils::FromXmlDateTimeL(message.Timestamp());
+ }
+ else serverTime = Time::NullTTime();
+
+ TTime clientTime;
+ clientTime.UniversalTime();
+
+#ifdef _SENDEBUG
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::ParseMessageL:");
+ if (clientTime != Time::NullTTime())
+ {
+ TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;
+ SenDateUtils::ToXmlDateTimeUtf82L(ts, clientTime);
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L8("- Client (device) time : %S"), &ts));
+ }
+#endif // _SENDEBUG
+
+ if ( serverTime != Time::NullTTime() )
+ {
+#ifdef _SENDEBUG
+ TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;
+ SenDateUtils::ToXmlDateTimeUtf82L(ts2, serverTime);
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L8("- Server (remote service) time : %S"), &ts2));
+
+#endif // _SENDEBUG
+
+ iClientServerInterval = serverTime.MicroSecondsFrom(clientTime);
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L8("- Interval in microseconds : %d"), iClientServerInterval.Int64()));
+ }
+
+ delete ipReceivedMessageId;
+ ipReceivedMessageId = NULL;
+ ipReceivedMessageId = message.MessageId().AllocL();
+
+ CIdWsfSiuHeader* siuheader = message.SiuHeader();
+ if (siuheader)
+ {
+ error = UpdateFromL(*siuheader);
+ if (error != KErrNone) return error;
+ }
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceSession::SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,
+ const TInt aTxnId,
+ MSenRemoteServiceConsumer& aConsumer,
+ MSenProperties* aResponseTransportProperties )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SendSoapMessageToConsumerL");
+ TInt retVal(KErrNone);
+
+ if( apMessage )
+ {
+ CleanupStack::PushL( apMessage ); // ownership is here
+
+ CIdWsfMessage* pIdWsfMessage = (CIdWsfMessage*)apMessage;
+
+ if ( iMessageThread )
+ {
+ // store the Id of the last received message here:
+ delete ipReceivedMessageId;
+ ipReceivedMessageId = pIdWsfMessage->MessageId().Alloc();
+ if ( !ipReceivedMessageId )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- OOM occured!");
+ CleanupStack::PopAndDestroy( apMessage ); // de-alloc the response immediately
+ retVal = SendErrorToConsumerL( KErrNoMemory, NULL, aTxnId, aConsumer, aResponseTransportProperties );
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8("- OOM occured. Sent KErrNoMemory to remote consumer. SendErrorToConsumerL returned: %d "), retVal));
+ return KErrNoMemory;
+ }
+ }
+
+ CIdWsfSessionConsumer* pConsumer = NULL;
+ // This takes care of messageIDs:
+ retVal = SessionConsumerL( *pIdWsfMessage, pConsumer );
+ if (!pConsumer)
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Session consumer not found! Invoking remote consumer via a call to base class functionality.");
+ CleanupStack::Pop( apMessage ); // Next method takes ownership:
+ retVal = CSenWebServiceSession::SendSoapMessageToConsumerL( apMessage, aTxnId, aConsumer, aResponseTransportProperties );
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KNormalLogLevel , _L8("- SendSoapMessageToConsumerL returned: %d "), retVal));
+ return KErrNotFound;
+ }
+ else
+ {
+ //TSW ID: EMKY-6S4CGS & ID:EMKY-6N3AGA
+ //check for completemessage flag
+ TBool completeServerMessages;
+ HasFacetL(KCompleteMessagesFacet, completeServerMessages);
+ CleanupStack::Pop( apMessage ); // Next method takes ownership:
+ retVal = pConsumer->HandleIdWsfMessageL( pIdWsfMessage, aTxnId, aResponseTransportProperties, completeServerMessages );
+ }
+ }
+ else // apMessage == NULL!
+ {
+ // There is no SOAP to handle
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Fatal(!): CIdWsfServiceSession::SendSoapMessageToConsumerL, apMessage == NULL, sending internal error to remote consumer!");
+ retVal = SendErrorToConsumerL( KErrSenInternal, NULL, aTxnId, aConsumer, aResponseTransportProperties );
+ }
+ return retVal;
+ }
+
+void CIdWsfServiceSession::SetEndPointL(const TDesC8& aURI)
+ {
+ CSenWebServiceSession::SetEndPointL(aURI);
+ if(iProvider)
+ {
+ iProvider->SetEndPointL(aURI);
+ }
+ }
+
+void CIdWsfServiceSession::SetFrameworkHeadersL(CSenSoapMessage& aMsg)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders(CSenSoapMessage& aMsg)");
+
+#ifdef _SENDEBUG
+ if(ipSenSecurityMechanism)
+ {
+ TPtrC8 secMec = ipSenSecurityMechanism->Des();
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel ,"Security mechanism: \n");
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel ,(secMec));
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,"Note: ipSenSecurityMechanism == NULL!");
+ }
+
+ if (ipSenSecurityMechanism &&
+ (*ipSenSecurityMechanism).Compare(KSecTlsBearer11) != 0 &&
+ (*ipSenSecurityMechanism).Compare(KSecNullBearer11) != 0 )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders");
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," - header for ID-WSF 1.0 needs to be used");
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders");
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," - header for ID-WSF 1.1 needs to be used");
+ }
+#endif
+
+ CIdWsfMessage& idWsfMessage = (CIdWsfMessage&)aMsg;
+ idWsfMessage.SetSecurityMechanism(ipSenSecurityMechanism);
+ CSenWebServiceSession::SetFrameworkHeadersL(aMsg);
+
+
+
+ /*
+
+ //Changes for IDWSF 1.1 support
+ // Added the condition to add the old-style WsSecurity header
+ // for non-IDWSF11 security mechanisms
+
+ if (ipSenSecurityMechanism &&
+ (*ipSenSecurityMechanism).Compare(KSecTlsBearer11) != 0 &&
+ (*ipSenSecurityMechanism).Compare(KSecNullBearer11) != 0 )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders \
+ - Setting header for ID-WSF 1.0");
+ // Add new OLD WsSecurityHeader to msg
+
+
+ CIdWsfSecurityHeader* pHeader = NULL;
+ if(iSecurity)
+ {
+ pHeader =
+ CIdWsfSecurityHeader::NewL(*iSecurity);
+ }
+ else
+ {
+ pHeader =
+ CIdWsfSecurityHeader::NewL();
+ }
+ aMsg.AddHeaderL( pHeader->AsElement() ) ;
+
+ // Above is equal with next line, if an aMsg argument
+ // is actually SenIdWsfSoapMessage(!), ID-WSF 1.1, matmatt
+ //CSenWebServiceSession::SetFrameworkHeaders(aMsg);
+ }
+ else // NOTE: now we default to 1.1 if !ipSenSecurityMechanism
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders \
+ - Setting header for ID-WSF 1.1");
+ // We need to use (newer) security header for ID-WSF 1.1
+ // this could be done in IdWsfSoapMessage class, if it would
+ // somehow know in NewSecurityHeaderL() method, that it is
+ // actually 1.0 or 1.1. But this current solution is rather
+ // clear also. Each new header type, we need a new
+ // else-if code segment inside this session class method,
+ // -> in here.
+ CSenWsSecurityHeader* pHeader = NULL;
+
+ if(iSecurity)
+ {
+ // ID-WSF 1.1, matmatt
+ pHeader =
+ CSenWsSecurityHeader::NewL(*iSecurity);
+ }
+ else
+ {
+ pHeader =
+ CSenWsSecurityHeader::NewL();
+ }
+ aMsg.AddHeaderL( pHeader->AsElement() ) ;
+ }
+ */
+
+ // CorrelationHeader adjustment is already done in the SessionConsumer
+
+ }
+
+void CIdWsfServiceSession::WriteExtensionsAsXMLToL(RWriteStream& aWriteStream)
+ {
+ CSenWebServiceSession::WriteExtensionsAsXMLToL(aWriteStream);
+
+ if(iProvider)
+ {
+ aWriteStream.WriteL(KProviderID);
+ aWriteStream.WriteL(ProviderId());
+ aWriteStream.WriteL(KProviderIDEnd);
+ }
+
+ if(ipResourceId)
+ {
+ aWriteStream.WriteL(KResourceID);
+ aWriteStream.WriteL(*ipResourceId);
+ aWriteStream.WriteL(KResourceIDEnd);
+ }
+
+ if(ipTrustAnchor)
+ {
+ aWriteStream.WriteL(KTrustAnchor);
+ aWriteStream.WriteL(*ipTrustAnchor);
+ aWriteStream.WriteL(KTrustAnchorEnd);
+ }
+
+ if(iClientServerInterval.Int64() != 0)
+ {
+ aWriteStream.WriteL(KServiceInterval);
+ TBuf8<64> buf;
+ buf.AppendNum(iClientServerInterval.Int64());
+ aWriteStream.WriteL(buf);
+ aWriteStream.WriteL(KServiceIntervalEnd);
+ }
+ }
+
+// Note: no ref-impl for this method in Java either yet
+TInt CIdWsfServiceSession::ConstructSecurityTokenL(
+ const TDesC& /* aToken */,
+ HBufC8*& /* aSecurityToken */)
+ {
+ return KErrNotSupported;
+ }
+
+// from service instance
+// NOTE(!): returns KErrNotFound if no known security mechanism was found.
+TInt CIdWsfServiceSession::InitializeFromL(
+ CIdWsfServiceInstance& aServiceInstance)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L("CIdWsfServiceSession::InitializeFromL")));
+ CSenWebServiceSession::SetSecurityL(KNullDesC8);
+ CSenWebServiceSession::InitializeFromL(
+ (MSenServiceDescription&)aServiceInstance);
+
+ TPtrC8 providerid = aServiceInstance.ProviderId();
+ if (providerid.Length()>0)
+ {
+ TPtrC8 endPoint = aServiceInstance.Endpoint();
+ CIdWsfServiceProvider* pProvider = CIdWsfServiceProvider::NewL(providerid,
+ endPoint);
+ delete iProvider;
+ iProvider = pProvider;
+ }
+
+ // the description should support one, and only one(!) of mechanisms:
+
+ if(aServiceInstance.SupportsMechanism(KSecNullBearer))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecNullBearer()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecNullBearer().AllocL();
+ }
+ else if(aServiceInstance.SupportsMechanism(KSecTlsBearer))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecTlsBearer()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecTlsBearer().AllocL();
+ }
+ else if(aServiceInstance.SupportsMechanism(KSecTlsNull))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecTlsNull()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecTlsNull().AllocL();
+ }
+ else if(aServiceInstance.SupportsMechanism(KSecNullNull))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecNullNull()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecNullNull().AllocL();
+ }
+
+ //Added following two conditions for ID-WSF 1.1 support
+ else if(aServiceInstance.SupportsMechanism(KSecNullBearer11))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecNullBearer11()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecNullBearer11().AllocL();
+ }
+ else if(aServiceInstance.SupportsMechanism(KSecTlsBearer11))
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(KSecTlsBearer11()));
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = KSecTlsBearer11().AllocL();
+ }
+
+ if(!ipSenSecurityMechanism)
+ {
+ _LIT(KInvalidDate,"19000101:"); //CodeScannerWarnigs
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L("FATAL ERROR in CIdWsfServiceSession::InitializeFromL: \
+ ipSenSecurityMechanism == NULL!")));
+
+ // invalidate the session, because we don't know any mechanism
+ // and we have no credential
+ iValidUntil.Set(KInvalidDate); // way back in history: January 1st 1900 // CodeScannerWarnig
+ SetStatusL();
+ return KErrNotFound;
+ }
+
+ if(IsBearerL(*ipSenSecurityMechanism) || IsSAMLL(*ipSenSecurityMechanism))
+ {
+ TPtrC8 endpoint = Endpoint();
+ if(endpoint.Length() > 0)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," Adding credential, endpoint is:");
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(endpoint));
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," Endpoint <not set>, adding credential.");
+ }
+
+ CSenCredential* pCredential = (CSenCredential *) aServiceInstance.Credential();
+
+ if(pCredential)
+ {
+ /*
+ if(IsBearerL(*ipSenSecurityMechanism))
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"Sun does not send validUntil, so let's trust Bearer mech creds valid. Service will tell when they do expire");
+ iValidUntil.Set(_L("22000101:"));
+ pCredential->SetValidUntil(iValidUntil);
+ }
+ */
+ AddCredentialL(*pCredential);
+ }
+ }
+
+ TPtrC8 resourceId = aServiceInstance.ResourceId();
+ HBufC8* pResourceId = resourceId.AllocL();
+ delete ipResourceId;
+ ipResourceId = pResourceId;
+ SetOptionsFromL(aServiceInstance);
+
+ /*
+ if(IsBearerL(*ipSenSecurityMechanism))
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"Sun does not send validUntil, so let's trus Bearer mech creds valid. Service will tell when they do expire");
+ iValidUntil.Set(_L("22000101:")); // way back in history: January 1st 1900
+ }
+ */
+ SetStatusL();
+
+ return KErrNone;
+ }
+
+TBool CIdWsfServiceSession::IsSAMLL(const TDesC8& aSecMechURI)
+ {
+ TInt index(KErrNotFound);
+
+ index = aSecMechURI.Find(KSAML);
+
+ TInt rightPosition = aSecMechURI.Length()-KSAML().Length();
+
+ if(rightPosition > 0 && index == rightPosition)
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+TBool CIdWsfServiceSession::IsBearerL(const TDesC8& aSecMechURI)
+ {
+ TInt index(KErrNotFound);
+
+ index = aSecMechURI.Find(KBEARER);
+
+ TInt rightPosition = aSecMechURI.Length()-KBEARER().Length();
+
+ if(rightPosition > 0 && index == rightPosition)
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+TPtrC8 CIdWsfServiceSession::ProviderId()
+ {
+ if(iProvider)
+ {
+ return iProvider->ProviderId();
+ }
+ else
+ {
+ return KNullDesC8();
+ }
+ }
+
+TPtrC8 CIdWsfServiceSession::ServiceType()
+ {
+ return CSenWebServiceSession::Contract();
+ }
+
+TInt CIdWsfServiceSession::UpdateFromL(CIdWsfSiuHeader& aHeader)
+ {
+ TInt retVal = KErrNone;
+
+ if (aHeader.Endpoint().Length()>0)
+ {
+ TPtrC8 endpoint = aHeader.Endpoint();
+ SetEndPointL(endpoint);
+ }
+
+ if (aHeader.SecurityMechId().Length()>0)
+ {
+ TPtrC8 securityMechId = aHeader.SecurityMechId();
+ SetSenSecurityMechanismL(securityMechId);
+ }
+
+ if (aHeader.Credential())
+ {
+ CSenWebServiceSession::SetSecurityL(KNullDesC8());
+ retVal = AddCredentialL(*aHeader.Credential());
+ }
+
+ SaveL();
+
+ return retVal;
+ }
+
+void CIdWsfServiceSession::SetProviderL(CIdWsfServiceProvider *aProvider)
+ {
+ delete iProvider;
+ iProvider = aProvider;
+ CSenWebServiceSession::SetEndPointL(aProvider->Endpoint());
+ }
+
+CIdWsfServiceProvider* CIdWsfServiceSession::Provider()
+ {
+ return iProvider;
+ }
+
+void CIdWsfServiceSession::SetResourceIdL(const TDesC8& aURI)
+ {
+ HBufC8* pNew = NULL;
+ if(aURI.Length()>0)
+ pNew = aURI.AllocL();
+ delete ipResourceId;
+ ipResourceId = pNew;
+ }
+
+TPtrC8 CIdWsfServiceSession::ResourceId()
+ {
+ if(ipResourceId)
+ return *ipResourceId;
+ else
+ return KNullDesC8();
+ }
+
+void CIdWsfServiceSession::SetServiceTypeL(const TDesC8& aURI)
+ {
+ if(aURI.Length()>0)
+ {
+ CSenWebServiceSession::SetContractL(aURI);
+ }
+ else
+ {
+ CSenWebServiceSession::SetContractL(KNullDesC8());
+ }
+ }
+
+void CIdWsfServiceSession::SetTrustAnchorL(const TDesC8& aURI)
+ {
+
+ HBufC8* pNew = NULL;
+ if(aURI.Length()>0)
+ {
+ pNew = aURI.AllocL();
+ }
+ delete ipTrustAnchor;
+ ipTrustAnchor = pNew;
+ }
+TPtrC8 CIdWsfServiceSession::TrustAnchor()
+ {
+ if(ipTrustAnchor)
+ return *ipTrustAnchor;
+ else
+ return KNullDesC8();
+ }
+
+void CIdWsfServiceSession::SetSenSecurityMechanismL(
+ const TDesC8& aSenSecurityMechanism)
+ {
+
+ HBufC8* pNew = NULL;
+ if(aSenSecurityMechanism.Length()>0)
+ pNew = aSenSecurityMechanism.AllocL();
+
+ delete ipSenSecurityMechanism;
+ ipSenSecurityMechanism = pNew;
+ }
+
+TPtrC8 CIdWsfServiceSession::SenSecurityMechanism()
+ {
+ if(ipSenSecurityMechanism)
+ {
+ return *ipSenSecurityMechanism;
+ }
+ else
+ {
+ return KNullDesC8();
+ }
+ }
+
+// Override the method from SenServiceSession to provide simple search from
+// list, because ID-WSF service sessions may have several consumers.
+MSenRemoteServiceConsumer* CIdWsfServiceSession::RemoteConsumerL(
+ const TDesC8& aSenderID)
+ {
+ TInt consumersCount(iConsumerList.Count());
+
+ for(TInt i=0; i<consumersCount; i++)
+ {
+ if(iConsumerList[i]->Id() == aSenderID)
+ {
+ return iConsumerList[i];
+ }
+ }
+ return NULL; // not found
+ }
+
+
+TInt CIdWsfServiceSession::SessionConsumerL(
+ CIdWsfMessage& aMessage,
+ CIdWsfSessionConsumer*& aSessionConsumer)
+ {
+ TInt consumersCount(iConsumerList.Count());
+
+ for(TInt i=0; i<consumersCount; i++)
+ {
+ CIdWsfSessionConsumer* pConsumer =
+ (CIdWsfSessionConsumer*) iConsumerList[i];
+ if (pConsumer->Expects(aMessage.RefToMessageId()))
+ {
+ aSessionConsumer = pConsumer;
+ return KErrNone;
+ }
+ }
+
+ aSessionConsumer = NULL; // not found
+ return KErrNotFound;
+ }
+
+TInt CIdWsfServiceSession::SessionConsumerL(const TDesC8& aSenderID,
+ CIdWsfSessionConsumer*& aSessionConsumer)
+ {
+ aSessionConsumer = (CIdWsfSessionConsumer*) RemoteConsumerL(aSenderID);
+ if(aSessionConsumer)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+
+// SYNC IMPLEMENTATION(!)
+// aSOAPMessage.IsFault() should always be TRUE.
+
+/**
+* Method checks if ID-WSF framework can handle this fault, if not, then
+* error is delivered to session consumer
+*/
+TInt CIdWsfServiceSession::HandleSoapFaultL(CSenSoapMessage* apSOAPMessage,
+ HBufC8*& aResponse)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::HandleSoapFaultL [sync]");
+
+ TInt retVal(KErrNone);
+
+ if ( apSOAPMessage )
+ {
+
+ CIdWsfMessage& idWsfMessage = (CIdWsfMessage&)*apSOAPMessage;
+ CleanupStack::PushL( apSOAPMessage ); // ownerhip is here
+
+ TInt answer = CanHandleErrorL(idWsfMessage);
+
+ if(answer == KErrSenReinitRequired) // ESenReAuthAndResendNeeded
+ {
+ TBool status(EFalse);
+ SetValidator(NULL);
+ iFramework.Manager().NotifyFrameworksL(
+ KDefaultIdWsfFrameworkID,
+ KSenEventIdWsfSessionValidatorRequested);
+
+ MIdWsfSessionValidator* pValidator = Validator();
+ if (pValidator)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,"* validator is available *");
+ TInt retVal(KErrNone);
+ iSubmitState = KSubmitStateInvalidCredentials;
+ // invalidate the current session
+ SetStatusL();
+ iSubmitState = KSubmitStateRevalidationAttempted;
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L8("Validator ptr: 0x%x"), pValidator));
+
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"Looking for session consumer.");
+ CIdWsfSessionConsumer* pConsumer = NULL;
+
+ // this takes care of messageIDs
+ TInt getConsumerRetVal = SessionConsumerL(idWsfMessage, pConsumer);
+ if(getConsumerRetVal != KErrNone)
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,
+ _L8(" - SessionConsumerL returned an error: %d"),
+ getConsumerRetVal));
+ status = EFalse;
+ }
+ else if(!pConsumer)
+ {
+ // consumer not found
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," - Consumer not found!");
+ status = EFalse;
+ }
+ else
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,_L8("Revalidating needed")));
+ retVal = pValidator->ValidateL(*this, *pConsumer); // this actually can call either ASC or DSC
+ status = (retVal == KErrNone) && IsReadyL();
+ }
+ }
+
+ #ifdef _SENDEBUG
+ if(status)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"HandleErrorL: InappropriateCredentials -> TRUE");
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"HandleErrorL: InappropriateCredentials -> FALSE");
+ }
+ #endif
+ if( !status )
+ {
+ // notify consumers (applications) about expired connection
+ SetStatusL();
+ answer = KErrNone;
+ // Change state to "re-validation failed" in order to indicate other,
+ // pending async messages that there is no use re-sending as one lacks
+ // valid credential(s)
+ iSubmitState = KSubmitStateRevalidationFailed;
+ }
+ }
+
+ if (iSubmitState != KSubmitStateRevalidationFailed && ( answer > KErrNone || answer == KErrSenReinitRequired || answer == KErrSenResendRequired ))
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CanHandleErrorL == TRUE");
+
+ CIdWsfSessionConsumer* pConsumer = NULL;
+
+ // this takes care of messageIDs
+ retVal = SessionConsumerL(idWsfMessage, pConsumer);
+ if(retVal != KErrNone)
+ {
+ CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed
+ return retVal;
+ }
+ else if(!pConsumer)
+ {
+ CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed
+ // consumer not found
+ return KErrNotFound;
+ }
+
+ TDesC8* pBody = pConsumer->BodyL(idWsfMessage.RefToMessageId());
+ if (pBody)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"Re-submitting the request");
+ retVal = SubmitL(*pBody, KNullDesC8, *pConsumer, aResponse);
+ }
+ }
+ else
+ {
+ CSenSoapFault* pDetached = idWsfMessage.DetachFaultL();
+ if(pDetached)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"Detached a SOAP fault");
+ CleanupStack::PushL(pDetached);
+ aResponse = pDetached->AsXmlL();
+ CleanupStack::PopAndDestroy(); // pDetached
+ CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed
+ return KErrSenSoapFault; // this is 2nd OK return code!
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"No SOAP fault was received.");
+ retVal = KErrSenInternal;
+ }
+ }
+ CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed
+ }
+
+ return retVal;
+ }
+
+/**
+* Method checks if ID-WSF framework can handle this fault, if not, then
+* error is delivered to session consumer
+*/
+TInt CIdWsfServiceSession::HandleSoapFaultL(CSenSoapMessage* apSOAPMessage,
+ const TInt aErrorCode,
+ const TInt aTxnId,
+ MSenRemoteServiceConsumer& aConsumer,
+ MSenProperties* aResponseTransportProperties)
+ {
+ CSLOG_L(aConsumer.ConnectionId() ,KMinLogLevel ,"CIdWsfServiceSession::HandleSoapFaultL [async]");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::HandleSoapFaultL [async]");
+
+ TInt retVal(KErrNone);
+
+ if ( apSOAPMessage )
+ {
+ CIdWsfMessage& idWsfMessage = (CIdWsfMessage&)*apSOAPMessage;
+ CleanupStack::PushL( apSOAPMessage ); // ownerhip is here
+
+ TInt answer = CanHandleErrorL(idWsfMessage);
+ if ( answer > KErrNone || answer == KErrSenReinitRequired || answer == KErrSenResendRequired )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KNormalLogLevel ,"CanHandleErrorL == TRUE");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CanHandleErrorL == TRUE");
+
+ aConsumer.HandleErrorL(NULL, answer, aTxnId, aResponseTransportProperties);
+ }
+ else
+ {
+ CSenSoapFault* pDetached = idWsfMessage.DetachFaultL();
+ if(pDetached)
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"Detached a SOAP fault");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"Detached a SOAP fault");
+ CleanupStack::PushL(pDetached);
+ // pass KErrSenSoapFault // which is 2nd "OK" return code!
+ HBufC8* pAsXml = pDetached->AsXmlL();
+ if(pAsXml)
+ {
+ aConsumer.HandleErrorL(pAsXml, KErrSenSoapFault, aTxnId, aResponseTransportProperties);
+ }
+ CleanupStack::PopAndDestroy(); // pDetached
+ retVal = KErrNone; // OK
+ }
+ else
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"No SOAP fault was received.");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"No SOAP fault was received.");
+ aConsumer.HandleErrorL(NULL, aErrorCode, aTxnId, aResponseTransportProperties);
+ retVal = KErrSenInternal; // one *could* pass on the orig error code
+ }
+ }
+ CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed
+ }
+
+ return retVal;
+ }
+
+TInt CIdWsfServiceSession::CanHandleErrorL(CIdWsfMessage& aMessage)
+ {
+ TInt answer(KErrNone);
+
+ const TDesC8* pCode = aMessage.StatusCodeL();
+
+ if(pCode)
+ {
+ if(SenXmlUtils::EndsWith(*pCode, KStatusEndpointMoved))
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CanHandleErrorL: Endpoint moved -> TRUE");
+ // We could probably re-submit the body of our outgoing message
+ // check if we received a SIU header with an endpoint
+ CIdWsfSiuHeader* pSIUHeader = aMessage.SiuHeader();
+ if(pSIUHeader && pSIUHeader->Endpoint().Length() > 0)
+ {
+ answer = KErrSenResendRequired; // ESenResendNeeded;
+ }
+ }
+ else if(SenXmlUtils::EndsWith(*pCode, KStatusInappropriateCredentials))
+ {
+ _LIT(KInvalidDate,"18000101:");
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CanHandleErrorL: InappropriateCredentials -> invalidating this session");
+ // ensure that session is CERTAINLY INVALID!
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,
+ _L8("Credentials expired. Handling SOAP fault %S"),
+ &KStatusInappropriateCredentials() ));
+
+ iValidUntil.Set(KInvalidDate); // way way back in history: January 1st 1800 //CodescannerWarnings
+
+
+ if (iSubmitState == KSubmitStateOK)
+ {
+ // Clear the current validator
+ SetValidator(NULL);
+ iFramework.Manager().NotifyFrameworksL(
+ KDefaultIdWsfFrameworkID,
+ KSenEventIdWsfSessionValidatorRequested);
+
+ MIdWsfSessionValidator* pValidator = Validator();
+ if (pValidator)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,"* validator is available *");
+ iSubmitState = KSubmitStateInvalidCredentials;
+ // Invalidate the current session
+ SetStatusL();
+ iSubmitState = KSubmitStateRevalidationAttempted;
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L8("Validator ptr: 0x%x"), pValidator));
+
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"Looking for session consumer.");
+ CIdWsfSessionConsumer* pConsumer = NULL;
+
+ // This takes care of messageIDs
+ TInt getConsumerRetVal = SessionConsumerL(aMessage, pConsumer);
+ if(getConsumerRetVal != KErrNone)
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,
+ _L8(" - SessionConsumerL returned an error: %d"),
+ getConsumerRetVal));
+ answer = KErrNone;
+ }
+ else if(!pConsumer)
+ {
+ // Consumer not found
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," - Consumer not found!");
+ answer = KErrNone;
+ }
+ else
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,_L8("- Revalidation needed")));
+ answer = KErrSenReinitRequired; // ESenReAuthAndResendNeeded;
+ }
+ }
+
+ }
+ else if ( iSubmitState == KSubmitStateRevalidationAttempted )
+ {
+ // Another message already triggered the re-validation phase,
+ // so: this operation requires re-sending only
+ answer = KErrSenResendRequired; // ESenResendNeeded;
+ iSubmitState = KSubmitStateRevalidationFailed; //ESenResend
+ }
+ //else if ( iSubmitState == KSubmitSateResend )
+ // {
+ // answer = KErrSenResendComplete; //ESenResendFailed
+ // iSubmitState = KSubmitSateResendFailed; //ESenResendFailed
+ // }
+ }
+ }
+
+ return answer;
+ }
+
+TBool CIdWsfServiceSession::Matches(MSenServiceDescription& aPattern)
+ {
+ TBool matches = CSenWebServiceSession::Matches(aPattern);
+
+ // for now the only interesting facet is the messageThread facet
+ // if this session uses messageThreads it should not match any
+ // description, as it essentially makes the session unique
+ // (unless nobody is using this session).
+ if (iMessageThread && HasConsumer())
+ {
+ // a new session is needed in any case
+ matches = EFalse;
+ }
+ else
+ {
+ TBool hasFacet(EFalse);
+ TInt leaveCode(KErrNone);
+ TRAP( leaveCode, aPattern.HasFacetL(KMessageThread, hasFacet); )
+ if (leaveCode != KErrNone)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"CIdWsfServiceSession::Matches - HasFacetL() leaved!");
+ matches = EFalse;
+ }
+ if (hasFacet)
+ {
+ if (matches && !HasConsumer()) matches = ETrue;
+ else matches = EFalse;
+ }
+ }
+ return matches;
+ }
+
+void CIdWsfServiceSession::CopyFacetsFromL(MSenServiceDescription& aPattern)
+ {
+ aPattern.HasFacetL(KMessageThread,iMessageThread);
+
+ if (iMessageThread)
+ {
+ CSenFacet* pNewFacet = CSenFacet::NewL();
+ CleanupStack::PushL(pNewFacet);
+ pNewFacet->SetValueL(KSenFacetValTrue);
+ SetFacetL(*pNewFacet);
+ CleanupStack::Pop(); // pNewFacet
+ }
+ else
+ {
+ RemoveFacet(KMessageThread);
+ }
+ }
+
+TInt CIdWsfServiceSession::SetOptionsFromL(MSenServiceDescription& aPattern)
+ {
+ RFacetArray options;
+ CleanupClosePushL(options);
+
+ CIdWsfDiscoveryServiceClient::DSOptionsL(options, aPattern);
+ if (options.Count() > 0)
+ {
+ TInt count(options.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ SetFacetL(*options[i]);
+ }
+ }
+ options.ResetAndDestroy();
+ CleanupStack::Pop(); //options
+
+ return KErrNone;
+ }
+
+void CIdWsfServiceSession::StartTransaction()
+ {
+ iMessageThread = ETrue;
+ }
+
+void CIdWsfServiceSession::TransactionCompleted()
+ {
+ delete ipReceivedMessageId;
+ ipReceivedMessageId = NULL;
+ }
+
+void CIdWsfServiceSession::SetValidator(MIdWsfSessionValidator* aValidator)
+ {
+ ipValidator = aValidator;
+ }
+
+MIdWsfSessionValidator* CIdWsfServiceSession::Validator()
+ {
+ return ipValidator;
+ }
+
+TInt CIdWsfServiceSession::SendL( const TDesC8& aMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ TInt& aTxnId,
+ HBufC8*& aRevalidationError )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SendL");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SendL");
+ // Temporary START
+ MSenTransport& transport = aConsumer.TransportL();
+ SetFrameworkPropertiesL( transport ); // retVal surpressed
+ // Temporary END
+ TInt retVal = CSenWebServiceSession::SendL( aMessage, aTransportProperties, aConsumer, aTxnId, aRevalidationError );
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SendL:");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SendL:");
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KNormalLogLevel , _L8("- Return value from CSenWebServiceSession::SendL %d: "), retVal));
+ //TLSLOG_FORMAT(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,(_L8("- Return value from CSenWebServiceSession::SendL %d: "), retVal));
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KNormalLogLevel , _L8("- Transaction ID (from transport): %d"), aTxnId));
+ //TLSLOG_FORMAT(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,(_L8("- Transaction ID (from transport): %d"), aTxnId));
+ return retVal;
+ }
+
+TInt CIdWsfServiceSession::SubmitL( const TDesC8& aMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ HBufC8*& aResponse )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SubmitL");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SubmitL");
+ MSenTransport& transport = aConsumer.TransportL();
+ SetFrameworkPropertiesL(transport); // retVal surpressed
+ TInt retVal = CSenWebServiceSession::SubmitL( aMessage, aTransportProperties, aConsumer, aResponse);
+ if (retVal == KErrNone)
+ {
+ iSubmitState = KSubmitStateOK;
+ }
+ return retVal;
+ }
+
+TInt CIdWsfServiceSession::SetStatusL()
+ {
+ // check if we are re-submitting
+ if ( iSubmitState == KSubmitStateInvalidCredentials )
+ {
+ TInt count(iConsumerList.Count());
+
+ // Create a local array to hold pointer(s) to consumer(s)
+ RServiceConsumerArray consumerList;
+ CleanupClosePushL(consumerList);
+
+ // Copy the consumers into temporary array
+ for (TInt i=0; i<count; i++)
+ {
+ TInt errorCode = consumerList.Append(iConsumerList[i]);
+ if(errorCode!=KErrNone)
+ {
+ User::Leave(errorCode); // out-of-memory occurred
+ }
+ }
+ // Clear the actual array to prevent false
+ // callbacks to SetStatusL() etc:
+ iConsumerList.Reset();
+
+ // Now it is safe to calculate the status
+ TInt retVal = CSenWebServiceSession::SetStatusL();
+
+ // The iConsumerList may be populated with original
+ // consumer(s)
+ for ( TInt j = 0; j < count; j++ )
+ {
+ iConsumerList.Append(consumerList[j]);
+ }
+
+ // Reset the temporary array and let it go out of scope
+ consumerList.Reset();
+ CleanupStack::Pop(); //consumerList
+ return retVal;
+ }
+
+ // Note: call to SetStatusL() can always result consumers being
+ // notified of their state changed
+ return CSenWebServiceSession::SetStatusL();
+ }
+
+/*
+* ID-WSF always expect that consumer application is providing the application body only.
+* So, we are extracting the Soap body from aSoapMessage and SendL of
+* ID-WSF has been called
+*/
+TInt CIdWsfServiceSession::SendSoapL( const TDesC8& aSoapMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ TInt& aTxnId,
+ HBufC8*& aRevalidationError )
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SendSoapL(TDesC8&, ...)");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SendSoapL(TDesC8&, ...)");
+
+ TInt retVal(KErrNone);
+ CSenXmlReader* pReader = iFramework.Manager().XMLReader(); // re-use the XML reader instance owned by core
+ CSenSoapMessage* pMsg = CSenSoapMessage::NewL();
+ CleanupStack::PushL( pMsg );
+ pMsg->SetReader( *pReader );
+ pReader->SetContentHandler( *pMsg );
+ TInt leaveCode( KErrNone );
+ TRAP( leaveCode, pMsg->ParseL( aSoapMessage ); )
+ if ( leaveCode )
+ {
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8("- Parsing descriptor into SOAP-MSG object failed, leave code: %d"), leaveCode ));
+ //TLSLOG_FORMAT(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,( _L("- Parsing descriptor into SOAP-MSG object failed, leave code: %d"), leaveCode ));
+ CleanupStack::PopAndDestroy( pMsg ); // de-alloc the SOAP-MSG object immediately
+ retVal = leaveCode;
+ }
+ else // parsing ok
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Successfully parsed descriptor into SOAP-MSG.");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"- Successfully parsed descriptor into SOAP-MSG.");
+ HBufC8* pHttpBody = pMsg->BodyAsStringL(); // extract the SOAP body
+ CleanupStack::PopAndDestroy( pMsg );
+ CleanupStack::PushL( pHttpBody );
+ retVal = SendL( *pHttpBody, aTransportProperties, aConsumer, aTxnId, aRevalidationError );
+ CleanupStack::PopAndDestroy( pHttpBody ); // assert in proper order
+ }
+ return retVal;
+ }
+
+/*
+* ID-WSF always expect that consumer application is providing the application body only.
+* So, we are extracting the Soap body from aSoapMessage and SubmitL of
+* ID-WSF has been called
+*/
+TInt CIdWsfServiceSession::SubmitSoapL( const TDesC8& aSoapMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ HBufC8*& aResponse )
+ {
+#ifdef _SENDEBUG
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfServiceSession::SubmitSoapL(TDesC8, ...");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SubmitSoapL(TDesC8, ...");
+ CSLOG_L(aConsumer.ConnectionId(), KMaxLogLevel ,"///////////////////////////////////////////////////////");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"///////////////////////////////////////////////////////");
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KMaxLogLevel , _L8("- Message (%d bytes):"), aSoapMessage.Length()));
+ //TLSLOG_FORMAT(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,(_L8("- Message (%d bytes):"), aSoapMessage.Length()));
+ CSLOG_ALL(aConsumer.ConnectionId(), KMaxLogLevel ,(aSoapMessage));
+ //TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,(aSoapMessage));
+ CSLOG_L(aConsumer.ConnectionId(), KMaxLogLevel ,"///////////////////////////////////////////////////////");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"///////////////////////////////////////////////////////");
+#endif
+ TInt retVal(KErrNone);
+ CSenXmlReader* pReader = iFramework.Manager().XMLReader(); // re-use the XML reader instance owned by core
+ CSenSoapMessage* pMsg = CSenSoapMessage::NewL();
+ CleanupStack::PushL( pMsg );
+ pMsg->SetReader( *pReader );
+ pReader->SetContentHandler( *pMsg );
+ TInt leaveCode( KErrNone );
+ TRAP( leaveCode, pMsg->ParseL( aSoapMessage ); )
+ if ( leaveCode )
+ {
+ CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8("- Parsing descriptor into SOAP-MSG object failed, leave code: %d"), leaveCode ));
+ //TLSLOG_FORMAT(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,( _L("- Parsing descriptor into SOAP-MSG object failed, leave code: %d"), leaveCode ));
+ CleanupStack::PopAndDestroy( pMsg ); // de-alloc the SOAP-MSG object immediately
+ retVal = leaveCode;
+ }
+ else // parsing ok
+ {
+ CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Successfully parsed descriptor into SOAP-MSG.");
+ //TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel ,"- Successfully parsed descriptor into SOAP-MSG.");
+ HBufC8* pHttpBody = pMsg->BodyAsStringL(); //Extracting the body
+ CleanupStack::PopAndDestroy( pMsg );
+ CleanupStack::PushL( pHttpBody );
+ retVal = SubmitL(*pHttpBody, aTransportProperties, aConsumer, aResponse);
+ CleanupStack::PopAndDestroy( pHttpBody ); // assert proper order
+ }
+ return retVal;
+ }
+
+
+TBool CIdWsfServiceSession::HasSuperClass( TDescriptionClassType aType )
+ {
+ if ( aType == MSenServiceDescription::EWebServiceSession ) // direct superclass!
+ {
+ // If asked type is the know *direct* father/mother, return true:
+ return ETrue;
+ }
+ else
+ {
+ // Otherwise, ask from superclass (chain, recursively)
+ return CSenWebServiceSession::HasSuperClass( aType );
+ }
+ }
+
+// Temporary
+TInt CIdWsfServiceSession::SetFrameworkPropertiesL(MSenTransport& aTransport)
+ {
+ return iFramework.SetTransportPropertiesL(aTransport);
+ }
+
+void CIdWsfServiceSession::FillCredentialIdentifierL(CSenCredentialIdentifier& aIdentifier)
+ {
+ CSenWebServiceSession::FillCredentialIdentifierL(aIdentifier);
+
+ _LIT8(KProviderIdElementLocalName, "ProviderID");
+ aIdentifier.SetPropertyL(KProviderIdElementLocalName, ProviderId());
+ }
+
+
+// End of file
+
+