/*

* 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)

            {

                {

                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;

    }