1 /*

     2 * Copyright (c) 2007 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:    

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include "stunassert.h"

    22 #include "natfwunsaflog.h"

    23 #include "natfwunsafmessagefactory.h"

    24 #include "natfwunsafbindingrequest.h"

    25 #include "natfwunsafallocaterequest.h"

    26 #include "natfwunsafconnectrequest.h"

    27 #include "natfwunsafsetactivedestinationrequest.h"

    28 #include "natfwunsafsendindication.h"

    29 #include "cstunrelaybindingimplementation.h"

    30 #include "natfwstunbinding.h"

    31 #include "cstunbindinginit.h"

    32 #include "cstunbindinggetsharedsecret.h"

    33 #include "cstunbindinggetaddress.h"

    34 #include "cstunbindingactive.h"

    35 #include "cstunbindingwaittoretry.h"

    36 #include "mstunbindingobserver.h"

    37 #include "cstuntransaction.h"

    38 #include "stunutils.h"

    39 #include "natfwstunclientdefs.h"

    40 #include "cstunindicationtransmitter.h"

    41 #include "natfwunsaftcprelaypacketfactory.h"

    42 

    43 // Attributes

    44 #include "natfwunsafusernameattribute.h"

    45 #include "natfwunsafxoronlyattribute.h"

    46 #include "natfwunsafunknownattributesattribute.h"

    47 #include "natfwunsafmagiccookieattribute.h"

    48 #include "natfwunsafdataattribute.h"

    49 #include "natfwunsafremoteaddressattribute.h"

    50 #include "natfwunsafusecandidateattribute.h"

    51 #include "natfwunsafpriorityattribute.h"

    52 #include "natfwunsaficecontrollingattribute.h"

    53 #include "natfwunsaficecontrolledattribute.h"

    54 #include "natfwunsafalternateserverattribute.h"

    55 #include "natfwunsafrealmattribute.h"

    56 #include "natfwunsafnonceattribute.h"

    57 

    58 

    59 

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

    61 

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

    63 // CSTUNRelayBindingImplementation::NewL

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

    65 //

    66 CSTUNRelayBindingImplementation*

    67     CSTUNRelayBindingImplementation::NewL( CBinding& aBinding,  

    68                                            MSTUNBindingObserver& aClient,

    69                                            RSocket& aSocket )

    70     {

    71 

    72     CSTUNRelayBindingImplementation* self =

    73     new ( ELeave ) CSTUNRelayBindingImplementation( aBinding, aClient, aSocket );

    74     CleanupStack::PushL( self );

    75     self->ConstructL();

    76     CleanupStack::Pop( self );

    77     return self;

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // CSTUNRelayBindingImplementation::NewL - overloaded

    82 // ---------------------------------------------------------------------------

    83 //

    84 CSTUNRelayBindingImplementation*

    85     CSTUNRelayBindingImplementation::NewL( CBinding& aBinding,  

    86                                            MSTUNBindingObserver& aClient,

    87                                            TUint aStreamId,

    88                                            TUint aConnectionId,

    89                                            MNcmConnectionMultiplexer* aMux )

    90     {

    91 

    92     CSTUNRelayBindingImplementation* self =

    93     new ( ELeave ) CSTUNRelayBindingImplementation( aBinding, aClient, aStreamId, 

    94                                                aConnectionId, aMux );

    95     CleanupStack::PushL( self );

    96     self->ConstructL( );

    97     CleanupStack::Pop( self );

    98     return self;

    99     }

   100 

   101 // ---------------------------------------------------------------------------

   102 // CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation

   103 // ---------------------------------------------------------------------------

   104 //

   105 CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation(

   106     CBinding& aBinding,

   107     MSTUNBindingObserver& aClient,

   108     RSocket& aSocket ) :

   109     CBindingImplementation( aClient, aBinding, aSocket )

   110     {

   111     }

   112 

   113 // ---------------------------------------------------------------------------

   114 // CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation

   115 // ---------------------------------------------------------------------------

   116 //

   117 CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation( 

   118     CBinding& aBinding,

   119     MSTUNBindingObserver& aClient, 

   120     TUint aStreamId,

   121     TUint aConnectionId,

   122     MNcmConnectionMultiplexer* aMux ) :

   123     CBindingImplementation( aClient, aBinding, aStreamId, aConnectionId, aMux )

   124     {

   125     }

   126     

   127 // ---------------------------------------------------------------------------

   128 // CSTUNRelayBindingImplementation::ConstructL

   129 // ---------------------------------------------------------------------------

   130 //

   131 void CSTUNRelayBindingImplementation::ConstructL()

   132     {

   133     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::ConstructL" )

   134     ClientL().AttachBindingL( iBinding );

   135 

   136     iGetAddress = new ( ELeave ) CSTUNBindingGetAddress();

   137     iGetSharedSecret =

   138     new ( ELeave ) CSTUNBindingGetSharedSecret( *iGetAddress );

   139     iInit = new ( ELeave ) CSTUNBindingInit( *iGetSharedSecret );

   140     iActive = new ( ELeave ) CSTUNBindingActive( *iGetSharedSecret );

   141     iWaitToRetry = new ( ELeave ) CSTUNBindingWaitToRetry( *iGetSharedSecret );

   142     iGetAddress->SetNeighbourStates( *iGetSharedSecret,

   143                                      *iWaitToRetry,

   144                                      *iActive );

   145     

   146     iIndicationTx = CStunIndicationTransmitter::NewL( *iMux, 

   147                                                       iStreamId, 

   148                                                       iConnectionId );

   149     ChangeState( *iInit );

   150     }

   151 

   152 // ---------------------------------------------------------------------------

   153 // CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation

   154 // ---------------------------------------------------------------------------

   155 //

   156 CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation()

   157     {

   158     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation" )

   159     if ( iClient )

   160         {

   161         iClient->DetachBinding( iBinding );

   162         }

   163 

   164     this->FreeRequestData();

   165 

   166     delete iInit;

   167     delete iGetSharedSecret;

   168     delete iGetAddress;

   169     delete iWaitToRetry;

   170     delete iActive;

   171     delete iIndicationTx;

   172     

   173     iSocket = NULL;

   174     iMux = NULL;

   175     

   176     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation exit" )

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // CSTUNRelayBindingImplementation::TimerExpiredL

   181 // -----------------------------------------------------------------------------

   182 //

   183 void CSTUNRelayBindingImplementation::TimerExpiredL()

   184     {

   185     iState->TimerExpiredL( *this );

   186     }

   187 

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

   189 // CSTUNRelayBindingImplementation::LeaveFromTimerExpired

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

   191 //

   192 void CSTUNRelayBindingImplementation::LeaveFromTimerExpired( TInt aError )

   193     {

   194     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::LeaveFromTimerExpired" )

   195     __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

   196 

   197     Terminate( aError );

   198     }

   199 

   200 // ---------------------------------------------------------------------------

   201 // CSTUNRelayBindingImplementation::PublicAddressObtainedL

   202 // ---------------------------------------------------------------------------

   203 //

   204 void CSTUNRelayBindingImplementation::PublicAddressObtainedL( 

   205     const TInetAddr& aAddress )

   206     {

   207     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::PublicAddressObtainedL 1" )

   208     iState->PublicAddressReceivedL( *this, aAddress );

   209     }

   210 

   211 // ---------------------------------------------------------------------------

   212 // CSTUNRelayBindingImplementation::PublicAddressObtainedL

   213 // ---------------------------------------------------------------------------

   214 //

   215 void CSTUNRelayBindingImplementation::PublicAddressObtainedL( 

   216     const TInetAddr& aReflexiveAddr, const TInetAddr& aRelayAddr )

   217     {

   218     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::PublicAddressObtainedL 2" )

   219     iState->PublicAddressReceivedL( *this, aReflexiveAddr, aRelayAddr );

   220     }

   221 

   222 // ---------------------------------------------------------------------------

   223 // CSTUNRelayBindingImplementation::TransactionError

   224 // ---------------------------------------------------------------------------

   225 //

   226 void CSTUNRelayBindingImplementation::TransactionError( TInt aError,

   227     CNATFWUNSAFUnknownAttributesAttribute* aUnknownAttr )

   228     {

   229     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::TransactionError" )

   230     delete iUnknownAttr;

   231     iUnknownAttr = aUnknownAttr;

   232 

   233     __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

   234     iState->TransactionError( *this, aError );

   235     }

   236 

   237 // ---------------------------------------------------------------------------

   238 // CSTUNRelayBindingImplementation::TransactionEventOccurredL

   239 // ---------------------------------------------------------------------------

   240 //

   241 void CSTUNRelayBindingImplementation::TransactionEventOccurredL( 

   242     TSTUNCallbackInfo::TFunction aEvent )

   243     {

   244     __STUNTURNCLIENT_INT1( 

   245         "CSTUNRelayBindingImplementation::TransactionEventOccurredL event:",

   246              aEvent )

   247     if ( ESetActiveDestinationRequest == iRequestType )

   248         {

   249         *iTimerValue = iTransaction->TimerValue();

   250         }

   251     

   252     FreeRequestData();

   253     ChangeState( *iActive );

   254     ClientL().BindingEventOccurred( iBinding, aEvent );

   255     }

   256 

   257 // ---------------------------------------------------------------------------

   258 // CSTUNRelayBindingImplementation::HandleTransactionError

   259 // ---------------------------------------------------------------------------

   260 //  

   261 TBool CSTUNRelayBindingImplementation::HandleTransactionError( TInt aError )

   262     {

   263     __STUNTURNCLIENT_INT1( "HandleTransactionError, reason", aError )

   264        

   265     const TInt KMaxErrorResponseCount = 3;

   266 

   267     __STUN_ASSERT_RETURN_VALUE( iRequest && aError != KErrNone,

   268     EFalse );

   269     

   270     delete iTransaction;

   271     iTransaction = NULL;

   272     iTransactionError = aError;

   273 

   274     if ( ( aError > 0 ) && ( ++iErrorResponseCount >= KMaxErrorResponseCount ) )

   275         {

   276         iErrorResponseCount = 0;

   277         return EFalse;

   278         }

   279         

   280     CNATFWUNSAFAlternateServerAttribute* alternateServer = NULL;

   281     HBufC8* realmValue = NULL;

   282     

   283     switch ( aError )

   284         {

   285         case KErrTimedOut:

   286             __STUNTURNCLIENT( 

   287                 "CSTUNRelayBindingImplementation - KErrTimedOut" )

   288             //Clear iAddXorOnly as another address is tried

   289             iAddXorOnly = EFalse;

   290             return iClient && iClient->ObtainServerAddress( iServerAddress );

   291         

   292         case E300TryAlternate:

   293             // The client SHOULD attempt a new transaction to the server

   294             // indicated in the ALTERNATE-SERVER attribute.

   295             alternateServer = static_cast<CNATFWUNSAFAlternateServerAttribute*>

   296             ( iRequest->Attribute( CNATFWUNSAFAttribute::EAlternateServer ) );

   297             if ( alternateServer )

   298                 {

   299                 iServerAddress = alternateServer->Address();

   300                 return ETrue;

   301                 }

   302             return EFalse;

   303         

   304         case E4XX:

   305             return EFalse;

   306                         

   307         case E401Unauthorized:        

   308             if ( iSharedSecret )

   309                 {                                              

   310                 CNATFWUNSAFRealmAttribute* realm = 

   311                     static_cast<CNATFWUNSAFRealmAttribute*>

   312                     ( iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) );

   313                 if ( realm || !iRealmFromResponse )

   314                     {

   315                     // indicates that this was retry and it did not work.

   316                     // notify client -> unrecoverable error

   317                     return EFalse;                   

   318                     }

   319                 }

   320             return ETrue;    

   321 

   322         case E420UnknownAttributes:

   323             //Remove the unknown attributes and retry

   324             return iUnknownAttr != NULL;

   325                             

   326         case E430StaleCredentials:

   327             // Client used a short term credential that has expired so

   328             // generate a new Shared Secret request            

   329             return iSharedSecret != NULL;

   330 

   331         case E431IntegrityCheckFailure:

   332             {

   333             TBool retry = EFalse;

   334             TRAPD( err, retry =

   335                 ClientL().SharedSecretRejectedL( iBinding,

   336                                                  Username(),

   337                                                  *iSharedSecret ) );

   338             return err == KErrNone && retry;

   339             }

   340                     

   341         case E432MissingUsername:

   342             //If missing USERNAME or MESSAGE-INTEGRITY, add them and retry

   343             return !iRequest->Attribute( CNATFWUNSAFAttribute::EUsername ) ||

   344                !iSharedSecret;

   345                

   346         case E433UseTLS:

   347             // If request was a Shared Secret request and wasn't sent over

   348             // TLS, the client SHOULD retry the request with TLS.

   349             return iSharedSecret != NULL;

   350 

   351         case E434MissingRealm:

   352             if ( !iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) &&

   353                  iSharedSecret )

   354                 {

   355                 // use a long term credential and retry the request using the username

   356                 // and password associated with the REALM

   357                 return ETrue;

   358                 }

   359                 

   360             TRAPD( err, realmValue = ( static_cast<CNATFWUNSAFRealmAttribute*>

   361                 ( iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) ) )->

   362                 Value().AllocL() );

   363             if ( err || !realmValue )

   364                 {

   365                 delete realmValue;

   366                 return EFalse;

   367                 }

   368                 

   369             if (  KErrNone != realmValue->Compare( *iRealmFromResponse ) )

   370                 {

   371                 // the client SHOULD retry using the username and 

   372                 // password associated with the REALM in the response

   373                 iUseRealmFromResponse = ETrue;

   374                 delete realmValue;

   375                 return ETrue;

   376                 }

   377             delete realmValue;           

   378             return EFalse;                                    

   379               

   380  

   381         case E435MissingNonce:

   382             if ( iRequest->Attribute( CNATFWUNSAFAttribute::ENonce ) )

   383                 {

   384                 return EFalse; 

   385                 }

   386             // retry using a nonce from error response                

   387             return ETrue;

   388                       

   389         case E436UnknownUsername:

   390             if ( iSharedSecret )

   391                 {

   392                 return ETrue;                

   393                 }

   394             // If the username was collected from the user, alert the user.

   395             return EFalse;

   396 

   397         case E437NoBindind:

   398             // There is none yet in place

   399             return EFalse;

   400 

   401         case E438StaleNonce:                                  

   402             if ( iRequest->Attribute( CNATFWUNSAFAttribute::ENonce ) )

   403                 {

   404                 // retry using a nonce from error response

   405                 return ETrue;

   406                 }

   407             return EFalse;

   408             

   409         case E439Transitioning:

   410             // The client should reset the active destination, wait for 

   411             // 5 seconds and set the active destination to the new value.

   412             return EFalse;

   413             

   414         case E442UnsupportedTransportProtocol:

   415 

   416             return EFalse;

   417                     

   418         case E443InvalidIPAddress:

   419             

   420             return EFalse;           

   421             

   422         case E444InvalidPort:

   423         

   424             return EFalse;

   425 

   426         case E445OperationForTCPOnly:

   427 

   428             return EFalse;

   429 

   430         case E446ConnectionAlreadyExists:

   431          

   432             return EFalse;

   433             

   434         case E486AllocationQuotaReached:

   435             // The user or client is not authorized to request additional

   436             // allocations.          

   437             return EFalse;

   438 

   439         case E500ServerError:               

   440             return ETrue;  

   441                                       

   442         case E507InsufficientCapacity:

   443             // The server cannot allocate a new port for this client as it has

   444             // exhausted its relay capacity.        

   445             return EFalse;

   446 

   447         case E600GlobalFailure:

   448             return EFalse; 

   449 

   450         case ERetryAfterAddingXorOnly:

   451             iAddXorOnly = ETrue;

   452             return ETrue;

   453 

   454         default:

   455             return STUNUtils::Is5xxResponse( aError );

   456         }

   457 

   458     }

   459 

   460 // ---------------------------------------------------------------------------

   461 // CSTUNRelayBindingImplementation::IcmpError

   462 // ---------------------------------------------------------------------------

   463 //

   464 void CSTUNRelayBindingImplementation::IcmpError( const TInetAddr& aAddress )

   465     {

   466     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::IcmpError" )

   467     if ( iTransaction && iServerAddress.CmpAddr( aAddress ) )

   468         {

   469         //Try next address, or terminate with KErrTimedOut.

   470         iTransaction->Terminate( KErrTimedOut );

   471         }

   472     }

   473 

   474 // ---------------------------------------------------------------------------

   475 // CSTUNRelayBindingImplementation::AllocateRequestL

   476 // ---------------------------------------------------------------------------

   477 //

   478 void CSTUNRelayBindingImplementation::AllocateRequestL( TUint /*aRtoValue*/ )

   479     {

   480     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::AllocateRequestL" )

   481     iRequestType = EAllocateRequest;

   482     iState->SendRequestL( *this );

   483     }

   484 

   485 // ---------------------------------------------------------------------------

   486 // CSTUNRelayBindingImplementation::SetActiveDestinationRequestL

   487 // ---------------------------------------------------------------------------

   488 //

   489 void CSTUNRelayBindingImplementation::SetActiveDestinationRequestL( 

   490     const TInetAddr& aRemoteAddr, TUint32& aTimerValue )

   491     {

   492     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SetActiveDestinationRequestL" )

   493     

   494     iRequestType = ESetActiveDestinationRequest;

   495     iRemoteAddr = aRemoteAddr;

   496     iTimerValue = NULL;

   497     iTimerValue = &aTimerValue;

   498     iState->SendRequestL( *this );

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CSTUNRelayBindingImplementation::SendIndicationL

   503 // ---------------------------------------------------------------------------

   504 //

   505 void CSTUNRelayBindingImplementation::SendIndicationL( 

   506     const TInetAddr& aRemoteAddr, const TDesC8& aData, 

   507     TBool /*aAddFingerprint*/ )

   508     {

   509     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SendIndicationL" )

   510     

   511     TNATFWUNSAFTransactionID transactionID;

   512     ClientL().ObtainTransactionIDL( transactionID );

   513     

   514     CNATFWUNSAFMessage* 

   515         indication = CNATFWUNSAFSendIndication::NewL( transactionID );

   516     CleanupStack::PushL( indication );

   517     

   518     indication->AddAttributeL( CNATFWUNSAFDataAttribute::NewLC( aData ) );

   519     CleanupStack::Pop(); // CNATFWUNSAFDataAttribute

   520     

   521     indication->AddAttributeL( CNATFWUNSAFRemoteAddressAttribute::NewLC( 

   522         aRemoteAddr ) );

   523     CleanupStack::Pop(); // CNATFWUNSAFRemoteAddressAttribute

   524     

   525 

   526     if ( iUnknownAttr )

   527         {

   528         STUNUtils::RemoveUnknownAttributes( *indication, *iUnknownAttr );

   529         delete iUnknownAttr;

   530         iUnknownAttr = NULL;

   531         }

   532         

   533     if ( ETcpProtocol == ClientL().TransportProtocol() )

   534         {

   535         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SendIndicationL TCP" )

   536         

   537         CBufBase* message = indication->EncodeL();

   538         CleanupStack::PushL( message );

   539         CNATFWUNSAFTcpRelayPacket* packet = 

   540             CNATFWUNSAFTcpRelayPacket::NewLC( message->Ptr( 0 ),

   541             CNATFWUNSAFTcpRelayPacket::EFrameTypeStun );

   542 

   543         iIndicationTx->TransmitL( *packet );

   544         CleanupStack::PopAndDestroy( packet );

   545         CleanupStack::PopAndDestroy( message );

   546         }

   547     else

   548         {

   549         iIndicationTx->TransmitL( *indication );

   550         }

   551 

   552     CleanupStack::PopAndDestroy( indication );

   553     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SendIndicationL exit" )

   554     }

   555 

   556 // ---------------------------------------------------------------------------

   557 // CSTUNRelayBindingImplementation::ConnectRequestL

   558 // ---------------------------------------------------------------------------

   559 //

   560 void CSTUNRelayBindingImplementation::ConnectRequestL( 

   561     const TInetAddr& aRemoteAddr )

   562     {

   563     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::ConnectRequestL" )

   564     iRemoteAddr = aRemoteAddr;

   565     iRequestType = ETCPConnectRequest;

   566     iState->SendRequestL( *this );

   567     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::ConnectRequestL end" )

   568     }

   569 

   570 // ---------------------------------------------------------------------------

   571 // CSTUNRelayBindingImplementation::StreamId

   572 // ---------------------------------------------------------------------------

   573 //

   574 TUint CSTUNRelayBindingImplementation::StreamId() const

   575     {

   576     return iStreamId;

   577     }

   578     

   579 // ---------------------------------------------------------------------------

   580 // CSTUNRelayBindingImplementation::ConnectionId

   581 // ---------------------------------------------------------------------------

   582 //

   583 TUint CSTUNRelayBindingImplementation::ConnectionId() const

   584     {

   585     return iConnectionId;

   586     }

   587 

   588 // ---------------------------------------------------------------------------

   589 // CSTUNRelayBindingImplementation::CancelRequest

   590 // If transaction exists, delete it to stop using the socket.

   591 // ---------------------------------------------------------------------------

   592 //

   593 void CSTUNRelayBindingImplementation::CancelRequest()

   594     {

   595     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::CancelRequest" )

   596     if ( AddressResolved() )

   597         {

   598         ChangeState( *iActive );

   599         }

   600     else

   601         {

   602         //The initial request is canceled

   603         ChangeState( *iInit );

   604         }

   605 

   606     delete iTransaction;

   607     iTransaction = NULL;

   608     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::CancelRequest end" )

   609     }

   610 

   611 // ---------------------------------------------------------------------------

   612 // CSTUNRelayBindingImplementation::Socket

   613 // ---------------------------------------------------------------------------

   614 //

   615 const RSocket& CSTUNRelayBindingImplementation::Socket() const

   616     {

   617     return *iSocket;

   618     }

   619 

   620 // ---------------------------------------------------------------------------

   621 // CSTUNRelayBindingImplementation::AddressResolved

   622 // The most recent public address is kept also during a refresh.

   623 // ---------------------------------------------------------------------------

   624 //

   625 TBool CSTUNRelayBindingImplementation::AddressResolved() const

   626     {

   627     return !iPublicAddr.IsUnspecified();

   628     }

   629 

   630 // ---------------------------------------------------------------------------

   631 // CSTUNRelayBindingImplementation::PublicAddr

   632 // ---------------------------------------------------------------------------

   633 //

   634 const TInetAddr& CSTUNRelayBindingImplementation::PublicAddr() const

   635     {

   636     return iPublicAddr;

   637     }

   638     

   639 // ---------------------------------------------------------------------------

   640 // CSTUNRelayBindingImplementation::AlternateServerAddr

   641 // ---------------------------------------------------------------------------

   642 //

   643 const TInetAddr& CSTUNRelayBindingImplementation::AlternateServerAddr() const

   644     {

   645     return iServerAddress;

   646     }

   647     

   648 // ---------------------------------------------------------------------------

   649 // CSTUNRelayBindingImplementation::RealmFromResponse

   650 // ---------------------------------------------------------------------------

   651 //

   652 const HBufC8* CSTUNRelayBindingImplementation::RealmFromResponse() const

   653     {

   654     return iRealmFromResponse;

   655     }          

   656 

   657 // ---------------------------------------------------------------------------

   658 // CSTUNRelayBindingImplementation::HandleDataL

   659 // Must NOT leave, if aData is not a STUN message!

   660 // ---------------------------------------------------------------------------

   661 //

   662 HBufC8* CSTUNRelayBindingImplementation::HandleDataL(

   663     const TDesC8& aData, TBool& aConsumed, TInetAddr& aRemoteAddr )

   664     {

   665     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::HandleDataL" )

   666     aConsumed = EFalse;

   667     TInt err( KErrNone );

   668     HBufC8* dataPointer = NULL;

   669     CNATFWUNSAFMessage* msg = NULL;    

   670     CNATFWUNSAFTcpRelayPacket* relayPacket = NULL;

   671     

   672     if ( ETcpProtocol == ClientL().TransportProtocol() )

   673         {

   674         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::HandleDataL - TCP" )

   675         

   676         TRAP( err, relayPacket = DecodeTcpRelayMessageL( aData ) );

   677         CleanupStack::PushL( relayPacket );

   678         

   679         if ( KErrNone == err && relayPacket && 

   680              CNATFWUNSAFTcpRelayPacket::EFrameTypeStun == relayPacket->Type() )

   681             {

   682             TRAP( err, msg = DecodeMessageL( relayPacket->Data() ) );

   683             if ( KErrNoMemory == err )

   684                 {

   685                 User::Leave( err );

   686                 }

   687             CleanupStack::PopAndDestroy( relayPacket );

   688             }

   689         else if ( relayPacket && 

   690                   CNATFWUNSAFTcpRelayPacket::EFrameTypeData == relayPacket->Type() )

   691             {

   692             HBufC8* ptr = relayPacket->Data().AllocL();

   693             CleanupStack::PopAndDestroy( relayPacket ); 

   694             return ptr;

   695             }

   696         else if ( KErrNoMemory == err )

   697             {

   698             User::Leave( err );

   699             }

   700         else

   701             {            

   702             __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::HandleDataL -\

   703                 Tcp framing invalid!" )

   704                 

   705             CleanupStack::PopAndDestroy( relayPacket );

   706             return NULL;

   707             }

   708         }

   709     else

   710         {

   711         TRAP( err, msg = DecodeMessageL( aData ) );

   712         if ( KErrNoMemory == err )

   713             {

   714             User::Leave( err );

   715             }

   716         }

   717     if ( msg )

   718         {

   719         CleanupStack::PushL( msg );

   720         CNATFWUNSAFRealmAttribute* realm = static_cast<CNATFWUNSAFRealmAttribute*>(

   721             msg->Attribute( CNATFWUNSAFAttribute::ERealm ) );          

   722         if ( realm )

   723             {

   724             delete iRealmFromResponse;

   725             iRealmFromResponse = NULL;

   726             const TDesC8& realmValue = ( static_cast<CNATFWUNSAFRealmAttribute*>(

   727                 msg->Attribute( CNATFWUNSAFAttribute::ERealm ) )->Value() );

   728             iRealmFromResponse = realmValue.AllocL();

   729             __STUNTURNCLIENT_STR8( "realm: ", *iRealmFromResponse )

   730             }

   731             

   732         CNATFWUNSAFNonceAttribute* nonce = static_cast<CNATFWUNSAFNonceAttribute*>(

   733             msg->Attribute( CNATFWUNSAFAttribute::ENonce ) );        

   734         if ( nonce )

   735             {

   736             delete iNonce;

   737             iNonce = NULL;

   738             const TDesC8& nonceValue = ( static_cast<CNATFWUNSAFNonceAttribute*>(

   739             msg->Attribute( CNATFWUNSAFAttribute::ENonce ) )->Value() );

   740             iNonce = nonceValue.AllocL();

   741             }

   742 

   743         // if aData contains data indication, decode it

   744         if ( msg->Type() == CNATFWUNSAFMessage::EDataIndication &&

   745              KErrNone == err )

   746             {

   747             const TDesC8& data = ( static_cast<CNATFWUNSAFDataAttribute*>(

   748                 msg->Attribute( CNATFWUNSAFAttribute::EData ) )->Value() );

   749 

   750             // Remote address is returned through reference

   751             CNATFWUNSAFRemoteAddressAttribute* remoteAddress =

   752                 static_cast<CNATFWUNSAFRemoteAddressAttribute*>

   753                 ( msg->Attribute( CNATFWUNSAFAttribute::ERemoteAddress ) );

   754 

   755             if( remoteAddress )

   756                 {

   757                 aRemoteAddr = remoteAddress->Address();

   758                 }

   759             else

   760                 {

   761                 remoteAddress = NULL;

   762                 }

   763 

   764             CNATFWUNSAFMessage* msg_unsaf = NULL;

   765 

   766             dataPointer = data.AllocLC(); // to cleanupstack

   767 

   768             TRAP( err, msg_unsaf = DecodeMessageL( *dataPointer ) );

   769             CleanupStack::PushL( msg_unsaf );

   770             if ( KErrNoMemory == err )

   771             	{

   772             	User::Leave( err );

   773             	}

   774             // if we have outstanding transaction, offer data to it

   775             if ( iTransaction && iRequest && !err && msg_unsaf )

   776                 {

   777                 if ( ValidateMsgType( msg_unsaf ) &&

   778                      iRequest->TransactionID() == msg_unsaf->TransactionID() )

   779                     {

   780                     // Data was encapsulated in data indication.

   781                     // Data is consumed. dataPointer is not needed.

   782                     aConsumed = ETrue;

   783                     iTransaction->ReceiveL( *msg_unsaf, *dataPointer );

   784                     CleanupStack::PopAndDestroy( msg_unsaf );

   785                     CleanupStack::PopAndDestroy( dataPointer );

   786                     dataPointer = NULL;

   787                     }

   788                 }

   789 

   790             if ( dataPointer )

   791                 {

   792                 // dataPointer is still valid. This means that message was not

   793                 // consumed, and data indication is ripped off from it.

   794                 // Message can also contain media data.

   795                 // Data indication is decapsulated out of that message.

   796                 CleanupStack::PopAndDestroy( msg_unsaf );

   797                 CleanupStack::Pop( dataPointer );

   798                 }

   799             }

   800 

   801         // Data was NOT in encapsulated in data indication, so offer

   802         // message to this client.

   803         else if ( KErrNone == err && iTransaction && iRequest )

   804             {

   805             if ( ValidateMsgType( msg ) &&

   806                  iRequest->TransactionID() == msg->TransactionID() )

   807                 {

   808                 aConsumed = ETrue;

   809                 iTransaction->ReceiveL( *msg, aData );

   810                 }

   811             }

   812         else

   813             {

   814             // for PCLint approval

   815             }

   816         CleanupStack::PopAndDestroy( msg );

   817         }

   818 

   819     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::HandleDataL end" )

   820 

   821     // if there is not any outstanding transaction, data does not belong

   822     // to this client. Pointer to decoded data IS NOT returned.

   823     return dataPointer;

   824     }

   825 

   826 

   827 // ---------------------------------------------------------------------------

   828 // CSTUNRelayBindingImplementation::STUNClient

   829 // ---------------------------------------------------------------------------

   830 //

   831 const CSTUNClient* CSTUNRelayBindingImplementation::STUNClient() const

   832     {

   833     return iClient ? &iClient->STUNClient() : NULL;

   834     }

   835 

   836 // ---------------------------------------------------------------------------

   837 // CSTUNRelayBindingImplementation::GetServerAddressL

   838 // ---------------------------------------------------------------------------

   839 //

   840 void CSTUNRelayBindingImplementation::GetServerAddressL()

   841     {

   842     __ASSERT_ALWAYS( iServerAddress.IsUnspecified(),

   843      User::Leave( KErrAlreadyExists ) );

   844     __ASSERT_ALWAYS( ClientL().ObtainServerAddress( iServerAddress ),

   845      User::Leave( KErrNotFound ) );

   846     }

   847 

   848 // ---------------------------------------------------------------------------

   849 // CSTUNRelayBindingImplementation::GetSharedSecretL

   850 // ---------------------------------------------------------------------------

   851 //

   852 void CSTUNRelayBindingImplementation::GetSharedSecretL()

   853     {

   854     ClientL().ObtainSharedSecretL( iBinding );

   855     }

   856 

   857 // ---------------------------------------------------------------------------

   858 // CSTUNRelayBindingImplementation::Username

   859 // ---------------------------------------------------------------------------

   860 //

   861 const TDesC8& CSTUNRelayBindingImplementation::Username() const

   862     {

   863     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::Username" )

   864     if ( iRequest && iRequest->HasAttribute( CNATFWUNSAFAttribute::EUsername ) )

   865         {

   866         return static_cast<CNATFWUNSAFUsernameAttribute*>(

   867         iRequest->Attribute( CNATFWUNSAFAttribute::EUsername ) )->Value();

   868         }

   869 

   870     return KNullDesC8;

   871     }

   872 

   873 // ---------------------------------------------------------------------------

   874 // CSTUNRelayBindingImplementation::DetachClient

   875 // ---------------------------------------------------------------------------

   876 //

   877 void CSTUNRelayBindingImplementation::DetachClient()

   878     {

   879     iClient = NULL;

   880     }

   881 

   882 // ---------------------------------------------------------------------------

   883 // CSTUNRelayBindingImplementation::StoreAddressL

   884 // Transaction no longer needed.

   885 // ---------------------------------------------------------------------------

   886 //

   887 void CSTUNRelayBindingImplementation::StoreAddressL( 

   888     const TInetAddr& aReflexiveAddr,

   889     const TInetAddr& aRelayAddr )

   890     {

   891     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::StoreAddressL" )

   892     

   893     iErrorResponseCount = 0;

   894     iPublicAddr = aReflexiveAddr;

   895     iRelayAddr = aRelayAddr;

   896     ClientL().AddressResolvedL( iBinding );

   897 

   898     FreeRequestData();

   899     

   900     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::StoreAddressL end" )

   901     }

   902 

   903 // ---------------------------------------------------------------------------

   904 // CSTUNRelayBindingImplementation::StoreAddressL

   905 // Transaction no longer needed.

   906 // This is kind of wrong functionality if this method get called.

   907 // ---------------------------------------------------------------------------

   908 //

   909 void CSTUNRelayBindingImplementation::StoreAddressL( 

   910     const TInetAddr& aPublicAddress )

   911     {

   912     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::StoreAddressL" )

   913     

   914     iErrorResponseCount = 0;

   915     iPublicAddr = aPublicAddress;

   916     ClientL().AddressResolvedL( iBinding );

   917 

   918     FreeRequestData();

   919     

   920     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::StoreAddressL end" )

   921     }

   922 

   923 // -----------------------------------------------------------------------------

   924 // CSTUNRelayBindingImplementation::ChangeState

   925 // -----------------------------------------------------------------------------

   926 //

   927 void CSTUNRelayBindingImplementation::ChangeState( 

   928     CSTUNBindingState& aNewState )

   929     {

   930     iState = &aNewState;

   931     }

   932 

   933 // ---------------------------------------------------------------------------

   934 // CSTUNRelayBindingImplementation::Terminate

   935 // Binding can be re-started with SendRequestL.

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

   937 //

   938 void CSTUNRelayBindingImplementation::Terminate( TInt aError )

   939     {

   940     __STUNTURNCLIENT_INT1( "CSTUNRelayBindingImplementation::Terminate, error:", aError )

   941     __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

   942 

   943     NATFWUNSAF_INTLOG( "STUNRelayBinding terminated, reason", aError )

   944 

   945     TInetAddr emptyAddr;

   946     iPublicAddr = emptyAddr;

   947     iServerAddress = emptyAddr;

   948     iAddXorOnly = EFalse;

   949     iErrorResponseCount = 0;

   950     FreeRequestData();

   951 

   952     if ( iState != iInit )

   953         {

   954         __STUNTURNCLIENT( "Binding terminated" )

   955         

   956         ChangeState( *iInit );

   957         TRAP_IGNORE( ClientL().BindingErrorL( Binding(), aError, ETrue ) )

   958         }

   959     }

   960 

   961 // ---------------------------------------------------------------------------

   962 // CSTUNRelayBindingImplementation::FreeRequestData

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

   964 //

   965 void CSTUNRelayBindingImplementation::FreeRequestData()

   966     {

   967     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::FreeRequestData" )

   968     delete iTransaction;

   969     iTransaction = NULL;

   970     delete iUnknownAttr;

   971     iUnknownAttr = NULL;

   972     delete iRequest;

   973     iRequest = NULL;

   974     delete iSharedSecret;

   975     iSharedSecret = NULL;

   976     delete iRealmFromResponse;

   977     iRealmFromResponse = NULL;

   978     delete iNonce;

   979     iNonce = NULL;    

   980     iRequestType = EUnknown;

   981     iRemoteAddr.SetAddress( KAFUnspec );

   982     iICEAttributes = TICEAttributes();

   983     

   984     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::FreeRequestData end" )

   985     }

   986 

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

   988 // CSTUNRelayBindingImplementation::IsWaitingSharedSecret

   989 // ---------------------------------------------------------------------------

   990 //

   991 TBool CSTUNRelayBindingImplementation::IsWaitingSharedSecret() const

   992     {

   993     return iState == iGetSharedSecret;

   994     }

   995 

   996 // ---------------------------------------------------------------------------

   997 // CSTUNRelayBindingImplementation::SharedSecretObtainedL

   998 // ---------------------------------------------------------------------------

   999 //

  1000 void CSTUNRelayBindingImplementation::SharedSecretObtainedL( 

  1001     const TDesC8& aUsername, const TDesC8& aPassword )

  1002     {

  1003     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SharedSecretObtainedL" )

  1004     __STUN_ASSERT_L( ( aUsername.Length() > 0 && aPassword.Length() > 0 ) ||

  1005      ( aUsername.Length() == 0 && aPassword.Length() == 0 ), KErrArgument );

  1006     

  1007     

  1008     iState->SharedSecretObtainedL( *this, aUsername, aPassword );

  1009     

  1010     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SharedSecretObtainedL end" )

  1011     }

  1012 

  1013 // ---------------------------------------------------------------------------

  1014 // CSTUNRelayBindingImplementation::CreateBindingRequestL

  1015 // ---------------------------------------------------------------------------

  1016 //

  1017 void CSTUNRelayBindingImplementation::CreateBindingRequestL( 

  1018     const TDesC8& aUsername, const TDesC8& aPassword )

  1019     {

  1020     __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::CreateBindingRequestL" )

  1021     

  1022     delete iRequest;

  1023     iRequest = NULL;

  1024 

  1025     if ( IsSharedSecretRequired() &&

  1026          ( aUsername.Length() == 0 || aPassword.Length() == 0 ) )

  1027          {

  1028          Terminate( KErrAccessDenied );

  1029          User::Leave( KErrAccessDenied );

  1030          }

  1031     iTransactionError = KErrNone;

  1032 

  1033     HBufC8* newSharedSecret = aPassword.AllocL();

  1034     delete iSharedSecret;

  1035     iSharedSecret = newSharedSecret;

  1036 

  1037     TNATFWUNSAFTransactionID transactionID;

  1038     ClientL().ObtainTransactionIDL( transactionID );

  1039     

  1040     // Check the request type

  1041     switch( iRequestType )

  1042         {

  1043         case ESendRequest:

  1044             __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1045             CreateBindingRequestL - BindingRequest" )

  1046             iRequest = CNATFWUNSAFBindingRequest::NewL( transactionID );

  1047             break;

  1048             

  1049         case EAllocateRequest:

  1050             __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1051             CreateBindingRequestL - AllocateRequest" )

  1052             iRequest = CNATFWUNSAFAllocateRequest::NewL( transactionID );

  1053             break;

  1054                         

  1055         case ETCPConnectRequest:

  1056             __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1057             CreateBindingRequestL - ConnectRequest" )

  1058             iRequest = CNATFWUNSAFConnectRequest::NewL( transactionID );

  1059             break;

  1060             

  1061         case ESetActiveDestinationRequest:

  1062             __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1063             CreateBindingRequestL - SetActiveDestinationRequest" )

  1064             iRequest = CNATFWUNSAFSetActiveDestinationRequest::NewL( 

  1065                 transactionID );

  1066             break;

  1067             

  1068         // request not recognised

  1069         default:

  1070             User::Leave( KErrArgument );

  1071         }

  1072 

  1073 

  1074     if ( aUsername.Length() > 0 )

  1075         {

  1076         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1077         CreateBindingRequestL - Add USERNAME attribute" )

  1078         iRequest->AddAttributeL( CNATFWUNSAFUsernameAttribute::NewLC( 

  1079             aUsername ) );

  1080         CleanupStack::Pop(); // CNATFWUNSAFUsernameAttribute

  1081         }

  1082 

  1083     if ( iICEAttributes.iPriority > 0 )

  1084         {

  1085         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1086         CreateBindingRequestL - Add PRIORITY attribute" )

  1087         iRequest->AddAttributeL( CNATFWUNSAFPriorityAttribute::NewLC( 

  1088             iICEAttributes.iPriority ) );

  1089         CleanupStack::Pop(); // CNATFWUNSAFPriorityAttribute

  1090         }

  1091     

  1092     if ( iICEAttributes.iUseCandidate )

  1093         {

  1094         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1095         CreateBindingRequestL - Add USE_CANDIDATE attribute" )

  1096         iRequest->AddAttributeL( CNATFWUNSAFUseCandidateAttribute::NewLC() );

  1097         CleanupStack::Pop(); // CNATFWUNSAFUseCandidateAttribute

  1098         }

  1099     

  1100     if ( iICEAttributes.iControlled > 0 )

  1101         {

  1102         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1103         CreateBindingRequestL - Add CONTROLLED attribute" )

  1104         iRequest->AddAttributeL( CNATFWUNSAFIceControlledAttribute::NewLC( 

  1105             iICEAttributes.iControlled ) );

  1106         CleanupStack::Pop(); // CNATFWUNSAFIceControlledAttribute

  1107         }

  1108         

  1109     if ( iICEAttributes.iControlling > 0 )

  1110         {

  1111         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1112         CreateBindingRequestL - Add CONTROLLING attribute" )

  1113         iRequest->AddAttributeL( CNATFWUNSAFIceControllingAttribute::NewLC( 

  1114             iICEAttributes.iControlling ) );

  1115         CleanupStack::Pop(); // CNATFWUNSAFIceControllingAttribute

  1116         }

  1117     

  1118     if ( !iRemoteAddr.IsUnspecified() )

  1119         {

  1120         __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::\

  1121         CreateBindingRequestL - Add REMOTEADDRESS attribute" )

  1122         iRequest->AddAttributeL( CNATFWUNSAFRemoteAddressAttribute::NewLC( 

  1123             iRemoteAddr ) );

  1124         CleanupStack::Pop(); // CNATFWUNSAFRemoteAddressAttribute

  1125         }

  1126     

  1127     if ( iUseRealmFromResponse )

  1128         {

  1129         iRequest->AddAttributeL( CNATFWUNSAFRealmAttribute::NewLC(

  1130             *iRealmFromResponse ) );

  1131        

  1132         CleanupStack::Pop(); // CNATFWUNSAFRealmAttribute

  1133         }

  1134         

  1135     if ( iUnknownAttr )