/*

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

#include "senwebservicesession.h"

#include <SenServiceConnection.h> // error codes etc

#include "senservicesession.h"

#include "SenServiceConnection.h" // session status constants

#include "SenSoapMessage.h"

#include "senwsdescription.h"

#include "msencoreservicemanager.h"

#include "msenremoteserviceconsumer.h"

#include "SenXmlUtils.h"

#include "SenDateUtils.h"

#include "msentransport.h"

#include "SenCredential.h"

//#include "SenPolicy.h"

#include "SenSoapFault.h"

#include "sendebug.h"

#include "senservicemanagerdefines.h"

#include "senservicepolicy.h"

#include "seninternalcredential.h"

#include "sensaxutils.h"

#include <SenIdentityProvider.h>

#include "senlogger.h"

#include <SenXmlConstants.h>

#include <SenTransportProperties.h>

// CONSTANTS

namespace

    {

    _LIT8(KServiceInterval1,"ServiceInterval");

    _LIT(KInvalideDate,"19000101:");

    /* microseconds before actual notOnOrAfter time

     * when credentials are treated

     * as expired.

     */

    const TInt KClockSlipMicroSeconds = 3*60*1000*1000;

    // constants for parsing

    _LIT8(KSDFramework,"<ServiceDescription framework=\"");

    _LIT8(KContractStart, "<Contract>");

    _LIT8(KContractEnd, "</Contract>");

    _LIT8(KTagWithAttrEnd, "\">");

    _LIT8(KEndPointStart, "<Endpoint>");

    _LIT8(KEndPointStartWithCue, "<Endpoint cue=\"");   

    _LIT8(KTagWithAttrClose, "\"/>"); 

    _LIT8(KEndPointEnd, "</Endpoint>");

    _LIT8(KCredentialsStart, "<Credentials");

    _LIT8(KCredentialsEnd, "</Credentials>");

    _LIT8(KNotOnOrAfterFormat, " notOnOrAfter=\"%S\" >");

    _LIT8(KEmptyTagEnd, " >");

    _LIT8(KSDEnd, "</ServiceDescription>");

    // localnames for element(s)

    _LIT8(KProviderPolicyLocalName, "ProviderPolicy");

    _LIT8(KNewLine, "\n");

    const TInt KCredIdBufSize           = 128;

    _LIT8(KCredentialIdLocalName,       "SenCredentialId");

    _LIT8(KCredentialIdStart,           "<SenCredentialId>");

    _LIT8(KCredentialIdEnd,             "</SenCredentialId>");

    _LIT8(KEndpointLocalname,           "Endpoint");

//    _LIT8(KContractLocalname,           "Contract");

    }

EXPORT_C CSenWebServiceSession::CSenWebServiceSession(TDescriptionClassType aType,

                                                      MSIF& aFramework)

:   CSenServiceSession(aType, aFramework)

    {

    }

EXPORT_C void CSenWebServiceSession::ConstructL()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,_L("CSenWebServiceSession::ConstructL()"));

    // Sets the local name to "ServiceDescription"

    // and initiates the inner ipElement

    CSenServiceSession::BaseConstructL();

    // Init member variables

    iClientServerInterval = 0;

    iValidUntil = Time::NullTTime();

    iFrameworkId = iFramework.Id().AllocL();

    }

EXPORT_C CSenWebServiceSession::~CSenWebServiceSession()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,_L("CSenWebServiceSession::~CSenWebServiceSession()"));

    delete iSecurity;

    delete iContract;

    delete iEndpoint;

    delete iFrameworkId;

    iFrameworkId = NULL;

    delete iTransportCue;

    iTransportCue = NULL;

    iCredentialPtr.RemoveCredentialObserver(*this);

    iCredentialPtr.Close();

    }

EXPORT_C TPtrC8 CSenWebServiceSession::TransportCue()

    {

    if( iTransportCue )

        {

        return *iTransportCue;

        }

    else 

        {

        return CSenServiceSession::TransportCue();

        }

    }

EXPORT_C TInt CSenWebServiceSession::InitializeFromL(MSenServiceDescription& aServiceDescription)

    {

   TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,_L("Zapping filelogged messages (.xml)"));

    // Call superclass method to initialize facets, transport (endpoint) cue, etc..

	CSenServiceSession::InitializeFromL(aServiceDescription);

    HBufC8* pContract = aServiceDescription.Contract().AllocL();

    delete iContract;

    iContract = pContract;

    HBufC8* pEndpoint = aServiceDescription.Endpoint().AllocL();

    delete iEndpoint;

    iEndpoint = pEndpoint;

    if(aServiceDescription.DescriptionClassType()

                        ==

        MSenServiceDescription::EWSDescription

                        ||

        aServiceDescription.DescriptionClassType()

                        ==

        MSenServiceDescription::EWSPattern

                        ||

        aServiceDescription.DescriptionClassType()

                        ==

        MSenServiceDescription::EIdentityProvider

        )

        {

        CSenWSDescription& xmlDesc =

                            (CSenWSDescription&)aServiceDescription;

        CSenElement* pElement =

                    (xmlDesc.AsElement()).Element(KServiceInterval1);

        if(pElement)

            {

            TLex8 lex(pElement->Content());

            TInt64 val;

            User::LeaveIfError(lex.Val(val));

            iClientServerInterval = val;

			TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase, KNormalLogLevel , _L8("Interval in microseconds (from file): %d"),

                                iClientServerInterval.Int64()));

            }

        RCredentialList& credentials = xmlDesc.Credentials();

        TInt count(credentials.Count());

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

            {

            CSenCredential* pCredential = credentials[i];

            if(pCredential)

                {

                // note: errors while adding single credential must ignored:

                // - the remaining credentials (array) must be processed..

                //CSenCredential* pCopy = CSenCredential::NewL(*pCredential);

                //CleanupStack::PushL(pCopy);

                AddCredentialL(*pCredential);

                //CleanupStack::Pop(); // pCopy

                }

            }

        // rebuild provider policy definition

        RebuildFrom(xmlDesc);

        // update provider policy information (new feature)

        MSenServicePolicy* servicePolicy = ServicePolicy();

        if(servicePolicy)

            {

            MSenServicePolicy* givenServicePolicy = xmlDesc.ServicePolicy();

            if(givenServicePolicy)

                (CSenServicePolicy*)servicePolicy->RebuildServicePolicyFrom(*givenServicePolicy);

            }            

        }

    SetStatusL();

    return KErrNone; // err value not currently in use

    }

EXPORT_C TInt CSenWebServiceSession::ComputeStatusL()

    {

    TInt retVal = CSenServiceSession::ComputeStatusL();

    if (retVal == KSenConnectionStatusReady)

        {

        TTime now;

        now.UniversalTime();

        now += iClientServerInterval;

#ifdef _SENDEBUG

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

                {

			TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase, KNormalLogLevel , _L8("Client-Server Interval in microseconds: %d"),

                                    iClientServerInterval.Int64()));

                TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;

                TInt leaveCode(KErrNone);

                TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

                if (leaveCode == KErrNone)

                    {

					TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Fixed client time : %S"), &ts));

                    TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;

                    TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts2, iValidUntil);)

			     TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Credential time : %S, clockslip: %d micros"), &ts2, KClockSlipMicroSeconds));

                    }

                leaveCode = 0; // not used

                }

#endif // _SENDEBUG

        if ((iValidUntil != Time::NullTTime() ) &&

            now >

            (iValidUntil-TTimeIntervalMicroSeconds(KClockSlipMicroSeconds)))

            {

			TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,_L("Credential is expired."));

            retVal = KSenConnectionStatusExpired;

            }

        }

    return retVal;

    }

EXPORT_C TBool CSenWebServiceSession::IsExpiredL()

    {

    ComputeStatusL();

    return (CSenServiceSession::StatusL() == KSenConnectionStatusExpired);

    }

EXPORT_C TInt CSenWebServiceSession::AddCredentialL(

                                                CSenCredential& aCredential)

    {

    if ( aCredential.AsElement().LocalName() == KCredentialIdLocalName )

        {

        delete iSecurity;

        iSecurity = NULL;

        iSecurity = aCredential.AsXmlL();

        TInt credentialId;

        TLex8 lex;

        lex.Assign(aCredential.AsElement().Content());

        lex.Val(credentialId);                        

        TInt error(KErrNone);

        RSenCredentialPtr credentialPtr;

        credentialPtr = ((MSenServiceManager&)iFramework.Manager()).CredentialL(credentialId,

                                                                                error);

        if ( error == KErrNone )

            {

            iCredentialPtr = credentialPtr.Clone();

            iCredentialPtr.AddCredentialObserverL(*this);		//codescannerwarnings

            iValidUntil = iCredentialPtr.Credential()->ValidUntil();

            if ( iClientServerInterval == 0 )

                {

                TPtrC8 value;

                TInt ret = iCredentialPtr.Credential()->PropertiesL().PropertyL( KServiceInterval1,

                                                                                 value );

                if ( ret == KErrNone )

                    {

                    TLex8 lex(value);

                    TInt64 val;

                    ret = lex.Val(val);

                    if ( ret == KErrNone )

                        {

                        iClientServerInterval = val;

                        }

                    }

                }

            }

        else

            {

            // invalidate the session, because we have no credential 

            iValidUntil.Set(KInvalideDate); // way back in history: January 1st 1900

            iCredentialPtr.RemoveCredentialObserver(*this);

            iCredentialPtr.Close();

            delete iSecurity;

            iSecurity = NULL;

            TBuf8<KCredIdBufSize> buffer;

            buffer.Num(KErrNotFound);

            iSecurity = HBufC8::NewL(buffer.Length()+KCredentialIdStart().Length()+KCredentialIdEnd().Length());

            TPtr8 sec = iSecurity->Des();

            sec.Append(KCredentialIdStart);

            sec.Append(buffer);

            sec.Append(KCredentialIdEnd);

            }

        }

    else

        {

        TInt retVal(KErrNone);

        delete iSecurity;

        iSecurity = NULL;

        HBufC8* pSecurityToken = 0;

        retVal = ConstructSecurityTokenL(aCredential, pSecurityToken);

        if (KErrNone != retVal)

            {

            if ( pSecurityToken != NULL )

                {

                delete pSecurityToken;

                pSecurityToken = NULL;

                iCredentialPtr.RemoveCredentialObserver(*this);

                iCredentialPtr.Close();

                }

            return retVal;

            }

        iValidUntil = aCredential.ValidUntil(); // SetSecurityL needs up-to-date iValidUntil(!)

        CleanupStack::PushL(pSecurityToken);

        SetSecurityL(*pSecurityToken);

        CleanupStack::PopAndDestroy(pSecurityToken);

        }

    SetStatusL();

    return KErrNone;

    }

EXPORT_C TInt CSenWebServiceSession::ConstructSecurityTokenL( CSenCredential& aCredential,

                                                              HBufC8*& aToken )

    {

    aToken = aCredential.AsXmlL();

    return KErrNone;

    }

EXPORT_C TInt CSenWebServiceSession::NewMessageL( CSenSoapMessage*& aMessage )

    {

    aMessage = CSenSoapMessage::NewL();

    return KErrNone;

    }

EXPORT_C TInt CSenWebServiceSession::MessageForSendingL( const TDesC8& aBody,

                                                         const TDesC8& /* aSenderID */,

                                                         CSenSoapMessage*& aMessage )

    {

    TInt retVal(KErrNone);

    aMessage = CSenSoapMessage::NewL();

    CleanupStack::PushL(aMessage);

    SetFrameworkHeadersL(*aMessage); 

    aMessage->SetBodyL(aBody);

    CleanupStack::Pop(); // aMessage

    return retVal;

    }

EXPORT_C TInt CSenWebServiceSession::ParseResponseL( const TDesC8& aResponse,

                                                     HBufC8*& aParsed )

    {

		TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL(const TDesC8&, HBufC8*&)");

    // this called only from the synchronous submit(..) methods

    TInt retVal(KErrNone);

    CSenSoapMessage* pSoapMessage = NULL;

    retVal = ParseResponseL(aResponse, pSoapMessage);

    if(retVal!=KErrNone)

        {

        delete pSoapMessage;

        return retVal;

        }

    CleanupStack::PushL(pSoapMessage);

    // Check for completeMessages

    TBool completeServerMessages;

    HasFacetL(KCompleteMessagesFacet,completeServerMessages);

    if (completeServerMessages)

        {

        aParsed = pSoapMessage->AsXmlL();

        }

    else

        {

        // If the message contained SOAP fault it will be in the body.

        // It's up to the client to check for a Fault.

        aParsed = pSoapMessage->BodyAsStringL();

        if (!aParsed)

            {

            retVal = KErrSenNoSoapBody; 

						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL - NULL from BodyAsStringL - return KErrSenNoSoapBody");

            }

        }

    CleanupStack::PopAndDestroy(); // pSoapMessage

    return retVal;

    }

EXPORT_C TInt CSenWebServiceSession::SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,

                                                                 const TInt aTxnId,

                                                                 MSenRemoteServiceConsumer& aConsumer,

                                                                 MSenProperties* aResponseTransportProperties )

    {

    if ( !apMessage )

        {

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

        CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"Fatal()!: NULL argument passed instead of valid pointer to CSenSoapMessage");

        return HandleErrorL( KErrSenInternal, NULL, aTxnId, aConsumer, aResponseTransportProperties );

        }

    CleanupStack::PushL(apMessage);

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

    TInt retVal(KErrNone);

    // Check if consumer wishes to receive complete server messages:

    TBool completeServerMessages;

    HasFacetL(KCompleteMessagesFacet, completeServerMessages);

    if(completeServerMessages)

        {

        HBufC8* pMessageAsXML = apMessage->AsXmlL();

        CleanupStack::PopAndDestroy(apMessage);

        if (pMessageAsXML)

            {

            retVal = aConsumer.HandleMessageL( pMessageAsXML, aTxnId, aResponseTransportProperties );

            }

        }

    else

        {

        //HBufC8* pBody = apMessage->BodyL().Content().AllocL(); 

        HBufC8* pBody = apMessage->BodyAsStringL();

        CleanupStack::PopAndDestroy(apMessage);

        retVal = aConsumer.HandleMessageL( pBody, aTxnId, aResponseTransportProperties );

        }    

    return retVal;

    }

// SYNC, takes ownership of apSoapMessage

EXPORT_C TInt CSenWebServiceSession::HandleSoapFaultL( CSenSoapMessage* apSoapMessage,

                                                       HBufC8*& aResponse /*,

                                                       CSenTransportProperties*& aResponseTransportProperties */) 

    {

    if( apSoapMessage )

        {

        CleanupStack::PushL(apSoapMessage);

        CSenSoapFault* pDetached = apSoapMessage->DetachFaultL();

        CleanupStack::PopAndDestroy( apSoapMessage );

        TBool completeServerMessages(ETrue);

        HasFacetL(KCompleteMessagesFacet, completeServerMessages);

        if(pDetached)

            {

            CleanupStack::PushL(pDetached);

            // Response contains only soapfault in case no completeServerMessages facet 

            // otherwise it should be left empty

            // aResponse is updated only when detached soap fault is required.

            if(completeServerMessages == EFalse)

            	{

            	aResponse = pDetached->AsXmlL();	

            	}

						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::HandleErrorL:");

						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- successfully detached SOAP fault:");

            CleanupStack::PopAndDestroy(pDetached); // pDetached

            // From *this* method, KErrSenSoapFault is *OK return code*, 

            // just like KErrNone generally is..

            return KErrSenSoapFault; 

            }

        }

    return KErrNotFound; // SOAP fault not found

    }

// ASYNC, takes ownership of apSoapMessage

EXPORT_C TInt CSenWebServiceSession::HandleSoapFaultL( CSenSoapMessage* apSoapMessage,

                                                       const TInt aErrorCode,

                                                       const TInt aTxnId,

                                                       MSenRemoteServiceConsumer& aConsumer,

                                                       MSenProperties* aResponseTransportProperties )

    {

    TInt retVal( KErrSenInternal );

    if ( apSoapMessage ) 

        {

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

        CSenSoapFault* pDetached = apSoapMessage->DetachFaultL();

        if(pDetached)

            {

            CleanupStack::PopAndDestroy( apSoapMessage ); // de-alloc msg, detach OK

            CleanupStack::PushL(pDetached);

            HBufC8* pAsXml = pDetached->AsXmlL();

            CleanupStack::PopAndDestroy(pDetached);

            retVal = aConsumer.HandleErrorL(pAsXml, aErrorCode, aTxnId, aResponseTransportProperties);

            }

        else

            {

            // Could not detach Soap fault (this method was called, but aSoapMessage did not include fault!)

            HBufC8* pAsXml = apSoapMessage->AsXmlL();

            CleanupStack::PopAndDestroy( apSoapMessage ); // de-alloc, serialization ok

            retVal = aConsumer.HandleErrorL(pAsXml, aErrorCode, aTxnId, aResponseTransportProperties);

            }

        }

    else

        {

        CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"Fatal(!): CSenWebServiceSession::HandleSoapFaultL - apSoapMessage arg is NULL. ");

            retVal = aConsumer.HandleErrorL(NULL, aErrorCode, aTxnId, aResponseTransportProperties);

        }        

    return retVal;

    }

EXPORT_C TInt CSenWebServiceSession::SendToConsumerL( HBufC8* apMessage,

                                                      const TInt aTxnId,

                                                      MSenRemoteServiceConsumer& aConsumer,

                                                      MSenProperties* aResponseTransportProperties )

    {

    CleanupStack::PushL( apMessage );