/*
* 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 "natfwpluginapi.h"
#include "natfwcandidatepair.h"
#include "natfwcandidate.h"
#include <cnatfwsettingsapi.h>
#include <mnatfwicesettings.h>
#include <badesca.h>
#include "cicenatplugincontainer.h"
#include "mncmconnectionmultiplexer.h"
#include "cicesessiondata.h"
#include "cicehostresolver.h"
#include "icecandidatehandlerdefs.h"
#include "icecandidatehandlerlogs.h"

const TInt KMaxNumberOfUtilityPlugins   = 2;

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

CIceNatPluginContainer::CIceNatPluginContainer( 
        const CIceSessionData& aSessionData,
        MNcmConnectionMultiplexer& aMultiplexer )
        :
        iInitParams( *this, aMultiplexer, 
            aSessionData.Domain(), aSessionData.IapId() )
    {
    }


void CIceNatPluginContainer::ConstructL()
    {
    __ICEDP( "CIceNatPluginContainer::ConstructL" )
    
    TInt startInd = MIceNatPluginEventObs::EFirstPluginEventInd;
    TInt stopInd = MIceNatPluginEventObs::ELastPluginEventInd;
    for ( TInt i = startInd; i <= stopInd; ++i )
        {
        RPointerArray<MIceNatPluginEventObs>* arrayForEvent 
            = new ( ELeave ) RPointerArray<MIceNatPluginEventObs>;
        CleanupClosePushL( *arrayForEvent );
        iObserversForEvent.AppendL( arrayForEvent );
        CleanupStack::Pop( arrayForEvent ); // lint #429
        }
    
    ResolvePluginsL();
    }


CIceNatPluginContainer* CIceNatPluginContainer::NewL( 
        const CIceSessionData& aSessionData,
        MNcmConnectionMultiplexer& aMultiplexer )
    {
    CIceNatPluginContainer* self 
        = CIceNatPluginContainer::NewLC( aSessionData, aMultiplexer );
    CleanupStack::Pop( self );
    return self;
    }


CIceNatPluginContainer* CIceNatPluginContainer::NewLC( 
        const CIceSessionData& aSessionData,
        MNcmConnectionMultiplexer& aMultiplexer )
    {
    CIceNatPluginContainer* self 
        = new( ELeave ) CIceNatPluginContainer( aSessionData, aMultiplexer );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


CIceNatPluginContainer::~CIceNatPluginContainer()
    {
    __ICEDP( "CIceNatPluginContainer::~CIceNatPluginContainer" )
    
    TInt count( iObserversForEvent.Count() );
    for ( TInt i = 0; i < count; ++i )
        {
        iObserversForEvent[i]->Close();
        }
    
    iObserversForEvent.ResetAndDestroy();
    
    iPlugins.ResetAndDestroy();
    
    REComSession::FinalClose();
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::ConnectPluginsL
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::ConnectPluginsL( const RSocketServ& aSocketServ,
        const TName& aConnectionName )
    {
    __ICEDP( "CIceNatPluginContainer::ConnectPluginsL" )
    
    for ( TInt i( iPlugins.Count() - 1 ); i >= 0; --i )
        {
        TRAPD( error,
            iPlugins[i]->ConnectServerL( aSocketServ, aConnectionName ) );
        
        if ( KErrNone != error )
            {
            delete iPlugins[i];
            iPlugins.Remove( i );
            }
        }
    
    __ASSERT_ALWAYS( iPlugins.Count(), User::Leave( KErrCouldNotConnect ) );
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::Count
// ---------------------------------------------------------------------------
//
TInt CIceNatPluginContainer::Count() const
    {
    return iPlugins.Count();
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::RegObserverForEventL
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::RegObserverForEventL( 
        const MIceNatPluginEventObs& aObserver,
        MIceNatPluginEventObs::TNatPluginEvent aEvent )
    {
    __ICEDP( "CIceNatPluginContainer::RegObserverForEventL" )
    __ASSERT_DEBUG( aEvent < iObserversForEvent.Count(), 
        User::Leave( KErrArgument ) );
    
    iObserversForEvent[aEvent]->InsertInAddressOrderL( &aObserver );
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::UnregObserverForEvent
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::UnregObserverForEvent( 
        const MIceNatPluginEventObs& aObserver,
        MIceNatPluginEventObs::TNatPluginEvent aEvent )
    {
    __ICEDP( "CIceNatPluginContainer::UnregObserverForEvent" )
    ASSERT( aEvent < iObserversForEvent.Count() );
    
    TInt ind = iObserversForEvent[aEvent]->Find( &aObserver );
    if ( KErrNotFound != ind )
        {
        iObserversForEvent[aEvent]->Remove( ind );
        }
    else
        {
        ASSERT( EFalse );
        }
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::UnregObserver
// Unregisters observer for all events.
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::UnregObserver( 
        const MIceNatPluginEventObs& aObserver )
    {
    __ICEDP( "CIceNatPluginContainer::UnregObserver" )
    
    TInt numOfEvents = iObserversForEvent.Count();
    for ( TInt i( numOfEvents - 1 ); i >= 0; --i )
        {
        TInt ind = iObserversForEvent[i]->Find( &aObserver );
        if ( KErrNotFound != ind )
            {
            iObserversForEvent[i]->Remove( ind );
            }
        }
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::ReleasePlugins
// Host plugin is always preserved.
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::ReleasePlugins( TBool aRetainRelay )
    {
    __ICEDP_INT1( "CIceNatPluginContainer::ReleasePlugins, RETAINRELAY:",
        aRetainRelay )
    
    for ( TInt i( iPlugins.Count() - 1 ); i >= 0; --i )
        {
        TPtrC8 type = ParsePluginType( iPlugins[i]->PluginIdentifier() );
        
        if ( !( aRetainRelay && KNatPluginTypeTurn() == type )
            && ( KNatPluginTypeHost() != type ) )
            {
            delete iPlugins[i];
            iPlugins.Remove( i );
            }
        }
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::PluginByIdentifier
// ---------------------------------------------------------------------------
//
CNATFWPluginApi* CIceNatPluginContainer::PluginByIdentifier( 
        const TDesC8& aIdentifier )
    {
    __ICEDP_STR( "CIceNatPluginContainer::PluginByIdentifier", aIdentifier )
    
    for ( TInt i( 0 ); i < iPlugins.Count(); ++i )
        {
        CNATFWPluginApi* item = iPlugins[i];
        if ( item->PluginIdentifier() == aIdentifier )
            {
            return item;
            }
        }
    
    return NULL;
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::PluginByType
// ---------------------------------------------------------------------------
//
CNATFWPluginApi* CIceNatPluginContainer::PluginByType( 
        const TDesC8& aType )
    {
    __ICEDP_STR( "CIceNatPluginContainer::PluginByType", aType )
    
    TInt numOfPlugins = iPlugins.Count();
    for ( TInt i( 0 ); i < numOfPlugins; ++i )
        {
        CNATFWPluginApi* item = iPlugins[i];
        
        TPtrC8 type = ParsePluginType( item->PluginIdentifier() );
        if ( type == aType )
            {
            return item;
            }
        }
    
    return NULL;
    }


// ---------------------------------------------------------------------------
// From class MNATFWPluginObserver.
// CIceNatPluginContainer::Error
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::Error( const CNATFWPluginApi& aPlugin,
        TUint aStreamId, TInt aErrorCode )
    {
    __ICEDP( "CIceNatPluginContainer::Error" )
    
    RPointerArray<MIceNatPluginEventObs>& observers = 
        *iObserversForEvent[MIceNatPluginEventObs::EGeneralError];
    
    TInt numOfObservers( observers.Count() );
    for ( TInt i = 0; i < numOfObservers; ++i )
        {
        observers[i]->PluginEventOccured( &aPlugin, aStreamId,
            MIceNatPluginEventObs::EGeneralError, 
            aErrorCode, NULL );
        }
    }


// ---------------------------------------------------------------------------
// From class MNATFWPluginObserver.
// CIceNatPluginContainer::Notify
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::Notify( const CNATFWPluginApi& aPlugin,
        TUint aStreamId, TNATFWPluginEvent aEvent, TInt aErrCode )
    {
    __ICEDP( "CIceNatPluginContainer::Notify" )
    
    MIceNatPluginEventObs::TNatPluginEvent convertedEvent;
    TInt error = GetConvertedEvent( aEvent, convertedEvent );
    if ( KErrNone == error )
        {
        RPointerArray<MIceNatPluginEventObs>& observers = 
            *iObserversForEvent[convertedEvent];
        
        TInt numOfObservers = observers.Count();
        for ( TInt i = 0; i < numOfObservers; ++i )
            {
            observers[i]->PluginEventOccured( &aPlugin,
                aStreamId, convertedEvent, aErrCode, NULL );
            }
        }
    }


// ---------------------------------------------------------------------------
// From class MNATFWPluginObserver.
// CIceNatPluginContainer::NewCandidatePairFound
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::NewCandidatePairFound( 
        const CNATFWPluginApi& aPlugin,
        CNATFWCandidatePair* aPair )
    {
    __ICEDP( "CIceNatPluginContainer::NewCandidatePairFound" )
    
    if ( aPair )
        {
        RPointerArray<MIceNatPluginEventObs>& observers = 
            *iObserversForEvent[MIceNatPluginEventObs::ECandidatePairFound];
        
        TInt numOfObservers = observers.Count();
        for ( TInt i = 0; i < numOfObservers; ++i )
            {
            CNATFWCandidatePair* pair( NULL );
            TRAP_IGNORE( ( pair = CNATFWCandidatePair::NewL( *aPair ) ) )
            if ( pair )
                {
                observers[i]->PluginEventOccured( 
                    &aPlugin,
                    aPair->LocalCandidate().StreamId(),
                    MIceNatPluginEventObs::ECandidatePairFound, 
                    KErrNone, pair );
                }
            }
        
        delete aPair;
        }
    else
        {
        __ICEDP( "CIceNatPluginContainer::NewCandidatePairFound, NULL" )
        }
    }


// ---------------------------------------------------------------------------
// From class MNATFWPluginObserver.
// CIceNatPluginContainer::NewLocalCandidateFound
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::NewLocalCandidateFound( 
        const CNATFWPluginApi& aPlugin,
        CNATFWCandidate* aCandidate )
    {
    __ICEDP( "CIceNatPluginContainer::NewLocalCandidateFound" )
    
    if ( aCandidate )
        {
        RPointerArray<MIceNatPluginEventObs>& observers = 
            *iObserversForEvent[MIceNatPluginEventObs::ELocalCandidateFound];
        
        TInt numOfObservers = observers.Count();
        for ( TInt i = 0; i < numOfObservers; ++i )
            {
            CNATFWCandidate* candidate( NULL );
            TRAP_IGNORE( ( candidate = CNATFWCandidate::NewL( *aCandidate ) ) )
            
            if ( candidate )
                {
                observers[i]->PluginEventOccured( 
                    &aPlugin,
                    candidate->StreamId(),
                    MIceNatPluginEventObs::ELocalCandidateFound, 
                    KErrNone, candidate );
                }
            }
        
        delete aCandidate;
        }
    else
        {
        __ICEDP( "CIceNatPluginContainer::NewLocalCandidateFound, NULL" )
        }
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::ResolvePluginsL
// ---------------------------------------------------------------------------
//
void CIceNatPluginContainer::ResolvePluginsL()
    {
    __ICEDP( "CIceNatPluginContainer::ResolvePluginsL" )
    
    CNATFWNatSettingsApi* natSettings = CNATFWNatSettingsApi::NewL( 
        iInitParams.iDomain );
    CleanupStack::PushL( natSettings );
    const MNATFWIceSettings& settings = natSettings->IceSettingsL();
    
    
    TInt hostPreference( MNATFWIceSettings::KPrefValueDisabled );
    settings.GetPrefValue( MNATFWIceSettings::EPrefHostCandidate,
        hostPreference );
    if ( MNATFWIceSettings::KPrefValueDisabled != hostPreference )
        {
        // Create host plugin
        CNATFWPluginApi* hostPlugin 
            = CIceHostResolver::NewL( &iInitParams );
        CleanupStack::PushL( hostPlugin );
        iPlugins.AppendL( hostPlugin );
        CleanupStack::Pop( hostPlugin );
        }
    
    // instantiate utility plugins
    const CDesC8Array& utilityPluginIds = settings.NatUtilityPlugins();
    TInt idCount( utilityPluginIds.Count() );
    __ASSERT_ALWAYS( idCount <= KMaxNumberOfUtilityPlugins, 
        User::Leave( KErrCorrupt ) );
    
    TInt stunPreference( MNATFWIceSettings::KPrefValueDisabled );
    settings.GetPrefValue( 
        MNATFWIceSettings::EPrefServerReflexiveCandidate, stunPreference );
    TInt relayPreference( MNATFWIceSettings::KPrefValueDisabled );
    settings.GetPrefValue( 
        MNATFWIceSettings::EPrefRelayCandidate, relayPreference );
    
    for ( TInt i( 0 ); i < idCount; ++i )
        {
        TPtrC8 type = ParsePluginType( utilityPluginIds[i] );
        if ( ( type.CompareF( KNatPluginTypeStun ) == 0 
                && MNATFWIceSettings::KPrefValueDisabled != stunPreference )
            || ( type.CompareF( KNatPluginTypeTurn ) == 0 
                && MNATFWIceSettings::KPrefValueDisabled != relayPreference ) )
            {
            CNATFWPluginApi* plugin = CNATFWPluginApi::NewL( 
                utilityPluginIds[i], iInitParams );
            CleanupStack::PushL( plugin );
            iPlugins.AppendL( plugin );
            CleanupStack::Pop( plugin );
            }        
        }
    
    CleanupStack::PopAndDestroy( natSettings );
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::GetConvertedEvent
// ---------------------------------------------------------------------------
//
TInt CIceNatPluginContainer::GetConvertedEvent( TNATFWPluginEvent aEvent, 
        MIceNatPluginEventObs::TNatPluginEvent& aConvertedEvent ) const
    {
    switch ( aEvent )
        {
        case MNATFWPluginObserver::EServerConnected:
            aConvertedEvent = MIceNatPluginEventObs::EServerConnected;
            break;
        case MNATFWPluginObserver::EFetchingCompleted:
            aConvertedEvent = MIceNatPluginEventObs::EFetchingCompleted;
            break;
        case MNATFWPluginObserver::ETcpConnSetupCompleted:
            aConvertedEvent = MIceNatPluginEventObs::ETcpConnSetupCompleted;
            break;
        case MNATFWPluginObserver::EReceivingActivated:
            aConvertedEvent = MIceNatPluginEventObs::EReceivingActivated;
            break;
        case MNATFWPluginObserver::EReceivingDeactivated:
            aConvertedEvent = MIceNatPluginEventObs::EReceivingDeactivated;
            break;
        case MNATFWPluginObserver::ESendingActivated:
            aConvertedEvent = MIceNatPluginEventObs::ESendingActivated;
            break;
        case MNATFWPluginObserver::ESendingDeactivated:
            aConvertedEvent = MIceNatPluginEventObs::ESendingDeactivated;
            break;
        case MNATFWPluginObserver::EConnChecksCompleted:
            aConvertedEvent = MIceNatPluginEventObs::EConnChecksCompleted;
            break;
        default:
            __ICEDP_INT1( "CIceNatPluginContainer::GetConvertedEvent DEF:",
                aEvent )
            
            return KErrArgument;
        }
    
    return KErrNone;
    }


// ---------------------------------------------------------------------------
// CIceNatPluginContainer::ParsePluginType
// ---------------------------------------------------------------------------
//
TPtrC8 CIceNatPluginContainer::ParsePluginType( 
        const TDesC8& aIdentifier ) const
    {
    TLex8 lex( aIdentifier );
    while( !lex.Eos() )
        {
        if ( lex.Get() == '.' )
            {
            lex.Mark();
            }
        }
    
    return lex.RemainderFromMark();
    }