/*

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

#include "natfwcredentials.h"

#include "natfwcandidatepair.h"

#include "mnatfwpluginobserver.h"

#include "mncmconnectionmultiplexer.h"

#include "ciceconnectionhandler.h"

#include "natfwstunclient.h"

#include "natfwstunbinding.h"

#include "cicesessiondata.h"

#include "miceconncheckobserver.h"

#include "miceconnhandlerobserver.h"

#include "ticenatplugincontaineriter.h"

#include "icecandidatehandlerlogs.h"

// CONSTANTS

const TInt KRetransmitIntervalInMs = 250;

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

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

// CIceConnectionHandler::CIceConnectionHandler

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

//

CIceConnectionHandler::CIceConnectionHandler(

        MNcmConnectionMultiplexer& aMultiplexer,

        MIceNatPluginEventObs& aEventObserver,

        CIceSessionData& aSessionData,

        CIceNatPluginContainer& aPluginContainer,

        MIceConnHandlerObserver& aConnHandlerObs )

    :

    iMultiplexer( aMultiplexer ),

    iEventObserver( aEventObserver ),

    iSessionData( aSessionData ),

    iPluginContainer( aPluginContainer ),

    iConnHandlerObs( aConnHandlerObs )

    {

    __ICEDP( "CIceConnectionHandler::CIceConnectionHandler" )

    }

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

// CIceConnectionHandler::ConstructL

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

//

void CIceConnectionHandler::ConstructL()

    {

    __ICEDP( "CIceConnectionHandler::ConstructL" )

    iTimerServices = CDeltaTimer::NewL( CActive::EPriorityStandard );

    // RTO value given here will be overridden when sending request

    iStunClient = CSTUNClient::NewL( KRetransmitIntervalInMs,

                                     *iTimerServices,

                                     *this,

                                     &iMultiplexer );

    iPluginContainer.RegObserverForEventL( *this, 

        MIceNatPluginEventObs::ESendingActivated );

    iPluginContainer.RegObserverForEventL( *this, 

        MIceNatPluginEventObs::ESendingDeactivated );

    iPluginContainer.RegObserverForEventL( *this, 

        MIceNatPluginEventObs::EReceivingActivated );

    iPluginContainer.RegObserverForEventL( *this, 

        MIceNatPluginEventObs::EReceivingDeactivated );        

    }

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

// CIceConnectionHandler::NewL

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

//

CIceConnectionHandler* CIceConnectionHandler::NewL(

        MNcmConnectionMultiplexer& aMultiplexer,

        MIceNatPluginEventObs& aEventObserver,

        CIceSessionData& aSessionData,

        CIceNatPluginContainer& aPluginContainer,

        MIceConnHandlerObserver& aConnHandlerObs )

    {

    __ICEDP( "CIceConnectionHandler::NewL" )

    CIceConnectionHandler* self 

        = CIceConnectionHandler::NewLC( 

            aMultiplexer, aEventObserver, aSessionData, aPluginContainer,

            aConnHandlerObs );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIceConnectionHandler::NewLC

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

//

CIceConnectionHandler* CIceConnectionHandler::NewLC(

        MNcmConnectionMultiplexer& aMultiplexer,

        MIceNatPluginEventObs& aEventObserver,

        CIceSessionData& aSessionData,

        CIceNatPluginContainer& aPluginContainer,

        MIceConnHandlerObserver& aConnHandlerObs )

    {

    __ICEDP( "CIceConnectionHandler::NewLC" )

    CIceConnectionHandler* self 

        = new( ELeave ) CIceConnectionHandler( 

            aMultiplexer, aEventObserver, aSessionData, 

            aPluginContainer, aConnHandlerObs );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIceConnectionHandler::~CIceConnectionHandler

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

//

CIceConnectionHandler::~CIceConnectionHandler()

    {

    __ICEDP( "CIceConnectionHandler::~CIceConnectionHandler" )

    FreeResources();

    delete iStunClient;

    // timer services must be deleted AFTER STUN Client

    delete iTimerServices;

    iPluginContainer.UnregObserver( *this );

    }

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

// CIceConnectionHandler::SetReceivingStateL

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

//

void CIceConnectionHandler::SetReceivingStateL( 

        const CNATFWCandidate& aLocalCandidate,

        TNATFWStreamingState aState )

    {

    __ICEDP( "CIceConnectionHandler::SetReceivingStateL" )

    CNATFWPluginApi* item = SolvePluginL( aLocalCandidate );

    item->SetReceivingStateL( aLocalCandidate, aState );

    }

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

// CIceConnectionHandler::SetSendingStateL

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

//

void CIceConnectionHandler::SetSendingStateL( 

        const CNATFWCandidate& aLocalCandidate,

        TNATFWStreamingState aState, const TInetAddr& aDestAddr )

    {

    __ICEDP( "CIceConnectionHandler::SetSendingStateL" )

    CNATFWPluginApi* item = SolvePluginL( aLocalCandidate );

    item->SetSendingStateL( aLocalCandidate, aState, aDestAddr );

    }

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

// CIceConnectionHandler::GetConnectionIdL

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

//

void CIceConnectionHandler::GetConnectionIdL( 

        const CNATFWCandidate& aLocalCandidate,

        TUint& aConnectionId )

    {

    __ICEDP( "CIceConnectionHandler::GetConnectionIdL" )

    CNATFWPluginApi* item = SolvePluginL( aLocalCandidate );

    item->GetConnectionIdL( aLocalCandidate, aConnectionId );

    }

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

// CIceConnectionHandler::CreateConnectionL

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

//

TUint CIceConnectionHandler::CreateConnectionL( 

        const CNATFWCandidatePair& aPair )

    {

    __ICEDP( "CIceConnectionHandler::CreateConnectionL" )

    const CNATFWCandidate& localCandidate( aPair.LocalCandidate() );

    TUint streamId( localCandidate.StreamId() );

    iMultiplexer.RegisterConnectionObserverL( streamId, *this );

    iMultiplexer.RegisterIncomingConnectionObserverL( streamId, *this );

    TUint connectionId( 0 );

    if ( CNATFWCandidate::ERelay == localCandidate.Type() )

        {

        // turnconnectionid is used when utilizing TURN-plugin

        CNATFWPluginApi* plugin 

            = iPluginContainer.PluginByType( KNatPluginTypeTurn() );

        __ASSERT_ALWAYS( plugin, User::Leave( KErrNotFound ) );

        plugin->GetConnectionIdL( localCandidate, connectionId );

        }

    else

        {

        // create a new host connection for the candidate pair

        connectionId = iMultiplexer.CreateConnectionL( 

            streamId, localCandidate.TransportAddr() );

        }

    CSTUNBinding* binding = 

        CSTUNBinding::NewLC( *iStunClient, streamId, connectionId );

    TIceConnectionType type = 

        CNATFWCandidate::ERelay == aPair.LocalCandidate().Type() ?

            EIceConnTypeTurn : EIceConnTypeHost;

    TBindingData bindingData( binding, type,

        streamId, connectionId, aPair.RemoteCandidate().TransportAddr() );

    iBindings.AppendL( bindingData );

    CleanupStack::Pop( binding );

    return connectionId;

    }

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

// CIceConnectionHandler::RemoveConnection

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

//

void CIceConnectionHandler::RemoveConnection( 

        TUint aStreamId, TUint aConnectionId )

    {

    __ICEDP( "CIceConnectionHandler::RemoveConnection" )

    DoRemoveConnection( aStreamId, aConnectionId, ETrue );

    }

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

// CIceConnectionHandler::PerformConnCheckL

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

//

void CIceConnectionHandler::PerformConnCheckL( TUint aStreamId,

        TUint aConnectionId, TUint aPriority, TBool aUseCandidate,

        TUint aRtoValue, const TInetAddr& aDestAddr,

        MIceConnCheckObserver& aObserver )

    {

    __ICEDP( "CIceConnectionHandler::PerformConnCheckL" )

    const CNATFWCredentials* credential = 

        iSessionData.Credentials( 

            aStreamId, CNATFWCredentials::EOutbound );

    __ASSERT_ALWAYS( NULL != credential, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS(

        credential->Username().Length(), User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS(

        credential->Password().Length(), User::Leave( KErrNotReady ) );

    iStunClient->SetCredentialsL( 

        credential->Username(), credential->Password() );

    TInt index( FindBindingIndex( aStreamId, aConnectionId, aDestAddr ) );

    __ASSERT_ALWAYS( KErrNotFound != index, User::Leave( index ) );

    iBindings[index].iObserver = &aObserver;

    TICEAttributes attributes( 

        aPriority, aUseCandidate, 

        ( EIceRoleControlled == iSessionData.Role() )

            ? iSessionData.TieBreaker() : TUint64( 0 ),

        ( EIceRoleControlling == iSessionData.Role() )

            ? iSessionData.TieBreaker() : TUint64( 0 ) );

    CSTUNBinding* stunBinding =

        static_cast<CSTUNBinding*>( iBindings[index].iBinding );

    stunBinding->SetICESpecificAttributes( attributes );

    iBindings[index].iCheckOngoing = ETrue;

    iBindings[index].iRtoValue = aRtoValue;

    if ( EStreamingStateActive != iBindings[index].iStreamingStatus )

        {

        if ( CIceConnectionHandler::EIceConnTypeTurn 

                != iBindings[index].iConnType )

            {

            iMultiplexer.SetReceivingStateL( iBindings[index].iStreamId,

                iBindings[index].iConnectionId, EStreamingStateActive );

            iMultiplexer.SetSendingStateL( iBindings[index].iStreamId, 

                iBindings[index].iConnectionId,

                iBindings[index].iDestAddr, EStreamingStateActive );

            // Wait for notify from multiplexer and after that call 

            // SendRequestL for this connection.

            }

        else

            {

            stunBinding->SendRequestL( 

                iBindings[index].iDestAddr, ETrue, 

                iBindings[index].iRtoValue );

            }

        }

    else

        {

        stunBinding->SendRequestL( 

            iBindings[index].iDestAddr, ETrue, iBindings[index].iRtoValue  );

        }

    }

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

// CIceConnectionHandler::CancelCheck

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

//

void CIceConnectionHandler::CancelCheck( TUint aStreamId, 

        TUint aConnectionId, const TInetAddr& aDestAddr )

    {

    __ICEDP( "CIceConnectionHandler::CancelCheck" )

    TInt index( FindBindingIndex( aStreamId, aConnectionId, aDestAddr ) );

    if ( KErrNotFound != index  )

        {

        CSTUNBinding* stunBinding =

            static_cast<CSTUNBinding*>( iBindings[index].iBinding );

        if ( EStreamingStateActive == iBindings[index].iStreamingStatus ||

             EIceConnTypeTurn == iBindings[index].iConnType )

            {

            // Previous transaction is fully terminated because STUN binding

            // does not currently support simultaneous transactions.

            stunBinding->CancelRequest();

            }

        else

            {

            // mux connection not yet activated

            __ICEDP( "CIceConnectionHandler::CancelCheck, NO ACTIVE CONN" )

            iBindings[index].iCancelled = ETrue;

            }

        }

    else

        {

        __ICEDP( "CIceConnectionHandler::CancelCheck, ASSERT" )

        ASSERT( EFalse );

        }

    }

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

// CIceConnectionHandler::ReleasePlugins

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

//

void CIceConnectionHandler::ReleasePlugins( TBool aRetainRelay )

    {

    __ICEDP( "CIceConnectionHandler::ReleasePlugins" )

    iPluginContainer.ReleasePlugins( aRetainRelay );

    }

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

// CIceConnectionHandler::STUNClientInitCompleted

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

//

void CIceConnectionHandler::STUNClientInitCompleted( 

        const CSTUNClient& /*aClient*/,

        TInt /*aCompletionCode*/ )

    {

    __ICEDP( "CIceConnectionHandler::STUNClientInitCompleted" )

    // SHOULD NOT GET CALLED IN THIS IMPLEMENTATION

    ASSERT( EFalse );

    }

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

// CIceConnectionHandler::STUNBindingEventOccurredL

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

//

void CIceConnectionHandler::STUNBindingEventOccurredL( 

        TSTUNBindingEvent aEvent, const CBinding& aBinding )

    {

    __ICEDP( "CIceConnectionHandler::STUNBindingEventOccurredL" )

    TInt index = FindBindingIndex( aBinding );

    User::LeaveIfError( index );

    // notify client about success of connectivity check with data got

    // in incoming message

    if ( EPublicAddressResolved == aEvent )

        {

        __ICEDP_ADDRLOG( "MAPPEDADDR:", aBinding.PublicAddr() )

        iBindings[index].iMappedAddr = aBinding.PublicAddr();

        ExecuteCallbackL( index, KErrNone );

        }

    else if ( ECredentialsRejected == aEvent )

        {

        iBindings[index].iMappedAddr.SetAddress( KAFUnspec );

        ExecuteCallbackL( index, KErrPermissionDenied );

        }

    else

        {

        __ICEDP( "CIceConnectionHandler::STUNBindingEventOccurredL, ELSE" )

        ASSERT( EFalse );

        }

    }

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

// CIceConnectionHandler::STUNBindingErrorOccurred

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

//

void CIceConnectionHandler::STUNBindingErrorOccurred( 

        const CBinding& aBinding, TInt aError )

    {

    __ICEDP( "CIceConnectionHandler::STUNBindingErrorOccurred" )

    TInt index = FindBindingIndex( aBinding );

    if ( KErrNotFound != index )

        {

        TRAP_IGNORE( ExecuteCallbackL( index, aError ) )

        }

    else

        {

        __ICEDP( "CIceConnectionHandler::STUNBindingErrorOccurred, ELSE" )

        ASSERT( EFalse );

        }

    }

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

// CIceConnectionHandler::ConnectionNotify

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

//

void CIceConnectionHandler::ConnectionNotify( 

        TUint aStreamId, TUint aConnectionId,

        MNcmConnectionObserver::TConnectionNotifyType aType, 

        TInt aError )

    {

    __ICEDP_INT1( 

        "CIceConnectionHandler::ConnectionNotify, ERR:", aError )

    TInt index( FindBindingIndex( aStreamId, aConnectionId ) );

    if ( KErrNotFound != index 

            && EIceConnTypeHost == iBindings[index].iConnType )

        {

        switch ( aType )

            {

            case MNcmConnectionObserver::EConnectionRemoved:

                {

                DoRemoveConnection( aStreamId, aConnectionId, EFalse );

                iConnHandlerObs.StreamClosed( aStreamId );

                }

                break;

            case MNcmConnectionObserver::EConnectionError:

                {

                // Handled with error handling below

                }

                break;

            case MNcmConnectionObserver::EReceivingActivated:

                {

                // Wait for MNcmConnectionObserver::ESendingActivated

                }

                break;

            case MNcmConnectionObserver::EReceivingDeactivated:

                {

                // Wait for MNcmConnectionObserver::ESendingDeactivated

                }

                break;

            case MNcmConnectionObserver::ESendingActivated:

                {

                iBindings[index].iStreamingStatus = EStreamingStateActive;

                if ( iBindings[index].iCancelled )

                    {

                    // Connectivity check is now 'cancelled' and new request

                    // can be received.

                    iBindings[index].iCancelled = EFalse;

                    }

                else

                    {

                    CSTUNBinding* stunBinding =

                        static_cast<CSTUNBinding*>( iBindings[index].iBinding );

                    TRAP_IGNORE( stunBinding->SendRequestL( 

                        iBindings[index].iDestAddr, ETrue, 

                        iBindings[index].iRtoValue ) )

                    }

                }

                break;

            case MNcmConnectionObserver::ESendingDeactivated:

                {

                iBindings[index].iStreamingStatus = EStreamingStatePassive;

                }

                break;

            case MNcmConnectionObserver::EFirstMediaPacketSent:

                {

                }

                break;    

            default:

                ASSERT( EFalse );

            }

        if ( aError )

            {