/*

* Copyright (c) 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 <sipprofile.h>

#include <sipinvitedialogassoc.h>

#include <sdpdocument.h>

#include "mcenatsipsession.h"

#include "mcenatsipstatemachine.h"

#include "mcemediamanager.h"

#include "mcenatpluginmanager.h"

#include "mcecssession.h"

#include "mcesipconnection.h"

#include "mceclient.pan"

#include "mcesrvlogs.h"

#include "mcecomsession.h"

#define PANIC( aPanic ) User::Panic( KMceServerPanic, aPanic )

#define DEBUG_PANIC( aPanic ) __ASSERT_DEBUG( EFalse, PANIC( aPanic ) )

// ======== MEMBER FUNCTIONS ========

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

// CMceNatSipSession::NewL

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

//

CMceNatSipSession* CMceNatSipSession::NewL( CMceCsSession& aClientSession, 

                                            CMceSipConnection& aSIPConnection,

								            CMceSipStateMachine& aStateMachine,

								            CSIPProfile& aProfile,

								            const CDesC8Array* aParams )

	{

    CMceNatSipSession* self = CMceNatSipSession::NewLC( aClientSession, 

                                                        aSIPConnection, 

                                                        aStateMachine,

                                                        aProfile,

                                                        aParams );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceNatSipSession::NewL

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

//

CMceNatSipSession* CMceNatSipSession::NewL( CMceCsSession& aClientSession, 

                                            CMceSipConnection& aSIPConnection,

								            CMceSipStateMachine& aStateMachine,

								            const CDesC8Array* aParams )

	{

    CMceNatSipSession* self = CMceNatSipSession::NewLC( aClientSession, 

                                                        aSIPConnection, 

                                                        aStateMachine,

                                                        aParams );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceNatSipSession::NewLC

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

//

CMceNatSipSession* CMceNatSipSession::NewLC( CMceCsSession& aClientSession, 

                                             CMceSipConnection& aSIPConnection,

 								             CMceSipStateMachine& aStateMachine,

 								             CSIPProfile& aProfile,

 								             const CDesC8Array* aParams )

	{

    CMceNatSipSession* self = new (ELeave) CMceNatSipSession( aClientSession, 

                                                              aSIPConnection, 

                                                              aStateMachine,

                                                              aProfile );

    CleanupStack::PushL(self);

    self->ConstructL( aClientSession, aSIPConnection, aParams );

    return self;

	}

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

// CMceNatSipSession::NewLC

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

//

CMceNatSipSession* CMceNatSipSession::NewLC( CMceCsSession& aClientSession, 

                                             CMceSipConnection& aSIPConnection,

 								             CMceSipStateMachine& aStateMachine,

 								             const CDesC8Array* aParams )

	{

    CMceNatSipSession* self = new (ELeave) CMceNatSipSession( aClientSession, 

                                                              aSIPConnection, 

                                                              aStateMachine );

    CleanupStack::PushL(self);

    self->ConstructL( aClientSession, aSIPConnection, aParams );

    return self;

	}

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

// CMceNatSipSession::CMceNatSipSession

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

//

CMceNatSipSession::CMceNatSipSession( CMceCsSession& aClientSession, 

								      CMceSipConnection& aSIPConnection,

								      CMceSipStateMachine& aStateMachine,

								      CSIPProfile& aProfile )

    : CMceSipSession( aClientSession, aSIPConnection, aStateMachine, aProfile )

	{

	}

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

// CMceNatSipSession::CMceNatSipSession

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

//

CMceNatSipSession::CMceNatSipSession( CMceCsSession& aClientSession, 

								      CMceSipConnection& aSIPConnection,

								      CMceSipStateMachine& aStateMachine )

    : CMceSipSession( aClientSession, aSIPConnection, aStateMachine )

	{

	}

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

// CMceNatSipSession::ConstructL

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

//

void CMceNatSipSession::ConstructL( CMceCsSession& aClientSession,

                                    CMceSipConnection& aSIPConnection,

                                    const CDesC8Array* aParams )

	{

    MCESRV_DEBUG( "*** CMceNatSipSession::ConstructL, Entry" )

	CMceSipSession::ConstructL( aClientSession ); // base class

    TRAPD( error, TryNatSessionL( aSIPConnection, aParams ) );

    if ( KErrNone != error )

        {

        NatErrorOccurred( error );

        }

    else

    	{

    	iNatSession = ETrue;

    	}

    MCESRV_DEBUG( "*** CMceNatSipSession::ConstructL, Exit" )  

	}

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

// CMceNatSipSession::TryNatSessionL

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

//

void CMceNatSipSession::TryNatSessionL( CMceSipConnection& aSIPConnection,

                                        const CDesC8Array* aParams )

    {

    iNatStateMachine = CMceNatSipStateMachine::NewL();

    TUint32 iapId = aSIPConnection.AccessPointId();

    const TDesC8* userAor = NULL;

    TPtrC8 originator;

    if ( ProfileConfigured() )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::TryNatSessionL, using profile" )

        CSIPProfile& profile = Profile();

        User::LeaveIfError( profile.GetParameter( KSIPUserAor, userAor ) );

        }

    else

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::TryNatSessionL, profile not used" )

        __ASSERT_ALWAYS( aParams && 

                         aParams->MdcaCount() > KMceArrayIndexOriginator, 

                         User::Leave( KErrArgument ) );

        originator.Set( aParams->MdcaPoint( KMceArrayIndexOriginator ) );

        userAor = &originator;

        }

    TUriParser8 uri8Parser;

    User::LeaveIfError( uri8Parser.Parse( *userAor ) );

    CUri8* cUri8 = CUri8::NewLC( uri8Parser );

    const TDesC8& domain = cUri8->Uri().Extract( EUriHost );

    CMceNatPluginManager& manager = Manager().MediaManager().NatPluginManager();

    iSessionId = manager.NewSessionL( *this, iapId, domain );

    CleanupStack::PopAndDestroy( cUri8 );

    MCESRV_DEBUG( "*** CMceNatSipSession::TryNatSessionL, Exit" )

    }

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

// CMceNatSipSession::~CMceNatSipSession

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

//

CMceNatSipSession::~CMceNatSipSession()

	{

	MCESRV_DEBUG( "*** CMceNatSipSession::~CMceNatSipSession, Entry" )

    delete iNatStateMachine;

    CMceNatPluginManager& manager = Manager().MediaManager().NatPluginManager();

    TRAP_IGNORE( manager.CloseSessionL( iSessionId ) )

    MCESRV_DEBUG( "*** CMceNatSipSession::~CMceNatSipSession, Exit" )

  	}

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

// CMceNatSipSession::UpdateMediaL

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

//

TMceReturnStatus CMceNatSipSession::UpdateMediaL()

    {

    MCESRV_DEBUG( "*** CMceNatSipSession::UpdateMediaL, Entry" )

    PrepareNatSessionUpdate();

    TMceReturnStatus status = CMceSipSession::UpdateMediaL();

    if ( KMceReady == status )

        {

        TMceNatStateTransitionEvent event( NULL, *this, EMceNatUpdated, *this,

        								   iSipEvent );

        if ( !iNatDisabled && iNatStateMachine->Accept( event ) )

            {

            MCESRV_DEBUG( "*** CMceNatSipSession::UpdateMediaL, processing" )

            iEntryPoint = ENatEntryUpdated;

            event.ParamStatus() = KMceReady;

            TRAPD( error, iNatStateMachine->ProcessL( event ) )

            if ( error != KErrNone )

                {

                iEntryPoint = ENatEntryNone;

                NatErrorOccurred( error );

                }

            else

                {

                status = event.ParamStatus();

                }

            }

        }

    MCESRV_DEBUG( "*** CMceNatSipSession::UpdateMediaL, Exit" )

    return status;

    }

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

// CMceNatSipSession::ReserveL

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

//

TMceReturnStatus CMceNatSipSession::ReserveL()

    {

    MCESRV_DEBUG("CMceNatSipSession::ReserveL, Entry")

    iReserveStatus = CMceSipSession::ReserveL();

    if ( iReserveStatus == KMceReady )

    	{

    	TMceReturnStatus async = 0;

    	iReserveStatus =

    		GetResourceReservationStatus() == async ? KMceAsync : KMceReady;

    	}

    return iReserveStatus;

    }

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

// CMceNatSipSession::Updated

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

//

void CMceNatSipSession::Updated( CMceComSession& aSession )

    {

    MCESRV_DEBUG( "*** CMceNatSipSession::Updated, Entry" )

    TMceNatStateTransitionEvent event(

            NULL, *this, EMceNatUpdated, *this, iSipEvent );

    if ( !iNatDisabled &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::Updated, processing" )

        iEntryPoint = ENatEntryUpdated;

        event.ParamStatus() = KMceAsync;

        TRAPD( error, iNatStateMachine->ProcessL( event ) )

        if ( KErrNone != error )

            {

            iEntryPoint = ENatEntryNone;

            CMceSipSession::Updated( aSession );

            NatErrorOccurred( error );

            }

        }

    else

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::Updated, passing forward" )

        CMceSipSession::Updated( aSession );

        }

    MCESRV_DEBUG("*** CMceNatSipSession::Updated, Exit" )

    }

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

// CMceNatSipSession::Offer

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

//

CSdpDocument* CMceNatSipSession::Offer()

    {

    if ( KMceNatPrevOfferSdp == iOfferedSdp )

        {

        MCESRV_DEBUG("*** CMceNatSipSession::Offer, iPrevOffer" )

        return iPrevOffer;        

        }

    else

        {

        return CMceSipSession::Offer();

        }

    }

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

// CMceNatSipSession::NatSession

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

//

TBool CMceNatSipSession::NatSession() const

    {

    return ETrue;

    }

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

// CMceNatSipSession::NatState

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

//

TInt CMceNatSipSession::NatState() const

    {

    return iNatStateMachine->State();

    }

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

// CMceNatSipSession::IsNatDisabled

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

//

TBool CMceNatSipSession::IsNatDisabled() const

	{

	return iNatDisabled;

	}

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

// CMceNatSipSession::Initialized

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

//

void CMceNatSipSession::Initialized( TUint aSessionId )

    {

    MCESRV_DEBUG( "*** CMceNatSipSession::Initialized, Entry" )

    __ASSERT_DEBUG( aSessionId == iSessionId, PANIC( KErrArgument ) );

    TMceNatStateTransitionEvent event( 

            NULL, *this, EMceNatInitialized, *this, iSipEvent );

    if ( !iNatDisabled &&

         aSessionId == iSessionId &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::Initialized, processing" )

        TRAPD( error, iNatStateMachine->ProcessL( event ) )

        if ( KErrNone != error )

            {

            NatErrorOccurred( error );

            }        

        }

    else

        {

        DEBUG_PANIC( KErrNotReady );

        }

    MCESRV_DEBUG( "*** CMceNatSipSession::Initialized, Entry" )

    }

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

// CMceNatSipSession::OfferReady

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

//

void CMceNatSipSession::OfferReady( TUint aSessionId, CSdpDocument* aOffer )

    {

    MCESRV_DEBUG("*** CMceNatSipSession::OfferReady, Entry" )

    __ASSERT_DEBUG( aSessionId == iSessionId, PANIC( KErrArgument ) );

    CMceNatPluginManager::WriteSdpToLog( _L("Offer"), aOffer );

    TMceNatStateTransitionEvent event(

            aOffer, *this, EMceNatOffer, *this, iSipEvent );

    if ( !iNatDisabled &&

         aSessionId == iSessionId &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::OfferReady, processing" )

        TRAPD( error, iNatStateMachine->ProcessL( event ) )

        if ( KErrNone != error )

            {

            NatErrorOccurred( error );

            }

        }

    else

        {

        SafeDelete( aOffer );

        DEBUG_PANIC( KErrNotReady );

        }

    MCESRV_DEBUG("*** CMceNatSipSession::OfferReady, Exit" )

    }

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

// CMceNatSipSession::AnswerReady

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

//

void CMceNatSipSession::AnswerReady( TUint aSessionId, CSdpDocument* aAnswer )

    {

    MCESRV_DEBUG("*** CMceNatSipSession::AnswerReady, Entry" )

    __ASSERT_DEBUG( aSessionId == iSessionId, PANIC( KErrArgument ) );

    CMceNatPluginManager::WriteSdpToLog( _L("Answer"), aAnswer );

    TMceNatStateTransitionEvent event(

            aAnswer, *this, EMceNatAnswer, *this, iSipEvent );

    if ( !iNatDisabled &&

         aSessionId == iSessionId &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::AnswerReady, processing" )

        TRAPD( error, iNatStateMachine->ProcessL( event ) );

        if ( KErrNone != error )

            {

            NatErrorOccurred( error );

            }

        }

    else

        {

        SafeDelete( aAnswer );

        DEBUG_PANIC( KErrNotReady );

        }

    MCESRV_DEBUG("*** CMceNatSipSession::AnswerReady, Exit" )

    }

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

// CMceNatSipSession::UpdateSdp

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

//

void CMceNatSipSession::UpdateSdp( TUint aSessionId, CSdpDocument* aOffer )

    {

    MCESRV_DEBUG( "*** CMceNatSipSession::UpdateSdp, Entry" )

    __ASSERT_DEBUG( aSessionId == iSessionId, PANIC( KErrArgument ) );

    TMceNatStateTransitionEvent event(

            aOffer, *this, EMceNatUpdateSdp, *this, iSipEvent );

    if ( !iNatDisabled &&

         aSessionId == iSessionId &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::UpdateSdp, processing" )

        TRAPD( error, iNatStateMachine->ProcessL( event ) );

        SafeDelete( aOffer );

        if ( KErrNone != error )

            {

            NatErrorOccurred( error );

            }

        }

    else

        {

        SafeDelete( aOffer );

        DEBUG_PANIC( KErrNotReady );

        }

    MCESRV_DEBUG( "*** CMceNatSipSession::UpdateSdp, Exit" )

    }

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

// CMceNatSipSession::ErrorOccurred

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

//

void CMceNatSipSession::ErrorOccurred( TUint aSessionId, TInt aError )

    {

    MCESRV_DEBUG( "*** CMceNatSipSession::ErrorOccurred, Entry" )

    MCESRV_DEBUG_DVALUE( "*** error", aError )

    __ASSERT_DEBUG( aSessionId == iSessionId, PANIC( KErrArgument ) );

    TMceNatStateTransitionEvent event(

            NULL, *this, EMceNatError, *this, iSipEvent, aError );

    if ( !iNatDisabled &&

         aSessionId == iSessionId &&

         iNatStateMachine->Accept( event ) )

        {

        MCESRV_DEBUG( "*** CMceNatSipSession::ErrorOccurred, processing" )

        TRAPD( error, iNatStateMachine->ProcessL( event ) )

        if ( KErrNone != error )

            {

            NatErrorOccurred( error );

            }

        }