/*

* 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 TURN 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 "natfwstunrelaybinding.h"

#include "natfwstunclient.h"

#include <mnatfwturnsettings.h>

#include "natfwturnconnectionhandler.h"

#include "natfwturnpluginlogs.h"

#include "natfwturnrefreshtimer.h"

#include "natfwturnstreamdata.h"

#include "natfwturnactivedestinationtimer.h"

#include "cturnasynccallback.h"

#include "cnatfwturnserversettings.h"

#include "natfwunsafmessage.h"

#include "natfwunsafmessagefactory.h"

#include "natfwunsafremoteaddressattribute.h"

#include "natfwunsafdataattribute.h"

#include "natfwunsaftcprelaypacket.h"

const TUint KDefaultStunSrvPort = 3478;

const TUint KDefaultRefreshInterval = 28000000;

const TUint KMicrosecFactor = 1000000;

const TUint32 KWaitTimeAfterReset = 5000000;

// transitioning time changed from 3000000=>0 to get ICE work

const TUint32 KDefaultSrvTransitioningTime = 0;

const TUint32 KRetryTimeAfter439 = 5000;

const TUint KNoBinding = 437;

const TUint KServerTransitioning = 439;

const TUint KTryAlternate = 300;

const TInt KClientSpecificError = -11000;

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

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

// C++ default constructor

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

//

CNATFWTurnConnectionHandler::CNATFWTurnConnectionHandler(

    const CNATFWPluginApi& aTurnPlugin )

    :

    iTurnPlugin( aTurnPlugin )

    {

    }

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

// Symbian constructor

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

//

void CNATFWTurnConnectionHandler::ConstructL(

    MNATFWPluginObserver& aPluginObserver )

    {

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

    iTurnRefreshTimer = CNATFWTurnRefreshTimer::NewL( *this );

    iActiveDestinationTimer = CNATFWTurnActiveDestinationTimer::NewL( *this );

    iAsyncCallback = CTurnAsyncCallback::NewL( iTurnPlugin, aPluginObserver );

    }

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

// Symbian constructor

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

//

CNATFWTurnConnectionHandler* CNATFWTurnConnectionHandler::NewL(

    const CNATFWPluginApi& aTurnPlugin,

    MNATFWPluginObserver& aPluginObserver )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::NewL" )

    CNATFWTurnConnectionHandler* self = CNATFWTurnConnectionHandler::NewLC(

        aTurnPlugin, aPluginObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian constructor

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

//

CNATFWTurnConnectionHandler* CNATFWTurnConnectionHandler::NewLC(

    const CNATFWPluginApi& aTurnPlugin,

    MNATFWPluginObserver& aPluginObserver )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::NewLC" )

    CNATFWTurnConnectionHandler* self =

        new( ELeave ) CNATFWTurnConnectionHandler( aTurnPlugin );

    CleanupStack::PushL( self );

    self->ConstructL( aPluginObserver );

    return self;

    }

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

// Destructor

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

//

CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler()

    {

    __TURNPLUGIN(

        "CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler start" )

    iServerList.ResetAndDestroy();

    delete iDomain;

    delete iNatSettings;

    delete iTurnRefreshTimer;

    delete iActiveDestinationTimer;

    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;

    __TURNPLUGIN(

        "CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler end" )

    }

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

// CNATFWTurnConnectionHandler::PluginInitializeL

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

//

void CNATFWTurnConnectionHandler::PluginInitializeL(

    TUint32 aIapId,

    const TDesC8& aDomain,

    MNcmConnectionMultiplexer& aMultiplexer )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::PluginInitializeL start" )

    iConnMux = &aMultiplexer;

    delete iDomain;

    iDomain = NULL;

    iDomain = aDomain.AllocL();

    delete iNatSettings;

    iNatSettings = NULL;

    iNatSettings = CNATFWNatSettingsApi::NewL( *iDomain );        

    iNatSettings->RetrieveIapSettingsL( aIapId );

    iTurnSettings = &iNatSettings->TurnSettingsL();

    // Generates Server list

    this->GenerateServerListL();

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::PluginInitializeL end" )

    }

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

// CNATFWTurnConnectionHandler::ConnectServerL

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

//

void CNATFWTurnConnectionHandler::ConnectServerL(

    const RSocketServ& aSocketServ,

    const TName& aConnectionName )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::ConnectServerL start" )

    iSocketServ = aSocketServ;

    TName name( aConnectionName );

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

    this->TryNextServerL();

    // wait MNATFWStunClientObserver::STUNClientInitCompleted

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::ConnectServerL end" )

    }

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

// CNATFWTurnConnectionHandler::FetchCandidateL

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

//

void CNATFWTurnConnectionHandler::FetchCandidateL( TUint aStreamId,

    TUint aRtoValue, TUint aAddrFamily, const TInetAddr& aBaseAddr )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::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.iServerAddr.SetAddress( iStunClient->STUNServerAddrL().

        Address() );

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

    connData.iLocalAddr = iConnMux->LocalIPAddressL( aStreamId,

        connectionId );

    TInt index( IndexByStreamId( aStreamId ) );

    if ( KErrNotFound == index )

        {

        TUint32 iapID( 0 );

        TInt qos( 0 );

        // The stream is new for the plug-in

        iConnMux->RegisterConnectionObserverL( aStreamId, *this );

        iConnMux->RegisterIncomingConnectionObserverL( aStreamId, *this );

        iConnMux->RegisterOutgoingConnectionObserverL( aStreamId, *this );

        iConnMux->RegisterMessageObserverL( 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 TURN server

    iConnMux->SetAcceptedFromAddressL( aStreamId, connectionId, 

        connData.iServerAddr );

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

    iConnMux->SetReceivingStateL( aStreamId, connectionId,

        EStreamingStateActive );

    iConnMux->SetSendingStateL( aStreamId, connectionId, connData.iServerAddr,

        EStreamingStateActive );

    // wait MNcmConnectionObserver::ConnectionNotify

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::FetchCandidateL end" )

    }

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

// CNATFWTurnConnectionHandler::GetConnectionIdL

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

//

void CNATFWTurnConnectionHandler::GetConnectionIdL(

    const CNATFWCandidate& aLocalCandidate,

    TUint aStreamId,

    TUint& aConnectionId )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::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::ERelay == 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 ) );

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::GetConnectionIdL end" )

    }

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

// CNATFWTurnConnectionHandler::StartTurnRefresh

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

//

void CNATFWTurnConnectionHandler::StartTurnRefresh()

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::StartTurnRefresh start" )

    iTurnRefreshStarted = EFalse;

    iTurnRefreshTimer->StartTurnRefresh( iTurnRefreshInterval );

    if ( iTurnRefreshTimer->IsRunning() )

        {

        iTurnRefreshStarted = ETrue;

        }

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::StartTurnRefresh end" )

    }

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

// CNATFWTurnConnectionHandler::CreateTURNBindingL

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

//

void CNATFWTurnConnectionHandler::CreateTURNBindingL( TUint aStreamId,

                                                      TUint aConnectionId )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::CreateTURNBindingL" )

    TInt streamInd( IndexByStreamId( aStreamId ) );

    TConnectionData* connection( NULL );

    if ( KErrNotFound != streamInd )

        {

        connection = ConnectionById( streamInd, aConnectionId );

        }

    if ( connection )

        {

        CSTUNRelayBinding* turnBinding = CSTUNRelayBinding::NewL(

            *iStunClient, aStreamId, aConnectionId );

        CleanupStack::PushL( turnBinding );

        delete connection->iTurnBinding;

        connection->iTurnBinding = turnBinding;

        turnBinding->AllocateRequestL( iStreamArray[streamInd].iRtoValue );

        CleanupStack::Pop( turnBinding );

        // wait MStunClientObserver::STUNBindingEventOccurredL

        }

    }

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

// CNATFWTurnConnectionHandler::SetReceivingStateL

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

//

void CNATFWTurnConnectionHandler::SetReceivingStateL(

    const CNATFWCandidate& aLocalCandidate,

    TNATFWStreamingState aState )

    {

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::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( TTurnPluginCallbackInfo::

                    EActiveReceiving, streamId, KErrNone, NULL );

                }

            else

                {

                iConnMux->SetReceivingStateL( streamId, connId,

                    EStreamingStateActive );

                }

            }

        else

            {

            if ( !connection->iReceivingActivated )

                {

                iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                    EDeactiveReceiving, streamId, KErrNone, NULL );

                }

            else

                {

                iConnMux->SetReceivingStateL( streamId, connId,

                    EStreamingStatePassive );

                }

            }

        }

    else

        {

        if ( EStreamingStateActive == aState )

            {

            iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                EActiveReceiving, streamId, KErrNotFound, NULL );

            }

        else

            {

            iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                EDeactiveReceiving, streamId, KErrNotFound, NULL );

            }

        }

    __TURNPLUGIN( "CNATFWTurnConnectionHandler::SetReceivingStateL end" )

    }

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

// CNATFWTurnConnectionHandler::SetSendingStateL

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

//

void CNATFWTurnConnectionHandler::SetSendingStateL(

    const CNATFWCandidate& aLocalCandidate,

    TNATFWStreamingState aState,

    const TInetAddr& aDestAddr )

    {

    __TURNPLUGIN_ADDRLOG(

    "CNATFWTurnConnectionHandler::SetSendingStateL start",

        aDestAddr )

    TUint streamId( aLocalCandidate.StreamId() );

    TUint connId( 0 );

    TConnectionData* connection = NULL;

    TInt streamInd( IndexByStreamId( streamId ) );

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

    if ( !err )

        {

        connection = ConnectionById( streamInd, connId );

        }

    if ( connection )

        {

        if ( EStreamingStateActive == aState && TConnectionData::

            EActDestTransitioning == connection->iActDestState )

            {

            // Only Active Destination reset (sending passivation)

            // can be done when in "Transitioning" state.

            iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                EActiveSending, streamId, KErrNotReady, NULL );

            }

        else

            {

            if ( EStreamingStateActive == aState )

                {

                // Do Set Active Destination Request if the remote

                // address differs from current active destination

                if ( !MatchAddresses( connection->iCurrentActDest,

                    aDestAddr ) )

                    {

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

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

                    if ( KProtocolInetTcp == iStreamArray[streamInd].

                        iTransportProtocol )

                        {

                        // We need to do the Connect Request first

                        // and have successfull response to it.

                        connection->iTurnBinding->ConnectRequestL(

                            connection->iPeerAddr );

                        }

                    else

                        {

                        connection->iTurnBinding

                            ->SetActiveDestinationRequestL(

                                connection->iPeerAddr, 

                                connection->iTimerValue );

                        }

                    }

                else

                    {

                    // No need to set this destination active again

                    iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                        EActiveSending, streamId, KErrNone, NULL );

                    }

                }

            else

                {

                // Plug-in's client wants to reset Active Destination.

                connection->iPeerAddr = KAFUnspec;

                connection->iTurnBinding->SetActiveDestinationRequestL(

                    connection->iPeerAddr, connection->iTimerValue );

                }

            }

        }

    else

        {

        if ( EStreamingStateActive == aState )

            {

            iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                EActiveSending, streamId, KErrNotFound, NULL );

            }

        else

            {

            iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

                EDeactiveSending, streamId, KErrNotFound, NULL );

            }

        }