/*
* 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:    Resolves host candidates for the streams.
*
*/




#include "mncmconnectionmultiplexer.h"
#include "natfwcandidate.h"
#include "mnatfwpluginobserver.h"
#include "cicehostresolver.h"
#include "ciceconnection.h"
#include "cicecallbackexecuter.h"
#include "icecandidatehandlerdefs.h"
#include "icecandidatehandlerlogs.h"


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

CIceHostResolver::CIceHostResolver()
    {

    }


void CIceHostResolver::ConstructL( TAny* aInitParams )
    {
    __ICEDP( "CIceHostResolver::ConstructL" )
    __ASSERT_ALWAYS( aInitParams, User::Leave( KErrArgument ) );
    
    iPluginId = KNatPluginIdNokiaHost().AllocL();
    
    CNATFWPluginApi::TNATFWPluginInitParams* initParams = 
        static_cast<CNATFWPluginApi::TNATFWPluginInitParams*>
        ( aInitParams );
    
    iPluginObserver = &(initParams->iObserver);
    iMultiplexer = &initParams->iMultiplexer;
    iCallBackExecuter 
        = CIceCallBackExecuter::NewL( CActive::EPriorityStandard );
    }


CIceHostResolver* CIceHostResolver::NewL( TAny* aInitParams )
    {
    CIceHostResolver* self = new( ELeave ) CIceHostResolver();
    CleanupStack::PushL( self );
    self->ConstructL( aInitParams );
    CleanupStack::Pop( self );
    return self;
    }


CIceHostResolver::~CIceHostResolver()
    {
    __ICEDP( "CIceHostResolver::~CIceHostResolver" )
    
    delete iPluginId;
    iPluginObserver = NULL;
    iMultiplexer = NULL;
    iHostCandidates.ResetAndDestroy();
    delete iCallBackExecuter;
    
    iConnections.ResetAndDestroy();
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::HandleCallBack
// ---------------------------------------------------------------------------
//
void CIceHostResolver::HandleCallBack( CBase& aObject, TInt aCallBackType )
    {
    __ICEDP( "CIceHostResolver::HandleCallBack" )
    
    CIceHostResolver& plugin( static_cast<CIceHostResolver&>( aObject ) );
    plugin.DoHandleCallBack( aCallBackType );
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::LocalAddress
// ---------------------------------------------------------------------------
//
TInetAddr CIceHostResolver::LocalAddress( 
        TUint aStreamId, TUint aAddrFamily ) const
    {
    __ICEDP( "CIceHostResolver::LocalAddress" )

    TInt count( iConnections.Count() );
    ASSERT( count );

    for ( TInt i( 0 ); i < count; i++ )
        {
        if ( iConnections[i]->StreamId() == aStreamId &&
             iConnections[i]->LocalAddress().Family() == aAddrFamily )
            {
            return iConnections[i]->LocalAddress();
            }
        }
    
    return TInetAddr();
    }


// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//    
void CIceHostResolver::ConnectServerL( const RSocketServ& /*aSocketServ*/,
        const TName& /*aConnectionName*/ )
    {
    __ICEDP( "CIceHostResolver::ConnectServerL" )
    
    TIceCallBack callback(
        HandleCallBack, *this, ECallBackServerConnected, 0 );
    iCallBackExecuter->AddCallBackL( callback );
    }
    

// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//
void CIceHostResolver::FetchCandidateL( TUint aStreamId, TUint /*aRtoValue*/,
        TUint aAddrFamily )
    {
    __ICEDP( "CIceHostResolver::FetchCandidateL" )
    
    CIceConnection* connection = CIceConnection::NewLC( 
        aStreamId, aAddrFamily, *iMultiplexer, *this );
    iConnections.AppendL( connection );
    CleanupStack::Pop( connection );
    
    // Host connections are used to receive checks from peer when local agent
    // has not yet started ICE processing.
    connection->SetReceivingStateL( EStreamingStateActive, 
        CIceConnection::ENotifyStateDisabled );
    
    // Unspecified destination allows STUN server response sending to
    // arbitrary address.
    TInetAddr unspecDestination;
    connection->SetSendingStateL( EStreamingStateActive, 
        CIceConnection::ENotifyStateDisabled, unspecDestination );
    
    // setup host candidate
    const TInetAddr& addr( connection->LocalAddress() );
    CNATFWCandidate* hostCandidate = CNATFWCandidate::NewLC();
    hostCandidate->SetStreamId( aStreamId );
    hostCandidate->SetType( CNATFWCandidate::EHost );
    hostCandidate->SetTransportAddrL( addr );
    hostCandidate->SetBase( addr );
    TUint protocol = connection->TransportProtocol();
    hostCandidate->SetTransportProtocol( protocol );
    
    iHostCandidates.AppendL( hostCandidate );
    CleanupStack::Pop( hostCandidate );
    connection->BindWithCandidateL( *hostCandidate );
    
    TIceCallBack callback( HandleCallBack, *this, ECallBackCandidateFound, 0 );
    iCallBackExecuter->AddCallBackL( callback );
    }


// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//
void CIceHostResolver::SetReceivingStateL(
        const CNATFWCandidate& aLocalCandidate, TNATFWStreamingState aState )
    {
    __ICEDP( "CIceHostResolver::SetReceivingStateL" )
    __ASSERT_ALWAYS( IsOwnedCandidate( aLocalCandidate ), 
        User::Leave( KErrNotFound ) );
    
    // find connection bound to the candidate
    CIceConnection* connection = FindConnection( aLocalCandidate );
    if ( NULL == connection &&
         CNATFWCandidate::EPeerReflexive == aLocalCandidate.Type() )
        {
        // Bind new peer-reflexive candidate with the corresponding host
        // connection. Peer-reflexive candidate has same base than host
        // candidate.
        connection = FindConnection( aLocalCandidate.Base() );
        if ( connection )
            {
            connection->BindWithCandidateL( aLocalCandidate );
            }
        }
    
    __ASSERT_ALWAYS( NULL != connection, User::Leave( KErrNotFound ) );
    connection->SetReceivingStateL( aState, 
        CIceConnection::ENotifyStateEnabled );
    }


// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//
void CIceHostResolver::SetSendingStateL(
        const CNATFWCandidate& aLocalCandidate,
        TNATFWStreamingState aState, const TInetAddr& aDestAddr )
    {
    __ICEDP( "CIceHostResolver::SetSendingStateL" )
    __ASSERT_ALWAYS( IsOwnedCandidate( aLocalCandidate ), 
        User::Leave( KErrNotFound ) );

    // find connection bound to the candidate
    CIceConnection* connection = FindConnection( aLocalCandidate );
    if ( NULL == connection &&
         CNATFWCandidate::EPeerReflexive == aLocalCandidate.Type() )
        {
        // Bind new peer-reflexive candidate with the corresponding host
        // connection. Peer-reflexive candidate has same base than host
        // candidate.
        connection = FindConnection( aLocalCandidate.Base() );
        if ( connection )
            {
            connection->BindWithCandidateL( aLocalCandidate );
            }
        }
    
    __ASSERT_ALWAYS( NULL != connection, User::Leave( KErrNotFound ) );
    connection->SetSendingStateL( aState, 
        CIceConnection::ENotifyStateEnabled, aDestAddr );
    }


// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//
void CIceHostResolver::GetConnectionIdL(
        const CNATFWCandidate& aLocalCandidate,
        TUint& aConnectionId )
    {
    __ICEDP( "CIceHostResolver::GetConnectionIdL" )
    __ASSERT_ALWAYS( IsOwnedCandidate( aLocalCandidate ), 
        User::Leave( KErrNotFound ) );
    
    // find connection bound to the candidate
    CIceConnection* connection = FindConnection( aLocalCandidate );
    if ( NULL == connection &&
         CNATFWCandidate::EPeerReflexive == aLocalCandidate.Type() )
        {
        // Bind new peer-reflexive candidate with the corresponding host
        // connection. Peer-reflexive candidate has same base than host
        // candidate.
        connection = FindConnection( aLocalCandidate.Base() );
        if ( connection )
            {
            connection->BindWithCandidateL( aLocalCandidate );
            }
        }
    
    __ASSERT_ALWAYS( NULL != connection, User::Leave( KErrNotFound ) );
    aConnectionId = connection->ConnectionId();
    }


// ---------------------------------------------------------------------------
// From class CNATFWPluginApi.
// ---------------------------------------------------------------------------
//
const TDesC8& CIceHostResolver::PluginIdentifier() const
    {
    return *iPluginId;
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::ConnectionNotify
// Passes media connection related events to the client.
// ---------------------------------------------------------------------------
//
void CIceHostResolver::ConnectionNotify( CIceConnection& aConnection,
        MIceConnectionObserver::TNotifyType aType, TInt aError )
    {
    __ICEDP( "CIceHostResolver::ConnectionNotify" )
    
    TInt connectionIndex( iConnections.Find( &aConnection ) );
    ASSERT( KErrNotFound != connectionIndex );
    if ( KErrNotFound != connectionIndex )
        {
        switch ( aType )
            {
            case MIceConnectionObserver::ENotifyConnectionRemoved:
                delete iConnections[connectionIndex];
                iConnections.Remove( connectionIndex );
                break;
           
            case MIceConnectionObserver::ENotifyConnectionError:
                iPluginObserver->Error( *this, aConnection.StreamId(),
                    aError );
                break;
            
            case MIceConnectionObserver::ENotifyRecvActivated:
                iPluginObserver->Notify( *this, aConnection.StreamId(), 
                    MNATFWPluginObserver::EReceivingActivated, aError );
                break;
            
            case MIceConnectionObserver::ENotifyRecvDeactivated:
                iPluginObserver->Notify( *this, aConnection.StreamId(), 
                    MNATFWPluginObserver::EReceivingDeactivated, aError );
                break;
            
            case MIceConnectionObserver::ENotifySendActivated:
                iPluginObserver->Notify( *this, aConnection.StreamId(), 
                    MNATFWPluginObserver::ESendingActivated, aError );
                break;
            
            case MIceConnectionObserver::ENotifySendDeactivated:
                iPluginObserver->Notify( *this, aConnection.StreamId(), 
                    MNATFWPluginObserver::ESendingDeactivated, aError );
                break;
            
            default:
                ASSERT( EFalse );
            }       
        }
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::DoHandleCallBack
// ---------------------------------------------------------------------------
//
void CIceHostResolver::DoHandleCallBack( TInt aCallBackType )
    {
    __ICEDP( "CIceHostResolver::DoHandleCallBack" )
    
    if ( ECallBackServerConnected == aCallBackType )
        {
        iPluginObserver->Notify( *this, 0,
            MNATFWPluginObserver::EServerConnected, KErrNone );
        }
    else if ( ECallBackCandidateFound  == aCallBackType )
        {
        ASSERT( iHostCandidates.Count() );
        TUint streamId( iHostCandidates[0]->StreamId() );
        iPluginObserver->NewLocalCandidateFound( *this, iHostCandidates[0] );
        iHostCandidates.Remove( 0 );
        iPluginObserver->Notify( *this, streamId,
            MNATFWPluginObserver::EFetchingCompleted, KErrNone );
        }
    else
        {
        __ICEDP( "CIceHostResolver::DoHandleCallBack, ELSE" )
        ASSERT( EFalse );
        }
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::FindConnection
// ---------------------------------------------------------------------------
//
CIceConnection* CIceHostResolver::FindConnection( 
        const CNATFWCandidate& aLocalCandidate )
    {
    CIceConnection* foundConnection( NULL );
    TInt index( iConnections.Count() - 1 );
    while ( NULL == foundConnection && 0 <= index )
        {
        if ( iConnections[index]->IsBoundToCandidate( aLocalCandidate ) )
            {
            foundConnection = iConnections[index];
            }
        
        index--;
        }
    
    return foundConnection;
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::FindConnection
// ---------------------------------------------------------------------------
//
CIceConnection* CIceHostResolver::FindConnection( 
        const TInetAddr& aLocalAddr )
    {
    CIceConnection* foundConnection( NULL );
    TInt index( iConnections.Count() - 1 );
    while ( NULL == foundConnection && 0 <= index )
        {
        if ( TIceUtils::MatchAddresses( 
                iConnections[index]->LocalAddress(), aLocalAddr ) )
            {
            foundConnection = iConnections[index];
            }
        
        index--;
        }
    
    return foundConnection;
    }


// ---------------------------------------------------------------------------
// CIceHostResolver::IsOwnedCandidate
// ---------------------------------------------------------------------------
//
TBool CIceHostResolver::IsOwnedCandidate( 
        const CNATFWCandidate& aLocalCandidate ) const
    {
    return ( CNATFWCandidate::EHost == aLocalCandidate.Type() || 
             CNATFWCandidate::EPeerReflexive == aLocalCandidate.Type() );
    }