--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsoviplugin/src/wsoviservicesession.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,1417 @@
+/*
+* Copyright (c) 2008 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 "wsoviservicesession.h"
+#include "sendebug.h"
+#include "senlogger.h"
+#include "senservicemanagerdefines.h"
+#include "SenServiceConnection.h" // err code definitions
+#include "senserviceinvocationframework.h"
+#include "SenHttpTransportProperties.h"
+#include "SenDateUtils.h"
+#include "sendebug.h"
+#include "senwspattern.h"
+#include "SenXmlUtils.h"
+#include <xmlengnodelist.h>
+#include <SenHttpTransportProperties.h>
+#include <SenIdentityProvider.h>
+#include "wsovicredentialobserver.h"
+#include "sencryptoutils.h"
+
+const TInt64 KClockSlipSeconds = 60*15;
+
+
+CWSOviServiceSession* CWSOviServiceSession::NewL(MSIF& aFramework)
+ {
+ CWSOviServiceSession* self = CWSOviServiceSession::NewLC(aFramework);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CWSOviServiceSession* CWSOviServiceSession::NewLC(MSIF& aFramework)
+ {
+ CWSOviServiceSession* self = new (ELeave) CWSOviServiceSession(
+ MSenServiceDescription::EOviServiceSession, aFramework);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CWSOviServiceSession::CWSOviServiceSession(TDescriptionClassType aType,
+ MSIF& aSIF)
+ : CSenWebServiceSession(aType, aSIF)
+ {
+ }
+
+CWSOviServiceSession::~CWSOviServiceSession()
+ {
+ delete iSessionContext;
+ delete iProviderID;
+ delete iTrustAnchor;
+ delete iOutContext;
+ delete iInContext;
+ delete iTransProp;
+ delete iOrginalEndpoint;
+
+ TInt count(iConsumerList.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ // we can assume that every remote consumer
+ // has been wrapped inside WSOviSessionConsumer
+ // -wrapperclass. Cast and destroy:
+ CWSOviSessionConsumer* pConsumer
+ = (CWSOviSessionConsumer*) iConsumerList[i];
+
+ // this destroys the wrapper, but the remote
+ // consumer objects ownership remains in either
+ // XMLDao or ClientSession (etc)
+ delete pConsumer;
+ }
+ delete iTokenObs;
+ }
+
+void CWSOviServiceSession::ConstructL()
+ {
+ CSenWebServiceSession::ConstructL();
+ iTokenObs = CWSOviCredentialObserver::NewL(this,iFramework.Manager().Log());
+ }
+
+TInt CWSOviServiceSession::AddConsumerL(MSenRemoteServiceConsumer& aConsumer)
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"CWSOviServiceSession::AddConsumerL");
+ 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
+ }
+ }
+
+ CWSOviSessionConsumer* pSessionConsumer =
+ CWSOviSessionConsumer::NewL(aConsumer);
+
+ return iConsumerList.Append(pSessionConsumer);
+ }
+
+TBool CWSOviServiceSession::ExistConsumerL()
+ {
+ const TInt consumerCount(iConsumerList.Count());
+ if( consumerCount == 0 )
+ {
+ return EFalse;
+ }
+ else
+ {
+ return ETrue;
+ }
+ }
+
+TInt CWSOviServiceSession::RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer)
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"CWSOviServiceSession::RemoveConsumerL:");
+ const TInt consumerCount(iConsumerList.Count());
+ for(TInt i=0; i<consumerCount; i++)
+ {
+ if(iConsumerList[i]->Id() == aConsumer.Id())
+ {
+ CWSOviSessionConsumer* pConsumer
+ = (CWSOviSessionConsumer*) iConsumerList[i];
+ delete pConsumer;
+ iConsumerList.Remove(i);
+ if( (consumerCount-1) == 0 )
+ {
+ iTokenObs->Cancel();
+ }
+ break;
+ }
+ }
+ // If this session has no consumers, we can hold our grip to the credential
+ // (note: this does NOT mean that credential is removed, not at all(!), but
+ // that new search for the credential has to be performed).
+ if( consumerCount == 0 )
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KNormalLogLevel ,"- Consumer count == 0");
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KNormalLogLevel ,"-> Closing the handle to the credential owned by the Credential Manager.");
+ SetSecurityL(KNullDesC8);
+ }
+ return CSenServiceSession::RemoveConsumerL(aConsumer);
+ }
+
+TInt CWSOviServiceSession::MessageForSendingL( CSenHttpTransportProperties*& aTP,
+ const TDesC8& aSenderID)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::MessageForSendingL");
+ TInt error(KErrNone);
+ if (AmIHostletSession())
+ {
+ return KErrNotSupported;
+ }
+ else
+ {
+ CWSOviSessionConsumer* pConsumer = NULL;
+ //senderID is internal id of consumer
+ error = SessionConsumerL(aSenderID, pConsumer);
+ if (error)
+ {
+ return error;
+ }
+
+ CWSOviSessionContext* ssCtx = (CWSOviSessionContext*)SessionContext();
+
+ iOutContext->UpdateFromSessionContextL(*ssCtx);
+ iOutContext->UpdateTP((CSenTransportProperties*&)aTP);
+ AdaptEndpointL(EFalse);
+ iOutContext->Update(OAuth::KEndpointKey,Endpoint());
+ AdaptEndpointL(ETrue);
+
+ error = ((CWSOviPlugin&)iFramework).ProcessOutboundMessageL(
+ iOutContext);
+
+ iSessionContext->UpdateFromMessageOutContextL(*iOutContext);
+ error = pConsumer->MessageForSendingL(aTP, iOutContext);
+ }
+ return error;
+ }
+
+
+
+
+MSenRemoteServiceConsumer* CWSOviServiceSession::RemoteConsumerL( const TDesC8& aSenderID )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::RemoteConsumerL");
+ TInt consumersCount(iConsumerList.Count());
+
+ for(TInt i=0; i<consumersCount; i++)
+ {
+ if(iConsumerList[i]->Id() == aSenderID)
+ {
+ return iConsumerList[i];
+ }
+ }
+ return NULL; // not found
+ }
+
+//---------------------------------------------------------------------------
+// To obtain consumer during processing INBOUND.
+//---------------------------------------------------------------------------
+//
+
+TInt CWSOviServiceSession::SessionConsumerL( CWSOviMessageContext*& /*aMsgCtx*/,
+ CWSOviSessionConsumer*& aSessionConsumer )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::SessionConsumerL");
+ TInt consumersCount(iConsumerList.Count());
+ TInt error(KErrNotFound);
+ if (error && consumersCount)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel,"CWSOviServiceSession::SessionConsumerL - consumer was not found - using the 1st one (as default)");
+ aSessionConsumer = (CWSOviSessionConsumer*)iConsumerList[0];
+ error = KErrNone;
+ }
+ return error;
+ }
+
+//---------------------------------------------------------------------------
+// To obtain consumer during processing OUTBOUND.
+//---------------------------------------------------------------------------
+//
+
+TInt CWSOviServiceSession::SessionConsumerL( const TDesC8& aSenderID,
+ CWSOviSessionConsumer*& aSessionConsumer )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::SessionConsumerL");
+ aSessionConsumer = (CWSOviSessionConsumer*) RemoteConsumerL(aSenderID);
+ if(aSessionConsumer)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+
+TBool CWSOviServiceSession::Matches(MSenServiceDescription& aPattern)
+ {
+ TBool matches = CSenWebServiceSession::Matches(aPattern);
+ if (!matches) return EFalse;
+
+ MSenElement& xmlPatternAsElement = ((CSenWSDescription&)aPattern).AsElement();
+ MSenElement* pElement = xmlPatternAsElement.Element( KSenIdpProviderIdLocalname );
+ if(pElement)
+ {
+ TPtrC8 patternProviderID = pElement->Content();
+ TPtrC8 thisProviderID = ProviderID();
+ if(patternProviderID.Length()>0)
+ {
+ if(!(thisProviderID.Length()>0 && patternProviderID == thisProviderID))
+ {
+ return EFalse;
+ }
+ }
+ }
+
+ if (aPattern.DescriptionClassType() == MSenServiceDescription::EWSDescription)
+ {
+ TPtrC8 patternTransportCue = ((CSenWSDescription&)aPattern).TransportCue();
+ if (patternTransportCue.Length() > 0)
+ {
+ if(!iTransportCue || (patternTransportCue != *iTransportCue))
+ {
+ return EFalse;
+ }
+ }
+ }
+ return matches;
+ }
+
+TInt CWSOviServiceSession::ScoreMatchL(MSenServiceDescription& aPattern)
+ {
+ TInt score = CSenWebServiceSession::ScoreMatchL(aPattern);
+
+ MSenElement& xmlPatternAsElement = ((CSenWSDescription&)aPattern).AsElement();
+ MSenElement* pElement = xmlPatternAsElement.Element(KSenIdpProviderIdLocalname);
+ if(pElement)
+ {
+ TPtrC8 patternProviderID = pElement->Content();
+ TPtrC8 thisProviderID = ProviderID();
+ if(patternProviderID.Length()>0)
+ {
+ if ( thisProviderID.Length()>0 && patternProviderID == thisProviderID )
+ {
+ score++;
+ }
+ }
+ }
+
+ if (aPattern.DescriptionClassType() == MSenServiceDescription::EWSDescription)
+ {
+ TPtrC8 patternTransportCue = ((CSenWSDescription&)aPattern).TransportCue();
+ if (patternTransportCue.Length() > 0)
+ {
+ if ( iTransportCue && (patternTransportCue == *iTransportCue) )
+ {
+ score++;
+ }
+ }
+ }
+
+ return score;
+ }
+
+TInt CWSOviServiceSession::SetTransportPropertiesL(const TDesC8& aProperties,
+ MSenRemoteServiceConsumer& aConsumer)
+ {
+ if(iTransProp)
+ {
+ delete iTransProp;
+ iTransProp = NULL;
+ }
+ iTransProp = HBufC8::NewL(aProperties.Length());
+ TPtr8 ptr = iTransProp->Des();
+ ptr.Append(aProperties);
+ CWSOviSessionConsumer* pConsumer = NULL;
+ //senderID is internal id of consumer
+ TInt error = SessionConsumerL(aConsumer.Id(), pConsumer);
+ if (!error && pConsumer)
+ {
+ MSenTransport& tp = pConsumer->TransportL();
+ CSenHttpTransportProperties* transProp = ApplyTransportPropertiesLC(aProperties);
+ HBufC8* utfTP = transProp->AsUtf8L();
+ CleanupStack::PushL(utfTP);
+ tp.SetPropertiesL(*utfTP, MSenLayeredProperties::ESenTransportLayer, &aConsumer);
+ CleanupStack::PopAndDestroy(utfTP);
+ CleanupStack::PopAndDestroy(transProp);
+ }
+ return KErrNone;
+ }
+
+CSenHttpTransportProperties* CWSOviServiceSession::ApplyTransportPropertiesLC(const TDesC8& aTransportProperties)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ApplyTransportPropertiesL():");
+ TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel,(aTransportProperties));
+ CSenXmlReader* reader = XmlReader();
+ TPtrC8 value;
+ CSenHttpTransportProperties* httpTransProp = NULL;
+ if (aTransportProperties.Length() <= KSenXmlPropertiesLocalname().Length()*2
+ + KSenLessThanSlash().Length()
+ + KSenLessThan().Length()
+ + KSenGreaterThan().Length()*2)
+ {
+ if (iTransProp && iTransProp->Length())
+ {
+ httpTransProp = CSenHttpTransportProperties::NewLC(*iTransProp, *reader);
+ }
+ else
+ {
+ httpTransProp = CSenHttpTransportProperties::NewLC();
+ }
+ }
+ else
+ {
+ httpTransProp = CSenHttpTransportProperties::NewLC(aTransportProperties, *reader);
+ if (iTransProp)
+ {
+ //1 merge session and message layer transport properties
+ CSenHttpTransportProperties* conHttpTransProp = CSenHttpTransportProperties::NewLC(*iTransProp, *reader);
+
+ if (httpTransProp->ProxyHostL(value) == KErrNotFound)
+ {
+ if (conHttpTransProp->ProxyHostL(value) != KErrNotFound)
+ {
+ httpTransProp->SetProxyHostL(value);
+ }
+ }
+ if (httpTransProp->PropertyL(KNCIMEndpoint, value) == KErrNotFound)
+ {
+ if (conHttpTransProp->PropertyL(KNCIMEndpoint, value) != KErrNotFound)
+ {
+ httpTransProp->SetPropertyL(KNCIMEndpoint, value);
+ }
+ }
+ if (httpTransProp->PropertyL(KNCIMConsumerKeyId, value) == KErrNotFound)
+ {
+ if (conHttpTransProp->PropertyL(KNCIMConsumerKeyId, value) != KErrNotFound)
+ {
+ httpTransProp->SetPropertyL(KNCIMConsumerKeyId, value);
+ }
+ }
+ if (httpTransProp->PropertyL(KNCIMConsumerSecret, value) == KErrNotFound)
+ {
+ if (conHttpTransProp->PropertyL(KNCIMConsumerSecret, value) != KErrNotFound)
+ {
+ httpTransProp->SetPropertyL(KNCIMConsumerSecret, value);
+ }
+ }
+ if (httpTransProp->PropertyL(KNCIMConsumerServiceId, value) == KErrNotFound)
+ {
+ if (conHttpTransProp->PropertyL(KNCIMConsumerServiceId, value) != KErrNotFound)
+ {
+ httpTransProp->SetPropertyL(KNCIMConsumerServiceId, value);
+ }
+ }
+
+ TBool boolValue;
+ if (httpTransProp->OnewayMessageOnOffL(boolValue) == KErrNotFound)
+ {
+ if (conHttpTransProp->OnewayMessageOnOffL(boolValue) != KErrNotFound)
+ {
+ httpTransProp->SetOnewayMessageOnOffL(boolValue);
+ }
+ }
+ if (httpTransProp->BoolPropertyL(KSenIAPDoNotPrompt, boolValue) == KErrNotFound)
+ {
+ if (conHttpTransProp->BoolPropertyL(KSenIAPDoNotPrompt, boolValue) != KErrNotFound)
+ {
+ httpTransProp->SetBoolPropertyL(KSenIAPDoNotPrompt, boolValue);
+ }
+ }
+ if (httpTransProp->UserAgentL(value) == KErrNotFound)
+ {
+ if (conHttpTransProp->UserAgentL(value) != KErrNotFound)
+ {
+ httpTransProp->SetUserAgentL(value);
+ }
+ }
+ TUint32 uint32value;
+ if (httpTransProp->IapIdL(uint32value) == KErrNotFound)
+ {
+ if (conHttpTransProp->IapIdL(uint32value) != KErrNotFound)
+ {
+ httpTransProp->SetIapIdL(uint32value);
+ httpTransProp->SetSnapIdL(0);
+ }
+ }
+ if (httpTransProp->SnapIdL(uint32value) == KErrNotFound)
+ {
+ if (conHttpTransProp->SnapIdL(uint32value) != KErrNotFound)
+ {
+ httpTransProp->SetSnapIdL(uint32value);
+ httpTransProp->SetIapIdL(0);
+ }
+ }
+
+ TInt intValue;
+ if (httpTransProp->MaxTimeToLiveL(intValue) == KErrNotFound)
+ {
+ if (conHttpTransProp->MaxTimeToLiveL(intValue) != KErrNotFound)
+ {
+ httpTransProp->SetMaxTimeToLiveL(intValue);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(conHttpTransProp);
+ }
+ }
+
+ return httpTransProp;
+ }
+
+TInt CWSOviServiceSession::SendL( const TDesC8& aMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ TInt& aTxnId,
+ HBufC8*& aRevalidationError )
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"CWSOviServiceSession::SendL(TDesC8&, ...)");
+ TInt retVal(KErrNone);
+ if ( AmIHostletSession() )
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"- This is a session for a hostlet.");
+ retVal = CSenWebServiceSession::SendL( aMessage, aTransportProperties, aConsumer, aTxnId, aRevalidationError );
+ TLSLOG_FORMAT((KSenClientSessionLogChannelBase+aConsumer.ConnectionId(), KNormalLogLevel , _L8("- Return value from CSenWebServiceSession::SendL: %d"), retVal ));
+ TLSLOG_FORMAT((KSenClientSessionLogChannelBase+aConsumer.ConnectionId(), KNormalLogLevel , _L8("- Transaction ID from transport: %d"), aTxnId ));
+ }
+ else
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"- This is a session for a consumer.");
+ PrepareOutCtxL(aMessage);
+ VerifyPermissionL();
+ //we still have to check if validUntil is not expired.
+ retVal = RevalidateMobileTicketIfExpiredL( aRevalidationError );
+ iSessionContext->Update(WSOviContextKeys::KOnlySharing, ETrue);
+
+ if( retVal == KErrNone )
+ {
+ delete aRevalidationError;
+ aRevalidationError = NULL;
+ CSenHttpTransportProperties* transProp = ApplyTransportPropertiesLC(aTransportProperties);
+ retVal = MessageForSendingL(transProp, aConsumer.Id());
+ if (aMessage.Length())
+ {
+ transProp->SetContentTypeL(OAuth::KFormUrlEncoded());
+ }
+
+ HBufC8* utfTP = transProp->AsUtf8L();
+ CleanupStack::PushL(utfTP);
+ MSenTransport& transport = aConsumer.TransportL();
+ AdaptEndpointL(EFalse);
+ const TDesC8* message = iOutContext->GetDesC8L(WSOviContextKeys::KMessageBody);
+ if (message)
+ {
+ retVal = transport.SendL(Endpoint(), *message, *utfTP, *this, aConsumer, aTxnId );
+ }
+ else
+ {
+ retVal = transport.SendL(Endpoint(), aMessage, *utfTP, *this, aConsumer, aTxnId );
+ }
+ AdaptEndpointL(ETrue);
+ CleanupStack::PopAndDestroy(utfTP);
+ CleanupStack::PopAndDestroy(transProp);
+ DestroyOutCtx();
+ }
+ }
+ return retVal;
+ }
+
+
+TInt CWSOviServiceSession::SubmitL( const TDesC8& aMessage,
+ const TDesC8& aTransportProperties,
+ MSenRemoteServiceConsumer& aConsumer,
+ HBufC8*& aResponse )
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() ,KMinLogLevel ,"CWSOviServiceSession::SubmitL(TDesC8&, ...)");
+ TInt retVal(KErrNone);
+ if (!AmIHostletSession())
+ {
+ PrepareOutCtxL(aMessage);
+ CSenHttpTransportProperties* transProp = ApplyTransportPropertiesLC(aTransportProperties);
+ retVal = MessageForSendingL(transProp, aConsumer.Id());
+ if (aMessage.Length())
+ {
+ transProp->SetContentTypeL(OAuth::KFormUrlEncoded());
+ }
+
+
+ HBufC8* utfTP = transProp->AsUtf8L();
+ CleanupStack::PushL(utfTP);
+ MSenTransport& transport = aConsumer.TransportL();
+ AdaptEndpointL(EFalse);
+
+ const TDesC8* message = iOutContext->GetDesC8L(WSOviContextKeys::KMessageBody);
+ if (message)
+ {
+ retVal = transport.SubmitL(Endpoint(), *message, *utfTP, aResponse, aConsumer);
+ }
+ else
+ {
+ retVal = transport.SubmitL(Endpoint(), aMessage, *utfTP, aResponse, aConsumer);
+ }
+
+ MSenProperties& prop = transport.PropertiesL();
+ ((CWSOviPlugin&)iFramework).ProcessInboundDispatchL(this, retVal, aResponse, &prop );
+
+ AdaptEndpointL(ETrue);
+ CleanupStack::PopAndDestroy(utfTP);
+ CleanupStack::PopAndDestroy(transProp);
+ DestroyOutCtx();
+
+ if (retVal == KErrNone)
+ {
+ iSubmitState = WSOviSession::KSubmitStateOK;
+ }
+
+ //becouse of lack phase (dispatch to proprr consumer).
+ //It is SUBMIT nature, only used internally between Client and NAUTH
+ //we have to make validation here
+ CWSOviSessionConsumer* consumer = NULL;
+ if (iInContext)
+ {
+ SessionConsumerL(iInContext, consumer);
+ if (!(consumer && consumer->Id() == aConsumer.Id()))
+ {
+ retVal = KErrNotFound;
+ }
+ }
+ }
+ return retVal;
+ }
+
+void CWSOviServiceSession::AdaptEndpointL(TBool aToOrginal)
+ {
+ TPtrC8 oldEndpoint = Endpoint();
+ if (aToOrginal)
+ {
+ SetEndPointL(*iOrginalEndpoint);
+ return;
+ }
+
+ delete iOrginalEndpoint;
+ iOrginalEndpoint = NULL;
+ iOrginalEndpoint = oldEndpoint.AllocL();
+
+ HBufC8* newEp(NULL);
+/* CSenIdentityProvider* pIdentityProvider = IdentityProviderFromCoreL(ProviderID());
+ if (pIdentityProvider)
+ {
+ TPtrC8 advAuth = pIdentityProvider->AdvisoryAuthnID();
+
+ newEp = HBufC8::NewLC(oldEndpoint.Length()
+ + advAuth.Length());
+ TPtr8 ptr = newEp->Des();
+ _LIT8(KMask, "%S");
+ TInt pos = oldEndpoint.Find(KMask());
+ if (pos != KErrNotFound)
+ {
+ ptr.Append(oldEndpoint.Left(pos));
+ ptr.Append(advAuth);
+ ptr.Append(oldEndpoint.Right(oldEndpoint.Length() - pos - KMask().Length()));
+ SetEndPointL(ptr);
+ }
+
+ CleanupStack::PopAndDestroy(newEp);
+ }
+*/
+ CSenTransportProperties* tp = iOutContext->TP();
+ if (tp)
+ {
+ TInt err(KErrNone);
+ TPtrC8 suffixEndpoint;
+ err = tp->EndpointResourceL(suffixEndpoint);
+ if (!err)
+ {
+ newEp = HBufC8::NewLC(suffixEndpoint.Length()
+ +oldEndpoint.Length());
+ TPtr8 ptrNewEp = newEp->Des();
+ ptrNewEp.Append(oldEndpoint);
+ ptrNewEp.Append(suffixEndpoint);
+ SetEndPointL(*newEp);
+ CleanupStack::PopAndDestroy(newEp);
+ }
+ }
+ }
+CSenIdentityProvider* CWSOviServiceSession::IdentityProviderFromCoreL(
+ const TDesC8& aProviderID)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::IdentityProviderLFromCore");
+ CSenIdentityProvider* pIdentityProvider = NULL;
+ if(aProviderID.Length() > 0)
+ {
+ CDesC8ArrayFlat* array = new (ELeave) CDesC8ArrayFlat(1);
+ CleanupStack::PushL(array);
+ array->AppendL(aProviderID);
+ pIdentityProvider = ((CWSOviPlugin&)iFramework).Manager().IdentityProviderL(*array, ETrue);
+ CleanupStack::PopAndDestroy(array);
+ }
+ return pIdentityProvider;
+ }
+TInt CWSOviServiceSession::CanHandleErrorL()
+ {
+ TInt answer(KErrNone);
+ const TInt* renewNeeded(NULL);
+ const TInt* retry = iSessionContext->GetIntL(WSOviContextKeys::KRetryNeeded());
+
+
+
+
+ if (iSessionContext)
+ {
+ renewNeeded = iSessionContext->GetIntL(WSOviContextKeys::KReAuthNeeded());
+ }
+ //retry in milisecunds
+ if (retry && *retry > 0 &&
+ iRetryCounter < WSOviSession::KCounterMax)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::CanHandleErrorL - RETRY request (new timestamp needed)");
+ iRetryCounter++;
+ answer = KErrSenResendRequired;
+ }
+ else if((renewNeeded && *renewNeeded &&
+ iRenewCounter < WSOviSession::KCounterMax)
+ )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::CanHandleErrorL - RENEW request (new ticket is needed)");
+ iRenewCounter++;
+ answer = KErrSenReinitRequired;
+ }
+ else
+ {
+ iRenewCounter = 0;
+ iRetryCounter = 0;
+ }
+ return answer;
+ }
+TInt CWSOviServiceSession::SendToConsumerL(HBufC8* aMessage,
+ const TInt aTxnId,
+ MSenRemoteServiceConsumer& aConsumer,
+ MSenProperties* aResponseTransportProperties)
+ {
+ ((CWSOviPlugin&)iFramework).ProcessInboundDispatchL(this, KErrNone, aMessage, aResponseTransportProperties);
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() , KMinLogLevel,"CWSOviServiceSession::ParseMessageL(CSenSoapMessage& )");
+ iRenewCounter = 0;
+ iRetryCounter = 0;
+ return aConsumer.HandleMessageL( aMessage, aTxnId, aResponseTransportProperties );
+ }
+
+TInt CWSOviServiceSession::SendErrorToConsumerL( const TInt aErrorCode,
+ HBufC8* apError,
+ const TInt aTxnId,
+ MSenRemoteServiceConsumer& aConsumer,
+ MSenProperties* aResponseTransportProperties )
+ {
+ TLSLOG_L(KSenClientSessionLogChannelBase+aConsumer.ConnectionId() , KMinLogLevel,"CWSOviServiceSession::SendErrorToConsumerL");
+ TLSLOG_FORMAT((KSenClientSessionLogChannelBase+aConsumer.ConnectionId(), KNormalLogLevel , _L8("- ErrorCode: %d"), aErrorCode ));
+ ((CWSOviPlugin&)iFramework).ProcessInboundDispatchL(this, aErrorCode, apError, aResponseTransportProperties);
+ TInt answer = CanHandleErrorL();
+ if (answer)
+ {
+ delete apError;
+ return aConsumer.HandleErrorL(NULL, answer, aTxnId, aResponseTransportProperties);
+ }
+ else
+ {
+ return HandleErrorL(aErrorCode, apError, aTxnId, aConsumer, aResponseTransportProperties);
+ }
+ }
+
+
+
+TInt CWSOviServiceSession::SubmitSoapL( const TDesC8& /*aSoapMessage*/,
+ const TDesC8& /*aTransportProperties*/,
+ MSenRemoteServiceConsumer& /*aConsumer*/,
+ HBufC8*& /*aResponse*/ )
+ {
+ return KErrNotSupported;
+ }
+
+TInt CWSOviServiceSession::SendSoapL( const TDesC8& /*aSoapMessage*/,
+ const TDesC8& /*aTransportProperties*/,
+ MSenRemoteServiceConsumer& /*aConsumer*/,
+ TInt& /*aTxnId*/,
+ HBufC8*& /*aRevalidationError*/ )
+ {
+ return KErrNotSupported;
+ }
+
+
+TBool CWSOviServiceSession::IsExpiredL()
+ {
+ CSenServiceSession::SetStatusL();
+ return (CSenServiceSession::StatusL() == KSenConnectionStatusExpired);
+ }
+
+
+void CWSOviServiceSession::SetSessionContext(CWSOviSessionContext* aContext)
+ {
+ delete iSessionContext;
+ iSessionContext = aContext;
+ }
+CWSOviSessionContext* CWSOviServiceSession::SessionContext()
+ {
+ return iSessionContext;
+ }
+
+void CWSOviServiceSession::ClearCredentialL()
+ {
+ // Before removing the credential, checkt that
+ // iCredentialPtr.Credential() != NULL
+ if ( HasSecurity() ) // this performs the NULL check for credential
+ {
+ // Remove Invalid Credential from Credentials DB
+ TInt credentialId = iCredentialPtr.Credential()->IdentifierL().IdL();
+ ((MSenServiceManager&)iFramework.Manager()).RemoveCredentialL(credentialId);
+ }
+
+ // Remove Credential usage from Session
+ SetSecurityL(KNullDesC8);
+ iValidUntil.Set(_L("18000101:"));
+ }
+
+TInt CWSOviServiceSession::InitializeFromL( MSenServiceDescription& aDescription)
+ {
+ CSenWebServiceSession::SetSecurityL(KNullDesC8);
+ iValidUntil.Set(_L("19000101:"));
+
+ TDescriptionClassType classType = aDescription.DescriptionClassType();
+ if( classType == MSenServiceDescription::EWSDescription
+ ||
+ classType == MSenServiceDescription::EWSPattern
+ ||
+ classType == MSenServiceDescription::EIdentityProvider
+ )
+ {
+ MSenElement& xmlSdAsElement = (
+ (CSenWSDescription*)&aDescription)->AsElement();
+
+
+ MSenElement* pElement = xmlSdAsElement.Element(KSenIdpProviderIdLocalname);
+ delete iProviderID;
+ iProviderID = NULL;
+ if(pElement)
+ {
+ iProviderID = pElement->Content().AllocL();
+ }
+ else
+ {
+ CSenIdentityProvider* provider = ((CWSOviPlugin&)iFramework).
+ Manager().IdentityProviderL(aDescription);
+ if (provider)
+ {
+ iProviderID = provider->ProviderID().AllocL();
+ }
+ }
+ pElement = xmlSdAsElement.Element(WSOviSession::KTrustAnchorElementLocalName);
+ if(pElement)
+ {
+ delete iTrustAnchor;
+ iTrustAnchor = NULL;
+ iTrustAnchor = pElement->Content().AllocL();
+ }
+
+ CSenXmlReader* reader = XmlReader();
+ if (!iSessionContext)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::InitializeFromL");
+ iSessionContext = CWSOviSessionContext::NewL();
+
+ //calling higher class load such things like iClientServerInterval
+ CSenWebServiceSession::InitializeFromL(aDescription);
+ if ( StatusL() != KSenConnectionStatusReady )
+ {
+ // Try to search Credential directly from CredentialManager
+ // if Connection/Credential is not ready
+ if ( TryToSearchValidCredentialL() == KErrNone ) //codescannerwarnings
+ {
+ SetStatusL();
+ }
+ }
+ if (!iCredentialPtr.Credential())
+ {
+ pElement = xmlSdAsElement.Element(WSOviSession::KTokenCreationTimeLocalName);
+ if(pElement)
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTokenCreationTime, pElement->Content()));
+ }
+ pElement = xmlSdAsElement.Element(WSOviSession::KTTLLocalName);
+ if(pElement)
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTTL, pElement->Content()));
+ }
+ pElement = xmlSdAsElement.Element(WSOviSession::KTokenSecretLocalName);
+ if(pElement)
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTokenSecret, pElement->Content()));
+ }
+ }
+ AddSecurityTokenToContextL();
+ }
+ }
+ else
+ {
+ CSenWebServiceSession::InitializeFromL(aDescription);
+ }
+
+ return KErrNone;
+ }
+
+void CWSOviServiceSession::AddSecurityTokenToContextL()
+ {
+ if ( HasSecurity() )
+ {
+ CSenCredentialProperties& properties = iCredentialPtr.Credential()->PropertiesL(); //codescannerwarnings
+ TInt retVal;
+ TPtrC8 value;
+ if ( iSessionContext )
+ {
+ retVal = properties.PropertyL(WSOviSession::KTokenCreationTimeLocalName, value);
+ if ( retVal == KErrNone )
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTokenCreationTime, value));
+ }
+ retVal = properties.PropertyL(WSOviSession::KTTLLocalName, value);
+ if ( retVal == KErrNone )
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTTL, value));
+ }
+ retVal = properties.PropertyL(WSOviSession::KTokenSecretLocalName, value);
+ if ( retVal == KErrNone )
+ {
+ User::LeaveIfError(iSessionContext->Add(WSOviContextKeys::KTokenSecret, value));
+ }
+
+ HBufC8* pSecurity = SecurityL();
+ if (pSecurity)
+ {
+ CleanupStack::PushL(pSecurity);
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::InitializeFromL - adding token to ctx");
+
+ User::LeaveIfError(iSessionContext->Add(
+ WSOviContextKeys::KToken,
+ *pSecurity));
+ CleanupStack::PopAndDestroy(pSecurity);
+ }
+ }
+ }
+ }
+
+void CWSOviServiceSession::AddPropertiesFromSessionContextToCredentialL()
+ {
+ if (iSessionContext)
+ {
+ if ( iCredentialPtr.Credential() )
+ {
+ CSenCredentialProperties& properties = iCredentialPtr.Credential()->PropertiesL(); //codescannerwarnings
+ const TDesC8* pValue = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenCreationTime);
+ if ( pValue )
+ {
+ properties.SetPropertyL(WSOviSession::KTokenCreationTimeLocalName(), *pValue);
+ }
+ pValue = iSessionContext->GetDesC8L(WSOviContextKeys::KTTL);
+ if ( pValue )
+ {
+ properties.SetPropertyL(WSOviSession::KTTLLocalName(), *pValue);
+ }
+ pValue = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenSecret);
+ if ( pValue )
+ {
+ properties.SetPropertyL(WSOviSession::KTokenSecretLocalName(), *pValue);
+ }
+
+ // Now, serialize this session (and all it's updated credentials) into database(s)
+ iFramework.Manager().SaveL( *this ); // this will currently *also* serialize associated credential (new/updated MT)
+ }
+ }
+ }
+
+
+void CWSOviServiceSession::WriteExtensionsAsXMLToL(RWriteStream& aWriteStream)
+ {
+ CSenWebServiceSession::WriteExtensionsAsXMLToL(aWriteStream);
+
+ if(iProviderID)
+ {
+ aWriteStream.WriteL(WSOviSession::KProviderIDTag);
+ aWriteStream.WriteL(*iProviderID);
+ aWriteStream.WriteL(WSOviSession::KProviderIDEndTag);
+ }
+
+ if(iTrustAnchor)
+ {
+ aWriteStream.WriteL(WSOviSession::KTrustAnchorTag);
+ aWriteStream.WriteL(*iTrustAnchor);
+ aWriteStream.WriteL(WSOviSession::KTrustAnchorEndTag);
+ }
+ if (iSessionContext)
+ {
+ if (!iCredentialPtr.Credential() )
+ {
+ const TDesC8* value = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenCreationTime);
+ if (value)
+ {
+ aWriteStream.WriteL(WSOviSession::KTokenCreationTimeTag);
+ aWriteStream.WriteL(*value);
+ aWriteStream.WriteL(WSOviSession::KTokenCreationTimeEndTag);
+ }
+ value = iSessionContext->GetDesC8L(WSOviContextKeys::KTTL);
+ if (value)
+ {
+ aWriteStream.WriteL(WSOviSession::KTTLTag);
+ aWriteStream.WriteL(*value);
+ aWriteStream.WriteL(WSOviSession::KTTLEndTag);
+ }
+ value = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenSecret);
+ if (value)
+ {
+ aWriteStream.WriteL(WSOviSession::KTokenSecretTag);
+ aWriteStream.WriteL(*value);
+ aWriteStream.WriteL(WSOviSession::KTokenSecretEndTag);
+ }
+ }
+ }
+ }
+
+TPtrC8 CWSOviServiceSession::ProviderID()
+ {
+ if(iProviderID)
+ return *iProviderID;
+ else
+ return KNullDesC8();
+
+ }
+
+void CWSOviServiceSession::SetProviderIDL(const TDesC8& aProviderId)
+ {
+ if (iProviderID)
+ {
+ delete iProviderID;
+ iProviderID = NULL;
+ }
+ iProviderID = aProviderId.AllocL();
+ }
+
+
+void CWSOviServiceSession::SetTrustAnchorL(const TDesC8& aURI)
+ {
+ delete iTrustAnchor;
+ iTrustAnchor = NULL;
+ iTrustAnchor = aURI.AllocL();
+ }
+TPtrC8 CWSOviServiceSession::TrustAnchor()
+ {
+ if(iTrustAnchor)
+ return *iTrustAnchor;
+ else
+ return KNullDesC8();
+ }
+
+TInt CWSOviServiceSession::ComputeStatusL()
+ {
+
+ TInt retVal = CSenServiceSession::ComputeStatusL();
+ //we copy logic from CSenWebServiceSession and add :1) IProviderID condition
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("CWSOviServiceSession::ComputeStatusL() - retval: %d"), retVal));
+ if ((retVal == KSenConnectionStatusReady) && iProviderID)
+ {
+ const TDesC8* tokenCreatedTimeDes = NULL;
+ const TDesC8* ttlDes = NULL;
+ TPtrC8 tokenCreationTimePtr;
+ TPtrC8 ttlPtr;
+
+ if ( HasSecurity() )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ComputeStatusL() - HasSecurity true");
+
+ CSenCredentialProperties& properties = iCredentialPtr.Credential()->PropertiesL(); //codescannerwarnings
+ TInt retVal(KErrNone);
+ retVal = properties.PropertyL(WSOviSession::KTokenCreationTimeLocalName(), tokenCreationTimePtr);
+ if (!retVal)
+ {
+ tokenCreatedTimeDes = &tokenCreationTimePtr;
+ }
+ retVal = properties.PropertyL(WSOviSession::KTTLLocalName(), ttlPtr);
+ if (!retVal)
+ {
+ ttlDes = &ttlPtr;
+ }
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ComputeStatusL() - HasSecurity false");
+ if (iSessionContext)
+ {
+ tokenCreatedTimeDes = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenCreationTime);
+ ttlDes = iSessionContext->GetDesC8L(WSOviContextKeys::KTTL);
+ }
+ }
+ if (tokenCreatedTimeDes && ttlDes)
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("CWSOviServiceSession::ComputeStatusL() - ttlDes: %S & tokencreationDes: %S"), ttlDes, tokenCreatedTimeDes));
+ TInt64 tokenCreatedTime(0);
+ TInt64 ttl(0);
+ TLex8 temp;
+
+ temp= *tokenCreatedTimeDes;
+ temp.Val(tokenCreatedTime);
+
+ temp = *ttlDes;
+ temp.Val(ttl);
+
+ if (tokenCreatedTime && ttl)
+ {
+ HBufC8* nowTimeDes = SenCryptoUtils::GetTimestampL();
+ TInt64 nowTime(0);
+ temp = *nowTimeDes;
+ temp.Val(nowTime);
+ delete nowTimeDes;
+
+ if (nowTime)
+ {
+ TTimeIntervalSeconds margin(KClockSlipSeconds);
+ TTimeIntervalSeconds diff = tokenCreatedTime + ttl -margin.Int() - nowTime;
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("CWSOviServiceSession::ComputeStatusL() - diff: %d "), diff.Int()));
+ if (diff.Int()<0)
+ {
+ retVal = KSenConnectionStatusExpired;
+ }
+ }
+ }
+ }
+ else
+ {
+ retVal = KSenConnectionStatusExpired;
+ }
+ }
+ return retVal;
+
+ }
+
+void CWSOviServiceSession::PrepareOutCtxL(const TDesC8& aMessageBody)
+ {
+ iClientTime.UniversalTime();
+
+ CSenXmlReader* reader = XmlReader();
+ if (iOutContext)
+ {
+ delete iOutContext;
+ iOutContext = NULL;
+ }
+ iOutContext = CWSOviMessageContext::NewL(SenContext::EOutgoing);
+ if (aMessageBody != KNullDesC8)
+ {
+ iOutContext->Update(WSOviContextKeys::KMessageBody, aMessageBody);
+ }
+ }
+
+void CWSOviServiceSession::DestroyOutCtx()
+ {
+ delete iOutContext;
+ iOutContext = NULL;
+ }
+
+TInt CWSOviServiceSession::RevalidateMobileTicketIfExpiredL( HBufC8*& aErrorMessage )
+ {
+ TInt result(KErrNone);
+ if (IsExpiredL())
+ {
+ //we need revalidate
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSOviServiceSession::RevalidateMobileTicketIfExpiredL - revalidation is required.")));
+ iTokenObs->Cancel();
+ result = ((CWSOviPlugin&)iFramework).ProcessOutboundValidationL( *this, this, aErrorMessage );
+ if ( result == KErrNone )
+ {
+ // validation succeeded => serialize this session (and its credentials immediately)
+ iFramework.Manager().SaveL( *this ); // this will currently *also* serialize associated credential (new/updated MT)
+ }
+ if (result > KErrNone)
+ {
+ result = KErrSenAuthenticationFault;
+ }
+ return result;
+ }
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSOviServiceSession::RevalidateMobileTicketIfExpiredL - ticket is still valid.")));
+ return KErrNone;
+ }
+
+TBool CWSOviServiceSession::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 );
+ }
+ }
+
+TInt CWSOviServiceSession::ShareTokenWithL( CWSOviServiceSession* aWSOviSessionDst)
+ {
+ TInt error(KErrNone);
+ if ( !HasSecurity() )
+ {
+ return KErrNotFound;
+ }
+ //share token (only not expired), otherway it is sensless
+ //dont call SetStatus/IsExpired becouse it will infornm consumer/Core about chnge.
+ //Session will not be able to revalidate by itself in next sending
+ if (ComputeStatusL() != KSenConnectionStatusExpired)
+ {
+
+ error = iSessionContext->ShareTokenWithL(
+ aWSOviSessionDst->SessionContext());
+
+ aWSOviSessionDst->AddCredentialL(iCredentialPtr, iValidUntil);
+ return error;
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+
+void CWSOviServiceSession::AddCredentialL( const TDesC8& aSecurity, TTime aValidUntil )
+ {
+ iValidUntil = aValidUntil;
+ SetSecurityL(aSecurity);
+ SetStatusL();
+ }
+
+void CWSOviServiceSession::AddCredentialL(RSenCredentialPtr aCredentialPtr, TTime aValidUntil)
+ {
+ iValidUntil = aValidUntil;
+ SetCredentialPtrL(aCredentialPtr); // Share same Credential between multiple Sessions //codescannerwarnings
+ SetStatusL();
+ }
+
+TBool CWSOviServiceSession::AmIHostletSession()
+ {
+ if(iTransportCue && (KSenTransportCueHostletConnection() == *iTransportCue))
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+void CWSOviServiceSession::FillCredentialIdentifierL(CSenCredentialIdentifier& aIdentifier)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::FillCredentialIdentifierL:");
+ CSenWebServiceSession::FillCredentialIdentifierL(aIdentifier);
+ //_LIT8(KProviderIdElementLocalName, "ProviderID");
+ //aIdentifier.SetPropertyL(KProviderIdElementLocalName, ProviderID());
+
+ TPtrC8 providerId = ProviderID();
+ aIdentifier.SetPropertyL(KSenIdpProviderIdLocalname, providerId);
+
+ // Add information about the account that is priviledged to consume this credential
+
+ // (a) find matching IDP description (which represents the account / userinfo)
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"- About to call LookupIdentityProviderL");
+ CSenIdentityProvider* pIdentityProvider = LookupIdentityProviderL();
+// CSenIdentityProvider* pIdentityProvider = NULL;
+// if ( providerId != KNullDesC8 )
+// {
+// LOG_WRITEFORMAT((_L8("- Searching for IdentityProvider using ProviderId : %S"), &providerId));
+// CSenWSDescription* pIdpPattern = CSenWSDescription::NewLC();
+// pIdpPattern->SetEndPointL(providerId);
+// pIdentityProvider = iFramework.Manager().IdentityProviderL(*pIdpPattern);
+// CleanupStack::PopAndDestroy(pIdpPattern);
+// }
+
+ if ( pIdentityProvider )
+ {
+ TPtrC8 username = pIdentityProvider->UserName();
+ if( username.Length() > 0 )
+ {
+ aIdentifier.SetPropertyL(KSenIdpAuthzIDLocalname, username);
+ }
+ TPtrC8 password = pIdentityProvider->Password();
+ if( password.Length() > 0 )
+ {
+ aIdentifier.SetPropertyL(KSenIdpPasswordLocalname, password);
+ }
+ }
+ }
+
+void CWSOviServiceSession::VerifyPermissionL()
+ {
+ if( HasSecurity() )
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::VerifyPermissionL:");
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"- Making call to LookupIdentityProviderL");
+ CSenIdentityProvider* pProvider = LookupIdentityProviderL();
+ if ( pProvider )
+ {
+ CSenCredentialIdentifier& identifier = iCredentialPtr.Credential()->IdentifierL();
+ TPtrC8 username; // that was used to acquire this credential
+ TInt retVal = identifier.PropertyL(KSenIdpAuthzIDLocalname, username);
+
+ TPtrC8 password; // that was used to acquire this credential
+ retVal = identifier.PropertyL(KSenIdpPasswordLocalname, password);
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMaxLogLevel, _L8("=> Credential properties: username = '%S', password = '%S'"), &username, &password));
+
+ TPtrC8 accountUsername = pProvider->UserName();
+ TPtrC8 accountPassword = pProvider->Password();
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMaxLogLevel, _L8("=> Candidate IDP details: username = '%S', password = '%S'"), &accountUsername, &accountPassword));
+
+ if( ( username.Length() > 0 && username != accountUsername ) ||
+ ( password.Length() > 0 && password != accountPassword ) )
+ {
+ // either username or password DOES NOT MATCH (and the mismatching
+ // one is not zero-length string)
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"-> Will not grant permission to consume current credential,");
+
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel," clearing credential & it's properties from context.");
+ SetSecurityL(KNullDesC8);
+ ClearCredentialPropertiesFromContext();
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"--> Permission to consume current credential is granted.");
+ // => Permission to consume this credential is granted(!)
+ }
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"- There is no IDP (account), clearing credential & it's properties from context.");
+ // It is not possible to consumer WS-* service(s) without IDP (account)
+ SetSecurityL(KNullDesC8);
+ ClearCredentialPropertiesFromContext();
+ }
+ }
+ else
+ {
+ // If session has no credential (neither MT or SCT), neither should it have any
+ // related data in context(!)
+ //--> LOG_WRITE_L("- There is no credential, clearing credential properties from context.");
+ //--> SetSecurityL(KNullDesC8);
+ ClearCredentialPropertiesFromContext();
+ }
+ }
+
+CSenIdentityProvider* CWSOviServiceSession::LookupIdentityProviderL()
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::LookupIdpL()");
+ TPtrC8 providerId = ProviderID();
+ CSenIdentityProvider* pIdentityProvider = NULL;
+ if ( providerId != KNullDesC8 )
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("- Searching for IdentityProvider using ProviderId : %S"), &providerId));
+ CSenWSDescription* pIdpPattern = CSenWSDescription::NewLC();
+ pIdpPattern->SetEndPointL(providerId);
+ pIdentityProvider = iFramework.Manager().IdentityProviderL(*pIdpPattern);
+ CleanupStack::PopAndDestroy(pIdpPattern);
+ }
+ return pIdentityProvider;
+ }
+
+
+
+TBool CWSOviServiceSession::HasEqualPrimaryKeysL( MSenServiceDescription& aCandidate )
+ {
+ TBool retVal(EFalse);
+ if ( CSenWSDescription::HasEqualPrimaryKeysL(aCandidate) )
+ {
+ // Endpoint, Contract and FrameworkID match, all of them.
+ // Now, in WS-Ovi, also check ProviderID
+ if (aCandidate.DescriptionClassType() == DescriptionClassType())
+ {
+ CWSOviServiceSession& sessionCandidate = (CWSOviServiceSession&)aCandidate;
+ if (sessionCandidate.ProviderID() == ProviderID())
+ {
+ retVal = ETrue;
+ }
+ }
+ }
+ return retVal;
+ }
+
+void CWSOviServiceSession::CredentialChanged( TSenCredentialChange aChange,
+ TAny* apPointer )
+ {
+ if ( aChange == MSenCredentialObserver::EDestroyed && iSessionContext )
+ {
+ ClearCredentialPropertiesFromContext();
+ }
+ else if ( aChange == MSenCredentialObserver::EAdded && iSessionContext)
+ {
+ AddSecurityTokenToContextL();
+ }
+ CSenWebServiceSession::CredentialChanged( aChange, apPointer );
+ }
+
+
+void CWSOviServiceSession::ClearCredentialPropertiesFromContext()
+ {
+ if( iSessionContext )
+ {
+ iSessionContext->Remove(WSOviContextKeys::KToken);
+ iSessionContext->Remove(WSOviContextKeys::KTokenCreationTime);
+ iSessionContext->Remove(WSOviContextKeys::KTTL);
+ iSessionContext->Remove(WSOviContextKeys::KTokenSecret);
+ }
+ }
+void CWSOviServiceSession::SetMaxValidUntil()
+ {
+ iValidUntil = Time::MaxTTime();
+ }
+
+void CWSOviServiceSession::ActiveTicketObserverL()
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL()");
+ if (iSessionContext)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL()- SessionContext exists");
+ const TDesC8* tokenCreatedTimeDes = iSessionContext->GetDesC8L(WSOviContextKeys::KTokenCreationTime);
+ const TDesC8* ttlDes = iSessionContext->GetDesC8L(WSOviContextKeys::KTTL);
+ if (tokenCreatedTimeDes && ttlDes)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL() - ttl & time creation exists");
+ TInt64 tokenCreatedTime(0);
+ TInt64 ttl(0);
+ TLex8 temp;
+ temp.Assign(*tokenCreatedTimeDes);
+ temp.Val(tokenCreatedTime);
+
+ temp = *ttlDes;
+ temp.Val(ttl);
+
+ if (tokenCreatedTime && ttl)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL() - ttl & time creation is valid");
+ HBufC8* nowTimeDes = SenCryptoUtils::GetTimestampL();
+ TInt64 nowTime(0);
+ temp = *nowTimeDes;
+ temp.Val(nowTime);
+ delete nowTimeDes;
+ if (nowTime)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL() - now time exists");
+ TInt marginForComputeStatus(10);
+ TTimeIntervalSeconds margin(KClockSlipSeconds-marginForComputeStatus);
+ TTimeIntervalSeconds diff = tokenCreatedTime + ttl -margin.Int() - nowTime;
+ if (diff.Int()>=0)
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSOviServiceSession::ActiveTicketObserverL() - start observer");
+ iTokenObs->Start(diff);
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+// End of file
+