1 /*

     2 * Copyright (c) 2006 - 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    Creates connection to Connection Multiplexer and STUN client.

    15 *                Handles connection specific issues and receives notifications

    16 *                through implemented observers. Sends notifications to NAT FW 

    17 *                Client through NAT Protocol Plug-in observer.

    18 *

    19 */

    20 

    21 

    22 

    23 

    24 #include "mncmconnectionmultiplexer.h"

    25 #include <cnatfwsettingsapi.h>

    26 #include <mnatfwserversettings.h>

    27 #include "natfwcandidate.h"

    28 #include "mnatfwpluginobserver.h"

    29 #include "natfwstunbinding.h"

    30 #include "natfwstunclient.h"

    31 #include <mnatfwstunsettings.h>

    32 

    33 #include "natfwstunconnectionhandler.h"

    34 #include "natfwstunpluginlogs.h"

    35 #include "natfwstunrefreshtimer.h"

    36 #include "natfwstunstreamdata.h"

    37 #include "cstunasynccallback.h"

    38 #include "cnatfwstunserversettings.h"

    39 

    40 const TUint KDefaultRefreshInterval = 28000000;

    41 const TUint KDefaultStunSrvPort = 3478;

    42 const TUint KMicrosecFactor = 1000000;

    43 const TUint KTryAlternate = 300;

    44 const TInt KClientSpecificError = -11000;

    45 

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

    47 

    48 // ---------------------------------------------------------------------------

    49 // C++ default constructor

    50 // ---------------------------------------------------------------------------

    51 //

    52 CNATFWStunConnectionHandler::CNATFWStunConnectionHandler(

    53     const CNATFWPluginApi& aStunPlugin )

    54     :

    55     iStunRefreshInterval( KDefaultRefreshInterval ),

    56     iStunPlugin( aStunPlugin )

    57     {

    58     }

    59 

    60 

    61 // ---------------------------------------------------------------------------

    62 // Symbian constructor

    63 // ---------------------------------------------------------------------------

    64 //

    65 void CNATFWStunConnectionHandler::ConstructL(

    66     MNATFWPluginObserver& aPluginObserver )

    67     {

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

    69     iStunRefreshTimer = CNATFWStunRefreshTimer::NewL( *this );

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

    71     }

    72 

    73 

    74 // ---------------------------------------------------------------------------

    75 // Symbian constructor

    76 // ---------------------------------------------------------------------------

    77 //

    78 CNATFWStunConnectionHandler* CNATFWStunConnectionHandler::NewL( 

    79     const CNATFWPluginApi& aStunPlugin,

    80     MNATFWPluginObserver& aPluginObserver )

    81     {

    82     __STUNPLUGIN( "CNATFWStunConnectionHandler::NewL" )

    83     CNATFWStunConnectionHandler* self = CNATFWStunConnectionHandler::NewLC(

    84         aStunPlugin, aPluginObserver );

    85     CleanupStack::Pop( self );

    86     return self;

    87     }

    88 

    89 

    90 // ---------------------------------------------------------------------------

    91 // Symbian constructor

    92 // ---------------------------------------------------------------------------

    93 //

    94 CNATFWStunConnectionHandler* CNATFWStunConnectionHandler::NewLC( 

    95     const CNATFWPluginApi& aStunPlugin,

    96     MNATFWPluginObserver& aPluginObserver )

    97     {

    98     __STUNPLUGIN( "CNATFWStunConnectionHandler::NewLC" )

    99     CNATFWStunConnectionHandler* self = new( ELeave ) 

   100         CNATFWStunConnectionHandler( aStunPlugin );

   101     CleanupStack::PushL( self );

   102     self->ConstructL( aPluginObserver );

   103     return self;

   104     }

   105 

   106 

   107 // ---------------------------------------------------------------------------

   108 // Destructor

   109 // ---------------------------------------------------------------------------

   110 //

   111 CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler()

   112     {

   113     __STUNPLUGIN(

   114         "CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler start" )

   115 

   116     iServerList.ResetAndDestroy();

   117 

   118     delete iDomain;

   119     delete iNatSettings;

   120     iStunSettings = NULL;

   121     delete iStunRefreshTimer;

   122 

   123     TInt count( iStreamArray.Count() );

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

   125         {

   126         DeleteStream( index, ETrue );

   127         }

   128 

   129     iStreamArray.Close();

   130     delete iStunClient;

   131     delete iTimerServ;

   132     iConnection.Close();

   133     iConnMux = NULL;

   134     delete iAsyncCallback;

   135 

   136     __STUNPLUGIN(

   137         "CNATFWStunConnectionHandler::~CNATFWStunConnectionHandler end" )

   138     }

   139 

   140 

   141 // ---------------------------------------------------------------------------

   142 // CNATFWStunConnectionHandler::PluginInitializeL

   143 // ---------------------------------------------------------------------------

   144 //

   145 void CNATFWStunConnectionHandler::PluginInitializeL(

   146     TUint32 aIapId,

   147     const TDesC8& aDomain,

   148     MNcmConnectionMultiplexer& aMultiplexer )

   149     {

   150     __STUNPLUGIN( "CNATFWStunConnectionHandler::PluginInitializeL start" )

   151 

   152     iConnMux = &aMultiplexer;

   153     iDomain = aDomain.AllocL();

   154     iNatSettings = CNATFWNatSettingsApi::NewL( *iDomain );

   155     

   156     iStunSettings = &iNatSettings->StunSettingsL();

   157     

   158     iNatSettings->RetrieveIapSettingsL( aIapId );

   159     

   160     // Generates Server list

   161     this->GenerateServerListL();

   162 

   163     __STUNPLUGIN( "CNATFWStunConnectionHandler::PluginInitializeL end" )

   164     }

   165 

   166 

   167 // ---------------------------------------------------------------------------

   168 // CNATFWStunConnectionHandler::ConnectServerL

   169 // ---------------------------------------------------------------------------

   170 //

   171 void CNATFWStunConnectionHandler::ConnectServerL(

   172     const RSocketServ& aSocketServ,

   173     const TName& aConnectionName )

   174     {

   175     __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectServerL start" )

   176     

   177     iSocketServ = aSocketServ;    

   178     TName name( aConnectionName );

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

   180     

   181     this->TryNextServerL();

   182     

   183     // wait MNATFWStunClientObserver::STUNClientInitCompleted

   184     __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectServerL end" )

   185     }

   186 

   187 

   188 // ---------------------------------------------------------------------------

   189 // CNATFWStunConnectionHandler::FetchCandidateL

   190 // ---------------------------------------------------------------------------

   191 //

   192 void CNATFWStunConnectionHandler::FetchCandidateL( TUint aStreamId,

   193     TUint aRtoValue, TUint aAddrFamily, const TInetAddr& aBaseAddr )

   194     {

   195     __STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL start" )

   196     

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

   198     __ASSERT_ALWAYS(

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

   200 

   201     TUint connectionId( aBaseAddr.IsUnspecified() ?

   202         iConnMux->CreateConnectionL( aStreamId, aAddrFamily ) :

   203         iConnMux->CreateConnectionL( aStreamId, aBaseAddr ) );

   204 

   205     TConnectionData connData;

   206     connData.iConnectionId = connectionId;

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

   208         Address() );

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

   210     

   211     TInt index( IndexByStreamId( aStreamId ) );

   212     

   213     if ( KErrNotFound == index )

   214         {

   215         TUint32 iapID( 0 );

   216         TInt qos( 0 );

   217         

   218         // The stream is new for the plug-in

   219         iConnMux->RegisterIncomingConnectionObserverL( aStreamId, *this );

   220         iConnMux->RegisterConnectionObserverL( aStreamId, *this );

   221         

   222         TStreamData streamData;

   223         streamData.iStreamId = aStreamId;

   224         iConnMux->GetStreamInfoL( aStreamId, iapID, qos,

   225             streamData.iTransportProtocol );

   226         streamData.iRtoValue = aRtoValue;

   227         streamData.iConnArray.AppendL( connData );

   228         CleanupClosePushL( streamData.iConnArray );

   229         iStreamArray.AppendL( streamData );

   230         CleanupStack::Pop( &streamData.iConnArray );

   231         }

   232     else

   233         {

   234         // Store new connection for the existing stream in array

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

   236         }

   237     

   238     // Accept data only from STUN server

   239     iConnMux->SetAcceptedFromAddressL( aStreamId, connectionId,

   240         connData.iStunSrvAddr );

   241     

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

   243     iConnMux->SetReceivingStateL( aStreamId, connectionId,

   244         EStreamingStateActive );

   245     

   246     iConnMux->SetSendingStateL( aStreamId, connectionId,

   247         connData.iStunSrvAddr, EStreamingStateActive );

   248     // wait MNcmConnectionObserver::ConnectionNotify

   249     

   250     __STUNPLUGIN( "CNATFWStunConnectionHandler::FetchCandidateL end" )

   251     }

   252 

   253 

   254 // ---------------------------------------------------------------------------

   255 // CNATFWStunConnectionHandler::GetConnectionIdL

   256 // ---------------------------------------------------------------------------

   257 //

   258 void CNATFWStunConnectionHandler::GetConnectionIdL(

   259     const CNATFWCandidate& aLocalCandidate,

   260     TUint aStreamId,

   261     TUint& aConnectionId )

   262     {

   263     __STUNPLUGIN( "CNATFWStunConnectionHandler::GetConnectionIdL start" )

   264     

   265     TInt streamInd( IndexByStreamId( aStreamId ) );

   266     TInt connInd( KErrNotFound );

   267     TBool connFound( EFalse );

   268     

   269     if ( KErrNotFound != streamInd )

   270         {

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

   272         }

   273     

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

   275         {

   276         TConnectionData* connection = ConnectionByIndex( streamInd, connInd );

   277         

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

   279             MatchAddresses( aLocalCandidate.Base(), connection->

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

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

   282             {

   283             connFound = ETrue;

   284             aConnectionId = connection->iConnectionId;

   285             }

   286         

   287         connInd--;

   288         }

   289     

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

   291     

   292     __STUNPLUGIN( "CNATFWStunConnectionHandler::GetConnectionIdL end" )

   293     }

   294 

   295 

   296 // ---------------------------------------------------------------------------

   297 // CNATFWStunConnectionHandler::StartStunRefresh

   298 // ---------------------------------------------------------------------------

   299 //

   300 void CNATFWStunConnectionHandler::StartStunRefresh()

   301     {

   302     __STUNPLUGIN( "CNATFWStunConnectionHandler::StartStunRefresh start" )

   303     

   304     iStunRefreshStarted = EFalse;

   305     iStunRefreshTimer->StartStunRefresh( iStunRefreshInterval );

   306     

   307     if ( iStunRefreshTimer->IsRunning() )

   308         {

   309         iStunRefreshStarted = ETrue;

   310         }

   311     

   312     __STUNPLUGIN( "CNATFWStunConnectionHandler::StartStunRefresh end" )

   313     }

   314 

   315 

   316 // ---------------------------------------------------------------------------

   317 // CNATFWStunConnectionHandler::CreateSTUNBindingL

   318 // ---------------------------------------------------------------------------

   319 //

   320 void CNATFWStunConnectionHandler::CreateSTUNBindingL( TUint aStreamId, 

   321                                                       TUint aConnectionId )

   322     {

   323     __STUNPLUGIN( "CNATFWStunConnectionHandler::CreateSTUNBindingL" )

   324     

   325     TInt streamInd( IndexByStreamId( aStreamId ) );

   326     TConnectionData* connection( NULL );

   327     

   328     if ( KErrNotFound != streamInd )

   329         {

   330         connection = ConnectionById( streamInd, aConnectionId );

   331         }

   332     

   333     if ( connection )

   334         {

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

   336                                                         aStreamId,

   337                                                         aConnectionId );

   338         CleanupStack::PushL( stunBinding );

   339         connection->iStunBinding = stunBinding;

   340         

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

   342             iStreamArray[streamInd].iRtoValue );

   343         

   344         CleanupStack::Pop( stunBinding );

   345         // wait MStunClientObserver::STUNBindingEventOccurredL

   346         }

   347     }

   348 

   349 

   350 // ---------------------------------------------------------------------------

   351 // CNATFWStunConnectionHandler::SetReceivingStateL

   352 // ---------------------------------------------------------------------------

   353 //

   354 void CNATFWStunConnectionHandler::SetReceivingStateL(

   355     const CNATFWCandidate& aLocalCandidate,

   356     TNATFWStreamingState aState )

   357     {

   358     __STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL start" )

   359     

   360     TUint streamId( aLocalCandidate.StreamId() );

   361     TUint connId( 0 );

   362     TConnectionData* connection = NULL;

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

   364     

   365     if ( !err )

   366         {

   367         TInt streamInd( IndexByStreamId( streamId ) );

   368         connection = ConnectionById( streamInd, connId );

   369         }

   370     

   371     if ( connection )

   372         {

   373         if ( EStreamingStateActive == aState )

   374             {

   375             if ( connection->iReceivingActivated  )

   376                 {

   377                 iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   378                     EActiveReceiving, streamId, KErrNone, NULL );

   379                 }

   380             else

   381                 {

   382                 iConnMux->SetReceivingStateL( streamId, connId,

   383                     EStreamingStateActive );

   384                 }

   385             }

   386         else

   387             {

   388             if ( !connection->iReceivingActivated )

   389                 {

   390                 iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   391                     EDeactiveReceiving, streamId, KErrNone, NULL );

   392                 }

   393             else

   394                 {

   395                 iConnMux->SetReceivingStateL( streamId, connId,

   396                     EStreamingStatePassive );

   397                 }

   398             }

   399         }

   400     else

   401         {

   402         if ( EStreamingStateActive == aState )

   403             {

   404             iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   405                 EActiveReceiving, streamId, KErrNotFound, NULL );

   406             }

   407         else

   408             {

   409             iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   410                 EDeactiveReceiving, streamId, KErrNotFound, NULL );

   411             }

   412         }

   413     

   414     __STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL end" )

   415     }

   416 

   417 

   418 // ---------------------------------------------------------------------------

   419 // CNATFWStunConnectionHandler::SetSendingStateL

   420 // ---------------------------------------------------------------------------

   421 //

   422 void CNATFWStunConnectionHandler::SetSendingStateL(

   423     const CNATFWCandidate& aLocalCandidate,

   424     TNATFWStreamingState aState,

   425     const TInetAddr& aDestAddr )

   426     {

   427     __STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL start" )

   428     

   429     TUint streamId( aLocalCandidate.StreamId() );

   430     TUint connId( 0 );

   431     TConnectionData* connection = NULL;

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

   433     

   434     if ( !err )

   435         {

   436         TInt streamInd( IndexByStreamId( streamId ) );

   437         connection = ConnectionById( streamInd, connId );

   438         }

   439     

   440     if ( connection )

   441         {

   442         // Client controls media connection, set address filtering

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

   444         

   445         if ( EStreamingStateActive == aState )

   446             {

   447             if ( connection->iSendingActivated && MatchAddresses(

   448                 connection->iDestAddr, aDestAddr ) )

   449                 {

   450                 iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   451                     EActiveSending, streamId, KErrNone, NULL );

   452                 }

   453             else

   454                 {

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

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

   457                 

   458                 iConnMux->SetSendingStateL( streamId, connId, aDestAddr,

   459                     EStreamingStateActive );

   460                 }

   461             }

   462         else

   463             {

   464             if ( !connection->iSendingActivated )

   465                 {

   466                 iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   467                     EDeactiveSending, streamId, KErrNone, NULL );

   468                 }

   469             else

   470                 {

   471                 iConnMux->SetSendingStateL( streamId, connId, aDestAddr,

   472                     EStreamingStatePassive );

   473                 }

   474             }

   475         }

   476     else

   477         {

   478         if ( EStreamingStateActive == aState )

   479             {

   480             iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   481                 EActiveSending, streamId, KErrNotFound, NULL );

   482             }

   483         else

   484             {

   485             iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::

   486                 EDeactiveSending, streamId, KErrNotFound, NULL );

   487             }

   488         }

   489     

   490     __STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL end" )

   491     }

   492 

   493 

   494 // ---------------------------------------------------------------------------

   495 // From base class MStunClientObserver.

   496 // CNATFWStunConnectionHandler::STUNClientInitCompleted

   497 // ---------------------------------------------------------------------------

   498 //

   499 void CNATFWStunConnectionHandler::STUNClientInitCompleted(

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

   501     {

   502     __STUNPLUGIN_INT1( "CNATFWStunConnectionHandler::STUNClientInitCompleted \

   503          start - Completion code:", aCompletionCode )

   504 

   505     TUint streamId( 0 );

   506    

   507     if ( KErrNone == aCompletionCode )

   508         {

   509         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   510             TStunPluginCallbackInfo::EConnectServer, streamId,

   511             aCompletionCode, NULL ) )

   512         }

   513     else

   514         {

   515         TInt error( KErrNone );

   516 

   517         TRAP( error, TryNextServerL() );

   518             

   519         if ( KErrNone != error )

   520             {

   521             delete iStunClient;

   522             iStunClient = NULL;

   523             

   524             TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   525                 TStunPluginCallbackInfo::EConnectServer, streamId,

   526                 ( KClientSpecificError + aCompletionCode ), NULL ) )

   527             }

   528         }

   529     

   530     __STUNPLUGIN(

   531         "CNATFWStunConnectionHandler::STUNClientInitCompleted end" )

   532     }

   533 

   534 

   535 // ---------------------------------------------------------------------------

   536 // From base class MStunClientObserver

   537 // CNATFWStunConnectionHandler::STUNBindingEventOccurredL

   538 // ---------------------------------------------------------------------------

   539 //

   540 void CNATFWStunConnectionHandler::STUNBindingEventOccurredL(

   541     TSTUNBindingEvent aEvent, 

   542     const CBinding& aBinding )

   543     {

   544     __STUNPLUGIN( 

   545         "CNATFWStunConnectionHandler::STUNBindingEventOccurredL start" )

   546         

   547     const CSTUNBinding& stunBinding =

   548         static_cast<const CSTUNBinding&>( aBinding );

   549     TUint streamId( stunBinding.StreamId() );

   550     TUint connId( stunBinding.ConnectionId() );

   551     

   552     TInt streamInd( IndexByStreamId( streamId ) );

   553     TConnectionData* connection( NULL );

   554     

   555     if ( KErrNotFound != streamInd )

   556         {

   557         connection = ConnectionById( streamInd, connId );

   558         }

   559     

   560     if ( connection )

   561         {

   562         switch ( aEvent )

   563             {

   564             case EPublicAddressResolved:

   565                 {

   566                 if ( !connection->iLocalCandidate )

   567                     {

   568                     if ( iStunRefreshTimer && !iStunRefreshStarted )

   569                         {

   570                         StartStunRefresh();

   571                         }

   572                     

   573                     TInetAddr publicAddr;

   574                     publicAddr.SetAddress( stunBinding.PublicAddr().

   575                         Address() );

   576                     publicAddr.SetPort( stunBinding.PublicAddr().Port() );

   577                     

   578                     __STUNPLUGIN_ADDRLOG( "CNATFWStunConnectionHandler::\

   579                     STUNBindingEventOccurredL  Adress Resolved ADDRESS: ",

   580                         publicAddr )

   581                     

   582                     CNATFWCandidate* newCandidate = CNATFWCandidate::NewL();

   583                     CleanupStack::PushL( newCandidate );

   584                     

   585                     // Set candidate parameters

   586                     newCandidate->SetStreamId( streamId );

   587                     newCandidate->SetType(

   588                         CNATFWCandidate::EServerReflexive );

   589                     TInetAddr baseAddr = iConnMux->LocalIPAddressL(

   590                         streamId, connId );

   591    

   592                     newCandidate->SetBase( baseAddr );

   593                     newCandidate->SetTransportAddrL( publicAddr );

   594                     newCandidate->SetTransportProtocol(

   595                         iStreamArray[streamInd].iTransportProtocol );

   596                     

   597                     CNATFWCandidate* copyCandidate = CNATFWCandidate::NewL(

   598                         *newCandidate );

   599                     connection->iLocalCandidate = copyCandidate;

   600                     

   601                     iAsyncCallback->MakeCallbackL(

   602                         TStunPluginCallbackInfo::ELocalCandidateFound,

   603                             streamId, KErrNone, newCandidate );

   604                     

   605                     iAsyncCallback->MakeCallbackL(

   606                         TStunPluginCallbackInfo::EFetchingEnd, streamId,

   607                         KErrNone, NULL );

   608                     

   609                     CleanupStack::Pop( newCandidate );

   610                     }

   611                 }

   612                 break;

   613 

   614             case ECredentialsRejected:

   615                 {

   616                 // STUN server rejected the credentials provided that were

   617                 // set with CSTUNClient::SetCredentialsL. Application

   618                 // should obtain valid credentials and then use

   619                 // CSTUNClient::SetCredentialsL.

   620                 iAsyncCallback->MakeCallbackL(

   621                     TStunPluginCallbackInfo::EFetchingEnd, streamId,

   622                     ( KClientSpecificError + KErrPermissionDenied ),

   623                     NULL );

   624 

   625                 // Remove failed entry from array

   626                 DeleteStream( streamInd, ETrue );

   627                 }

   628                 break;

   629             }

   630         }

   631 

   632     __STUNPLUGIN(

   633         "CNATFWStunConnectionHandler::STUNBindingEventOccurredL end" )

   634     }

   635 

   636 

   637 // ---------------------------------------------------------------------------

   638 // From base class MStunClientObserver

   639 // CNATFWStunConnectionHandler::STUNBindingErrorOccurred

   640 // ---------------------------------------------------------------------------

   641 //

   642 void CNATFWStunConnectionHandler::STUNBindingErrorOccurred(

   643     const CBinding& aBinding,

   644     TInt aError )

   645     {

   646     __STUNPLUGIN(

   647         "CNATFWStunConnectionHandler::STUNBindingErrorOccurred start" )

   648 

   649     const CSTUNBinding& stunBinding =

   650         static_cast<const CSTUNBinding&>( aBinding );

   651     TUint streamId( stunBinding.StreamId() );

   652     TUint connId( stunBinding.ConnectionId() );

   653     

   654     TInt streamInd( IndexByStreamId( streamId ) );

   655     TConnectionData* connection( NULL );

   656     

   657     if ( KErrNotFound != streamInd )

   658         {

   659         connection =  ConnectionById( streamInd, connId );

   660         }

   661     

   662     if ( connection )

   663         {

   664         if ( !connection->iLocalCandidate )

   665             {

   666             if ( KTryAlternate == aError )

   667                 {

   668                 __STUNPLUGIN( "CNATFWStunConnectionHandler::\

   669                 STUNBindingErrorOccurred  KTryAlternate == aError" )

   670                 

   671                 connection->iStunSrvAddr.SetAddress( stunBinding.

   672                     AlternateServerAddr().Address() );

   673                 connection->iStunSrvAddr.SetPort( stunBinding.

   674                     AlternateServerAddr().Port() );

   675                 

   676                 delete connection->iStunBinding;

   677                 connection->iStunBinding = NULL;

   678                 

   679                 TRAP_IGNORE( iConnMux->SetSendingStateL( streamId, connId,

   680                     connection->iStunSrvAddr, EStreamingStateActive ) )

   681                 // wait MNcmConnectionObserver::ConnectionNotify

   682                 }

   683             else

   684                 {

   685                 // If error occurs when trying to fetch candidate

   686                 TInt errcode( KClientSpecificError + ( aError ) );

   687                 TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   688                     TStunPluginCallbackInfo::EFetchingEnd, streamId,

   689                         errcode, NULL ) )

   690 

   691                 // Remove failed entry from array

   692                 DeleteStream( streamInd, ETrue );

   693                 }

   694             }

   695         else

   696             {

   697             // Do nothing if error occurs when doing binding refresh

   698             }

   699         }

   700 

   701     __STUNPLUGIN(

   702         "CNATFWStunConnectionHandler::STUNBindingErrorOccurred end" )

   703     }

   704 

   705 

   706 // ---------------------------------------------------------------------------

   707 // from base class MNcmIncomingConnectionObserver

   708 // CNATFWStunConnectionHandler::IncomingMessageL

   709 // ---------------------------------------------------------------------------

   710 //

   711 void CNATFWStunConnectionHandler::IncomingMessageL(

   712     TUint aStreamId,

   713     const TDesC8& aMessage,

   714     const TInetAddr& /*aLocalAddr*/,

   715 #ifdef _DEBUG

   716     const TInetAddr& aFromAddr,

   717     const TInetAddr& aPeerRemoteAddr,

   718 #else

   719     const TInetAddr& /*aFromAddr*/,

   720     const TInetAddr& /*aPeerRemoteAddr*/,

   721 #endif

   722     TBool& aConsumed )

   723     {

   724     __STUNPLUGIN_ADDRLOG(

   725         "CNATFWStunConnectionHandler::IncomingMessageL FROMADDR", aFromAddr )

   726     __STUNPLUGIN_ADDRLOG(

   727         "CNATFWStunConnectionHandler::IncomingMessageL PEERADDR",

   728             aPeerRemoteAddr )

   729     

   730     TInetAddr peerAddrFromIndication( KAFUnspec );

   731     HBufC8* indicationData( NULL );

   732     TInt consumingBindingInd( KErrNotFound );

   733     

   734     TInt streamInd( IndexByStreamId( aStreamId ) );

   735     TInt connInd( KErrNotFound );

   736     

   737     if ( KErrNotFound != streamInd )

   738         {

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

   740         }

   741 

   742     // Offer message for every binding in the stream until consumed

   743     while ( KErrNotFound != streamInd && KErrNotFound == consumingBindingInd

   744         && ( 0 <= connInd ) )

   745         {

   746         __STUNPLUGIN( "CNATFWStunConnectionHandler::IncomingMessageL\

   747         HandleDataL method to be called" )

   748         

   749         TBool consumed( EFalse );

   750         TConnectionData* connection = ConnectionByIndex( streamInd, connInd );

   751         

   752         if ( connection->iStunBinding )

   753             {

   754             if ( indicationData )

   755                 {

   756                 connection->iStunBinding->HandleDataL( *indicationData,

   757                     consumed, peerAddrFromIndication );

   758                 }

   759             else

   760                 {

   761                 indicationData = connection->iStunBinding->HandleDataL(

   762                     aMessage, consumed, peerAddrFromIndication );

   763                 }

   764             }

   765         

   766         if ( consumed )

   767             {

   768             consumingBindingInd = connInd;

   769             aConsumed = ETrue;

   770             }

   771         

   772         connInd--;

   773         }

   774     

   775     delete indicationData;

   776     }

   777 

   778 

   779 // ---------------------------------------------------------------------------

   780 // from base class MNcmConnectionObserver

   781 // CNATFWStunConnectionHandler::ConnectionNotify

   782 // ---------------------------------------------------------------------------

   783 //

   784 void CNATFWStunConnectionHandler::ConnectionNotify(

   785     TUint aStreamId,

   786     TUint aConnectionId,

   787     TConnectionNotifyType aType,

   788     TInt aError )

   789     {

   790     __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectionNotify start" )

   791     

   792     TInt streamInd( IndexByStreamId( aStreamId ) );

   793     TConnectionData* connection( NULL );

   794     

   795     if ( KErrNotFound != streamInd )

   796         {

   797         connection = ConnectionById( streamInd, aConnectionId );

   798         }

   799     

   800     if ( connection )

   801         {

   802         if ( aError || EConnectionError == aType )

   803             {

   804             if ( !connection->iLocalCandidate )

   805                 {

   806                 // If error occurs when trying to fetch candidate

   807                 TInt errcode( KClientSpecificError + ( aError ) );

   808                 TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   809                     TStunPluginCallbackInfo::EFetchingEnd, aStreamId, errcode,

   810                         NULL ) )

   811                 }

   812             else

   813                 {

   814                 TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   815                     TStunPluginCallbackInfo::EError, aStreamId, aError,

   816                         NULL ) )

   817                 }

   818             

   819             // Remove failed entry from array

   820             DeleteStream( streamInd, ETrue );

   821             }

   822         else

   823             {

   824             switch ( aType )

   825                 {

   826                 case ESendingActivated:

   827                     {

   828                     connection->iSendingActivated = ETrue;

   829                     

   830                     if ( connection->iLocalCandidate )

   831                         {

   832                         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   833                             TStunPluginCallbackInfo::EActiveSending,

   834                                 aStreamId, KErrNone, NULL ) )

   835                         }

   836                     else

   837                         {

   838                         // Candidate fetching ongoing

   839                         if ( !connection->iStunBinding )

   840                             {

   841                             TRAP_IGNORE( CreateSTUNBindingL( aStreamId,

   842                                 aConnectionId ) )

   843                             }

   844                         }

   845                     }

   846                     break;

   847                 

   848                 case EReceivingActivated:

   849                     {

   850                     connection->iReceivingActivated = ETrue;

   851                     

   852                     if ( connection->iLocalCandidate )

   853                         {

   854                         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   855                             TStunPluginCallbackInfo::EActiveReceiving,

   856                                 aStreamId, KErrNone, NULL ) )

   857                         }

   858                     }

   859                     break;

   860                 

   861                 case ESendingDeactivated:

   862                     {

   863                     connection->iSendingActivated = EFalse;

   864                     

   865                     if ( connection->iLocalCandidate )

   866                         {

   867                         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   868                             TStunPluginCallbackInfo::EDeactiveSending,

   869                                 aStreamId, KErrNone, NULL ) )

   870                         }

   871                     }

   872                     break;

   873                 

   874                 case EReceivingDeactivated:

   875                     {

   876                     connection->iReceivingActivated = EFalse;

   877                     

   878                     if ( connection->iLocalCandidate )

   879                         {

   880                         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   881                             TStunPluginCallbackInfo::EDeactiveReceiving,

   882                                 aStreamId, KErrNone, NULL ) )

   883                         }

   884                     }

   885                     break;

   886                 

   887                 case EConnectionRemoved:

   888                     {

   889                     DeleteStream( streamInd, EFalse );

   890                     }

   891                     break;

   892  

   893                  case EFirstMediaPacketSent:

   894                     {

   895                     connection->iMediaSendingActivated = ETrue;

   896                     }

   897                     break;                       

   898                 }

   899             }

   900         }

   901 

   902     __STUNPLUGIN( "CNATFWStunConnectionHandler::ConnectionNotify end" )

   903     }

   904 

   905 

   906 // ---------------------------------------------------------------------------

   907 // from base class MNATFWRefreshObserver

   908 // CNATFWStunConnectionHandler::BindingRefreshL

   909 // ---------------------------------------------------------------------------

   910 //

   911 void CNATFWStunConnectionHandler::BindingRefreshL()

   912     {

   913     TInt streamCount( iStreamArray.Count() );

   914     

   915     for ( TInt streamInd = 0; streamInd < streamCount; streamInd++ )

   916         {

   917         TInt connCount( iStreamArray[streamInd].iConnArray.Count() );

   918         

   919         for ( TInt connInd = 0; connInd < connCount; connInd++ )

   920             {

   921             TConnectionData* connection = ConnectionByIndex( streamInd,

   922                 connInd );

   923             

   924             if ( !connection->iMediaSendingActivated )

   925                 {

   926                 connection->iStunBinding->SendRequestL( connection->

   927                     iStunSrvAddr, EFalse, iStreamArray[streamInd].iRtoValue );

   928                 }

   929             }

   930         }

   931     }

   932 

   933 

   934 // ---------------------------------------------------------------------------

   935 // CNATFWStunConnectionHandler::DeleteStream

   936 // ---------------------------------------------------------------------------

   937 //

   938 void CNATFWStunConnectionHandler::DeleteStream( TUint aStreamInd,

   939     TBool aRemoveMuxConn )

   940     {

   941     __STUNPLUGIN( "CNATFWStunConnectionHandler::DeleteStream, start" )

   942     ASSERT( aStreamInd < TUint( iStreamArray.Count() ) );

   943     

   944     TRAP_IGNORE( 

   945         iConnMux->UnregisterIncomingConnectionObserverL(

   946             iStreamArray[aStreamInd].iStreamId, *this ) )

   947     TRAP_IGNORE( 

   948         iConnMux->UnregisterConnectionObserverL(

   949             iStreamArray[aStreamInd].iStreamId, *this ) )

   950     

   951     // Remove the stream's connections

   952     TInt connIndex( iStreamArray[aStreamInd].iConnArray.Count() - 1 );

   953     

   954     for ( TInt i( connIndex ); i >= 0; i-- )

   955         {

   956         TConnectionData* connection = ConnectionByIndex( aStreamInd, i );

   957         

   958         if( connection->iStunBinding )

   959             {

   960             connection->iStunBinding->CancelRequest();

   961             

   962             delete connection->iStunBinding;

   963             connection->iStunBinding = NULL;

   964             delete connection->iLocalCandidate;

   965             connection->iLocalCandidate = NULL;

   966             }

   967         

   968         if ( aRemoveMuxConn )

   969             {

   970             TRAP_IGNORE( iConnMux->RemoveConnectionL(

   971                 iStreamArray[aStreamInd].iStreamId, connection->

   972                     iConnectionId ) )

   973             }

   974         

   975         iStreamArray[aStreamInd].iConnArray.Remove( i );

   976         }

   977     

   978     iStreamArray[aStreamInd].iConnArray.Close();

   979     iStreamArray.Remove( aStreamInd );

   980     

   981     __STUNPLUGIN( "CNATFWStunConnectionHandler::DeleteStream, end" )

   982     }

   983 

   984 

   985 // ---------------------------------------------------------------------------

   986 // CNATFWStunConnectionHandler::IndexByStreamId

   987 // ---------------------------------------------------------------------------

   988 //

   989 TInt CNATFWStunConnectionHandler::IndexByStreamId( TUint aStreamId )

   990     {

   991     __STUNPLUGIN( "CNATFWStunConnectionHandler::IndexByStreamId" )

   992     

   993     TInt index( iStreamArray.Count() - 1 );

   994     

   995     while ( 0 <= index )

   996         {

   997         if ( aStreamId == iStreamArray[index].iStreamId )

   998             {

   999             return index;

  1000             }

  1001         

  1002         index--;

  1003         }

  1004     

  1005     return KErrNotFound;

  1006     }

  1007 

  1008 

  1009 // ---------------------------------------------------------------------------

  1010 // CNATFWStunConnectionHandler::GenerateServerListL

  1011 // ---------------------------------------------------------------------------

  1012 //

  1013 void CNATFWStunConnectionHandler::GenerateServerListL()

  1014     {

  1015     __STUNPLUGIN( "CNATFWStunConnectionHandler::GenerateServerListL start" )

  1016     

  1017     RPointerArray<MNATFWServerSettings> serverArray;

  1018     iStunSettings->GetStunServerArrayL( serverArray );

  1019     

  1020     CleanupClosePushL( serverArray );

  1021     TInt count( serverArray.Count() );

  1022     

  1023     HBufC8* serverAddress =

  1024         iStunSettings->LatestConnectedServerAddr().AllocLC();

  1025     TUint latestPort = iStunSettings->LatestConnectedServerPort();

  1026     

  1027     // Add Latest connected STUN server

  1028     if ( serverAddress->Compare( KNullDesC8 ) )

  1029         {

  1030         __STUNPLUGIN( "CNATFWStunConnectionHandler::GenerateServerListL\

  1031         - Latest stun server added" )

  1032         

  1033         CStunServerSettings* settings = CStunServerSettings::NewLC();

  1034         settings->SetAddressL( *serverAddress );

  1035         settings->SetPort( latestPort );

  1036         

  1037         for ( TInt index( 0 ); index < count; index++ )

  1038             {

  1039             if ( *serverAddress == serverArray[index]->Address() &&

  1040                 serverArray[index]->Username().Length() &&

  1041                 serverArray[index]->Password().Length() )

  1042                 {

  1043                 settings->SetUsernameL( serverArray[index]->Username() );

  1044                 settings->SetPasswordL( serverArray[index]->Password() );

  1045                 break;

  1046                 }

  1047             }

  1048         

  1049         iServerList.AppendL( settings );

  1050         CleanupStack::Pop( settings );

  1051         }

  1052     

  1053     CleanupStack::PopAndDestroy( serverAddress );

  1054     

  1055     // Add provisioned servers

  1056     for ( TInt index( 0 ); index < count; index++ )

  1057         {

  1058         CStunServerSettings* settings = CStunServerSettings::NewLC();

  1059         

  1060         settings->SetAddressL( serverArray[index]->Address() );

  1061         settings->SetPort( serverArray[index]->Port() );

  1062         

  1063         if ( serverArray[index]->Username().Length() &&

  1064             serverArray[index]->Password().Length() )

  1065             {

  1066             settings->SetUsernameL( serverArray[index]->Username() );

  1067             settings->SetPasswordL( serverArray[index]->Password() );

  1068             }

  1069         

  1070         if ( settings->Address().Compare( KNullDesC8 ) )

  1071             {

  1072             __STUNPLUGIN( "CNATFWStunConnectionHandler::GenerateServerListL\

  1073             - provisioned server added" )

  1074             iServerList.AppendL( settings );

  1075             }

  1076         

  1077         CleanupStack::Pop( settings );

  1078         }

  1079     

  1080     // Domain

  1081     CStunServerSettings* settings = CStunServerSettings::NewLC();

  1082     settings->SetAddressL( *iDomain );

  1083     settings->SetPort( ( latestPort ) ? latestPort : KDefaultStunSrvPort );

  1084     

  1085     for ( TInt index( 0 ); index < count; index++ )

  1086         {

  1087         if ( *iDomain == serverArray[index]->Address() &&

  1088             serverArray[index]->Username().Length() &&

  1089             serverArray[index]->Password().Length() )

  1090             {

  1091             settings->SetUsernameL( serverArray[index]->Username() );

  1092             settings->SetPasswordL( serverArray[index]->Password() );

  1093             break;

  1094             }

  1095         }

  1096     

  1097     iServerList.AppendL( settings );

  1098     CleanupStack::Pop( settings );

  1099     

  1100     CleanupStack::PopAndDestroy( &serverArray );

  1101     __STUNPLUGIN( "CNATFWStunConnectionHandler::GenerateServerListL end" )

  1102     }

  1103 

  1104 

  1105 // ---------------------------------------------------------------------------

  1106 // CNATFWStunConnectionHandler::TryNextServerL

  1107 // ---------------------------------------------------------------------------

  1108 //

  1109 void CNATFWStunConnectionHandler::TryNextServerL()

  1110     {

  1111     __STUNPLUGIN( "CNATFWStunConnectionHandler::TryNextServerL start" )

  1112     

  1113     delete iStunClient;

  1114     iStunClient = NULL;

  1115     

  1116     _LIT8( KZeroAddrIpv4_1, "0" );

  1117     _LIT8( KZeroAddrIpv4_2, "0.0" );

  1118     _LIT8( KZeroAddrIpv4_3, "0.0.0" );

  1119     _LIT8( KZeroAddrIpv4_4, "0.0.0.0" );

  1120     _LIT8( KZeroAddrIpv6, "::" );

  1121         

  1122     if ( iServerIndex < iServerList.Count() )

  1123         {

  1124         TInt index( iServerIndex );

  1125         iServerIndex++;

  1126         

  1127         if ( iServerList[index]->Address().Compare( KZeroAddrIpv4_1 ) == 0 || 

  1128              iServerList[index]->Address().Compare( KZeroAddrIpv4_2 ) == 0 ||

  1129              iServerList[index]->Address().Compare( KZeroAddrIpv4_3 ) == 0 ||

  1130              iServerList[index]->Address().Compare( KZeroAddrIpv4_4 ) == 0 ||

  1131              iServerList[index]->Address().Compare( KZeroAddrIpv6 ) == 0 )

  1132             {

  1133             __STUNPLUGIN("CNATFWStunConnectionHandler::TryNextServerL address\

  1134             '0.0.0.0' or '::' are not accepted, stop public IP resolving..")

  1135             User::Leave( KErrCouldNotConnect );