/*

* Copyright (c) 2006-2006 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 "wsstarservicesession.h"

#include "sendebug.h"

#include "senlogger.h"

#include "SenSoapFault.h"

#include "senservicemanagerdefines.h"

#include "SenServiceConnection.h" // err code definitions

#include "senserviceinvocationframework.h"

#include "SenHttpTransportProperties.h"

#include "senvtcptransportproperties.h"

#include "SenDateUtils.h"

#include "wsstarpolicy.h"

#include "sendebug.h"

#include "sencryptoutils.h"

#include "senwspattern.h"

#include "SenXmlUtils.h"

#include <SenIdentityProvider.h>

#include "wsstarcredentialobserver.h"

using namespace WSPolicy;

/* Constant margin. Value is copied from framework internal class.

 * We check if MT is expired (now < validUntil - skew time - margin)

 * Margin is 15 minutes.

 */

const TInt64 KClockSlipMinutes = 15;

CWSStarServiceSession* CWSStarServiceSession::NewL(MSIF& aFramework)

    {

    CWSStarServiceSession* self = CWSStarServiceSession::NewLC(aFramework);

    CleanupStack::Pop(self);

    return self;

    }

CWSStarServiceSession* CWSStarServiceSession::NewLC(MSIF& aFramework)

    {

    CWSStarServiceSession* self = new (ELeave) CWSStarServiceSession(

        MSenServiceDescription::EWSStarServiceSession, aFramework);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CWSStarServiceSession::CWSStarServiceSession(TDescriptionClassType aType,

                                           MSIF& aSIF)

    : CSenWebServiceSession(aType, aSIF),

        iMessageThread(EFalse),

        iSubmitState(WSStarSession::KSubmitStateOK)

    {

    }

CWSStarServiceSession::~CWSStarServiceSession()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::~CWSStarServiceSession");            

    delete iSessionContext;

    delete iProviderID;

    delete iTrustAnchor;

    delete iOutContext;

    delete iInContext;

    delete ipReceivedMessageIdInTrans;

    delete iTransProp;

    TInt count(iConsumerList.Count());

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("CWSStarServiceSession::~CWSStarServiceSession leaved ConsumerL now=  %d"), count));

    for(TInt i=0; i<count; i++)

        {

        // we can assume that every remote consumer

        // has been wrapped inside WSStarSessionConsumer

        // -wrapperclass. Cast and destroy:

        CWSStarSessionConsumer* pConsumer

            = (CWSStarSessionConsumer*) iConsumerList[i];

        // this destroys the wrapper, but the remote

        // consumer objects ownership remains in either

        // XMLDao or ClientSession (etc)

        delete pConsumer;

        }

    delete iTicketObs;

    }

void CWSStarServiceSession::ConstructL()

    {

    CSenWebServiceSession::ConstructL();    

    iTicketObs = CWSStarCredentialObserver::NewL(this, iFramework.Manager().Log());

    }

TInt CWSStarServiceSession::AddConsumerL(MSenRemoteServiceConsumer& aConsumer)

    {

    CSLOG_L(aConsumer.ConnectionId() ,KMinLogLevel ,"CWSStarServiceSession::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

            }

        }

    CWSStarSessionConsumer* pSessionConsumer =

                                    CWSStarSessionConsumer::NewL(aConsumer, *Log());

    TInt error = iConsumerList.Append(pSessionConsumer);

    CWSStarPlugin* fmw = (CWSStarPlugin*)&iFramework;

    fmw->PolicyConsumerAddedL(this,*pSessionConsumer);

    return KErrNone;

    }

/**

 * DetachCredentialsL

 *

 * This function  invalidates the session by deleting the credential

 * This also call setStatusL to recompute the status

*/

void CWSStarServiceSession::DetachCredentialsL()

	{

		ClearCredentialL() ;

		SetStatusL() ;

	}

TBool CWSStarServiceSession::ExistConsumerL()

    {

    const TInt consumerCount(iConsumerList.Count());

    if( consumerCount == 0 )

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"   - Consumer count = 0");

        return EFalse;

        }

    else

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("- Consumer count =  %d"), consumerCount));

        return ETrue;

        }

    }

TInt CWSStarServiceSession::RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer)

    {

    CSLOG_L(aConsumer.ConnectionId() ,KMinLogLevel ,"CWSStarServiceSession::RemoveConsumerL:");    

    const TInt consumerCount(iConsumerList.Count());

    for(TInt i=0; i<consumerCount; i++)

        {

        if(iConsumerList[i]->Id() == aConsumer.Id())

            {

            CWSStarSessionConsumer* pConsumer

                            = (CWSStarSessionConsumer*) iConsumerList[i];

            delete pConsumer;

            iConsumerList.Remove(i);

            CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel , _L8("CWSStarServiceSession::Removed ConsumerL now=  %d"), consumerCount-1));

            if( (consumerCount-1) == 0 )

                {

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

        {

        CSLOG_L(aConsumer.ConnectionId() ,KNormalLogLevel ,"- Consumer count == 0");

        CSLOG_L(aConsumer.ConnectionId() ,KNormalLogLevel ,"-> Closing the handle to the credential owned by the Credential Manager.");

        SetSecurityL(KNullDesC8); // this removes the reference to credential, but

                                  // it can be regained on next lookup

                                  // This needs to implemet. so that userinfo (password)

                                  // that grants the permission to use the credential

                                  // will be checked on that (credential sharing) lookup.

        }           

    return CSenServiceSession::RemoveConsumerL(aConsumer);

    }

TInt CWSStarServiceSession::MessageForSendingL( const TDesC8& aBody,

                                                const TDesC8& aSenderID,

                                                CSenSoapMessage*& aMessage)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::MessageForSendingL");    

    TInt error(KErrNone);

    if (AmIHostletSession())

        {

        return CSenWebServiceSession::MessageForSendingL(aBody, aSenderID, aMessage);

        }

    else

        {

        CleanupStack::PushL(aMessage);

        CWSStarSessionConsumer* pConsumer = NULL;

        //senderID is internal id of consumer

        error = SessionConsumerL(aSenderID, pConsumer);

        if (error)

            {

            CleanupStack::Pop(aMessage);

            return error; 

            }

        CWSStarSessionContext* ssCtx = (CWSStarSessionContext*)SessionContext();

        //----adding addressing info

        //messageId - set by handler

        User::LeaveIfError(iOutContext->Add(WSStarContextKeys::KTo, Contract()));

        if(ipReceivedMessageIdInTrans)

            {

            User::LeaveIfError(iOutContext->Add(WSStarContextKeys::KRelatesTo,

                    *ipReceivedMessageIdInTrans));

            }

        else

            {

            User::LeaveIfError(iOutContext->Add(WSStarContextKeys::KRelatesTo, NULL));

            }

        iOutContext->SetOwnedEnvelope();

        iOutContext->UpdateFromSessionContextL(*ssCtx);

        CleanupStack::Pop(aMessage);

        error = ((CWSStarPlugin&)iFramework).ProcessOutboundMessageL(

                iOutContext, &aBody, aMessage);

        iSessionContext->UpdateFromMessageOutContextL(*iOutContext);

        const TDesC8* resolvedBody = iSessionContext->GetDesC8L(WSStarContextKeys::KBody);

        if (resolvedBody && (!error))

            {

            error = pConsumer->MessageForSendingL(*resolvedBody , iOutContext);

            }

        aMessage = iOutContext->GetCurrentSoapMessage();

        iOutContext->SetOwnedEnvelope(EFalse);

        delete iOutContext;

        iOutContext = NULL;

        }

    return error;

    }

TInt CWSStarServiceSession::NewMessageL(CSenSoapMessage*& aMessage)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::NewMessageL( CSenSoapMessage*& )");                    

    //method used during ibound processing

    const TInt* soapVer = iSessionContext->GetIntL(WSStarContextKeys::KSoapVersion);

    if (soapVer)

        {

        aMessage = CSenSoapMessage::NewL((TSOAPVersion)*soapVer);    

        }

    else

        {

        aMessage = CSenSoapMessage::NewL(ESOAP12);    

        }

    CSenXmlReader* reader = XmlReader();

    if (iInContext)

        {

        delete iInContext;

        iInContext = NULL;

        }

    iInContext = CWSStarMessageContext::NewL(SenContext::EIncoming, reader);

    CWSStarSessionContext* ssCtx = (CWSStarSessionContext*)SessionContext();

    iInContext->UpdateFromSessionContextL(*ssCtx);

    return KErrNone;

    }

TInt CWSStarServiceSession::ParseMessageL(CSenSoapMessage& aSOAPMessage)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::ParseMessageL(CSenSoapMessage& )");

//-----SCHarF ------- 7.5.3.3 Inbound messageflow    

    //CSenXmlReader* reader = XmlReader();

    CSenSoapMessage* soapMessage = &aSOAPMessage;

    ((CWSStarPlugin&)iFramework).ProcessInboundDispatchL(this, soapMessage);

    ((CWSStarPlugin&)iFramework).ProcessInboundMessageL(iInContext, soapMessage);

    iServerTime.UniversalTime();

    //keep transaction chain

    if (iMessageThread)

        {

        const TDesC8* msgId = iInContext->GetDesC8L(WSStarContextKeys::KMessageID());

        if (msgId)

            {

            delete ipReceivedMessageIdInTrans;

            ipReceivedMessageIdInTrans = NULL;

            ipReceivedMessageIdInTrans = msgId->AllocL();

            }

        else

            {

            //transaction mode is enabled, but no messageId in response so what to do.

            //anyway we will continue without signalizing error

            }

        }

    iSessionContext->UpdateFromMessageInContextL(*iInContext);

    return CSenWebServiceSession::ParseMessageL(aSOAPMessage);

    }

TInt CWSStarServiceSession::SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,

                                                        const TInt aTxnId,

                                                        MSenRemoteServiceConsumer& aConsumer,

                                                        MSenProperties* aResponseTransportProperties )

    {

    //-----SCHarF ------- glue with dispather for handlers 7.5.3.2 inbound

    CSLOG_L(aConsumer.ConnectionId() ,KMinLogLevel ,"CWSStarServiceSession::SendSoapMessageToConsumerL");

    if ( apMessage )

        {

        CleanupStack::PushL( apMessage );

        //dispatch to proper consumer

        CWSStarSessionConsumer* pConsumer = NULL;

        SessionConsumerL( iInContext, pConsumer );

        if (!pConsumer) 

            {

            CleanupStack::PopAndDestroy( apMessage ); // de-alloc immediately! Change this, if WS-stack one day gives back faults to Service Connections

            // No related consumer, signalize fault error 

            aConsumer.HandleErrorL( NULL, KErrSenBrokenSoapEnvelope, aTxnId, aResponseTransportProperties );

            }

        else

            {

            // handle message destroys this

            TBool completeServerMessages;

            HasFacetL(KCompleteMessagesFacet, completeServerMessages);

            CleanupStack::Pop( apMessage ); // REQUIREMENT for next method => it MUST take ownership IMMEDIATELY

            pConsumer->HandleSoapMessageL( apMessage, aTxnId, aResponseTransportProperties, completeServerMessages );

            }

        iRetryCounter = 0;     //reset counter for retryAfter faults. If proper message incomes, we can reset counter

        iRenewCounter = 0;     //

        iRedirectCounter =0 ;

        delete iInContext;

        iInContext = NULL;        

        return KErrNone;

        }

    else

        {

        CSLOG_L(aConsumer.ConnectionId() ,KMinLogLevel ,"CWSStarServiceSession::SendSoapMessageToConsumerL - apMessage == NULL => invoking remote consumer's HandleErrorL with KErrSenBrokenSoapEnvelope");

        /*TInt retVal = */ aConsumer.HandleErrorL( NULL, KErrSenBrokenSoapEnvelope, aTxnId, aResponseTransportProperties );

        return KErrSenInternal;

        }

    }

MSenRemoteServiceConsumer* CWSStarServiceSession::RemoteConsumerL( const TDesC8& aSenderID )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::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 CWSStarServiceSession::SessionConsumerL( CWSStarMessageContext*& aMsgCtx,

                                              CWSStarSessionConsumer*& aSessionConsumer )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::SessionConsumerL");                

    TInt consumersCount(iConsumerList.Count());

    TInt error(KErrNotFound);

    const TDesC8* relatesTo = aMsgCtx->GetDesC8L(WSStarContextKeys::KRelatesTo);

    const TDesC8* endpoint = aMsgCtx->GetDesC8L(WSStarContextKeys::KTo);

    for(TInt i=0; i<consumersCount; i++)

        {

        CWSStarSessionConsumer* pConsumer = (CWSStarSessionConsumer*)iConsumerList[i];

        if ((relatesTo) && (pConsumer->Expects(*relatesTo, endpoint)))

            {

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::SessionConsumerL - Found consumer");

            aSessionConsumer = pConsumer;

            error = KErrNone;

            break;

            }

        }

    if (error && consumersCount)

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSStarServiceSession::SessionConsumerL - consumer was not found - using the 1st one (as default)");

        aSessionConsumer = (CWSStarSessionConsumer*)iConsumerList[0];

        error = KErrNone;

        }

    return error;

    }

//---------------------------------------------------------------------------

// To obtain consumer during processing OUTBOUND.

//---------------------------------------------------------------------------

//   

TInt CWSStarServiceSession::SessionConsumerL( const TDesC8& aSenderID,

                                              CWSStarSessionConsumer*& aSessionConsumer )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::SessionConsumerL");                        

    aSessionConsumer = (CWSStarSessionConsumer*) RemoteConsumerL(aSenderID);

    if(aSessionConsumer)

        {

        return KErrNone;

        }

    else

        {

        return KErrNotFound;

        }

    }

// SYNC IMPLEMENTATION(!) - only available internally.

//  It means, that all SYNC operation for 3rd developer from public API are in fact ASYNC. 

//  @see SenServiceConnectionImpl.cpp

//  aSOAPMessage.IsFault() should always be TRUE.

// 

TInt CWSStarServiceSession::HandleSoapFaultL( CSenSoapMessage* apSOAPMessage,

                                              HBufC8*& aResponse )

    { 

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarServiceSession::HandleErrorL(CSenSoapMessage&, HBufC8*&)");

    TInt retVal(KErrNone);

    if ( apSOAPMessage )

        {

        CleanupStack::PushL( apSOAPMessage ); // ownerhip is here

        TInt answer = CanHandleErrorL();

        if (answer == KErrSenResendRequired)

            {

            CleanupStack::PopAndDestroy( apSOAPMessage ); // not needed atm

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CanHandleErrorL == TRUE");

            CWSStarSessionConsumer* pConsumer = NULL;

            // this takes care of messageIDs

            retVal = SessionConsumerL(iInContext, pConsumer);

            if(!pConsumer)

                {

                CleanupStack::PopAndDestroy( apSOAPMessage );

                return KErrNotFound;

                }

            const TDesC8* relatesTo = iInContext->GetDesC8L(WSStarContextKeys::KRelatesTo);

            if (!relatesTo)

                {

                //if response from backend doesn't include any relatesTo we can try assume

                //      that response is for last outgoing message. This trick is used by passport phase

                const TInt* isPassportEnabled = iInContext->GetIntL(WSStarContextKeys::KPassportEnabled);

                if (isPassportEnabled && *isPassportEnabled == TRUE)

                    {

                    relatesTo = iSessionContext->GetDesC8L(WSStarContextKeys::KMessageID);    

                    }

                }

            if (relatesTo)

                {

                TDesC8* pBody = pConsumer->BodyL(*relatesTo);

                if (pBody)

                    {

                    HBufC8* pTemp = HBufC8::NewLC(pBody->Length());

                    TPtr8 temp = pTemp->Des();

                    temp.Append(*pBody);

                    HBufC8* startBody = HBufC8::NewLC(KSenSoapEnvelopeBodyQName().Length()+

                                                    KSenLessThan().Length()+

                                                    KSenGreaterThan().Length());

                    TPtr8 startBodyPtr = startBody->Des();

                    startBodyPtr.Append(KSenLessThan());                                

                    startBodyPtr.Append(KSenSoapEnvelopeBodyQName());                                

                    startBodyPtr.Append(KSenGreaterThan());                                

                    HBufC8* endBody = HBufC8::NewLC(KSenSoapEnvelopeBodyQName().Length()+

                                                    KSenLessThanSlash().Length()+

                                                    KSenGreaterThan().Length());

                    TPtr8 endBodyPtr = endBody->Des();

                    endBodyPtr.Append(KSenLessThanSlash());                                

                    endBodyPtr.Append(KSenSoapEnvelopeBodyQName());                                

                    endBodyPtr.Append(KSenGreaterThan());                                

                    if( SenXmlUtils::StartsWith(*pBody, *startBody) )

                        {

                        temp.Delete( 0,startBody->Length() );

                        }

                    if( SenXmlUtils::EndsWith(*pTemp, *endBody) )

                        {

                        temp.Delete( pTemp->Length()-endBody->Length(),endBody->Length() );

                        }

                    CleanupStack::PopAndDestroy(endBody);                

                    CleanupStack::PopAndDestroy(startBody);                

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Re-submitting the request");

                    //clear Id

                    retVal = SubmitL(*pTemp,

                           pConsumer->TransportProperties(*relatesTo),

                            *pConsumer, aResponse);

                    //retVal = SubmitL(*pTemp, KNullDesC8, *pConsumer, aResponse);        

                    CleanupStack::PopAndDestroy(pTemp);                

                    return retVal;

                    }    

                }

            }

        // In any other case, it is mean that we can not handle error, we can not

        // replace with new response.