1 /*

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

    22 #include "natfwcandidatepair.h"

    23 #include "cicecheckprioritizer.h"

    24 #include "ciceconnectivitycheck.h"

    25 #include "icecandidatehandlerlogs.h"

    26 

    27 /** variables used in priority calculation */

    28 const TUint64 K2ToPowerOf32 = 2^32;

    29 const TUint64 KNumValTwo = 2;

    30 

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

    32 

    33 

    34 CIceCheckPrioritizer::CIceCheckPrioritizer()

    35     {

    36     __ICEDP( "CIceCheckPrioritizer::CIceCheckPrioritizer" )

    37     }

    38 

    39 

    40 CIceCheckPrioritizer* CIceCheckPrioritizer::NewL()

    41     {

    42     __ICEDP( "CIceCheckPrioritizer::NewL" )

    43 

    44     CIceCheckPrioritizer* self = CIceCheckPrioritizer::NewLC();

    45     CleanupStack::Pop( self );

    46 

    47     return self;

    48     }

    49 

    50 

    51 CIceCheckPrioritizer* CIceCheckPrioritizer::NewLC()

    52     {

    53     __ICEDP( "CIceCheckPrioritizer::NewLC" )

    54 

    55     CIceCheckPrioritizer* self = new( ELeave ) CIceCheckPrioritizer();

    56     CleanupStack::PushL( self );

    57     

    58     return self;

    59     }

    60 

    61 

    62 CIceCheckPrioritizer::~CIceCheckPrioritizer()

    63     {  

    64     __ICEDP( "CIceCheckPrioritizer::~CIceCheckPrioritizer" )

    65     }   

    66 

    67 

    68 // ---------------------------------------------------------------------------

    69 // CIceCheckPrioritizer::PrioritizePair

    70 // ---------------------------------------------------------------------------

    71 //  

    72 void CIceCheckPrioritizer::PrioritizePair( CNATFWCandidatePair& aPair,

    73         TNATFWIceRole aCurrentRole ) const

    74     {

    75     __ICEDP( "CIceCheckPrioritizer::PrioritizePair" )

    76     

    77     /*

    78     ICE-17, section 5.7.2.

    79     Let G be the priority for the candidate provided by the controlling

    80     agent. Let D be the priority for the candidate provided by the

    81     controlled agent. The priority for a pair is computed as:

    82 

    83       pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)

    84 

    85     Where G>D?1:0 is an expression whose value is 1 if G is greater than

    86     D, and 0 otherwise.  This formula ensures a unique priority for each

    87     pair.

    88     */

    89     TUint64 controllingPri( 0 );

    90     TUint64 controlledPri( 0 );

    91     if ( EIceRoleControlling == aCurrentRole )

    92         {

    93         controllingPri = aPair.LocalCandidate().Priority();

    94         controlledPri = aPair.RemoteCandidate().Priority();

    95         }

    96     else

    97         {

    98         controlledPri = aPair.LocalCandidate().Priority();

    99         controllingPri = aPair.RemoteCandidate().Priority();

   100         }

   101     

   102     TUint64 pairPri = K2ToPowerOf32 * Min( controllingPri, controlledPri )

   103         + KNumValTwo * Max( controllingPri, controlledPri )

   104         + ( 

   105             ( controllingPri > controlledPri ) ? TUint64( 1 ) : TUint64( 0 )

   106           );

   107     

   108     aPair.SetPriority( pairPri );

   109     }

   110 

   111 

   112 // ---------------------------------------------------------------------------

   113 // CIceCheckPrioritizer::PrioritizePairs

   114 // ---------------------------------------------------------------------------

   115 //  

   116 void CIceCheckPrioritizer::PrioritizePairs( 

   117         RPointerArray<CNATFWCandidatePair>& aPairs,

   118         TNATFWIceRole aCurrentRole ) const

   119     {

   120     __ICEDP( "CIceCheckPrioritizer::PrioritizePairs" )

   121     

   122     TInt ind( aPairs.Count() );

   123     while ( ind-- )

   124         {

   125         PrioritizePair( *aPairs[ind], aCurrentRole );

   126         }

   127     }

   128 

   129 

   130 // ---------------------------------------------------------------------------

   131 // CIceCheckPrioritizer::PrioritizeCheck

   132 // ---------------------------------------------------------------------------

   133 //  

   134 void CIceCheckPrioritizer::PrioritizeCheck( 

   135         CIceConnectivityCheck& aCheck, TNATFWIceRole aCurrentRole ) const

   136     {

   137     __ICEDP( "CIceCheckPrioritizer::PrioritizeCheck" )

   138     

   139     PrioritizePair( 

   140         const_cast<CNATFWCandidatePair&>( aCheck.CandidatePair() ), 

   141         aCurrentRole );

   142     }

   143 

   144    

   145 // ---------------------------------------------------------------------------

   146 // CIceCheckPrioritizer::PrioritizeChecks

   147 // ---------------------------------------------------------------------------

   148 //  

   149 void CIceCheckPrioritizer::PrioritizeChecks( 

   150         RPointerArray<CIceConnectivityCheck>& aChecks,

   151         TNATFWIceRole aCurrentRole ) const

   152     {

   153     __ICEDP( "CIceCheckPrioritizer::PrioritizeChecks" )

   154     

   155     TInt ind( aChecks.Count() );

   156     while ( ind-- )

   157         {

   158         PrioritizeCheck( *aChecks[ind], aCurrentRole );

   159         }

   160     }