/*

* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:        

*

*/

// INCLUDE

#include <SenServiceConnection.h> // error code definitions

#include <SenDateUtils.h>

#include <SenSoapFault.h>

#include <SenWsSecurityHeader.h>

#include <SenTransportProperties.h>

#include <SenSoapConstants.h> // SOAPAction constants, like KSenSoapActionHeaderName

#include "sendebug.h"

#include "senlogger.h"

#include "msencoreservicemanager.h"

#include "senservicemanagerdefines.h"

#include "senserviceinvocationframework.h"

#include "midwsfsessionvalidator.h"

#include "idwsfservicesession.h"

#include "idwsfsessionconsumer.h"

#include "idwsfserviceinstance.h"

#include "seninternalcredential.h"

#include <SenXmlReader.h>

namespace

    {

    _LIT8(KSAML,                        "SAML");

    _LIT8(KBEARER,                      "Bearer");

    _LIT8(KProviderID,                  "<ProviderID>");

    _LIT8(KProviderIDEnd,               "</ProviderID>");

    _LIT8(KResourceID,                  "<ResourceID>");

    _LIT8(KResourceIDEnd,               "</ResourceID>");

    _LIT8(KTrustAnchor,                 "<TrustAnchor>");

    _LIT8(KTrustAnchorEnd,              "</TrustAnchor>");

    _LIT8(KServiceInterval,             "<ServiceInterval>");

    _LIT8(KServiceIntervalEnd,          "</ServiceInterval>");

    _LIT8(KProviderIdElementLocalName,  "ProviderID");

    _LIT8(KResourceIDElementLocalName,  "ResourceID");

    _LIT8(TrustAnchorElementLocalName,  "TrustAnchor");

    //_LIT8(KServiceIntervalElementLocalName, "ServiceInterval");

    const TInt KSubmitStateOK                       = 1;

    const TInt KSubmitStateInvalidCredentials       = 2;

    const TInt KSubmitStateRevalidationAttempted    = 3;

    const TInt KSubmitStateRevalidationFailed       = 4;

    //const TInt KSubmitSateResend					= 5;

    //const TInt KSubmitSateResendFailed			= 6;

    }

CIdWsfServiceSession* CIdWsfServiceSession::NewL(MSIF& aFramework)

    {

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

    CleanupStack::Pop(self);

    return self;

    }

CIdWsfServiceSession* CIdWsfServiceSession::NewLC(MSIF& aFramework)

    {

    CIdWsfServiceSession* self = new (ELeave) CIdWsfServiceSession(

        MSenServiceDescription::EIdWSFServiceSession, aFramework);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CIdWsfServiceSession::CIdWsfServiceSession(TDescriptionClassType aType,

                                           MSIF& aSIF)

    : CSenWebServiceSession(aType, aSIF),

        iProvider(NULL),

        ipResourceId(NULL),

        ipTrustAnchor(NULL),

        ipReceivedMessageId(NULL),

        ipSenSecurityMechanism(NULL),

        iMessageThread(EFalse),

        ipValidator(NULL),

        iSubmitState(KSubmitStateOK)

    {

    }

CIdWsfServiceSession::~CIdWsfServiceSession()

    {

    delete iProvider;

    delete ipResourceId;

    delete ipTrustAnchor;

    delete ipReceivedMessageId;

    delete ipSenSecurityMechanism;

    TInt count(iConsumerList.Count());

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

        {

        // we can assume that every remote consumer

        // has been wrapped inside IdWsfSessionConsumer

        // -wrapperclass. Cast and destroy:

        CIdWsfSessionConsumer* pConsumer

            = (CIdWsfSessionConsumer*) iConsumerList[i];

        // this destroys the wrapper, but the remote

        // consumer objects ownership remains in either

        // XMLDao or ClientSession (etc)

        delete pConsumer;

        }

    }

void CIdWsfServiceSession::ConstructL()

    {

    // sets local name to "ServiceDescription" and

    // initiates the inner ipElement

    CSenWebServiceSession::ConstructL();

    }

TInt CIdWsfServiceSession::AddConsumerL(MSenRemoteServiceConsumer& aConsumer)

    {

    const TInt consumerCount(iConsumerList.Count());

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

        {

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

            return KErrAlreadyExists; // already added, nothing to do

        }

    CIdWsfSessionConsumer* pSessionConsumer =

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

    iConsumerList.Append(pSessionConsumer);

    // clears the array and inserts item as the only one..

    // remove next line, when NEW routing is in use:

    return KErrNone;

    }

TInt CIdWsfServiceSession::RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer)

    {

    const TInt consumerCount(iConsumerList.Count());

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

        {

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

            {

            CIdWsfSessionConsumer* pConsumer

                            = (CIdWsfSessionConsumer*) iConsumerList[i];

            delete pConsumer;

            iConsumerList.Remove(i);

            break;

            }

        }

    return CSenServiceSession::RemoveConsumerL(aConsumer);

    }

TPtrC8 CIdWsfServiceSession::FrameworkId()

    {

    return iFramework.Id();

    }

TInt CIdWsfServiceSession::MessageForSendingL(const TDesC8& aBody,

                                              const TDesC8& aSenderID,

                                              CSenSoapMessage*& aMessage)

    {

    CIdWsfSessionConsumer* pConsumer = NULL;

    TInt retVal = SessionConsumerL(aSenderID, pConsumer);

    if (retVal != KErrNone)

        {

        return retVal; 

        }

    if(ipReceivedMessageId)

        {

        retVal = pConsumer->MessageForSendingL(aBody,

                                                *ipReceivedMessageId,

                                                (CIdWsfMessage*&)aMessage);

        }

    else

        {

        retVal = pConsumer->MessageForSendingL( aBody,

                                                KNullDesC8(),

                                                (CIdWsfMessage*&)aMessage);

        }

    if (retVal != KErrNone)

        {

        return retVal; 

        }

    SetFrameworkHeadersL(*aMessage);

    return KErrNone;

    }

TInt CIdWsfServiceSession::NewMessageL(CSenSoapMessage*& aMessage)

    {

    aMessage = CIdWsfMessage::NewL();

    return KErrNone;

    }

// from XML service description

TInt CIdWsfServiceSession::InitializeFromL(

                    MSenServiceDescription& aDescription)

    {

    CSenWebServiceSession::SetSecurityL(KNullDesC8);

    CSenWebServiceSession::InitializeFromL(aDescription);

    if ( StatusL() != KSenConnectionStatusReady )

        {

        if ( TryToSearchValidCredentialL() == KErrNone )	//codescannerwarnings

            {

            SetStatusL();

            }

        }

    aDescription.HasFacetL(KMessageThread,iMessageThread);

    TDescriptionClassType classType = aDescription.DescriptionClassType();

    if( classType == MSenServiceDescription::EWSDescription

                                            ||

        classType == MSenServiceDescription::EWSPattern

                                            ||

        classType == MSenServiceDescription::EIdentityProvider

        )

        {

        MSenElement& xmlSdAsElement = (

            (CSenWSDescription*)&aDescription)->AsElement();

        MSenElement* pElement =

                        xmlSdAsElement.Element(KProviderIdElementLocalName);

        if(pElement)

            {

            TPtrC8 providerId = pElement->Content();

            TPtrC8 endPoint = aDescription.Endpoint();

            CIdWsfServiceProvider* pNewProvider =

                CIdWsfServiceProvider::NewL(providerId, endPoint);

            // now it is safe to free & re-assign

            delete iProvider;

            iProvider = pNewProvider;

            }

        pElement = xmlSdAsElement.Element(KResourceIDElementLocalName);

        if(pElement)

            {

            HBufC8* pNewResourceId = (pElement->Content()).AllocL();

            // now it is safe to free & re-assign

            delete ipResourceId;

            ipResourceId = pNewResourceId;

            }

        pElement = xmlSdAsElement.Element(TrustAnchorElementLocalName);

        if(pElement)

            {

            HBufC8* pNewTrustAnchor = (pElement->Content()).AllocL();

            delete ipTrustAnchor;

            ipTrustAnchor = pNewTrustAnchor;

            }

        }

    TPtrC8  contract = Contract(); 

    if (contract == KNullDesC8)

        {

        return KErrSenNoContract;

        }

    return KErrNone;

    }

TInt CIdWsfServiceSession::ParseMessageL(CSenSoapMessage& aSOAPMessage)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfServiceSession::ParseMessageL");

    if (iMessageThread)

        {

        delete ipReceivedMessageId;

        ipReceivedMessageId =

                        ((CIdWsfMessage&)aSOAPMessage).MessageId().Alloc();

        if (!ipReceivedMessageId)

            return KErrNoMemory;

        }

    TInt error = CSenWebServiceSession::ParseMessageL(aSOAPMessage);

    if (error != KErrNone)

        {

        return error;

        }

    CIdWsfMessage& message = (CIdWsfMessage&)aSOAPMessage;

    TTime serverTime;

    if (message.Timestamp().Length() > 0)

        {

        serverTime = SenDateUtils::FromXmlDateTimeL(message.Timestamp());

        }

    else serverTime = Time::NullTTime();

    TTime clientTime;

    clientTime.UniversalTime();

#ifdef _SENDEBUG

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfServiceSession::ParseMessageL:");

    if (clientTime != Time::NullTTime())

        {

        TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;

        SenDateUtils::ToXmlDateTimeUtf82L(ts, clientTime);

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KNormalLogLevel  ,_L8("- Client (device) time : %S"), &ts));

        }

#endif // _SENDEBUG

    if ( serverTime != Time::NullTTime() )

        {

#ifdef _SENDEBUG

        TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;

        SenDateUtils::ToXmlDateTimeUtf82L(ts2, serverTime);

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KNormalLogLevel  ,_L8("- Server (remote service) time : %S"), &ts2));

#endif // _SENDEBUG

        iClientServerInterval = serverTime.MicroSecondsFrom(clientTime);

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KNormalLogLevel  ,_L8("- Interval in microseconds : %d"),  iClientServerInterval.Int64()));

        }

    delete ipReceivedMessageId;

    ipReceivedMessageId = NULL;

    ipReceivedMessageId = message.MessageId().AllocL();

    CIdWsfSiuHeader* siuheader = message.SiuHeader();

    if (siuheader)

        {

        error = UpdateFromL(*siuheader);

        if (error != KErrNone) return error;

        }

    return KErrNone;

    }

TInt CIdWsfServiceSession::SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,

                                                       const TInt aTxnId,

                                                       MSenRemoteServiceConsumer& aConsumer,

                                                       MSenProperties* aResponseTransportProperties ) 

    {

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

    TInt retVal(KErrNone);

    if( apMessage )

        {

        CleanupStack::PushL( apMessage ); // ownership is here

        CIdWsfMessage* pIdWsfMessage = (CIdWsfMessage*)apMessage;

        if ( iMessageThread )

            {

            // store the Id of the last received message here:

            delete ipReceivedMessageId;

            ipReceivedMessageId = pIdWsfMessage->MessageId().Alloc();

            if ( !ipReceivedMessageId ) 

                {

                CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- OOM occured!");

                CleanupStack::PopAndDestroy( apMessage ); // de-alloc the response immediately

                retVal = SendErrorToConsumerL( KErrNoMemory, NULL, aTxnId, aConsumer, aResponseTransportProperties );

                CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8("- OOM occured. Sent KErrNoMemory to remote consumer. SendErrorToConsumerL returned: %d "), retVal));

                return KErrNoMemory;

                }

            }

        CIdWsfSessionConsumer* pConsumer = NULL;

        // This takes care of messageIDs:

        retVal = SessionConsumerL( *pIdWsfMessage, pConsumer );

        if (!pConsumer)

            {

            CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Session consumer not found! Invoking remote consumer via a call to base class functionality.");

            CleanupStack::Pop( apMessage ); // Next method takes ownership:

            retVal = CSenWebServiceSession::SendSoapMessageToConsumerL( apMessage, aTxnId, aConsumer, aResponseTransportProperties );

            CSLOG_FORMAT((aConsumer.ConnectionId(), KNormalLogLevel , _L8("- SendSoapMessageToConsumerL returned: %d "), retVal));

            return KErrNotFound;

            }

        else

            {

            //TSW ID: EMKY-6S4CGS & ID:EMKY-6N3AGA

            //check for completemessage flag

            TBool completeServerMessages;

            HasFacetL(KCompleteMessagesFacet, completeServerMessages);

            CleanupStack::Pop( apMessage ); // Next method takes ownership:

            retVal = pConsumer->HandleIdWsfMessageL( pIdWsfMessage, aTxnId, aResponseTransportProperties, completeServerMessages );

            }

        }

    else // apMessage == NULL!

        {

        // There is no SOAP to handle

        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Fatal(!): CIdWsfServiceSession::SendSoapMessageToConsumerL, apMessage == NULL, sending internal error to remote consumer!");

        retVal = SendErrorToConsumerL( KErrSenInternal, NULL, aTxnId, aConsumer, aResponseTransportProperties );

        }        

    return retVal;

    }

void CIdWsfServiceSession::SetEndPointL(const TDesC8& aURI)

    {

    CSenWebServiceSession::SetEndPointL(aURI);

    if(iProvider)

        {

        iProvider->SetEndPointL(aURI);

        }

    }

void CIdWsfServiceSession::SetFrameworkHeadersL(CSenSoapMessage& aMsg)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders(CSenSoapMessage& aMsg)");

#ifdef _SENDEBUG

    if(ipSenSecurityMechanism)

        {

        TPtrC8 secMec = ipSenSecurityMechanism->Des();

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,"Security mechanism: \n");

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(secMec));

        }

    else

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel ,"Note: ipSenSecurityMechanism == NULL!");

        }

    if (ipSenSecurityMechanism &&

         (*ipSenSecurityMechanism).Compare(KSecTlsBearer11) != 0 &&

         (*ipSenSecurityMechanism).Compare(KSecNullBearer11) != 0 )

        {

       TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders");

       TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ," - header for ID-WSF 1.0 needs to be used");

        }

    else

        {

       TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders");

       TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ," - header for ID-WSF 1.1 needs to be used");

        }

#endif

    CIdWsfMessage& idWsfMessage = (CIdWsfMessage&)aMsg;

    idWsfMessage.SetSecurityMechanism(ipSenSecurityMechanism);

    CSenWebServiceSession::SetFrameworkHeadersL(aMsg);

        /*

    //Changes for IDWSF 1.1 support

    // Added the condition to add the old-style WsSecurity header 

    // for non-IDWSF11 security mechanisms

    if (ipSenSecurityMechanism &&

             (*ipSenSecurityMechanism).Compare(KSecTlsBearer11) != 0 &&

             (*ipSenSecurityMechanism).Compare(KSecNullBearer11) != 0 )

        {

           TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders \

               - Setting header for ID-WSF 1.0");

          // Add new OLD WsSecurityHeader to msg

          CIdWsfSecurityHeader* pHeader = NULL;

          if(iSecurity)

            {

            pHeader = 

                CIdWsfSecurityHeader::NewL(*iSecurity); 

            }

          else

            {

            pHeader = 

                CIdWsfSecurityHeader::NewL(); 

            }

          aMsg.AddHeaderL( pHeader->AsElement() ) ;

          // Above is equal with next line, if an aMsg argument 

          // is actually SenIdWsfSoapMessage(!), ID-WSF 1.1, matmatt

          //CSenWebServiceSession::SetFrameworkHeaders(aMsg);

        }

       else // NOTE: now we default to 1.1 if !ipSenSecurityMechanism 

       {

           TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel ,"CIdWsfServiceSession::SetFrameworkHeaders \

               - Setting header for ID-WSF 1.1");

            // We need to use (newer) security header for ID-WSF 1.1

            // this could be done in IdWsfSoapMessage class, if it would

            // somehow know in NewSecurityHeaderL() method, that it is

            // actually 1.0 or 1.1. But this current solution is rather

            // clear also. Each new header type, we need a new 

            // else-if code segment inside this session class method,

            // -> in here.

           CSenWsSecurityHeader* pHeader = NULL;

          if(iSecurity)

            {

            // ID-WSF 1.1, matmatt

            pHeader = 

                CSenWsSecurityHeader::NewL(*iSecurity); 

            }

          else

            {

            pHeader = 

                CSenWsSecurityHeader::NewL(); 

            }

           aMsg.AddHeaderL( pHeader->AsElement() ) ;

        }

       */

    // CorrelationHeader adjustment is already done in the SessionConsumer

    }

void CIdWsfServiceSession::WriteExtensionsAsXMLToL(RWriteStream& aWriteStream)

    {

    CSenWebServiceSession::WriteExtensionsAsXMLToL(aWriteStream);

    if(iProvider)

        {

        aWriteStream.WriteL(KProviderID);

        aWriteStream.WriteL(ProviderId());

        aWriteStream.WriteL(KProviderIDEnd);

        }

    if(ipResourceId)

        {