/*

* Copyright (c) 2006-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 "natfwunsafserverresolver.h"

#include "natfwunsafserverresolverobserver.h"

#include "cnatfwunsaficmpreceiver.h"

#include "natfwunsaflog.h"

#include "casynccallback.h"

#include "stunassert.h"

#include "cstunclientimplementation.h"

#include "cstunclientresolvingtcp.h"

#include "cstunclientresolvingtls.h"

#include "cstunclientresolvingudp.h"

#include "cstunclientgetsharedsecret.h"

#include "cstunclientready.h"

#include "cstunclientrenewsharedsecret.h"

#include "natfwstunbinding.h"

#include "cstunbindingimplementation.h"

#include "ctransactionidgenerator.h"

#include "cstunsharedsecret.h"

#include "cstuncredentials.h"

#include "cstuncredentials.h"

_LIT8( KUdp, "udp" );

_LIT8( KTcp, "tcp" );

_LIT8( KTls, "tls" );

const TUint KTlsPort = 443;

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

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

// CSTUNClientImplementation::NewL

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

//

CSTUNClientImplementation*

CSTUNClientImplementation::NewL( CSTUNClient& aClient,

                                 TInt aRetransmitInterval,

                                 const TDesC8& aServerAddress,

                                 TUint aServerPort,

                                 const TDesC8& aServiceName,

                                 RSocketServ& aSocketServ,

                                 RConnection& aConnection,

                                 CDeltaTimer& aTimer,

                                 MSTUNClientObserver& aObserver,

                                 TBool aObtainSharedSecret,

                                 TBool aFailIfNoSRVRecordsFound,

                                 TBool aIcmpReceiverUsed,

                                 MNcmConnectionMultiplexer* aMultiplexer,

                                 TTransportProtocol aTransportProtocol )

    {

    CSTUNClientImplementation* self =

        new ( ELeave ) CSTUNClientImplementation( aClient,

                                                  aRetransmitInterval,

                                                  aServerPort,

                                                  aSocketServ,

                                                  aConnection,

                                                  aTimer,

                                                  aObserver,

                                                  aObtainSharedSecret,

                                                  aMultiplexer,

                                                  aTransportProtocol );

    CleanupStack::PushL( self );

    self->ConstructL( aServerAddress, aServiceName, 

                      aFailIfNoSRVRecordsFound, aIcmpReceiverUsed );

    CleanupStack::Pop( self );

    return self;    

    }

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

// CSTUNClientImplementation::NewL - overloaded for ICE conn check usage

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

//

CSTUNClientImplementation*

CSTUNClientImplementation::NewL( CSTUNClient& aClient,

                                 TInt aRetransmitInterval,

                                 CDeltaTimer& aTimer,

                                 MSTUNClientObserver& aObserver,

                                 MNcmConnectionMultiplexer* aMultiplexer,

                                 TTransportProtocol aTransportProtocol )

    {

    CSTUNClientImplementation* self =

        new ( ELeave ) CSTUNClientImplementation( aClient,

                                                  aRetransmitInterval,

                                                  aTimer,

                                                  aObserver,

                                                  aMultiplexer,

                                                  aTransportProtocol );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;    

    }

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

// CSTUNClientImplementation::CSTUNClientImplementation

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

//

CSTUNClientImplementation::CSTUNClientImplementation(

    CSTUNClient& aClient,

    TInt aRetransmitInterval,

    TUint aServerPort,

    RSocketServ& aSocketServ,

    RConnection& aConnection,

    CDeltaTimer& aTimer,

    MSTUNClientObserver& aObserver,

    TBool aObtainSharedSecret,

    MNcmConnectionMultiplexer* aMultiplexer,

    TTransportProtocol aTransportProtocol ) :

    CSTUNTimerUser( aTimer ),

    iClient( aClient ),

    iRetransmitInterval( aRetransmitInterval ),

    iServerPort( aServerPort ? aServerPort : EDefaultSTUNPort ),

    iSocketServer( aSocketServ ),

    iConnection( aConnection ),    

    iObserver( aObserver ),

    iObtainSharedSecret( aObtainSharedSecret ),

    iMultiplexer( aMultiplexer ),

    iTransportProtocol( aTransportProtocol )

#ifdef TEST_EUNIT

    , iTcpAddresses( 1 ),

    iUdpAddresses( 1 )

#endif

    {    

    }

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

// CSTUNClientImplementation::CSTUNClientImplementation - overloaded

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

//

CSTUNClientImplementation::CSTUNClientImplementation(

    CSTUNClient& aClient,

    TInt aRetransmitInterval,

    CDeltaTimer& aTimer,

    MSTUNClientObserver& aObserver,

    MNcmConnectionMultiplexer* aMultiplexer,

    TTransportProtocol aTransportProtocol ) :

    CSTUNTimerUser( aTimer ),

    iClient( aClient ),

    iRetransmitInterval( aRetransmitInterval ),

    iSocketServer( *( RSocketServ* )0x1 ),

    iConnection( *( RConnection* )0x1 ),

    iObserver( aObserver ),

    iMultiplexer( aMultiplexer ),

    iTransportProtocol( aTransportProtocol )

    {

    }

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

// CSTUNClientImplementation::CSTUNClientImplementation

// Dummy implementation. Default constructor is declared private and not used.

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

//

CSTUNClientImplementation::CSTUNClientImplementation() :

    CSTUNTimerUser( *( CDeltaTimer* )0x1 ),        

    iClient( *( CSTUNClient* )0x1 ),

    iSocketServer( *( RSocketServ* )0x1 ),

    iConnection( *( RConnection* )0x1 ),

    iObserver( *( MSTUNClientObserver* )0x1 )

    {

    }

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

// CSTUNClientImplementation::CSTUNClientImplementation

// Dummy implementation. Copy constructor is declared private and not used.

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

//

CSTUNClientImplementation::CSTUNClientImplementation(

    const CSTUNClientImplementation& aImplementation ) :

    CSTUNTimerUser( *( CDeltaTimer* )0x1 ),

    iClient( aImplementation.iClient ),

    iSocketServer( aImplementation.iSocketServer ),

    iConnection( aImplementation.iConnection ),

    iObserver( aImplementation.iObserver )

    {

    }

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

// CSTUNClientImplementation::ConstructL

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

//

void CSTUNClientImplementation::ConstructL( const TDesC8& aServerAddress,

                                            const TDesC8& aServiceName,

                                            TBool aFailIfNoSRVRecordsFound,

                                            TBool aIcmpReceiverUsed )

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::ConstructL IN" )

    __ASSERT_ALWAYS( aServerAddress.Length() > 0, 

        User::Leave( KErrArgument ) );

    __STUNTURNCLIENT_STR8( "CSTUNClientImplementation stunserver=",

        aServerAddress )

    iServerAddress = aServerAddress.AllocL();

    __STUNTURNCLIENT_STR8( "CSTUNClientImplementation servicename=",

        aServiceName )

    iServiceName = aServiceName.AllocL();

    iAsyncCallback = CAsyncCallback::NewL( iObserver );

    iResolver = CNATFWUNSAFServerResolver::NewL( iSocketServer,

                                                 iConnection,

                                                 *this,

                                                 aFailIfNoSRVRecordsFound );

    iTransactionIDGenerator = CTransactionIDGenerator::NewL();

    if ( aIcmpReceiverUsed )

        {

        iIcmpReceiver = CIcmpReceiver::NewL( *this, iSocketServer );

        }

    iRenewSharedSecret = new ( ELeave ) CSTUNClientRenewSharedSecret;

    iReady = new ( ELeave ) CSTUNClientReady( *iRenewSharedSecret );

    iGetSharedSecret = new ( ELeave ) CSTUNClientGetSharedSecret( *iReady );

    iResolvingUDP = new ( ELeave ) CSTUNClientResolvingUDP( *iGetSharedSecret,

                                                            *iReady );

    if ( iObtainSharedSecret )

        {

        iResolvingTLS = new ( ELeave ) 

            CSTUNClientResolvingTLS( *iResolvingUDP );

        iResolvingTCP = new ( ELeave ) 

            CSTUNClientResolvingTCP( *iResolvingTLS, *iResolvingUDP );

        }

    else

        {

        iResolvingTCP = new ( ELeave )

            CSTUNClientResolvingTCP( *iResolvingUDP );

        }

    iRenewSharedSecret->SetNeighbourStates( *iReady );

    if ( iServiceName->Compare( KStunRelay ) == 0 && iObtainSharedSecret )

        {

        ChangeState( iResolvingTLS );

        ResolveAddressL( KTls, iTcpAddresses, KTlsPort, KStunRelay );

        }

    else if ( iObtainSharedSecret )

        {

        ChangeState( iResolvingTCP );

        ResolveAddressL( KTcp, iTcpAddresses, iServerPort, *iServiceName );

        }

    else

        {

        ChangeState( iResolvingUDP );

        ResolveUdpL();

        }

    __STUNTURNCLIENT( "CSTUNClientImplementation::ConstructL OUT" )

    }

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

// CSTUNClientImplementation::ConstructL - overloaded for ICE conn check usage

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

//

void CSTUNClientImplementation::ConstructL( )

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::ConstructL for ICE" )

    TInetAddr defaultAddr;

    defaultAddr.SetAddress( KInetAddrAll );

    // Make state machine work with hack

    iUdpAddresses.AppendL( defaultAddr );

    iObtainSharedSecret = EFalse;

    iAsyncCallback = CAsyncCallback::NewL( iObserver );

    iTransactionIDGenerator = CTransactionIDGenerator::NewL();

    iRenewSharedSecret = new ( ELeave ) CSTUNClientRenewSharedSecret;

    iReady = new ( ELeave ) CSTUNClientReady( *iRenewSharedSecret );

    iGetSharedSecret = new ( ELeave ) CSTUNClientGetSharedSecret( *iReady );

    iResolvingUDP = new ( ELeave ) CSTUNClientResolvingUDP( *iGetSharedSecret,

                                                            *iReady );

    iResolvingTCP = new ( ELeave ) CSTUNClientResolvingTCP( *iResolvingUDP );

    iRenewSharedSecret->SetNeighbourStates( *iReady );

    ChangeState( iReady );

    // do not send notify, act as syncronous

    }

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

// CSTUNClientImplementation::~CSTUNClientImplementation

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

//

CSTUNClientImplementation::~CSTUNClientImplementation()

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::~CSTUNClientImplementation" )

    TInt count( iBindings.Count() );

    if ( count > 0 )

        {

        for ( TInt i = 0; i < count; ++i ) // check that ++i

            {        

            iBindings[i]->Implementation().DetachClient();

            }

        }

    iBindings.Close();    

    FreeResolverResources();

    delete iAsyncCallback;

    delete iResolvingTLS;

    delete iResolvingTCP;

    delete iResolvingUDP;

    delete iGetSharedSecret;

    delete iReady;

    delete iRenewSharedSecret;

    delete iTransactionIDGenerator;

    delete iSharedSecret;

    delete iCredentials;

    delete iIcmpReceiver;

    delete iTimer;

    delete iServiceName;

    iTcpAddresses.Close();

    iUdpAddresses.Close();

    delete iServerAddress;

    iMultiplexer = NULL;

    iState = NULL;

    __STUNTURNCLIENT( "CSTUNClientImplementation::\

    ~CSTUNClientImplementation end" )

    }

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

// CSTUNClientImplementation::CompletedL

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

//

void CSTUNClientImplementation::CompletedL()

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::CompletedL" )

    __TEST_INVARIANT;

    if ( iState )

        {

        iState->ResolvingCompletedL( *this, iObtainSharedSecret );

        }

    __TEST_INVARIANT;

    __STUNTURNCLIENT( "CSTUNClientImplementation::CompletedL end" )

    }

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

// CSTUNClientImplementation::ErrorOccured

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

//

void CSTUNClientImplementation::ErrorOccured( TInt aError )

    {

    __STUNTURNCLIENT_INT1( "CSTUNClientImplementation::ErrorOccured: "

        , aError )

    __TEST_INVARIANT;

    if ( iState )

        {

        if ( aError != KErrNoMemory )

            {

            aError = KErrNATFWDnsFailure;

            }

        iState->ResolvingFailed( *this, aError );

        }

    __TEST_INVARIANT;    

    __STUNTURNCLIENT( "CSTUNClientImplementation::ErrorOccured end" )

    }

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

// CSTUNClientImplementation::IcmpError

// Don't compare aAddress to iUdpAddresses, as some binding may still have an

// address that has been removed from iUdpAddresses if another binding called

// ObtainServerAddress.

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

//

void CSTUNClientImplementation::IcmpError( const TInetAddr& aAddress )

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::IcmpError" )

    __TEST_INVARIANT;

    for ( TInt i = 0; i < iBindings.Count(); ++i )

        {

        iBindings[i]->Implementation().IcmpError( aAddress );

        }

    RemoveAddress( aAddress );

    __TEST_INVARIANT;

    __STUNTURNCLIENT( "CSTUNClientImplementation::IcmpError end" )

    }

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

// CSTUNClientImplementation::SharedSecretObtainedL

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

//

void CSTUNClientImplementation::SharedSecretObtainedL()

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::SharedSecretObtainedL" )

    __TEST_INVARIANT;

    if ( iState )

        {        

        iState->SharedSecretReceivedL( *this );

        }

    __TEST_INVARIANT;

    __STUNTURNCLIENT( "CSTUNClientImplementation::SharedSecretObtainedL end" )

    }

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

// CSTUNClientImplementation::SharedSecretErrorL

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

//

void CSTUNClientImplementation::SharedSecretErrorL( TInt aError )

    {

    __STUNTURNCLIENT( "CSTUNClientImplementation::SharedSecretErrorL" )

    __TEST_INVARIANT;

    if ( iState )

        {

        iState->SharedSecretErrorL( *this, aError );

        }

    __TEST_INVARIANT;

    __STUNTURNCLIENT( "CSTUNClientImplementation::SharedSecretErrorL end" )

    }

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

// CSTUNClientImplementation::STUNClient

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

//

const CSTUNClient& CSTUNClientImplementation::STUNClient() const

    {

    __TEST_INVARIANT;

    return iClient;

    }

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

// CSTUNClientImplementation::TimerProvider

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

//

CDeltaTimer& CSTUNClientImplementation::TimerProvider()

    {

    __TEST_INVARIANT;

    return DeltaTimer();

    }

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

// CSTUNClientImplementation::RetransmitInterval

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

//

TInt CSTUNClientImplementation::RetransmitInterval() const

    {

    __TEST_INVARIANT;

    return iRetransmitInterval;

    }

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

// CSTUNClientImplementation::TransportProtocol

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

//

TTransportProtocol CSTUNClientImplementation::TransportProtocol() const

    {

    __TEST_INVARIANT;

    return iTransportProtocol;

    }

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

// CSTUNClientImplementation::AddressResolvedL

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

//

void CSTUNClientImplementation::AddressResolvedL(

    const CBinding& aBinding ) const

    {

    __TEST_INVARIANT;

    iAsyncCallback->MakeCallbackL( TSTUNCallbackInfo::EEventAddressResolvedL,

                                   &aBinding );

    }

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

// CSTUNClientImplementation::ObtainSharedSecretL

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

//

void CSTUNClientImplementation::ObtainSharedSecretL( CBinding& aBinding )

    {

    __TEST_INVARIANT;

    __ASSERT_ALWAYS( iState != NULL, User::Leave( KErrServerTerminated ) );

    iState->ObtainSharedSecretL( *this, aBinding );

    __TEST_INVARIANT;

    }

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

// CSTUNClientImplementation::SharedSecretRejectedL

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

//

TBool

CSTUNClientImplementation::SharedSecretRejectedL( const CBinding& aBinding,

                                                  const TDesC8& aUsername,

                                                  const TDesC8& aPassword )

    {

    __TEST_INVARIANT;

    return iState && iState->SharedSecretRejectedL( *this,

                                                    aBinding,

                                                    aUsername,