/*
* 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 )
            {
            if ( iBindings[index].iCheckOngoing )
                {
                iBindings[index].iCheckOngoing = EFalse;
                TRAP_IGNORE( ExecuteCallbackL( index, KErrUnknown ) )
                }
            
            DoRemoveConnection( aStreamId, aConnectionId, ETrue );
            }
        }
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::IncomingMessageL
// For protocol message receiving.
// ---------------------------------------------------------------------------
//
void CIceConnectionHandler::IncomingMessageL( TUint aStreamId,
        const TDesC8& aMessage, const TInetAddr& aLocalAddr,
        const TInetAddr& aFromAddr, const TInetAddr& aPeerAddr,
        TBool& aConsumed )
    {
    __ICEDP_ADDRLOG( 
        "CIceConnectionHandler::IncomingMessageL FROMADDR", aFromAddr )
    __ICEDP_ADDRLOG( 
        "CIceConnectionHandler::IncomingMessageL PEERADDR", aPeerAddr )
    
    TInt index( iBindings.Count() - 1 );
    __ASSERT_ALWAYS( 0 <= index, User::Leave( KErrNotReady ) );
    
    TInetAddr peerAddrFromIndication( KAFUnspec );
    HBufC8* indicationData( NULL );
    TInt consumingBindingInd( KErrNotFound );
    
    // offer message for every binding in the stream until consumed
    while ( ( KErrNotFound == consumingBindingInd ) && ( 0 <= index ) )
        {
        if ( iBindings[index].iStreamId == aStreamId )
            {
            CSTUNBinding* stunBinding = NULL;
            stunBinding = 
                static_cast<CSTUNBinding*>( iBindings[index].iBinding );
            
            TBool consumed( EFalse );
            if ( indicationData )
                {
                stunBinding->HandleDataL( 
                    *indicationData, consumed, peerAddrFromIndication );
                }
            else
                {
                indicationData = stunBinding->HandleDataL( 
                    aMessage, consumed, peerAddrFromIndication );
                }
            
            if ( consumed )
                {
                consumingBindingInd = index;
                aConsumed = ETrue;
                }
            }
        
        index--;
        }
    
    if ( KErrNotFound != consumingBindingInd )
        {
        iBindings[consumingBindingInd].iLocalAddr = aLocalAddr;
        iBindings[consumingBindingInd].iFromAddr = aFromAddr;
        
        if ( aPeerAddr.IsUnspecified() )
            {
            if ( peerAddrFromIndication.IsUnspecified() )
                {
                iBindings[consumingBindingInd].iPeerAddr = aFromAddr;
                }
            else
                {
                iBindings[consumingBindingInd].iPeerAddr 
                    = peerAddrFromIndication;
                }
            }
        else
            {
            iBindings[consumingBindingInd].iPeerAddr = aPeerAddr;
            }
        
        __ICEDP_ADDRLOG( 
            "CIceConnectionHandler::IncomingMessageL BINDING PEERADDR",
            iBindings[consumingBindingInd].iPeerAddr )
        
        // mapped address is filled when binding event occurs
        }
    
    delete indicationData;
    }


// ---------------------------------------------------------------------------
// From class MIceNatPluginEventObs.
// CIceConnectionHandler::PluginEventOccured
// ---------------------------------------------------------------------------
//
void CIceConnectionHandler::PluginEventOccured( 
        const CNATFWPluginApi* /*aPlugin*/, TUint aStreamId, 
        MIceNatPluginEventObs::TNatPluginEvent aEventCode,
        TInt aErrorCode, TAny* aEventData, TUint /*aStreamConnectionId*/,
        TUint /*aComponentId*/, TBool /*aIPv6After*/ )
    {
    __ICEDP( "CIceConnectionHandler::PluginEventOccured" )
    
    switch ( aEventCode )
        {
        case MIceNatPluginEventObs::ESendingActivated:
        case MIceNatPluginEventObs::ESendingDeactivated:
        case MIceNatPluginEventObs::EReceivingActivated:
        case MIceNatPluginEventObs::EReceivingDeactivated:
            {
            iEventObserver.PluginEventOccured( NULL, aStreamId, 
                aEventCode, aErrorCode, aEventData );
            }
            break;
        
        default:
            __ICEDP( "CIceConnectionHandler::PluginEventOccured, DEFAULT" )
            ASSERT( EFalse );
        }
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::FindBindingIndex
// Private. For finding the right binding.
// ---------------------------------------------------------------------------
//
TInt CIceConnectionHandler::FindBindingIndex( 
        TUint aStreamId, TUint aConnectionId ) const
    {
    __ICEDP( "CIceConnectionHandler::FindBindingIndex" )
    
    TInt index( iBindings.Count() - 1 );
    while ( ( index >= 0 ) 
            && !( ( iBindings[index].iStreamId == aStreamId )
            && ( iBindings[index].iConnectionId == aConnectionId ) ) )
        {
        index--;
        }
    
    return index;
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::FindBindingIndex
// Private. For finding the right binding.
// ---------------------------------------------------------------------------
//
TInt CIceConnectionHandler::FindBindingIndex( 
        const CBinding& aBinding ) const
    {
    TInt index( iBindings.Count() - 1 );
    while ( ( index >= 0 ) && ( iBindings[index].iBinding != &aBinding ) )
        {
        index--;
        }
    
    return index;
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::FindBindingIndex
// Private. For finding the right binding.
// ---------------------------------------------------------------------------
//
TInt CIceConnectionHandler::FindBindingIndex( 
        TUint aStreamId, TUint aConnectionId, 
        const TInetAddr& aDestAddr ) const
    {
    __ICEDP( "CIceConnectionHandler::FindBindingIndex" )
    
    TInt foundConnectionInd( KErrNotFound );
    TInt index( iBindings.Count() - 1 );
    while ( KErrNotFound == foundConnectionInd && 0 <= index )
        {
        if ( ( iBindings[index].iStreamId == aStreamId ) &&
             ( iBindings[index].iConnectionId == aConnectionId ) &&
             ( TIceUtils::MatchAddresses( 
                   iBindings[index].iDestAddr, aDestAddr ) ) )
            {
            foundConnectionInd = index;
            }
        
        index--;
        }
    
    return foundConnectionInd;
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::SolvePluginL
// Private. Solves plugin owning given candidate.
// ---------------------------------------------------------------------------
//
CNATFWPluginApi* CIceConnectionHandler::SolvePluginL( 
        const CNATFWCandidate& aLocalCandidate )
    {
    CNATFWPluginApi* item( NULL );
    switch ( aLocalCandidate.Type() )
        {
        case CNATFWCandidate::EHost:
        case CNATFWCandidate::EPeerReflexive:
            // Host plugin is ICE instantiated object and can be resolved
            // with hardcoded id. Host plugin binds peer reflexive candidate
            // to the host connection when candidate is given to the plugin 
            // first time.
            item = iPluginContainer.PluginByIdentifier( 
                KNatPluginIdNokiaHost() );
            break;
        
        case CNATFWCandidate::EServerReflexive:
            item = iPluginContainer.PluginByType( KNatPluginTypeStun() );
            break;
        
        case CNATFWCandidate::ERelay:
            item = iPluginContainer.PluginByType( KNatPluginTypeTurn() );
            break;
       
        default:
            ASSERT( EFalse );
        }
    
    __ASSERT_ALWAYS( NULL != item, User::Leave( KErrNotFound ) );
    return item;
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::FreeResources
// Private. Remove data from binding array.
// ---------------------------------------------------------------------------
//
void CIceConnectionHandler::FreeResources()
    {
    __ICEDP( "CIceConnectionHandler::FreeResources" )
    
    TInt count( iBindings.Count() );
    for ( TInt i( 0 ); i < count; ++i )
        {
        delete iBindings[i].iBinding;
        iBindings[i].iBinding = NULL;
        
        TRAP_IGNORE( 
            iMultiplexer.UnregisterConnectionObserverL( 
                iBindings[i].iStreamId, *this ) )
        TRAP_IGNORE(
            iMultiplexer.UnregisterIncomingConnectionObserverL( 
                iBindings[i].iStreamId, *this ) )
        
        if ( EIceConnTypeHost == iBindings[i].iConnType )
            {
            TRAP_IGNORE(
                iMultiplexer.RemoveConnectionL( 
                    iBindings[i].iStreamId, iBindings[i].iConnectionId ) )
            }
        }
    
    iBindings.Close();
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::ExecuteCallbackL
// Private.
// ---------------------------------------------------------------------------
//
void CIceConnectionHandler::ExecuteCallbackL( TInt aIndex, TInt aError )
    {
    __ICEDP( "CIceConnectionHandler::ExecuteCallbackL" )
    
    iBindings[aIndex].iCheckOngoing = EFalse;
    __ASSERT_ALWAYS( NULL != iBindings[aIndex].iObserver, 
        User::Leave( KErrNotReady ) );
    
    iBindings[aIndex].iObserver->ConnCheckCompletedL( 
        aError,
        iBindings[aIndex].iLocalAddr,
        iBindings[aIndex].iPeerAddr,
        iBindings[aIndex].iMappedAddr );
    }


// ---------------------------------------------------------------------------
// CIceConnectionHandler::DoRemoveConnection
// ---------------------------------------------------------------------------
//
void CIceConnectionHandler::DoRemoveConnection( 
        TUint aStreamId, TUint aConnectionId, TBool aRemoveMuxConn )
    {
    __ICEDP_INT1( "CIceConnectionHandler::DoRemoveConnection, start:",
        aRemoveMuxConn )
    
    TInt index( FindBindingIndex( aStreamId, aConnectionId ) );
    if ( KErrNotFound != index )
        {
        if ( aRemoveMuxConn && 
                EIceConnTypeHost == iBindings[index].iConnType )
            {
            TRAP_IGNORE(
                iMultiplexer.RemoveConnectionL( 
                    iBindings[index].iStreamId, 
                    iBindings[index].iConnectionId ) )
            }
        
        delete iBindings[index].iBinding;
        iBindings.Remove( index );
        }
    
    __ICEDP( "CIceConnectionHandler::DoRemoveConnection, end" )
    }