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

    30 #include "natfwstunclient.h"

    31 #include <mnatfwturnsettings.h>

    32 

    33 #include "natfwturnconnectionhandler.h"

    34 #include "natfwturnpluginlogs.h"

    35 #include "natfwturnrefreshtimer.h"

    36 #include "natfwturnstreamdata.h"

    37 #include "natfwturnactivedestinationtimer.h"

    38 #include "cturnasynccallback.h"

    39 #include "cnatfwturnserversettings.h"

    40 

    41 #include "natfwunsafmessage.h"

    42 #include "natfwunsafmessagefactory.h"

    43 #include "natfwunsafremoteaddressattribute.h"

    44 #include "natfwunsafdataattribute.h"

    45 #include "natfwunsaftcprelaypacket.h"

    46 

    47 const TUint KDefaultStunSrvPort = 3478;

    48 const TUint KDefaultRefreshInterval = 28000000;

    49 const TUint KMicrosecFactor = 1000000;

    50 const TUint32 KWaitTimeAfterReset = 5000000;

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

    52 const TUint32 KDefaultSrvTransitioningTime = 0;

    53 const TUint32 KRetryTimeAfter439 = 5000;

    54 const TUint KNoBinding = 437;

    55 const TUint KServerTransitioning = 439;

    56 const TUint KTryAlternate = 300;

    57 const TInt KClientSpecificError = -11000;

    58 

    59 

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

    61 

    62 // ---------------------------------------------------------------------------

    63 // C++ default constructor

    64 // ---------------------------------------------------------------------------

    65 //

    66 CNATFWTurnConnectionHandler::CNATFWTurnConnectionHandler(

    67     const CNATFWPluginApi& aTurnPlugin )

    68     :

    69     iTurnPlugin( aTurnPlugin )

    70     {

    71 

    72     }

    73 

    74 

    75 // ---------------------------------------------------------------------------

    76 // Symbian constructor

    77 // ---------------------------------------------------------------------------

    78 //

    79 void CNATFWTurnConnectionHandler::ConstructL(

    80     MNATFWPluginObserver& aPluginObserver )

    81     {

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

    83     iTurnRefreshTimer = CNATFWTurnRefreshTimer::NewL( *this );

    84     iActiveDestinationTimer = CNATFWTurnActiveDestinationTimer::NewL( *this );

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

    86     }

    87 

    88 

    89 // ---------------------------------------------------------------------------

    90 // Symbian constructor

    91 // ---------------------------------------------------------------------------

    92 //

    93 CNATFWTurnConnectionHandler* CNATFWTurnConnectionHandler::NewL(

    94     const CNATFWPluginApi& aTurnPlugin,

    95     MNATFWPluginObserver& aPluginObserver )

    96     {

    97     __TURNPLUGIN( "CNATFWTurnConnectionHandler::NewL" )

    98     CNATFWTurnConnectionHandler* self = CNATFWTurnConnectionHandler::NewLC(

    99         aTurnPlugin, aPluginObserver );

   100     CleanupStack::Pop( self );

   101     return self;

   102     }

   103 

   104 

   105 // ---------------------------------------------------------------------------

   106 // Symbian constructor

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

   108 //

   109 CNATFWTurnConnectionHandler* CNATFWTurnConnectionHandler::NewLC(

   110     const CNATFWPluginApi& aTurnPlugin,

   111     MNATFWPluginObserver& aPluginObserver )

   112     {

   113     __TURNPLUGIN( "CNATFWTurnConnectionHandler::NewLC" )

   114     CNATFWTurnConnectionHandler* self =

   115         new( ELeave ) CNATFWTurnConnectionHandler( aTurnPlugin );

   116     CleanupStack::PushL( self );

   117     self->ConstructL( aPluginObserver );

   118     return self;

   119     }

   120 

   121 

   122 // ---------------------------------------------------------------------------

   123 // Destructor

   124 // ---------------------------------------------------------------------------

   125 //

   126 CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler()

   127     {

   128     __TURNPLUGIN(

   129         "CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler start" )

   130 

   131     iServerList.ResetAndDestroy();

   132 

   133     delete iDomain;

   134     delete iNatSettings;

   135     delete iTurnRefreshTimer;

   136     delete iActiveDestinationTimer;

   137 

   138     TInt count( iStreamArray.Count() );

   139     

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

   141         {

   142         DeleteStream( index, ETrue );

   143         }

   144 

   145     iStreamArray.Close();

   146     delete iStunClient;

   147     delete iTimerServ;

   148     iConnection.Close();

   149     iConnMux = NULL;

   150     delete iAsyncCallback;

   151 

   152     __TURNPLUGIN(

   153         "CNATFWTurnConnectionHandler::~CNATFWTurnConnectionHandler end" )

   154     }

   155 

   156 

   157 // ---------------------------------------------------------------------------

   158 // CNATFWTurnConnectionHandler::PluginInitializeL

   159 // ---------------------------------------------------------------------------

   160 //

   161 void CNATFWTurnConnectionHandler::PluginInitializeL(

   162     TUint32 aIapId,

   163     const TDesC8& aDomain,

   164     MNcmConnectionMultiplexer& aMultiplexer )

   165     {

   166     __TURNPLUGIN( "CNATFWTurnConnectionHandler::PluginInitializeL start" )

   167     iConnMux = &aMultiplexer;

   168     delete iDomain;

   169     iDomain = NULL;

   170     iDomain = aDomain.AllocL();

   171     delete iNatSettings;

   172     iNatSettings = NULL;

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

   174     iNatSettings->RetrieveIapSettingsL( aIapId );

   175     iTurnSettings = &iNatSettings->TurnSettingsL();

   176     

   177     // Generates Server list

   178     this->GenerateServerListL();

   179     

   180     __TURNPLUGIN( "CNATFWTurnConnectionHandler::PluginInitializeL end" )

   181     }

   182 

   183 

   184 // ---------------------------------------------------------------------------

   185 // CNATFWTurnConnectionHandler::ConnectServerL

   186 // ---------------------------------------------------------------------------

   187 //

   188 void CNATFWTurnConnectionHandler::ConnectServerL(

   189     const RSocketServ& aSocketServ,

   190     const TName& aConnectionName )

   191     {

   192     __TURNPLUGIN( "CNATFWTurnConnectionHandler::ConnectServerL start" )

   193     

   194     iSocketServ = aSocketServ;

   195     TName name( aConnectionName );

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

   197     this->TryNextServerL();

   198     

   199     // wait MNATFWStunClientObserver::STUNClientInitCompleted

   200     __TURNPLUGIN( "CNATFWTurnConnectionHandler::ConnectServerL end" )

   201     }

   202 

   203 

   204 // ---------------------------------------------------------------------------

   205 // CNATFWTurnConnectionHandler::FetchCandidateL

   206 // ---------------------------------------------------------------------------

   207 //

   208 void CNATFWTurnConnectionHandler::FetchCandidateL( TUint aStreamId,

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

   210     {

   211     __TURNPLUGIN( "CNATFWTurnConnectionHandler::FetchCandidateL start" )

   212     

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

   214     __ASSERT_ALWAYS( iStunClient->IsInitialized(), User::Leave(

   215         KErrNotReady) );

   216     

   217     TUint connectionId( aBaseAddr.IsUnspecified() ?

   218         iConnMux->CreateConnectionL( aStreamId, aAddrFamily ) :

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

   220     

   221     TConnectionData connData;

   222     connData.iConnectionId = connectionId;

   223     connData.iServerAddr.SetAddress( iStunClient->STUNServerAddrL().

   224         Address() );

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

   226     connData.iLocalAddr = iConnMux->LocalIPAddressL( aStreamId,

   227         connectionId );

   228     

   229     TInt index( IndexByStreamId( aStreamId ) );

   230     

   231     if ( KErrNotFound == index )

   232         {

   233         TUint32 iapID( 0 );

   234         TInt qos( 0 );

   235         

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

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

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

   239         iConnMux->RegisterOutgoingConnectionObserverL( aStreamId, *this );

   240         iConnMux->RegisterMessageObserverL( aStreamId, *this );

   241         

   242         TStreamData streamData;

   243         streamData.iStreamId = aStreamId;

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

   245             streamData.iTransportProtocol );

   246         streamData.iRtoValue = aRtoValue;

   247         streamData.iConnArray.AppendL( connData );

   248         CleanupClosePushL( streamData.iConnArray );

   249         iStreamArray.AppendL( streamData );

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

   251         }

   252     else

   253         {

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

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

   256         }

   257     

   258     // Accept data only from TURN server

   259     iConnMux->SetAcceptedFromAddressL( aStreamId, connectionId, 

   260         connData.iServerAddr );

   261     

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

   263     iConnMux->SetReceivingStateL( aStreamId, connectionId,

   264         EStreamingStateActive );

   265     

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

   267         EStreamingStateActive );

   268     // wait MNcmConnectionObserver::ConnectionNotify

   269     

   270     __TURNPLUGIN( "CNATFWTurnConnectionHandler::FetchCandidateL end" )

   271     }

   272 

   273 

   274 // ---------------------------------------------------------------------------

   275 // CNATFWTurnConnectionHandler::GetConnectionIdL

   276 // ---------------------------------------------------------------------------

   277 //

   278 void CNATFWTurnConnectionHandler::GetConnectionIdL(

   279     const CNATFWCandidate& aLocalCandidate,

   280     TUint aStreamId,

   281     TUint& aConnectionId )

   282     {

   283     __TURNPLUGIN( "CNATFWTurnConnectionHandler::GetConnectionIdL start" )

   284     

   285     TInt streamInd( IndexByStreamId( aStreamId ) );

   286     TInt connInd( KErrNotFound );

   287     TBool connFound( EFalse );

   288     

   289     if ( KErrNotFound != streamInd )

   290         {

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

   292         }

   293     

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

   295         {

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

   297         

   298         if ( CNATFWCandidate::ERelay == aLocalCandidate.Type() &&

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

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

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

   302             {

   303             connFound = ETrue;

   304             aConnectionId = connection->iConnectionId;

   305             }

   306         

   307         connInd--;

   308         }

   309     

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

   311     

   312     __TURNPLUGIN( "CNATFWTurnConnectionHandler::GetConnectionIdL end" )

   313     }

   314 

   315 

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

   317 // CNATFWTurnConnectionHandler::StartTurnRefresh

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

   319 //

   320 void CNATFWTurnConnectionHandler::StartTurnRefresh()

   321     {

   322     __TURNPLUGIN( "CNATFWTurnConnectionHandler::StartTurnRefresh start" )

   323     

   324     iTurnRefreshStarted = EFalse;

   325     iTurnRefreshTimer->StartTurnRefresh( iTurnRefreshInterval );

   326     

   327     if ( iTurnRefreshTimer->IsRunning() )

   328         {

   329         iTurnRefreshStarted = ETrue;

   330         }

   331 

   332     __TURNPLUGIN( "CNATFWTurnConnectionHandler::StartTurnRefresh end" )

   333     }

   334 

   335 

   336 // ---------------------------------------------------------------------------

   337 // CNATFWTurnConnectionHandler::CreateTURNBindingL

   338 // ---------------------------------------------------------------------------

   339 //

   340 void CNATFWTurnConnectionHandler::CreateTURNBindingL( TUint aStreamId,

   341                                                       TUint aConnectionId )

   342     {

   343     __TURNPLUGIN( "CNATFWTurnConnectionHandler::CreateTURNBindingL" )

   344     

   345     TInt streamInd( IndexByStreamId( aStreamId ) );

   346     TConnectionData* connection( NULL );

   347     

   348     if ( KErrNotFound != streamInd )

   349         {

   350         connection = ConnectionById( streamInd, aConnectionId );

   351         }

   352     

   353     if ( connection )

   354         {

   355         CSTUNRelayBinding* turnBinding = CSTUNRelayBinding::NewL(

   356             *iStunClient, aStreamId, aConnectionId );

   357         

   358         CleanupStack::PushL( turnBinding );

   359         delete connection->iTurnBinding;

   360         connection->iTurnBinding = turnBinding;

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

   362         CleanupStack::Pop( turnBinding );

   363         // wait MStunClientObserver::STUNBindingEventOccurredL

   364         }

   365     }

   366 

   367 

   368 // ---------------------------------------------------------------------------

   369 // CNATFWTurnConnectionHandler::SetReceivingStateL

   370 // ---------------------------------------------------------------------------

   371 //

   372 void CNATFWTurnConnectionHandler::SetReceivingStateL(

   373     const CNATFWCandidate& aLocalCandidate,

   374     TNATFWStreamingState aState )

   375     {

   376     __TURNPLUGIN( "CNATFWTurnConnectionHandler::SetReceivingStateL start" )

   377     

   378     TUint streamId( aLocalCandidate.StreamId() );

   379     TUint connId( 0 );

   380     TConnectionData* connection = NULL;

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

   382     

   383     if ( !err )

   384         {

   385         TInt streamInd( IndexByStreamId( streamId ) );

   386         connection = ConnectionById( streamInd, connId );

   387         }

   388     

   389     if ( connection )

   390         {

   391         if ( EStreamingStateActive == aState )

   392             {

   393             if ( connection->iReceivingActivated  )

   394                 {

   395                 iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   396                     EActiveReceiving, streamId, KErrNone, NULL );

   397                 }

   398             else

   399                 {

   400                 iConnMux->SetReceivingStateL( streamId, connId,

   401                     EStreamingStateActive );

   402                 }

   403             }

   404         else

   405             {

   406             if ( !connection->iReceivingActivated )

   407                 {

   408                 iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   409                     EDeactiveReceiving, streamId, KErrNone, NULL );

   410                 }

   411             else

   412                 {

   413                 iConnMux->SetReceivingStateL( streamId, connId,

   414                     EStreamingStatePassive );

   415                 }

   416             }

   417         }

   418     else

   419         {

   420         if ( EStreamingStateActive == aState )

   421             {

   422             iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   423                 EActiveReceiving, streamId, KErrNotFound, NULL );

   424             }

   425         else

   426             {

   427             iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   428                 EDeactiveReceiving, streamId, KErrNotFound, NULL );

   429             }

   430         }

   431     

   432     __TURNPLUGIN( "CNATFWTurnConnectionHandler::SetReceivingStateL end" )

   433     }

   434 

   435 

   436 // ---------------------------------------------------------------------------

   437 // CNATFWTurnConnectionHandler::SetSendingStateL

   438 // ---------------------------------------------------------------------------

   439 //

   440 void CNATFWTurnConnectionHandler::SetSendingStateL(

   441     const CNATFWCandidate& aLocalCandidate,

   442     TNATFWStreamingState aState,

   443     const TInetAddr& aDestAddr )

   444     {

   445     __TURNPLUGIN_ADDRLOG(

   446     "CNATFWTurnConnectionHandler::SetSendingStateL start",

   447         aDestAddr )

   448     

   449     TUint streamId( aLocalCandidate.StreamId() );

   450     TUint connId( 0 );

   451     TConnectionData* connection = NULL;

   452     TInt streamInd( IndexByStreamId( streamId ) );

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

   454     

   455     if ( !err )

   456         {

   457         connection = ConnectionById( streamInd, connId );

   458         }

   459     

   460     if ( connection )

   461         {

   462         if ( EStreamingStateActive == aState && TConnectionData::

   463             EActDestTransitioning == connection->iActDestState )

   464             {

   465             // Only Active Destination reset (sending passivation)

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

   467             iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   468                 EActiveSending, streamId, KErrNotReady, NULL );

   469             }

   470         else

   471             {

   472             if ( EStreamingStateActive == aState )

   473                 {

   474                 // Do Set Active Destination Request if the remote

   475                 // address differs from current active destination

   476                 

   477                 if ( !MatchAddresses( connection->iCurrentActDest,

   478                     aDestAddr ) )

   479                     {

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

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

   482                     

   483                     if ( KProtocolInetTcp == iStreamArray[streamInd].

   484                         iTransportProtocol )

   485                         {

   486                         // We need to do the Connect Request first

   487                         // and have successfull response to it.

   488                         connection->iTurnBinding->ConnectRequestL(

   489                             connection->iPeerAddr );

   490                         }

   491                     else

   492                         {

   493                         connection->iTurnBinding

   494                             ->SetActiveDestinationRequestL(

   495                                 connection->iPeerAddr, 

   496                                 connection->iTimerValue );

   497                         }

   498                     }

   499                 else

   500                     {

   501                     // No need to set this destination active again

   502                     iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   503                         EActiveSending, streamId, KErrNone, NULL );

   504                     }

   505                 }

   506             else

   507                 {

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

   509                 connection->iPeerAddr = KAFUnspec;

   510                 

   511                 connection->iTurnBinding->SetActiveDestinationRequestL(

   512                     connection->iPeerAddr, connection->iTimerValue );

   513                 }

   514             }

   515         }

   516     else

   517         {

   518         if ( EStreamingStateActive == aState )

   519             {

   520             iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   521                 EActiveSending, streamId, KErrNotFound, NULL );

   522             }

   523         else

   524             {

   525             iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   526                 EDeactiveSending, streamId, KErrNotFound, NULL );

   527             }

   528         }

   529     

   530     __TURNPLUGIN(

   531         "CNATFWTurnConnectionHandler::SetSendingStateL end" )

   532     }

   533 

   534 

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

   536 // CNATFWTurnConnectionHandler::IsRequestOrIndicationL

   537 // ---------------------------------------------------------------------------

   538 //

   539 TBool CNATFWTurnConnectionHandler::IsRequestOrIndicationL(

   540     const TDesC8& aMessage ) const

   541     {

   542     __TURNPLUGIN( "CNATFWTurnConnectionHandler::IsRequestOrIndicationL" )

   543 

   544     CNATFWUNSAFMessageFactory* decoder = CNATFWUNSAFMessageFactory::NewLC();

   545     CNATFWUNSAFMessage* msg = decoder->DecodeL( aMessage );

   546     CleanupStack::PopAndDestroy( decoder );

   547 

   548     if ( CNATFWUNSAFMessage::EAllocateRequest == msg->Type() ||

   549          CNATFWUNSAFMessage::EConnectRequest == msg->Type() ||

   550          CNATFWUNSAFMessage::ESetActiveDestinationRequest == msg->Type() ||

   551          CNATFWUNSAFMessage::ESendIndication == msg->Type() )

   552         {

   553         delete msg;

   554         return ETrue;

   555         }

   556     else

   557         {

   558         delete msg;

   559         return EFalse;

   560         }

   561     }

   562 

   563 

   564 // ---------------------------------------------------------------------------

   565 // CNATFWTurnConnectionHandler::IsTurnResponseL

   566 // ---------------------------------------------------------------------------

   567 //

   568 TBool CNATFWTurnConnectionHandler::IsTurnResponseL(

   569     const TDesC8& aMessage ) const

   570     {

   571     __TURNPLUGIN( "CNATFWTurnConnectionHandler::IsTurnResponseL" )

   572 

   573     CNATFWUNSAFMessageFactory* decoder = CNATFWUNSAFMessageFactory::NewLC();

   574     CNATFWUNSAFMessage* msg = decoder->DecodeL( aMessage );

   575     CleanupStack::PopAndDestroy( decoder );

   576 

   577     if ( CNATFWUNSAFMessage::EAllocateResponse == msg->Type() ||

   578          CNATFWUNSAFMessage::EAllocateErrorResponse == msg->Type() ||

   579          CNATFWUNSAFMessage::ESetActiveDestinationResponse == msg->Type() ||

   580          CNATFWUNSAFMessage::ESetActiveDestinationErrorResponse ==

   581             msg->Type() ||

   582          CNATFWUNSAFMessage::EConnectResponse == msg->Type() ||

   583          CNATFWUNSAFMessage::EConnectErrorResponse == msg->Type() )

   584         {

   585         delete msg;

   586         return ETrue;

   587         }

   588     else

   589         {

   590         delete msg;

   591         return EFalse;

   592         }

   593     }

   594 

   595 

   596 // ---------------------------------------------------------------------------

   597 // From base class MStunClientObserver.

   598 // CNATFWTurnConnectionHandler::STUNClientInitCompleted

   599 // ---------------------------------------------------------------------------

   600 //

   601 void CNATFWTurnConnectionHandler::STUNClientInitCompleted(

   602     const CSTUNClient& /*aClient*/,

   603     TInt aCompletionCode )

   604     {

   605     __TURNPLUGIN(

   606         "CNATFWTurnConnectionHandler::STUNClientInitCompleted start" )

   607     

   608     if ( KErrNone == aCompletionCode )

   609         {

   610         TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   611             TTurnPluginCallbackInfo::EConnectServer, 0,

   612             aCompletionCode, NULL ) )

   613         }

   614     else

   615         {

   616         TInt error( KErrNone );

   617         TRAP( error, TryNextServerL() );

   618         

   619         if ( KErrNone != error )

   620             {

   621             delete iStunClient;

   622             iStunClient = NULL;

   623             

   624             TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   625                 TTurnPluginCallbackInfo::EConnectServer, 0,

   626                 ( KClientSpecificError + aCompletionCode), NULL ) )

   627             }

   628         }

   629     

   630     __TURNPLUGIN(

   631         "CNATFWTurnConnectionHandler::STUNClientInitCompleted end" )

   632     }

   633 

   634 

   635 // ---------------------------------------------------------------------------

   636 // From base class MStunClientObserver

   637 // CNATFWTurnConnectionHandler::STUNBindingEventOccurredL

   638 // ---------------------------------------------------------------------------

   639 //

   640 void CNATFWTurnConnectionHandler::STUNBindingEventOccurredL(

   641     TSTUNBindingEvent aEvent,

   642     const CBinding& aBinding )

   643     {

   644     __TURNPLUGIN(

   645         "CNATFWTurnConnectionHandler::STUNBindingEventOccurredL start" )

   646     

   647     const CSTUNRelayBinding& turnBinding =

   648         static_cast<const CSTUNRelayBinding&>( aBinding );

   649     TUint streamId( turnBinding.StreamId() );

   650     TUint connId( turnBinding.ConnectionId() );

   651     

   652     TInt streamInd( IndexByStreamId( streamId ) );

   653     TConnectionData* connection( NULL );

   654     

   655     if ( KErrNotFound != streamInd )

   656         {

   657         connection = ConnectionById( streamInd, connId );

   658         }

   659     

   660     if ( connection )

   661         {

   662         switch ( aEvent )

   663             {

   664             case EPublicAddressResolved:

   665                 {

   666                 if ( !connection->iLocalCandidate )

   667                     {

   668                     if ( iTurnRefreshTimer && !iTurnRefreshStarted )

   669                         {

   670                         StartTurnRefresh();

   671                         }

   672                     

   673                     TInetAddr relayAddr;

   674                     relayAddr.SetAddress( turnBinding.RelayAddr().Address() );

   675                     relayAddr.SetPort( turnBinding.RelayAddr().Port() );

   676                     

   677                     __TURNPLUGIN_ADDRLOG( "CNATFWTurnConnectionHandler::\

   678                     STUNBindingEventOccurredL  Adress Resolved ADDRESS: ",

   679                         relayAddr )

   680                     

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

   682                     CleanupStack::PushL( newCandidate );

   683                     

   684                     // Set candidate parameters

   685                     newCandidate->SetStreamId( streamId );

   686                     newCandidate->SetType( CNATFWCandidate::ERelay );

   687                     newCandidate->SetBase( relayAddr );

   688                     newCandidate->SetTransportAddrL( relayAddr );

   689                     newCandidate->SetTransportProtocol(

   690                         iStreamArray[streamInd].iTransportProtocol );

   691                     

   692                     CNATFWCandidate* copyCandidate = CNATFWCandidate::NewL(

   693                         *newCandidate );

   694                     connection->iLocalCandidate = copyCandidate;

   695                     

   696                     iAsyncCallback->MakeCallbackL(

   697                         TTurnPluginCallbackInfo::ELocalCandidateFound,

   698                             streamId, KErrNone, newCandidate );

   699                     

   700                     iAsyncCallback->MakeCallbackL(

   701                         TTurnPluginCallbackInfo::EFetchingEnd, streamId,

   702                             KErrNone, NULL );

   703                     

   704                     CleanupStack::Pop( newCandidate );

   705                     }

   706                 }

   707                 break;

   708             

   709             case ECredentialsRejected:

   710                 {

   711                 __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

   712                     STUNBindingEventOccurredL  Credentials Rejected" )

   713                 

   714                 // TURN server rejected the credentials provided that were

   715                 // set with CSTUNClient::SetCredentialsL. Application

   716                 // should obtain valid credentials and then use

   717                 // CSTUNClient::SetCredentialsL.

   718                 iAsyncCallback->MakeCallbackL( TTurnPluginCallbackInfo::

   719                     EFetchingEnd, streamId, ( KClientSpecificError +

   720                         KErrPermissionDenied ), NULL );

   721 

   722                 // Remove failed entry from array

   723                 DeleteStream( streamInd, ETrue );

   724                 }

   725                 break;

   726             

   727             case ETCPConnectOk:

   728                 {

   729                 __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

   730                     STUNBindingEventOccurredL  TCP Connect Ok" )

   731                 

   732                 // After TCP connect is OK we can set Active Destination.

   733                 connection->iTurnBinding->SetActiveDestinationRequestL(

   734                     connection->iPeerAddr, connection->iTimerValue );

   735                 }

   736                 break;

   737             

   738             // Success

   739             case EActiveDestinationSet:

   740                 {

   741                 __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

   742                     STUNBindingEventOccurredL  Active Destination Set" )

   743 

   744                 if ( TConnectionData::EActDestNoneSet == connection->

   745                     iActDestState && !connection->iPeerAddr.IsUnspecified() )

   746                     {

   747                     if ( connection->iActDestAlreadySetOnServer )

   748                         {

   749                         // Active Destination was reset on server. Media

   750                         // flows in indications while trying to set the

   751                         // Active Destination again after 5 seconds.

   752                         iAsyncCallback->MakeCallbackL(

   753                             TTurnPluginCallbackInfo::EActiveSending,

   754                                 iStreamArray[streamInd].iStreamId, KErrNone,

   755                                     NULL );

   756 

   757                         iActiveDestinationTimer->StartTimer(

   758                             KWaitTimeAfterReset, iStreamArray[streamInd].

   759                                 iStreamId, connection->iConnectionId );

   760                         }

   761                     else

   762                         {

   763                         iAsyncCallback->MakeCallbackL(

   764                             TTurnPluginCallbackInfo::EActiveSending,

   765                                 iStreamArray[streamInd].iStreamId, KErrNone,

   766                                     NULL );

   767                         

   768                         iActiveDestinationTimer->StartTimer(

   769                             KDefaultSrvTransitioningTime,

   770                                 iStreamArray[streamInd].iStreamId,

   771                                     connection->iConnectionId );

   772                         

   773                         // If a successful response was received, but

   774                         // there was a REMOTE-ADDRESS in the request, the

   775                         // state machine transitions to the "Set" state

   776                         // after three seconds, and the client sets the

   777                         // active destination to the value of the REMOTE-

   778                         // ADDRESS attribute that was in the request.

   779                         }

   780                     }

   781                 

   782                 // else If, while in the "None Set" state, the client

   783                 // sent a Set Active Destination request without a

   784                 // REMOTE-ADDRESS, and got a successful response,

   785                 // there is no change in state.

   786                 

   787                 else if ( TConnectionData::EActDestSet == connection->

   788                     iActDestState )

   789                     {

   790                     if ( connection->iPeerAddr.IsUnspecified() ||

   791                         !MatchAddresses( connection->iPeerAddr, connection->

   792                         iCurrentActDest ) )

   793                         {

   794                         connection->iActDestState = TConnectionData::

   795                             EActDestTransitioning;

   796                         

   797                         // the client enters the "Transitioning" state.

   798                         // While in this state, the client MUST NOT send

   799                         // a new Set Active Destination request. The value

   800                         // of the active destination remains unchanged. In

   801                         // addition, the client sets a timer. This timer

   802                         // MUST have a value equal to the value of the

   803                         // TIMER-VAL attribute from the Set Active

   804                         // Destination response.  This is necessary for

   805                         // coordinating the state machines between client

   806                         // and server.

   807                         

   808                         iActiveDestinationTimer->StartTimer(

   809                             connection->iTimerValue, iStreamArray[streamInd].

   810                                 iStreamId, connection->iConnectionId );

   811                         }

   812                     

   813                     // In addition, if, while in the "Set" state, the

   814                     // client sends a Set Active Destination request whose

   815                     // REMOTE-ADDRESS attribute equals the current active

   816                     // destination, and that request generates a success

   817                     // response, the client remains in the "Set" state.

   818                     }

   819                 else

   820                     {

   821                     // Only Active Destination reset request can be done when

   822                     // in "Transitioning" state.

   823                     if ( connection->iPeerAddr.IsUnspecified() )

   824                         {

   825                         iActiveDestinationTimer->StartTimer( connection->

   826                             iTimerValue, iStreamArray[streamInd].iStreamId,

   827                                 connection->iConnectionId );

   828                         }

   829                     }

   830                 }

   831                 break;

   832             }

   833         }

   834 

   835     __TURNPLUGIN(

   836         "CNATFWTurnConnectionHandler::STUNBindingEventOccurredL end" )

   837     }

   838 

   839 

   840 // ---------------------------------------------------------------------------

   841 // From base class MStunClientObserver

   842 // CNATFWTurnConnectionHandler::STUNBindingErrorOccurred

   843 // ---------------------------------------------------------------------------

   844 //

   845 void CNATFWTurnConnectionHandler::STUNBindingErrorOccurred(

   846     const CBinding& aBinding,

   847     TInt aError )

   848     {

   849     __TURNPLUGIN(

   850         "CNATFWTurnConnectionHandler::STUNBindingErrorOccurred start" )

   851 

   852     const CSTUNRelayBinding& turnBinding =

   853         static_cast<const CSTUNRelayBinding&>( aBinding );

   854     TUint streamId( turnBinding.StreamId() );

   855     TUint connId( turnBinding.ConnectionId() );

   856     

   857     TInt streamInd( IndexByStreamId( streamId ) );

   858     TConnectionData* connection( NULL );

   859     

   860     if ( KErrNotFound != streamInd )

   861         {

   862         connection = ConnectionById( streamInd, connId );

   863         }

   864     

   865     if ( connection )

   866         {

   867         if ( KNoBinding == aError && connection->iLocalCandidate )

   868             {

   869             // A 437 response implies that the allocation has been

   870             // removed, and thus the state machine destroyed. A client

   871             // MUST NOT send a new Set Active Destination request prior

   872             // to the receipt of a response to the previous. The state

   873             // machine will further limit the transmission of subsequent

   874             // Set Active Destination requests.

   875             TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   876                 TTurnPluginCallbackInfo::EActiveSending, streamId,

   877                     KErrNotFound, NULL ) )

   878 

   879             // Remove entry from array as binding does not exist anymore

   880             DeleteStream( streamInd, ETrue );

   881             }

   882         else if ( KServerTransitioning == aError && connection->

   883             iLocalCandidate )

   884             {

   885             if ( TConnectionData::EActDestSet == connection->iActDestState )

   886                 {

   887                 // When this error is received, the client remains in the

   888                 // "Set" state. The client SHOULD retry its Set Active

   889                 // Destination request, but no sooner than 500ms after

   890                 // receipt of the 439 response.

   891                 iActiveDestinationTimer->StartTimer(

   892                     KRetryTimeAfter439, iStreamArray[streamInd].iStreamId,

   893                         connection->iConnectionId );

   894                 }

   895             else if ( TConnectionData::EActDestNoneSet == connection->

   896                 iActDestState )

   897                 {

   898                 // Set Active Destination request was received by the

   899                 // server over UDP. However, the active destination is

   900                 // already set to another value. The client should reset

   901                 // the active destination, wait for 5 seconds and set the

   902                 // active destination to the new value.

   903                 connection->iActDestAlreadySetOnServer = ETrue;

   904                 

   905                 TRAP_IGNORE( connection->iTurnBinding->

   906                     SetActiveDestinationRequestL( KAFUnspec, connection->

   907                         iTimerValue ) )

   908                 }

   909             else

   910                 {

   911                 // Not possible that this error occurs when in

   912                 // "transitioning" state

   913                 }

   914             }

   915         else

   916             {

   917             if ( !connection->iLocalCandidate )

   918                 {

   919                 if( KTryAlternate == aError )

   920                     {

   921                     __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

   922                     STUNBindingErrorOccurred  KTryAlternate == aError" )

   923                     

   924                     connection->iServerAddr.SetAddress( turnBinding.

   925                         AlternateServerAddr().Address() );

   926                     connection->iServerAddr.SetPort( turnBinding.

   927                         AlternateServerAddr().Port() );

   928                     

   929                     delete connection->iTurnBinding;

   930                     connection->iTurnBinding = NULL;

   931                     

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

   933                         connection->iServerAddr, EStreamingStateActive ) )

   934                     // wait MNcmConnectionObserver::ConnectionNotify

   935                     }

   936                 else

   937                     {

   938                     // If error occurs when trying to fetch candidate

   939                     TInt errcode( KClientSpecificError + ( aError ) );

   940                     TRAP_IGNORE( iAsyncCallback->MakeCallbackL(

   941                         TTurnPluginCallbackInfo::EFetchingEnd, streamId,

   942                             errcode, NULL ) )

   943                     

   944                     // Remove failed entry from array

   945                     DeleteStream( streamInd, ETrue );

   946                     }

   947                 }

   948             else

   949                 {

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

   951                 }

   952             }

   953         }

   954 

   955     __TURNPLUGIN(

   956         "CNATFWTurnConnectionHandler::STUNBindingErrorOccurred end" )

   957     }

   958 

   959 

   960 // ---------------------------------------------------------------------------

   961 // from base class MNcmIncomingConnectionObserver

   962 // CNATFWTurnConnectionHandler::IncomingMessageL

   963 // ---------------------------------------------------------------------------

   964 //

   965 void CNATFWTurnConnectionHandler::IncomingMessageL(

   966     TUint aStreamId,

   967     const TDesC8& aMessage,

   968     const TInetAddr& /*aLocalAddr*/,

   969 #ifdef _DEBUG

   970     const TInetAddr& aFromAddr,

   971     const TInetAddr& aPeerAddr,

   972 #else

   973     const TInetAddr& /*aFromAddr*/,

   974     const TInetAddr& /*aPeerAddr*/,

   975 #endif

   976     TBool& aConsumed )

   977     {

   978     __TURNPLUGIN_ADDRLOG(

   979         "CNATFWTurnConnectionHandler::IncomingMessageL FROMADDR", aFromAddr )

   980     __TURNPLUGIN_ADDRLOG(

   981         "CNATFWTurnConnectionHandler::IncomingMessageL PEERADDR", aPeerAddr )

   982     

   983     TInetAddr peerAddrFromIndication( KAFUnspec );

   984     HBufC8* indicationData( NULL );

   985     TInt consumingBindingInd( KErrNotFound );

   986     

   987     TInt streamInd( IndexByStreamId( aStreamId ) );

   988     TInt connInd( KErrNotFound );

   989     

   990     if ( KErrNotFound != streamInd )

   991         {

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

   993         }

   994     

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

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

   997         && ( 0 <= connInd ) )

   998         {

   999         __TURNPLUGIN( "CNATFWTurnConnectionHandler::IncomingMessageL\

  1000         HandleDataL method to be called" )

  1001         

  1002         TBool consumed( EFalse );

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

  1004         

  1005         if ( connection->iTurnBinding )

  1006             {

  1007             if ( indicationData )

  1008                 {

  1009                 connection->iTurnBinding->HandleDataL( *indicationData,

  1010                     consumed, peerAddrFromIndication );

  1011                 }

  1012             else

  1013                 {

  1014                 indicationData = connection->iTurnBinding->HandleDataL(

  1015                     aMessage, consumed, peerAddrFromIndication );

  1016                 }

  1017             }

  1018         

  1019         if ( consumed )

  1020             {

  1021             consumingBindingInd = connInd;

  1022             aConsumed = ETrue;

  1023             }

  1024         

  1025         connInd--;

  1026         }

  1027     

  1028     delete indicationData;

  1029     }

  1030 

  1031 

  1032 // ---------------------------------------------------------------------------

  1033 // from base class MNcmOutgoingConnectionObserver

  1034 // CNATFWTurnConnectionHandler::OutgoingMessageL

  1035 // ---------------------------------------------------------------------------

  1036 //

  1037 void CNATFWTurnConnectionHandler::OutgoingMessageL(

  1038     TUint aStreamId,

  1039     TUint aConnectionId,

  1040     const TInetAddr& aPeerAddr,

  1041     const TDesC8& aMessage,

  1042     TBool& aConsumed )

  1043     {

  1044     __TURNPLUGIN( "CNATFWTurnConnectionHandler::OutgoingMessageL" )

  1045     

  1046     aConsumed = EFalse;

  1047     

  1048     TBool controlMsgDetected( EFalse );

  1049     TRAPD( err, controlMsgDetected = IsRequestOrIndicationL( aMessage ) )

  1050     

  1051     if ( !controlMsgDetected || err ) // Prevent loopback in msg handling

  1052         {        

  1053         TInt streamInd( IndexByStreamId( aStreamId ) );

  1054         TConnectionData* connection( NULL );

  1055         

  1056         if ( KErrNotFound != streamInd )

  1057             {

  1058             connection = ConnectionById( streamInd, aConnectionId );

  1059             }

  1060         

  1061         if ( connection )

  1062             {

  1063             aConsumed = ETrue;

  1064             

  1065             if ( aPeerAddr.IsUnspecified() )

  1066                 {

  1067                 if ( TConnectionData::EActDestNoneSet == connection->

  1068                     iActDestState || TConnectionData::EActDestTransitioning ==

  1069                     connection->iActDestState )

  1070                     {

  1071                     __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

  1072                     OutgoingMessageL  Media will be sent in indication" )

  1073                     

  1074                     connection->iTurnBinding->SendIndicationL( connection->

  1075                         iPeerAddr, aMessage, EFalse );

  1076                     }

  1077                 else

  1078                     {

  1079                     __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

  1080                     OutgoingMessageL  Media will be sent directly" )

  1081                     

  1082                     if ( KProtocolInetTcp == iStreamArray[streamInd].

  1083                         iTransportProtocol )

  1084                         {

  1085                         CNATFWUNSAFTcpRelayPacket* packet =

  1086                             CNATFWUNSAFTcpRelayPacket::NewLC( aMessage,

  1087                                 CNATFWUNSAFTcpRelayPacket::EFrameTypeData);

  1088                         

  1089                         CBufBase* message = packet->EncodeL();

  1090                         CleanupStack::PopAndDestroy( packet );

  1091                         

  1092                         CleanupStack::PushL( message );

  1093                         iConnMux->SendL( aStreamId, connection->iConnectionId,

  1094                             message->Ptr(0), ETrue );

  1095                         CleanupStack::PopAndDestroy( message );

  1096                         }

  1097                     else

  1098                         {

  1099                         iConnMux->SendL( aStreamId, connection->iConnectionId,

  1100                             aMessage, ETrue );

  1101                         }

  1102                     }

  1103                 }

  1104             else

  1105                 {

  1106                 // Must be protocol message, send in indication(TURNbis-03, 4)

  1107                 __TURNPLUGIN( "CNATFWTurnConnectionHandler::\

  1108                     OutgoingMessageL  PROTOCOL MSG will be sent" )

  1109                 __TURNPLUGIN_ADDRLOG( 

  1110                     "CNATFWTurnConnectionHandler::OutgoingMessageL PEERADDR",

  1111                     aPeerAddr )

  1112                 connection->iTurnBinding->SendIndicationL( aPeerAddr,

  1113                     aMessage, EFalse );

  1114                 }

  1115             }

  1116         }

  1117     }

  1118 

  1119 

  1120 // ---------------------------------------------------------------------------

  1121 // from base class MNcmMessageObserver

  1122 // CNATFWTurnConnectionHandler::IncomingMessageNotify

  1123 // ---------------------------------------------------------------------------

  1124 //

  1125 HBufC8* CNATFWTurnConnectionHandler::IncomingMessageNotify(

  1126     TUint aStreamId,

  1127     const TDesC8& aMessage,

  1128     const TInetAddr& aLocalAddr,

  1129     const TInetAddr& aFromAddr,

  1130     TInetAddr& aPeerAddr )

  1131     {

  1132     __TURNPLUGIN( "CNATFWTurnConnectionHandler::IncomingMessageNotify" )

  1133     

  1134     HBufC8* modifiedMessage( NULL );

  1135     TRAPD( error, modifiedMessage = HandleIncomingMessageL(