/*

* Copyright (c) 2006 - 2008 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:    Creates connection to Connection Multiplexer and STUN client.

*                Handles connection specific issues and receives notifications

*                through implemented observers. Sends notifications to NAT FW 

*                Client through NAT Protocol Plug-in observer.

*

*/

#include "mncmconnectionmultiplexer.h"

#include <cnatfwsettingsapi.h>

#include <mnatfwserversettings.h>

#include "natfwcandidate.h"

#include "mnatfwpluginobserver.h"

#include "natfwstunbinding.h"

#include "natfwstunclient.h"

#include <mnatfwstunsettings.h>

#include "natfwstunconnectionhandler.h"

#include "natfwstunpluginlogs.h"

#include "natfwstunrefreshtimer.h"

#include "natfwstunstreamdata.h"

#include "cstunasynccallback.h"

#include "cnatfwstunserversettings.h"

const TUint KDefaultRefreshInterval = 28000000;

const TUint KDefaultStunSrvPort = 3478;

const TUint KMicrosecFactor = 1000000;

const TUint KTryAlternate = 300;

const TInt KClientSpecificError = -11000;

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

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

// C++ default constructor

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

//

CNATFWStunConnectionHandler::CNATFWStunConnectionHandler(

    const CNATFWPluginApi& aStunPlugin )

    :

    iStunRefreshInterval( KDefaultRefreshInterval ),

    iStunPlugin( aStunPlugin )

    {

    }

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

// Symbian constructor

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

//

void CNATFWStunConnectionHandler::ConstructL(

    MNATFWPluginObserver& aPluginObserver )

    {

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

    iStunRefreshTimer = CNATFWStunRefreshTimer::NewL( *this );

    iAsyncCallback = CStunAsyncCallback::NewL( iStunPlugin, aPluginObserver );

    }

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

// Symbian constructor

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

//

CNATFWStunConnectionHandler* CNATFWStunConnectionHandler::NewL( 

    const CNATFWPluginApi& aStunPlugin,

    MNATFWPluginObserver& aPluginObserver )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::NewL" )

    CNATFWStunConnectionHandler* self = CNATFWStunConnectionHandler::NewLC(

        aStunPlugin, aPluginObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian constructor

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

//

CNATFWStunConnectionHandler* CNATFWStunConnectionHandler::NewLC( 

    const CNATFWPluginApi& aStunPlugin,

    MNATFWPluginObserver& aPluginObserver )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::NewLC" )

    CNATFWStunConnectionHandler* self = new( ELeave ) 

        CNATFWStunConnectionHandler( aStunPlugin );

    CleanupStack::PushL( self );

    self->ConstructL( aPluginObserver );

    return self;

    }

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

// Destructor

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

//

CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler()

    {

    __STUNPLUGIN(

        "CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler start" )

    iServerList.ResetAndDestroy();

    delete iDomain;

    delete iNatSettings;

    iStunSettings = NULL;

    delete iStunRefreshTimer;

    TInt count( iStreamArray.Count() );

    for ( TInt index = count - 1; index >= 0; index-- )

        {

        DeleteStream( index, ETrue );

        }

    iStreamArray.Close();

    delete iStunClient;

    delete iTimerServ;

    iConnection.Close();

    iConnMux = NULL;

    delete iAsyncCallback;

    __STUNPLUGIN(

        "CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler end" )

    }

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

// CNATFWStunConnectionHandler::PluginInitializeL

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

//

void CNATFWStunConnectionHandler::PluginInitializeL(

    TUint32 aIapId,

    const TDesC8& aDomain,

    MNcmConnectionMultiplexer& aMultiplexer )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::PluginInitializeL start" )

    iConnMux = &aMultiplexer;

    iDomain = aDomain.AllocL();

    iNatSettings = CNATFWNatSettingsApi::NewL( *iDomain );

    iStunSettings = &iNatSettings->StunSettingsL();

    iNatSettings->RetrieveIapSettingsL( aIapId );

    // Generates Server list

    this->GenerateServerListL();

    __STUNPLUGIN( "CNATFWStunConnectionHandler::PluginInitializeL end" )

    }

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

// CNATFWStunConnectionHandler::ConnectServerL

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

//

void CNATFWStunConnectionHandler::ConnectServerL(

    const RSocketServ& aSocketServ,

    const TName& aConnectionName )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectServerL start" )

    iSocketServ = aSocketServ;    

    TName name( aConnectionName );

    User::LeaveIfError( iConnection.Open( iSocketServ, name ) );

    this->TryNextServerL();

    // wait MNATFWStunClientObserver::STUNClientInitCompleted

    __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectServerL end" )

    }

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

// CNATFWStunConnectionHandler::FetchCandidateL

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

//

void CNATFWStunConnectionHandler::FetchCandidateL( TUint aStreamId,

    TUint aRtoValue, TUint aAddrFamily, const TInetAddr& aBaseAddr )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL start" )

    __ASSERT_ALWAYS( iStunClient, User::Leave( KErrNotReady) );

    __ASSERT_ALWAYS(

        iStunClient->IsInitialized(), User::Leave( KErrNotReady) );

    TUint connectionId( aBaseAddr.IsUnspecified() ?

        iConnMux->CreateConnectionL( aStreamId, aAddrFamily ) :

        iConnMux->CreateConnectionL( aStreamId, aBaseAddr ) );

    TConnectionData connData;

    connData.iConnectionId = connectionId;

    connData.iStunSrvAddr.SetAddress( iStunClient->STUNServerAddrL().

        Address() );

    connData.iStunSrvAddr.SetPort( iStunClient->STUNServerAddrL().Port() );

    TInt index( IndexByStreamId( aStreamId ) );

    if ( KErrNotFound == index )

        {

        TUint32 iapID( 0 );

        TInt qos( 0 );

        // The stream is new for the plug-in

        iConnMux->RegisterIncomingConnectionObserverL( aStreamId, *this );

        iConnMux->RegisterConnectionObserverL( aStreamId, *this );

        TStreamData streamData;

        streamData.iStreamId = aStreamId;

        iConnMux->GetStreamInfoL( aStreamId, iapID, qos,

            streamData.iTransportProtocol );

        streamData.iRtoValue = aRtoValue;

        streamData.iConnArray.AppendL( connData );

        CleanupClosePushL( streamData.iConnArray );

        iStreamArray.AppendL( streamData );

        CleanupStack::Pop( &streamData.iConnArray );

        }

    else

        {

        // Store new connection for the existing stream in array

        iStreamArray[index].iConnArray.AppendL( connData );

        }

    // Accept data only from STUN server

    iConnMux->SetAcceptedFromAddressL( aStreamId, connectionId,

        connData.iStunSrvAddr );

    // Set receiving and sending state active for the created connection

    iConnMux->SetReceivingStateL( aStreamId, connectionId,

        EStreamingStateActive );

    iConnMux->SetSendingStateL( aStreamId, connectionId,

        connData.iStunSrvAddr, EStreamingStateActive );

    // wait MNcmConnectionObserver::ConnectionNotify

    __STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL end" )

    }

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

// CNATFWStunConnectionHandler::GetConnectionIdL

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

//

void CNATFWStunConnectionHandler::GetConnectionIdL(

    const CNATFWCandidate& aLocalCandidate,

    TUint aStreamId,

    TUint& aConnectionId )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::GetConnectionIdL start" )

    TInt streamInd( IndexByStreamId( aStreamId ) );

    TInt connInd( KErrNotFound );

    TBool connFound( EFalse );

    if ( KErrNotFound != streamInd )

        {

        connInd = iStreamArray[streamInd].iConnArray.Count() - 1;

        }

    while ( KErrNotFound != streamInd && !connFound && ( 0 <= connInd ) )

        {

        TConnectionData* connection = ConnectionByIndex( streamInd, connInd );

        if ( CNATFWCandidate::EServerReflexive == aLocalCandidate.Type() &&

            MatchAddresses( aLocalCandidate.Base(), connection->

            iLocalCandidate->Base() ) && MatchAddresses( aLocalCandidate.

            TransportAddr(), connection->iLocalCandidate->TransportAddr() ) )

            {

            connFound = ETrue;

            aConnectionId = connection->iConnectionId;

            }

        connInd--;

        }

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

    __STUNPLUGIN( "CNATFWStunConnectionHandler::GetConnectionIdL end" )

    }

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

// CNATFWStunConnectionHandler::StartStunRefresh

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

//

void CNATFWStunConnectionHandler::StartStunRefresh()

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::StartStunRefresh start" )

    iStunRefreshStarted = EFalse;

    iStunRefreshTimer->StartStunRefresh( iStunRefreshInterval );

    if ( iStunRefreshTimer->IsRunning() )

        {

        iStunRefreshStarted = ETrue;

        }

    __STUNPLUGIN( "CNATFWStunConnectionHandler::StartStunRefresh end" )

    }

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

// CNATFWStunConnectionHandler::CreateSTUNBindingL

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

//

void CNATFWStunConnectionHandler::CreateSTUNBindingL( TUint aStreamId, 

                                                      TUint aConnectionId )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::CreateSTUNBindingL" )

    TInt streamInd( IndexByStreamId( aStreamId ) );

    TConnectionData* connection( NULL );

    if ( KErrNotFound != streamInd )

        {

        connection = ConnectionById( streamInd, aConnectionId );

        }

    if ( connection )

        {

        CSTUNBinding* stunBinding = CSTUNBinding::NewL( *iStunClient,

                                                        aStreamId,

                                                        aConnectionId );

        CleanupStack::PushL( stunBinding );

        connection->iStunBinding = stunBinding;

        stunBinding->SendRequestL( connection->iStunSrvAddr, EFalse,

            iStreamArray[streamInd].iRtoValue );

        CleanupStack::Pop( stunBinding );

        // wait MStunClientObserver::STUNBindingEventOccurredL

        }

    }

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

// CNATFWStunConnectionHandler::SetReceivingStateL

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

//

void CNATFWStunConnectionHandler::SetReceivingStateL(

    const CNATFWCandidate& aLocalCandidate,

    TNATFWStreamingState aState )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL start" )

    TUint streamId( aLocalCandidate.StreamId() );

    TUint connId( 0 );

    TConnectionData* connection = NULL;

    TRAPD( err, GetConnectionIdL( aLocalCandidate, streamId, connId ) );

    if ( !err )

        {

        TInt streamInd( IndexByStreamId( streamId ) );

        connection = ConnectionById( streamInd, connId );

        }

    if ( connection )

        {

        if ( EStreamingStateActive == aState )

            {

            if ( connection->iReceivingActivated  )

                {

                iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                    EActiveReceiving, streamId, KErrNone, NULL );

                }

            else

                {

                iConnMux->SetReceivingStateL( streamId, connId,

                    EStreamingStateActive );

                }

            }

        else

            {

            if ( !connection->iReceivingActivated )

                {

                iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                    EDeactiveReceiving, streamId, KErrNone, NULL );

                }

            else

                {

                iConnMux->SetReceivingStateL( streamId, connId,

                    EStreamingStatePassive );

                }

            }

        }

    else

        {

        if ( EStreamingStateActive == aState )

            {

            iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                EActiveReceiving, streamId, KErrNotFound, NULL );

            }

        else

            {

            iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                EDeactiveReceiving, streamId, KErrNotFound, NULL );

            }

        }

    __STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL end" )

    }

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

// CNATFWStunConnectionHandler::SetSendingStateL

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

//

void CNATFWStunConnectionHandler::SetSendingStateL(

    const CNATFWCandidate& aLocalCandidate,

    TNATFWStreamingState aState,

    const TInetAddr& aDestAddr )

    {

    __STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL start" )

    TUint streamId( aLocalCandidate.StreamId() );

    TUint connId( 0 );

    TConnectionData* connection = NULL;

    TRAPD( err, GetConnectionIdL( aLocalCandidate, streamId, connId ) );

    if ( !err )

        {

        TInt streamInd( IndexByStreamId( streamId ) );

        connection = ConnectionById( streamInd, connId );

        }

    if ( connection )

        {

        // Client controls media connection, set address filtering

        iConnMux->SetAcceptedFromAddressL( streamId, connId, aDestAddr );

        if ( EStreamingStateActive == aState )

            {

            if ( connection->iSendingActivated && MatchAddresses(

                connection->iDestAddr, aDestAddr ) )

                {

                iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                    EActiveSending, streamId, KErrNone, NULL );

                }

            else

                {

                connection->iDestAddr.SetAddress( aDestAddr.Address() );

                connection->iDestAddr.SetPort( aDestAddr.Port() );

                iConnMux->SetSendingStateL( streamId, connId, aDestAddr,

                    EStreamingStateActive );

                }

            }

        else

            {

            if ( !connection->iSendingActivated )

                {

                iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                    EDeactiveSending, streamId, KErrNone, NULL );

                }

            else

                {

                iConnMux->SetSendingStateL( streamId, connId, aDestAddr,

                    EStreamingStatePassive );

                }

            }

        }

    else

        {

        if ( EStreamingStateActive == aState )

            {

            iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                EActiveSending, streamId, KErrNotFound, NULL );

            }

        else

            {

            iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

                EDeactiveSending, streamId, KErrNotFound, NULL );

            }

        }

    __STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL end" )

    }

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

// From base class MStunClientObserver.

// CNATFWStunConnectionHandler::STUNClientInitCompleted

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

//

void CNATFWStunConnectionHandler::STUNClientInitCompleted(

    const CSTUNClient& /*aClient*/, TInt aCompletionCode )

    {

    __STUNPLUGIN_INT1( "CNATFWStunConnectionHandler::STUNClientInitCompleted \

         start - Completion code:", aCompletionCode )

    TUint streamId( 0 );

    if ( KErrNone == aCompletionCode )

        {

        TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

            TStunPluginCallbackInfo::EConnectServer, streamId,

            aCompletionCode, NULL ) )

        }

    else

        {

        TInt error( KErrNone );

        TRAP( error, TryNextServerL() );

        if ( KErrNone != error )

            {

            delete iStunClient;

            iStunClient = NULL;

            TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

                TStunPluginCallbackInfo::EConnectServer, streamId,

                ( KClientSpecificError + aCompletionCode ), NULL ) )

            }

        }