diff -r 000000000000 -r 62f9d29f7211 webservices/wsoviplugin/src/wsoviservicesession.cpp
--- /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
+