/*

* 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 <s32mem.h>                         // RChunk

#include <e32property.h>                    // RProperty

#include <SenServiceConnection.h>           // error codes and framework ids

#include <SenHostletConnection.h>           // error code(s)

#include "senwsdescription.h"

#include "senwspattern.h"

#include <SenIdentityProvider.h>

#include <SenXmlUtils.h>

#include <SenXmlProperties.h>

#include <xmlengnodelist.h> 

#include <defaultcaps.hrh>

#include "senclientsession.h"

#include "senservicemanagerdefines.h"       // IPC enumerations

#include "msencoreservicemanager.h"

#include "sendebug.h"                       // internal Utils\inc

#include "sennotplugindlg.h"                // internal NotifierPlugin\inc

#include "senidentifier.h"

#include "senserviceinvocationframework.h"  // internal Framework\inc

#include "msenremoteservicesession.h"       // internal Framework\inc

#include "sentransport.h"                   // internal Framework\inc

#include "sentransportcontext.h"            // internal Framework\inc

//#include "SenServiceSession.h"              // internal Framework\inc

#include "senwebservicesession.h"                // internal Framework\inc

#include "senlayeredtransportproperties.h"  // internal Framework\inc

#include "senmessagecontext.h"              // internal Framework\inc

#include "SenSoapEnvelope2.h"

#include "sensoapmessagedom2.h"

#include "xmlengchunkcontainer.h"

#include "xmlengfilecontainer.h"

#include "xmlengdeserializer.h"

#include "SenParser.h"

#include "seninternalcredential.h"

#include "senservercontext.h"

#include "senapplicationcontext.h"

#include "senclientcontext.h"

#include "senxmldebug.h"

#include "senlogger.h"

#include "SenServiceConnection.h"  

#include <SenTransportProperties.h>

#ifdef __TEST_RETRY_TTL

#include <SenVtcpTransportProperties.h>//internal for lonlived test

#endif //__TEST_RETRY_TTL

namespace

    {

    const TInt KFlatBufSize = 128;

	const TInt KMaxAuthenticationRetries = 3;

    _LIT8(KTab, "\t");

    _LIT8(KNewline, "\n");

    _LIT8(KProviderPolicyLocalName,     "ProviderPolicy");

    _LIT8(KServicePolicyLocalName,      "ServicePolicy");

    _LIT8(KProviderIdLocalName,         "ProviderID");

    // _LIT8( KSenCidPostfix, "@example.org" );

    #ifdef RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS

    _LIT8( KSenCidPostfix, "@" );

    const TInt KSenMaxCidLength = 10;

    #endif //RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS

    }

CSenMessageResourceHandler::CSenMessageResourceHandler(TInt aTxnId,

        TBool aIncoming, TBool aIsSoap, TInt aProgress,

        RSenConnectionServerSession* aOwner): CActive(EPriorityStandard),

        iOwner(aOwner)

    {

    TTransferProgress& data = iProgressData();

    data.iTxnId = aTxnId;

    data.iIncoming = aIncoming;

    data.iSoap = aIsSoap;

    data.iProgress = aProgress;

    }

CSenMessageResourceHandler::~CSenMessageResourceHandler()

    {

    Cancel();

    delete iSoapOrCid;

    }

void CSenMessageResourceHandler::DoCancel()

    {

    }

void CSenMessageResourceHandler::RunL()

    {

    iOwner->Remove(this);

    delete this;

    }

TInt CSenMessageResourceHandler::SetBuffer(const TDesC8& aSoapOrCid)

    {

    iSoapOrCid = aSoapOrCid.Alloc();

    if (iSoapOrCid)

        {

        return KErrNone;

        }

    return KErrNoMemory;

    }

TInt RSenConnectionServerSession::CreateSession(const RMessage2& aMessage)

    {

    TFullName name;

    TInt err = aMessage.Read(0, name);

    if (err != KErrNone)

        {

        return err;

        }

    err = RSessionBase::CreateSession(name, TVersion(), KAsyncMessageSlots);

    return err;

    }

void RSenConnectionServerSession::SendFileProgress(TInt aTxnId, TBool aIncoming,

        TBool aIsSoap, const TDesC8& aSoapOrCid, TInt aProgress)

    {

    CSenMessageResourceHandler* resHandler = new CSenMessageResourceHandler(

            aTxnId, aIncoming, aIsSoap, aProgress, this);

    if (!resHandler)

        {

        return;

        }

    if (resHandler->SetBuffer(aSoapOrCid) != KErrNone)

        {

        delete resHandler;

        return;

        }

    if (iFirst)

        {

        iFirst->iPrevious = resHandler;

        }

    resHandler->iNext = iFirst;

    iFirst = resHandler;

    CActiveScheduler::Add(resHandler);

    resHandler->SetActive();

    resHandler->iStatus = KRequestPending;

    TIpcArgs args(&resHandler->iProgressData, resHandler->iSoapOrCid);

    SendReceive(ESenCliServTransferProgress, args, resHandler->iStatus);

    }

TBool RSenConnectionServerSession::OnGetBrandIdL(  const TDesC8& aBrandIdListAsXmlSnippet, RBuf8& aSelectedBrandId)

    {

    HBufC8* cbXmlSnippet = aBrandIdListAsXmlSnippet.Alloc();

    CleanupStack::PushL(cbXmlSnippet);    

	TInt retVal(KErrNone);

	TIpcArgs args;

	TRequestStatus  status = KRequestPending; 	

	TBool goNogo = EFalse;

	args.Set(0, &goNogo);

	args.Set(1, cbXmlSnippet);

	args.Set(2, &aSelectedBrandId);

	SendReceive(ESenCliServGoNoGo, args, status);

   	User::WaitForRequest(status);

   	retVal = status.Int();

    CleanupStack::PopAndDestroy(cbXmlSnippet);    

    if(retVal == KErrNone)

	    return goNogo;        

	else

	    return EFalse;

    }

void RSenConnectionServerSession::Remove(

        CSenMessageResourceHandler* aResourceHandler)

    {

    if (aResourceHandler == iFirst)

        {

        iFirst = aResourceHandler->iNext;

        if (iFirst)

            {

            iFirst->iPrevious = NULL;

            }

        }

    else

        {

        aResourceHandler->iPrevious->iNext = aResourceHandler->iNext;

        }

    }

void RSenConnectionServerSession::Close()

    {

    CSenMessageResourceHandler* resHandler = iFirst;

    while (resHandler)

        {

        resHandler->Cancel();

        CSenMessageResourceHandler* tmp = resHandler;

        resHandler = resHandler->iNext;

        delete tmp;

        }

    RSessionBase::Close();

    }

TInt RSenConnectionServerSession::InitProgressObserver(const RMessage2& aMessage)

	{

	TIpcArgs args(aMessage.Ptr1(), aMessage.Ptr2());

    TInt err = Send(ESenCliServInitialize, args);

    return err;

	}

#ifdef __ENABLE_ALR__

TInt RSenConnectionServerSession::InitMobilityObserver(const RMessage2& aMessage)

	{

	TIpcArgs args(aMessage.Ptr1(), aMessage.Ptr2());

    TInt err = Send(ESenCliServMobilityInitialize, args);

    return err;

	}

TInt RSenConnectionServerSession::PreferredCarrierAvailable( TAccessPointInfo& aOldAPInfo,

                                        TAccessPointInfo& aNewAPInfo, TBool& aIsUpgrade, TBool& aIsSeemLess)

	{

        // Note : Using TPtr8 since aIsSeamless is binary information

	 TPtr8 upGradeDescriptor(reinterpret_cast<TUint8*>(&aIsUpgrade),sizeof(aIsUpgrade),

        sizeof(aIsUpgrade));

	 TPtr8 seemLessdescriptor(reinterpret_cast<TUint8*>(&aIsSeemLess),sizeof(aIsSeemLess),

        sizeof(aIsSeemLess));

    TInt retVal(KErrNone);

    TIpcArgs args(aOldAPInfo.AccessPoint(), aNewAPInfo.AccessPoint(), &upGradeDescriptor, &seemLessdescriptor);    

	CSenConnAgentSync* caSync = new CSenConnAgentSync();

	if(caSync)

		{

		caSync->Start();

		SendReceive(ESenCliServPrefferedCarrierAvailable, args, caSync->iStatus);

        retVal = caSync->iStatus.Int();

		delete caSync;

		}

	return retVal;        

	}

TInt RSenConnectionServerSession::NewCarrierActive( TAccessPointInfo& aNewAPInfo, TBool& aIsSeamless )

    {

    // Note : Using TPtr8 since aIsSeamless is binary information

    TPtr8 descriptor(reinterpret_cast<TUint8*>(&aIsSeamless),sizeof(aIsSeamless),

    sizeof(aIsSeamless));

    TInt retVal(KErrNone);

    TIpcArgs args(aNewAPInfo.AccessPoint(), &descriptor);    

    CSenConnAgentSync* caSync = new CSenConnAgentSync();

    if(caSync)

        {

        caSync->Start();		

        SendReceive(ESenCliServNewCarrierActive, args, caSync->iStatus);

        retVal = caSync->iStatus.Int();

        delete caSync;

        }

    return retVal;

    }

TInt RSenConnectionServerSession::MobilityError( TInt& aError )

    {

    TInt retVal(KErrNone);

    TIpcArgs args(aError);

    CSenConnAgentSync* caSync = new CSenConnAgentSync();

    if(caSync)

        {

        caSync->Start();		

        SendReceive(ESenCliServMobilityError, args, caSync->iStatus);

        retVal = caSync->iStatus.Int();

        delete caSync;

        }

    return retVal;        

    }

#endif //__ENABLE_ALR__

TInt RSenConnectionServerSession::InitAuthObserver(const RMessage2& aMessage)

	{

	TIpcArgs args(aMessage.Ptr1(), aMessage.Ptr2());

    TInt err = Send(ESenCliServAuthInitialize, args);

    return err;

	}

TInt RSenConnectionServerSession::InitCoBrandingObserver(const RMessage2& aMessage)

	{

	TIpcArgs args(aMessage.Ptr1(), aMessage.Ptr2());

    TInt err = Send(ESenCliServCoBrandingInitialize, args);

    return err;

	}

TInt RSenConnectionServerSession::ReauthenticationNeeded(CSenChunk& aSenChunk)

	{

	TInt retVal(KErrNoMemory);

	TIpcArgs args;

	CActiveSchedulerWait asWait;

	aSenChunk.ChunkToArgs(args, 0);

	args.Set(1, &asWait);

	CSenConnAgentSync* caSync = new CSenConnAgentSync();

	if(caSync)

		{

		SendReceive(ESenCliServReAuthNeeded, args, caSync->iStatus);

		caSync->Start();

		Mem::FillZ(&asWait, sizeof(asWait));

		asWait.Start();

		retVal = caSync->iStatus.Int();

		delete caSync;

		}

	return retVal;

	}

CSenConnAgentSync::CSenConnAgentSync(): CActive(EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	iStatus = KRequestPending;

	}

CSenConnAgentSync::~CSenConnAgentSync()

	{

	if(IsActive())

		{

		Cancel();

		}

	}

void CSenConnAgentSync::DoCancel()

	{	

	}

void CSenConnAgentSync::RunL()

	{

	}

void CSenConnAgentSync::Start()

	{

	SetActive();

	}

CSenClientSession* CSenClientSession::NewL(MSenServiceManager& aServer, CSenServerContext& aCtx)

    {

    CSenClientSession* self = CSenClientSession::NewLC(aServer, aCtx);

    CleanupStack::Pop(self) ;

    return self ;

    }

CSenClientSession* CSenClientSession::NewLC(MSenServiceManager& aServer, CSenServerContext& aCtx)

    {

    CSenClientSession* self = new (ELeave) CSenClientSession(aServer, aCtx);

    CleanupStack::PushL(self) ;

    self->ConstructL() ;

    return self;

    }

CSenClientSession::CSenClientSession(MSenServiceManager& aServer, CSenServerContext& aCtx)

    : CSession2(),

    iManager(aServer),

    iStatus(0),

    iConsumerID(NULL),

    iSendBuf(NULL),

    iInitializer(NULL),

    iAllowWSDataReg(ENotChecked),

    iAllowWSDataUnReg(ENotChecked),

    ipTransport(NULL),

    ipIdentifier(NULL),

    ipHostletAwaitOp(NULL),

    iHostletRequests( ETrue, EFalse ),

    iAllowShowDialogCount(0),

    iConnectionID(KErrNotFound),

    iAuthenticationRetries(0),

    iServerContext( aCtx ),

    iConnectionHasCoBrandingCallback(EFalse),

    iReauthResendNeeded(EFalse)

#ifdef __ENABLE_ALR__

    ,iMobiltyObserver(NULL),

    iALRObserver(NULL),

    iMobilityCallBackForwarded(EFalse),

    iMobilityChoice(EFalse)

#endif

    {

    }

void CSenClientSession::ConstructL()

    {

    iConnectionID = iManager.NextConnectionID();

    #ifdef _SENDEBUG

    TFileName logFile;

    logFile.Append( KSenCoreServiceManagerLogFile().Left(KSenCoreServiceManagerLogFile().Length()-4) ); // exclude ".log" file extension

    logFile.AppendNum( iConnectionID );

    logFile.Append( KSenUnderline );

    logFile.Append( KSenCoreServiceManagerLogFile().Right(4) ); // postfix with ".log" file extension

    TLSLOG_OPEN_TO_MODE(KSenClientSessionLogChannelBase+iConnectionID, KSenClientSessionLogLevel, KSenCoreServiceManagerLogDir, logFile, EFileLoggingModeAppend);

#endif

    CSLOG_L(iConnectionID, KMinLogLevel ,"CSenClientSession::ConstructL");

    // Generate unique id for this consumer

    iConsumerID = iManager.RandomGuidL();

    ipIdentifier = CSenIdentifier::NewL(SenIdentifier::ESession, *iConsumerID);

    __ASSERT_ALWAYS(iConsumerID!=NULL, User::Leave(KErrConsumerIdIsNull));

    CSLOG(iConnectionID, KNormalLogLevel ,(iConsumerID->Des()));

    iInitializer = CSenWSDescription::NewL();

    iManager.IncrementConnections();

    }

CSenClientSession::~CSenClientSession()

    {

    CSLOG_L(iConnectionID, KMinLogLevel ,"CSenClientSession::~CSenClientSession - START");

#ifdef __ENABLE_ALR__    

    iMobiltyObserver = NULL ;

#endif

    switch( iSessionType )

        {

        case ERemoteConsumer_SC:

            {

            CSLOG_L(iConnectionID, KMinLogLevel ,"- session type: ERemoteConsumer_SC");

            //TTL maangement

            if( iServiceSession )

                {

                MSenTransport* pTransport = iServiceSession->Transport();

                if ( pTransport )

                    {

                    TRAP_IGNORE( pTransport->UnsubscribeEventListenerL(*this); )

                    }

                // Notify the framework plug-in about consumer being removed

                if( iFwNotified )

                    {

                    TRAP_IGNORE( iManager.NotifyFrameworksL(

                            iServiceSession->FrameworkId(),

                            KSenEventConsumerRemoved,

                            this); )        

                    }

                }

            }

        break;

        case ERemoteHostlet_HC:

            {

            CSLOG_L(iConnectionID, KMinLogLevel ,"- session type: ERemoteHostlet_HC");

            // Remove this hostlet from the session

            if( iServiceSession )

                {

                TRAP_IGNORE( iServiceSession->SetHostletL(NULL); )

                }

            }

        break;

        case ENotInitialized:

            {

            CSLOG_L(iConnectionID, KMinLogLevel ,"- session type: ENotInitialized");

            }

        break;

        default:

            {

            CSLOG_L(iConnectionID, KMinLogLevel ,"- unknown session type.");

            }

        }

    //Loop and complete orphan RMessage2s

    CSLOG_L(iConnectionID, KMinLogLevel ,"- Loop and complete orphan RMessage2s");

    CSenClientSession::CompletePendingMessages();

    TInt count(iHostletRequests.Count());

    if( count > 0)

        {

        CSLOG_FORMAT((iConnectionID, KNormalLogLevel , _L8("- %d hostlet request(s) waiting. Completing due this host is freed."), count));

        for ( TInt hr=(count-1); hr>=0; hr-- )

            {

            CSenClientMessage* pMessage = (CSenClientMessage*)iHostletRequests.ValueAt( hr ); 

            TInt* pKey = iHostletRequests.KeyAt( hr );

            if( pMessage && pKey )

                {

                MSenRemoteServiceConsumer* pConsumer = pMessage->Consumer();

                if( pConsumer )

                    {

                    // Notifying consumer

                    TPtrC8 id = pConsumer->Id();

                    CSLOG_FORMAT((iConnectionID, KNormalLogLevel , _L8("- Notifying consumer (ID: '%S') that it's host is gone."), &id));

                    TRAP_IGNORE( pConsumer->HandleErrorL(NULL, KErrSenCancelled, *pKey, NULL); ) 

                    }

                }

            }

        iHostletRequests.Reset(); // de-allocates the keys (pKey -pointers)

        }

    iPendingTransactions.ResetAndDestroy();

    iPendingTxnIds.ResetAndDestroy();

    if(ipHostletAwaitOp)

        {

        RMessage2& await = ipHostletAwaitOp->RMessage();

        await.Complete(ESenServRequestCancelled);

        }

    if(iServiceSession)

        {

        // Notify responsible framework, so that it 

        // can do required cleanup for the session

        CSenClientSession::ReleaseServiceSession();

        }

    delete iSendBuf;