multimediacommsengine/mmcesrv/mmceserver/src/mcesipconnection.cpp
changeset 0 1bce908db942
child 39 7ef91bf0eaa2
equal deleted inserted replaced
-1:000000000000 0:1bce908db942
       
     1 /*
       
     2 * Copyright (c) 2005 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 <badesca.h>
       
    22 #include <in_pkt.h>
       
    23 #include <sip.h>
       
    24 #include <sipprofile.h>
       
    25 #include <sipdialog.h>
       
    26 #include <sipinvitedialogassoc.h>
       
    27 #include <sipcontactheader.h>
       
    28 #include <sipprofileregistry.h>
       
    29 #include "mcesip.h"
       
    30 #include "mcesrvlogs.h"
       
    31 
       
    32 #include "mcesipconnection.h"
       
    33 #include "mcesipmanager.h"
       
    34 #include "mcesipsession.h"
       
    35 #include "mcecssessionimplementation.h"
       
    36 #include "mcelocaladdrresolver.h"
       
    37 
       
    38 //const TInt KMaxAddressLength = 256;
       
    39     
       
    40 // -----------------------------------------------------------------------------
       
    41 // CMceSipConnection::NewLC
       
    42 // -----------------------------------------------------------------------------
       
    43 //
       
    44 
       
    45 CMceSipConnection* CMceSipConnection::NewLC( 
       
    46     CMceSipManager& aSessionManager,
       
    47     CSIPProfile& aProfile,
       
    48     CSIPProfileRegistry& aProfileRegistry )
       
    49     {
       
    50     CMceSipConnection* self = new (ELeave) CMceSipConnection( aSessionManager,
       
    51     														  aProfile );
       
    52     CleanupStack::PushL( self );
       
    53     self->ConstructL( aProfile, aProfileRegistry );
       
    54     return self;
       
    55     }
       
    56 
       
    57 // -----------------------------------------------------------------------------
       
    58 // CMceSipConnection::NewLC
       
    59 // -----------------------------------------------------------------------------
       
    60 //
       
    61 
       
    62 CMceSipConnection* CMceSipConnection::NewLC( CMceSipManager& aSessionManager, 
       
    63                                              TUint32 aIAPId )
       
    64     {
       
    65     CMceSipConnection* self = new (ELeave) CMceSipConnection( aSessionManager, 
       
    66                                                               aIAPId );
       
    67     CleanupStack::PushL( self );
       
    68     self->ConstructL();
       
    69     return self;
       
    70     }
       
    71 
       
    72 #define MCE_SIP_CONNECTION_UNUSABLE( connection )\
       
    73     (connection->State() == CSIPConnection::EInactive ||\
       
    74      connection->State() == CSIPConnection::EUnavailable )
       
    75 
       
    76 // -----------------------------------------------------------------------------
       
    77 // CMceSipConnection::~CMceSipConnection
       
    78 // -----------------------------------------------------------------------------
       
    79 //
       
    80 CMceSipConnection::~CMceSipConnection()
       
    81     {
       
    82     MCESRV_DEBUG("CMceSipConnection::CMceSipConnection, Entry")  
       
    83     
       
    84     delete iClientConnection;
       
    85     iSessions.Reset();
       
    86     iSessions.Close();
       
    87     
       
    88     delete iLocalAddrResolver;
       
    89     MCESRV_DEBUG("CMceSipConnection::CMceSipConnection, Exit")   
       
    90     }
       
    91 
       
    92 // -----------------------------------------------------------------------------
       
    93 // CMceSipConnection::Connection
       
    94 // -----------------------------------------------------------------------------
       
    95 //
       
    96 CSIPConnection& CMceSipConnection::Connection() const
       
    97     {
       
    98     return *iClientConnection;
       
    99     }
       
   100 
       
   101 // -----------------------------------------------------------------------------
       
   102 // CMceSipConnection::State
       
   103 // -----------------------------------------------------------------------------
       
   104 //
       
   105 CSIPConnection::TState CMceSipConnection::State() const
       
   106     {
       
   107     return iClientConnection->State();
       
   108     }
       
   109 
       
   110 // -----------------------------------------------------------------------------
       
   111 // CMceSipConnection::AccessPointId
       
   112 // -----------------------------------------------------------------------------
       
   113 //
       
   114 TUint32 CMceSipConnection::AccessPointId() const
       
   115     {
       
   116     return iIAPId;
       
   117     }
       
   118 
       
   119 // -----------------------------------------------------------------------------
       
   120 // CMceSipConnection::AttachL
       
   121 // -----------------------------------------------------------------------------
       
   122 //
       
   123 void CMceSipConnection::AttachL( CMceCsSubSession& aSession )
       
   124     {
       
   125     User::LeaveIfError( MCE_SIP_CONNECTION_UNUSABLE( iClientConnection ) ? 
       
   126                         KErrNotReady : KErrNone );
       
   127     User::LeaveIfError( 
       
   128         iSessions.Find( &aSession ) < 0 ? KErrNone : KErrArgument );
       
   129     
       
   130     iSessions.AppendL( &aSession );  
       
   131     }
       
   132     
       
   133 // -----------------------------------------------------------------------------
       
   134 // CMceSipConnection::Detach
       
   135 // -----------------------------------------------------------------------------
       
   136 //
       
   137 TInt CMceSipConnection::Detach( CMceCsSubSession& aSession )
       
   138     {
       
   139     
       
   140     TInt index = iSessions.Find( &aSession );
       
   141     
       
   142     if ( index >= KErrNone )
       
   143         {
       
   144         iSessions.Remove( index );
       
   145         }
       
   146     
       
   147     return iSessions.Count();
       
   148     }
       
   149 
       
   150 // -----------------------------------------------------------------------------
       
   151 // CMceSipConnection::CMceSipConnection
       
   152 // -----------------------------------------------------------------------------
       
   153 //
       
   154 
       
   155 CMceSipConnection::CMceSipConnection ( CMceSipManager& aSessionManager, 
       
   156                                        CSIPProfile& aProfile )
       
   157    : iIAPId( (TUint32)KErrNotFound ),
       
   158      iSessionManager( aSessionManager )
       
   159     {
       
   160     aProfile.GetParameter( KSIPAccessPointId, iIAPId );
       
   161     }
       
   162 
       
   163 // -----------------------------------------------------------------------------
       
   164 // CMceSipConnection::CMceSipConnection
       
   165 // -----------------------------------------------------------------------------
       
   166 //
       
   167 CMceSipConnection::CMceSipConnection ( CMceSipManager& aSessionManager, 
       
   168                                        TUint32 aIAPId )
       
   169    : iIAPId( aIAPId ),
       
   170      iSessionManager( aSessionManager )
       
   171     {
       
   172     }
       
   173 
       
   174 // -----------------------------------------------------------------------------
       
   175 // CMceSipConnection::ConstructL
       
   176 // -----------------------------------------------------------------------------
       
   177 // 
       
   178 void CMceSipConnection::ConstructL( CSIPProfile& aProfile, 
       
   179 									CSIPProfileRegistry& aProfileRegistry )
       
   180     {
       
   181     MCESRV_DEBUG("CMceSipConnection::ConstructL, Entry")
       
   182 	
       
   183 	if ( !aProfileRegistry.IsEnabled( aProfile ) )
       
   184 	    {
       
   185         MCESRV_DEBUG("CMceSipConnection::ConstructL, enabling profile")
       
   186         aProfileRegistry.EnableL( aProfile, *this );
       
   187         }
       
   188 
       
   189 	iClientConnection = aProfileRegistry.ConnectionL( aProfile );
       
   190 	
       
   191     iLocalAddrResolver = 
       
   192         CMceLocalAddrResolver::NewL( 
       
   193             iSessionManager.SocketServ(), 
       
   194             AccessPointId() );
       
   195 	
       
   196     MCESRV_DEBUG("CMceSipConnection::ConstructL, Exit")
       
   197     }
       
   198 
       
   199 // -----------------------------------------------------------------------------
       
   200 // CMceSipConnection::ConstructL
       
   201 // -----------------------------------------------------------------------------
       
   202 // 
       
   203 void CMceSipConnection::ConstructL( )
       
   204     {
       
   205     MCESRV_DEBUG("CMceSipConnection::ConstructL, Entry")
       
   206 
       
   207     MCESRV_DEBUG("CMceSipConnection::ConstructL, new connection")
       
   208     
       
   209     iClientConnection = 
       
   210         CSIPConnection::NewL( iSessionManager.SIPClient(), 
       
   211                               AccessPointId(),
       
   212                               *this );
       
   213                               
       
   214     iLocalAddrResolver = 
       
   215         CMceLocalAddrResolver::NewL( 
       
   216             iSessionManager.SocketServ(), 
       
   217             AccessPointId() );
       
   218 	
       
   219     MCESRV_DEBUG("CMceSipConnection::ConstructL, Exit")
       
   220     }    
       
   221     
       
   222 // -----------------------------------------------------------------------------
       
   223 // CMceSipConnection::IncomingRequest
       
   224 // -----------------------------------------------------------------------------
       
   225 //
       
   226 void CMceSipConnection::IncomingRequest( 
       
   227     CSIPServerTransaction* aTransaction )
       
   228     {
       
   229     MCESRV_DEBUG("CMceSipConnection::IncomingRequest( sa ), Entry")
       
   230     MCESRV_DEBUG_SVALUE("request", MceSip::Method( *aTransaction ).DesC() )
       
   231     TInt error = KErrNone;
       
   232     TBool sessionConsumed = EFalse;
       
   233     TBool requestConsumed = EFalse;
       
   234     
       
   235     sessionConsumed = iSessionManager.Consumes( *aTransaction );
       
   236     if ( sessionConsumed )
       
   237         {
       
   238         TRAP( error, iSessionManager.CreateSubSessionL( aTransaction, *this ) );
       
   239         requestConsumed = error ? EFalse : ETrue;
       
   240         }
       
   241     else
       
   242         {
       
   243         CMceCsSubSession* session = NULL;
       
   244         TInt index = 0;
       
   245         while ( !requestConsumed && index < iSessions.Count() )
       
   246             {
       
   247             session = iSessions[ index++ ];
       
   248             sessionConsumed = session->Consumes( *aTransaction );
       
   249             if ( sessionConsumed )
       
   250                 {
       
   251                 requestConsumed = session->MessageRequestReceived( aTransaction );
       
   252                 }
       
   253             }
       
   254         }
       
   255     
       
   256     if ( !sessionConsumed )
       
   257         {
       
   258         MCESRV_DEBUG("IncomingRequest( sa ): not consumed ->discard")
       
   259         MceSip::DiscardRequest( aTransaction, KMceSipNotImplemented );
       
   260         }
       
   261     else if ( !requestConsumed || error )
       
   262         {
       
   263         MCESRV_DEBUG("IncomingRequest( sa ): error->discard")
       
   264         MceSip::DiscardRequest( aTransaction );
       
   265         }
       
   266     else
       
   267         {
       
   268         // NOP
       
   269         }
       
   270 
       
   271     iSessionManager.Cleanup();
       
   272         
       
   273     MCESRV_DEBUG("CMceSipConnection::IncomingRequest( sa ), Exit")
       
   274     }
       
   275 
       
   276 // -----------------------------------------------------------------------------
       
   277 // CMceSipConnection::IncomingRequest
       
   278 // -----------------------------------------------------------------------------
       
   279 //
       
   280 void CMceSipConnection::IncomingRequest ( 
       
   281     CSIPServerTransaction* aTransaction,
       
   282     CSIPDialog& aDialog )
       
   283     {
       
   284     MCESRV_DEBUG("CMceSipConnection::IncomingRequest( inside dialog ), Entry")
       
   285     MCESRV_DEBUG_SVALUE("request", MceSip::Method( *aTransaction ).DesC() )
       
   286     CMceCsSubSession* session = NULL;
       
   287     CMceCsSubSession* assocSession = NULL;
       
   288     TBool sessionConsumed = EFalse;
       
   289     TBool requestConsumed = EFalse;
       
   290     TInt index = 0;
       
   291     
       
   292     while ( !requestConsumed && index < iSessions.Count() )
       
   293         {
       
   294         TBool assocDialog( EFalse );
       
   295         session = iSessions[ index++ ];
       
   296 
       
   297         sessionConsumed = session->Consumes( aDialog, *aTransaction, assocDialog );
       
   298         if ( sessionConsumed )
       
   299             {
       
   300             requestConsumed = session->DialogRequestReceived( aTransaction, aDialog );
       
   301             }
       
   302             
       
   303         if ( assocDialog && !assocSession )
       
   304             {
       
   305             assocSession = session;
       
   306             }
       
   307         }
       
   308         
       
   309     TInt error = KErrNone;  
       
   310     if( !requestConsumed )
       
   311         {
       
   312         index = 0;
       
   313         while ( !requestConsumed && index < iSessions.Count() )
       
   314             {
       
   315             session = iSessions[ index++ ];
       
   316             if ( !session->Client().IsOrphan() && 
       
   317                   session->Dialog()->Dialog() == aDialog )
       
   318                 {
       
   319                 TRAP( error, iSessionManager.CreateSubSessionL( 
       
   320                                         aTransaction, 
       
   321                                         session->Client().ClientSession(), 
       
   322                                         *this, 
       
   323                                         assocSession ) );
       
   324                 sessionConsumed = error ? EFalse : ETrue;
       
   325                 requestConsumed = sessionConsumed;   
       
   326                 }
       
   327             }
       
   328         }
       
   329     
       
   330     if ( !sessionConsumed )
       
   331         {
       
   332         // Unknown method
       
   333         MCESRV_DEBUG("IncomingRequest: not consumed -> discard")
       
   334         MceSip::DiscardRequest( aTransaction, KMceSipNotImplemented );
       
   335         }
       
   336     else if ( !requestConsumed || error )
       
   337         {
       
   338         MCESRV_DEBUG("IncomingRequest: error -> discard")
       
   339         MceSip::DiscardRequest( aTransaction );
       
   340         }
       
   341     else
       
   342         {
       
   343         // NOP
       
   344         }
       
   345     iSessionManager.Cleanup();
       
   346         
       
   347     MCESRV_DEBUG("CMceSipConnection::IncomingRequest( inside dialog ), Exit")      
       
   348     }
       
   349 
       
   350 // -----------------------------------------------------------------------------
       
   351 // CMceSipConnection::IncomingResponse
       
   352 // -----------------------------------------------------------------------------
       
   353 //
       
   354 void CMceSipConnection::IncomingResponse(
       
   355     CSIPClientTransaction& aTransaction )
       
   356     {
       
   357     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( standalone ), Entry")
       
   358     MCESRV_DEBUG_DVALUE("response", MceSip::ResponseCode( aTransaction ) )
       
   359     MCESRV_DEBUG_SVALUE("to", aTransaction.Type().DesC() )
       
   360     CMceCsSubSession* session = NULL;
       
   361     TBool consumed = EFalse;    
       
   362     TInt index = 0;
       
   363     
       
   364     while ( !consumed && index < iSessions.Count() )
       
   365         {
       
   366         session = iSessions[ index++ ];
       
   367         consumed = session->Consumes( aTransaction );
       
   368         if ( consumed )
       
   369             {
       
   370             session->MessageResponseReceived( aTransaction );
       
   371             }
       
   372         }
       
   373         
       
   374     iSessionManager.Cleanup();
       
   375     
       
   376     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( standalone ), Exit")
       
   377     }
       
   378 
       
   379 // -----------------------------------------------------------------------------
       
   380 // CMceSipConnection::IncomingResponse
       
   381 // -----------------------------------------------------------------------------
       
   382 //
       
   383 void CMceSipConnection::IncomingResponse(
       
   384     CSIPClientTransaction& aTransaction,
       
   385     CSIPDialogAssocBase& aDialogAssoc )
       
   386     {
       
   387     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( inside dialog ), Entry")
       
   388     MCESRV_DEBUG_DVALUE("response", MceSip::ResponseCode( aTransaction ) )
       
   389     MCESRV_DEBUG_SVALUE("to", aTransaction.Type().DesC() )
       
   390     CMceCsSubSession* session = NULL;
       
   391     TBool consumed = EFalse;    
       
   392     TInt index = 0;
       
   393     
       
   394     while ( !consumed && index < iSessions.Count() )
       
   395         {
       
   396         session = iSessions[ index++ ];
       
   397         if ( session->Consumes( aTransaction ) )
       
   398             {
       
   399             consumed = ETrue;
       
   400             session->ResponseReceivedWithinDialog( aTransaction, aDialogAssoc );
       
   401             }
       
   402         }
       
   403         
       
   404     iSessionManager.Cleanup();
       
   405     
       
   406     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( inside dialog ), Exit")
       
   407     }
       
   408 
       
   409 // -----------------------------------------------------------------------------
       
   410 // CMceSipConnection::IncomingResponse
       
   411 // -----------------------------------------------------------------------------
       
   412 //
       
   413 void CMceSipConnection::IncomingResponse (
       
   414     CSIPClientTransaction& aTransaction,
       
   415     CSIPInviteDialogAssoc* aDialogAssoc )
       
   416     {
       
   417     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( forked ), Entry")
       
   418     MCESRV_DEBUG_DVALUE("response", MceSip::ResponseCode( aTransaction ) )
       
   419     MCESRV_DEBUG_SVALUE("to", aTransaction.Type().DesC() )
       
   420     
       
   421     // Find the session
       
   422     CMceCsSubSession* session = NULL;
       
   423     TBool consumed = EFalse;    
       
   424     TInt index = 0;
       
   425     TInt error = KErrNone;
       
   426     
       
   427     while ( !consumed && index < iSessions.Count() )
       
   428         {
       
   429         session = iSessions[ index++ ];
       
   430         if ( session->Consumes( aTransaction ) && 
       
   431              session->Type() == CMceCsSubSession::EOutSIPSession )
       
   432             {
       
   433             consumed = ETrue;
       
   434             TRAP( error, static_cast<CMceSipSession*>( session )->
       
   435                   InviteForkedL( aTransaction, aDialogAssoc ) );
       
   436             }
       
   437         }
       
   438     
       
   439     if ( error != KErrNone || !consumed )
       
   440         {
       
   441         Reject( aDialogAssoc );
       
   442         }
       
   443         
       
   444     iSessionManager.Cleanup();
       
   445     
       
   446     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( forked ), Exit")
       
   447     }
       
   448 
       
   449 // -----------------------------------------------------------------------------
       
   450 // CMceSipConnection::IncomingResponse
       
   451 // -----------------------------------------------------------------------------
       
   452 //
       
   453 void
       
   454 CMceSipConnection::IncomingResponse( 
       
   455     CSIPClientTransaction& /*aTransaction*/,
       
   456     CSIPRegistrationBinding& /*aRegistration*/ )
       
   457     {
       
   458     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( reg ), Entry")
       
   459     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( reg ), NOT IMPLEMENTED")
       
   460     //NOT IMPLEMENTED
       
   461     MCESRV_DEBUG("CMceSipConnection::IncomingResponse( reg ), Exit")
       
   462     }
       
   463 
       
   464 // -----------------------------------------------------------------------------
       
   465 // CMceSipConnection::ErrorOccured
       
   466 // -----------------------------------------------------------------------------
       
   467 //
       
   468 void CMceSipConnection::ErrorOccured( 
       
   469     TInt aError,
       
   470     CSIPTransactionBase& aTransaction )
       
   471     {
       
   472     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( standalone ), Entry")
       
   473     MCESRV_DEBUG_DVALUE("error", aError )
       
   474     
       
   475     CMceCsSubSession* session = NULL;
       
   476     TBool consumed = EFalse;    
       
   477     TInt index = 0;
       
   478     
       
   479     while ( !consumed && index < iSessions.Count() )
       
   480         {
       
   481         session = iSessions[ index++ ];
       
   482         consumed = session->Consumes( aTransaction );
       
   483         if ( consumed )
       
   484             {
       
   485             session->ErrorOccured( aError, aTransaction );
       
   486             }
       
   487         }
       
   488     
       
   489     iSessionManager.Cleanup();
       
   490     
       
   491     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( standalone ), Exit")
       
   492     }
       
   493 
       
   494 // -----------------------------------------------------------------------------
       
   495 // CMceSipConnection::ErrorOccured
       
   496 // -----------------------------------------------------------------------------
       
   497 //
       
   498 void CMceSipConnection::ErrorOccured (
       
   499 	TInt aError,
       
   500     CSIPTransactionBase& aTransaction,
       
   501 	CSIPDialogAssocBase& aDialogAssoc)
       
   502     {
       
   503     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( inside dialog ), Entry")
       
   504     MCESRV_DEBUG_DVALUE("error", aError )
       
   505     
       
   506     CMceCsSubSession* session = NULL;
       
   507     TBool consumed = EFalse;    
       
   508     TInt index = 0;
       
   509     
       
   510     while ( !consumed && index < iSessions.Count() )
       
   511         {
       
   512         session = iSessions[ index++ ];
       
   513         if ( session->Dialog() == &aDialogAssoc &&
       
   514              session->Consumes( aTransaction ) )
       
   515             {
       
   516             consumed = ETrue;
       
   517             session->ErrorOccured( aError, aTransaction );
       
   518             }
       
   519         }
       
   520         
       
   521     iSessionManager.Cleanup();
       
   522     
       
   523     MCESRV_DEBUG("CMceSipConnection::ErrorOccured(inside dialog ), Exit")
       
   524     }
       
   525 
       
   526 // -----------------------------------------------------------------------------
       
   527 // CMceSipConnection::ErrorOccured
       
   528 // -----------------------------------------------------------------------------
       
   529 //
       
   530 void CMceSipConnection::ErrorOccured(
       
   531     TInt aError,			
       
   532     CSIPDialogAssocBase& aDialogAssoc )
       
   533     {
       
   534     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( dialog ), Entry")
       
   535     MCESRV_DEBUG_DVALUE("error", aError )
       
   536     
       
   537     CMceCsSubSession* session = NULL;
       
   538     TBool consumed = EFalse;    
       
   539     TInt index = 0;
       
   540     
       
   541     while ( !consumed && index < iSessions.Count() )
       
   542         {
       
   543         session = iSessions[ index++ ];
       
   544         if ( session->Dialog() == &aDialogAssoc )
       
   545             {
       
   546             session->ErrorOccured( aError );
       
   547             consumed = ETrue;
       
   548             }
       
   549         }
       
   550     
       
   551     iSessionManager.Cleanup();
       
   552     
       
   553     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( dialog ), Exit")
       
   554     }
       
   555 
       
   556 // -----------------------------------------------------------------------------
       
   557 // CMceSipConnection::InviteCompleted
       
   558 // -----------------------------------------------------------------------------
       
   559 //
       
   560 void CMceSipConnection::InviteCompleted( 
       
   561     CSIPClientTransaction& aTransaction )
       
   562     {
       
   563     MCESRV_DEBUG("CMceSipConnection::InviteCompleted, Entry")
       
   564     CMceCsSubSession* session = NULL;
       
   565     TBool consumed = EFalse;    
       
   566     TInt index = 0;
       
   567     
       
   568     while ( !consumed && index < iSessions.Count() )
       
   569         {
       
   570         session = iSessions[ index++ ];
       
   571         consumed = session->Consumes( aTransaction );
       
   572         if ( consumed )
       
   573             {
       
   574             session->InviteCompleted( aTransaction );
       
   575             }
       
   576         }
       
   577         
       
   578     MCESRV_DEBUG("CMceSipConnection::InviteCompleted, Exit")
       
   579     }
       
   580 
       
   581 // -----------------------------------------------------------------------------
       
   582 // CMceSipConnection::InviteCanceled
       
   583 // -----------------------------------------------------------------------------
       
   584 //
       
   585 void CMceSipConnection::InviteCanceled(
       
   586     CSIPServerTransaction& aTransaction )
       
   587     {
       
   588     MCESRV_DEBUG("CMceSipConnection::InviteCanceled, Entry")
       
   589     CMceCsSubSession* session = NULL;
       
   590     TBool consumed = EFalse;    
       
   591     TInt index = 0;
       
   592     
       
   593     while ( !consumed && index < iSessions.Count() )
       
   594         {
       
   595         session = iSessions[ index++ ];
       
   596         consumed = session->Consumes( aTransaction );
       
   597         if ( consumed )
       
   598             {
       
   599             session->Canceled();
       
   600             }
       
   601         }
       
   602     MCESRV_DEBUG("CMceSipConnection::InviteCanceled, Exit")
       
   603     }
       
   604     
       
   605 // -----------------------------------------------------------------------------
       
   606 // CMceSipConnection::ConnectionStateChanged
       
   607 // -----------------------------------------------------------------------------
       
   608 //
       
   609 void CMceSipConnection::ConnectionStateChanged(
       
   610     CSIPConnection::TState aState )
       
   611     {
       
   612     MCESRV_DEBUG("CMceSipConnection::ConnectionStateChanged, Entry")
       
   613     MCESRV_DEBUG_DVALUE("state", aState )
       
   614     
       
   615     TInt index = 0;
       
   616     while ( index < iSessions.Count() )
       
   617         {
       
   618         CMceCsSubSession* session = iSessions[ index++ ];
       
   619         session->ConnectionStateChanged( aState );
       
   620         
       
   621         if ( MCE_SIP_CONNECTION_UNUSABLE( iClientConnection ) )
       
   622             {
       
   623             session->Canceled();
       
   624             }
       
   625         }
       
   626     MCESRV_DEBUG("CMceSipConnection::ConnectionStateChanged, Exit")
       
   627     }
       
   628 
       
   629 // -----------------------------------------------------------------------------
       
   630 // CMceSipConnection::ErrorOccured
       
   631 // -----------------------------------------------------------------------------
       
   632 //
       
   633 void CMceSipConnection::ErrorOccured(
       
   634     TInt /*aError*/,
       
   635     CSIPClientTransaction& /*aTransaction*/,
       
   636     CSIPRegistrationBinding& /*aRegistration*/)
       
   637     {
       
   638     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( reg ), Entry")
       
   639     MCESRV_DEBUG("NOT IMPLEMENTED")
       
   640     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( reg ), Exit")
       
   641     }
       
   642 
       
   643 // -----------------------------------------------------------------------------
       
   644 // CMceSipConnection::ErrorOccured
       
   645 // -----------------------------------------------------------------------------
       
   646 //
       
   647 void CMceSipConnection::ErrorOccured(
       
   648     TInt /*aError*/,
       
   649     CSIPRefresh& /*aSIPRefresh*/ )
       
   650     {
       
   651     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( refresh ), Entry")
       
   652     MCESRV_DEBUG("NOT IMPLEMENTED")
       
   653     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( refresh ), Exit")
       
   654     }
       
   655 
       
   656 // -----------------------------------------------------------------------------
       
   657 // CMceSipConnection::ErrorOccured
       
   658 // -----------------------------------------------------------------------------
       
   659 //
       
   660 void CMceSipConnection::ErrorOccured(
       
   661     TInt /*aError*/,					
       
   662     CSIPRegistrationBinding& /*aRegistration*/ )
       
   663     {
       
   664     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( sa reg ), Entry")
       
   665     MCESRV_DEBUG("NOT IMPLEMENTED")
       
   666     MCESRV_DEBUG("CMceSipConnection::ErrorOccured( sa reg ), Exit")
       
   667     }    
       
   668 
       
   669 // -----------------------------------------------------------------------------
       
   670 // CMceSipConnection::Reject
       
   671 // -----------------------------------------------------------------------------
       
   672 //
       
   673 void CMceSipConnection::Reject( CSIPInviteDialogAssoc* aDialogAssoc )
       
   674     {
       
   675     MCESRV_DEBUG("CMceSipConnection::Reject( assoc ), Entry")
       
   676     
       
   677     delete aDialogAssoc;
       
   678     
       
   679     MCESRV_DEBUG("CMceSipConnection::Reject( assoc ), Entry")
       
   680     }
       
   681 
       
   682 // -----------------------------------------------------------------------------
       
   683 // CMceSipConnection::LocalIPAddressL
       
   684 // -----------------------------------------------------------------------------
       
   685 //
       
   686 TInetAddr CMceSipConnection::LocalIPAddressL( TInetAddr* aNextHop )
       
   687     {
       
   688     MCESRV_DEBUG("CMceSipConnection::LocalIPAddressL, Entry")
       
   689     TInetAddr localIpAddress;
       
   690     iLocalAddrResolver->RefreshLocalAddressesL();
       
   691     FillWithMatchingAddrFamily( localIpAddress, aNextHop );  
       
   692     MCESRV_DEBUG("CMceSipConnection::LocalIPAddressL, Exit")
       
   693 	return localIpAddress;
       
   694     }
       
   695 
       
   696 // -----------------------------------------------------------------------------
       
   697 // CMceSipConnection::UpdateConnectionL
       
   698 // -----------------------------------------------------------------------------
       
   699 //
       
   700 void CMceSipConnection::UpdateConnectionL( TUint aSignallingTypeOfService )
       
   701     {
       
   702     if ( aSignallingTypeOfService != iCurrentSignallingTypeOfService )
       
   703         {
       
   704         MCESRV_DEBUG_DVALUE( "CMceSipConnection::UpdateConnectionL, tos", 
       
   705                              aSignallingTypeOfService )
       
   706                              
       
   707         iClientConnection->SetOptL( KSoIpTOS, 
       
   708                                     KProtocolInetIp, 
       
   709                                     aSignallingTypeOfService );
       
   710                                     
       
   711         iCurrentSignallingTypeOfService = aSignallingTypeOfService;
       
   712         
       
   713         MCESRV_DEBUG("CMceSipConnection::UpdateConnectionL, tos set")
       
   714         }
       
   715     }
       
   716     
       
   717 // -----------------------------------------------------------------------------
       
   718 // CMceSipConnection::FillWithMatchingAddrFamily
       
   719 // -----------------------------------------------------------------------------
       
   720 //
       
   721 void CMceSipConnection::FillWithMatchingAddrFamily( TInetAddr& aAddr,
       
   722                                                  const TInetAddr* aNextHop )
       
   723     {
       
   724     MCESRV_DEBUG("CMceSipConnection::FillWithMatchingAddrFamily, Entry")
       
   725     
       
   726     MCESRV_DEBUG_ADDRVALUE(
       
   727         "CMceSipConnection::FillWithMatchingAddrFamily: local IP addr",
       
   728         iLocalAddrResolver->Addr() )
       
   729     
       
   730     MCESRV_DEBUG_ADDRVALUE(
       
   731         "CMceSipConnection::FillWithMatchingAddrFamily: local IPv4 addr",               
       
   732         iLocalAddrResolver->IPv4Addr() )
       
   733     
       
   734     if ( iLocalAddrResolver->HasIPv4Addr() )
       
   735 	    {
       
   736 	    aAddr = iLocalAddrResolver->IPv4Addr();
       
   737 	    }
       
   738 	else
       
   739 	    {
       
   740 	    aAddr = iLocalAddrResolver->Addr();
       
   741 	    }
       
   742     
       
   743 	if ( aNextHop )
       
   744 	    {
       
   745         MCESRV_DEBUG_ADDRVALUE(
       
   746             "CMceSipConnection::FillWithMatchingAddrFamily: next hop",               
       
   747             *aNextHop )
       
   748 	    
       
   749         MCESRV_DEBUG_DVALUE(
       
   750             "CMceSipConnection::FillWithMatchingAddrFamily: next hop family",
       
   751             aNextHop->Family() )
       
   752                        
       
   753 	    if ( aNextHop->Family() == KAfInet )
       
   754 	        {
       
   755 	        if ( !iLocalAddrResolver->HasIPv4Addr() &&
       
   756 	             ( aAddr.IsV4Compat() || aAddr.IsV4Mapped() ) )
       
   757 	            {
       
   758 	            aAddr.ConvertToV4();
       
   759 	            }
       
   760 	        }
       
   761 	    else
       
   762 	        {
       
   763 	        aAddr = iLocalAddrResolver->Addr();
       
   764 	        if ( aAddr.Family() == KAfInet )
       
   765 	            {
       
   766 	            aAddr.ConvertToV4Compat();
       
   767 	            }
       
   768 	        }
       
   769 	    }
       
   770 	MCESRV_DEBUG_ADDRVALUE(
       
   771 	    "CMceSipConnection::FillWithMatchingAddrFamily returns", aAddr )
       
   772 	    
       
   773     MCESRV_DEBUG("CMceSipConnection::FillWithMatchingAddrFamily, Exit")	
       
   774     }
       
   775 
       
   776 // -----------------------------------------------------------------------------
       
   777 // CMceSipConnection::IsProfileUsedInSession
       
   778 // -----------------------------------------------------------------------------
       
   779 //
       
   780 TBool CMceSipConnection::IsProfileUsedInSession( CSIPProfile& aProfile )
       
   781     {
       
   782     TBool result = EFalse;
       
   783     for( TInt i = 0; i < iSessions.Count() && !result; i++ )
       
   784     	{
       
   785     	result = ( &aProfile == &iSessions[ i ]->Profile() );
       
   786     	}
       
   787     return result;
       
   788     }
       
   789 
       
   790 //EOF