1 /*

     2 * Copyright (c) 2009-2010 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 * Handles client requests.

    16 *

    17 */

    18 

    19 #include <sysutil.h>

    20 #include <cmconnectionmethoddef.h>

    21 #include <cmpluginembdestinationdef.h>

    22 #include <cmdefconnvalues.h>

    23 

    24 #include "cmmserver.h"

    25 #include "cmmserverdefs.h"

    26 #include "cmmsession.h"

    27 #include "cmmdestinationinstance.h"

    28 #include "cmmconnmethodinstance.h"

    29 

    30 #include "OstTraceDefinitions.h"

    31 #ifdef OST_TRACE_COMPILER_IN_USE

    32 #include "cmmsessionTraces.h"

    33 #endif

    34 

    35 

    36 CCmmSession* CCmmSession::NewL( CCmmServer& aServer, CCmmCache& aCache )

    37     {

    38     OstTraceFunctionEntry0( CCMMSESSION_NEWL_ENTRY );

    39 

    40     CCmmSession* self = CCmmSession::NewLC( aServer, aCache );

    41     CleanupStack::Pop( self );

    42 

    43     OstTraceFunctionExit0( CCMMSESSION_NEWL_EXIT );

    44     return self;

    45     }

    46 

    47 CCmmSession* CCmmSession::NewLC( CCmmServer& aServer, CCmmCache& aCache )

    48     {

    49     OstTraceFunctionEntry0( CCMMSESSION_NEWLC_ENTRY );

    50 

    51     CCmmSession* self = new( ELeave ) CCmmSession( aServer, aCache );

    52     CleanupStack::PushL( self ) ;

    53     self->ConstructL() ;

    54 

    55     OstTraceFunctionExit0( CCMMSESSION_NEWLC_EXIT );

    56     return self ;

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // Constructor.

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

    62 //

    63 CCmmSession::CCmmSession( CCmmServer& aServer, CCmmCache& aCache )

    64         :

    65         iServer( aServer ),

    66         iCache( aCache ),

    67         iFsConnected( EFalse )

    68     {

    69     OstTraceFunctionEntry0( CCMMSESSION_CCMMSESSION_ENTRY );

    70 

    71     iDestinationContainer = NULL;

    72     iDestinationObjects = NULL;

    73     iConnMethodContainer = NULL;

    74     iConnMethodObjects = NULL;

    75 

    76     OstTraceFunctionExit0( CCMMSESSION_CCMMSESSION_EXIT );

    77     }

    78 

    79 // -----------------------------------------------------------------------------

    80 // The second phase of two phase construction.

    81 // -----------------------------------------------------------------------------

    82 //

    83 void CCmmSession::ConstructL()

    84     {

    85     OstTraceFunctionEntry0( CCMMSESSION_CONSTRUCTL_ENTRY );

    86 

    87     iServer.IncrementSessions();

    88 

    89     // Create a new object index (it stores the destination objects owned by

    90     // this session).

    91     iDestinationObjects = CObjectIx::NewL();

    92 

    93     // Initialize the object container using the object container index in the

    94     // server (Object container provides unique ids for the objects owned by

    95     // this session).

    96     iDestinationContainer = iServer.NewContainerL();

    97 

    98     // The same for connection method subsessions.

    99     iConnMethodObjects = CObjectIx::NewL();

   100     iConnMethodContainer = iServer.NewContainerL();

   101 

   102     OstTraceFunctionExit0( CCMMSESSION_CONSTRUCTL_EXIT );

   103     }

   104 

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

   106 // Destructor.

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

   108 //

   109 CCmmSession::~CCmmSession()

   110     {

   111     OstTraceFunctionEntry0( DUP1_CCMMSESSION_CCMMSESSION_ENTRY );

   112 

   113     iServer.DecrementSessions();

   114 

   115     delete iDestinationObjects;

   116     iDestinationObjects = NULL;

   117 

   118     if ( iDestinationContainer != 0 )

   119         {

   120         iServer.RemoveContainer( iDestinationContainer );

   121         iDestinationContainer = NULL;

   122         }

   123 

   124     delete iConnMethodObjects;

   125     iConnMethodObjects = NULL;

   126 

   127     if ( iConnMethodContainer != 0 )

   128         {

   129         iServer.RemoveContainer( iConnMethodContainer );

   130         iConnMethodContainer = NULL;

   131         }

   132 

   133     if ( iFsConnected )

   134         {

   135         iFs.Close();

   136         iFsConnected = EFalse;

   137         }

   138 

   139     OstTraceFunctionExit0( DUP1_CCMMSESSION_CCMMSESSION_EXIT );

   140     }

   141 

   142 // -----------------------------------------------------------------------------

   143 // CCmmSession::ServiceL

   144 // -----------------------------------------------------------------------------

   145 //

   146 void CCmmSession::ServiceL( const RMessage2& aMessage )

   147     {

   148     OstTraceFunctionEntry0( CCMMSESSION_SERVICEL_ENTRY );

   149 

   150     TInt result( KErrNone );

   151     switch ( aMessage.Function() )

   152         {

   153         case ECmmGetBearerInfoInt:

   154             {

   155             GetBearerInfoIntL( aMessage );

   156             }

   157             break;

   158         case ECmmGetBearerInfoBool:

   159             {

   160             GetBearerInfoBoolL( aMessage );

   161             }

   162             break;

   163         case ECmmGetBearerInfoString:

   164             {

   165             GetBearerInfoStringL( aMessage );

   166             }

   167             break;

   168         case ECmmGetBearerInfoString8:

   169             {

   170             GetBearerInfoString8L( aMessage );

   171             }

   172             break;

   173         case ECmmGetConnMethodInfoInt:

   174             {

   175             GetConnMethodInfoIntL( aMessage );

   176             }

   177             break;

   178         case ECmmGetConnMethodInfoBool:

   179             {

   180             GetConnMethodInfoBoolL( aMessage );

   181             }

   182             break;

   183         case ECmmGetConnMethodInfoString:

   184             {

   185             GetConnMethodInfoStringL( aMessage );

   186             }

   187             break;

   188         case ECmmGetConnMethodInfoString8:

   189             {

   190             GetConnMethodInfoString8L( aMessage );

   191             }

   192             break;

   193         case ECmmGetConnMethodArray:

   194             {

   195             GetConnMethodArrayL( aMessage );

   196             }

   197             break;

   198         case ECmmGetAllDestinations:

   199             {

   200             GetAllDestinationsL( aMessage );

   201             }

   202             break;

   203         case ECmmGetEasyWlanId:

   204             {

   205             GetEasyWLANIdL( aMessage );

   206             }

   207             break;

   208         case ECmmRemoveAllReferences: // CM becomes uncategorized.

   209             {

   210             RemoveAllReferencesL( aMessage );

   211             }

   212             break;

   213         case ECmmGetSupportedBearers:

   214             {

   215             GetSupportedBearersL( aMessage );

   216             }

   217             break;

   218         case ECmmGetUncategorizedIcon:

   219             {

   220             GetUncategorizedIconL( aMessage );

   221             }

   222             break;

   223         case ECmmReadDefaultConnection:

   224             {

   225             ReadDefaultConnectionL( aMessage );

   226             }

   227             break;

   228         case ECmmWriteDefaultConnection:

   229             {

   230             // Default connection is now just internet snap.

   231             result = KErrNotSupported;

   232             }

   233             break;

   234         case ECmmReadGeneralConnectionSettings:

   235             {

   236             ReadGenConnSettingsL( aMessage );

   237             }

   238             break;

   239         case ECmmWriteGeneralConnectionSettings:

   240             {

   241             WriteGenConnSettingsL( aMessage );

   242             }

   243             break;

   244         case ECmmGetBearerPriorityArray:

   245             {

   246             GetBearerPriorityArrayL( aMessage );

   247             }

   248             break;

   249         case ECmmUpdateBearerPriorityArray:

   250             {

   251             UpdateBearerPriorityArrayL( aMessage );

   252             }

   253             break;

   254         case ECmmCopyConnMethod:

   255             {

   256             CopyConnMethodL( aMessage );

   257             }

   258             break;

   259         case ECmmMoveConnMethod:

   260             {

   261             MoveConnMethodL( aMessage );

   262             }

   263             break;

   264         case ECmmRemoveConnMethod:

   265             {

   266             RemoveConnMethodL( aMessage );

   267             }

   268             break;

   269 

   270         case EDestGetDestination:

   271         case EDestRefresh:

   272         case EDestCreateDestinationWithName:

   273         case EDestCreateDestinationWithNameAndId:

   274         case EDestCloseDestination:

   275         case EDestGetConnMethodCount:

   276         case EDestGetConnMethodPriority:

   277         case EDestGetName:

   278         case EDestGetId:

   279         case EDestGetElementId:

   280         case EDestMetadata:

   281         case EDestGetProtectionLevel:

   282         case EDestIsConnected:

   283         case EDestIsHidden:

   284         case EDestIsEqual:

   285         case EDestGetIcon:

   286         case EDestAddConnMethod:

   287         case EDestAddEmbeddedDestination:

   288         case EDestDeleteConnMethod:

   289         case EDestRemoveConnMethod:

   290         case EDestModifyPriority:

   291         case EDestSetName:

   292         case EDestSetMetadata:

   293         case EDestSetProtection:

   294         case EDestSetHidden:

   295         case EDestUpdate:

   296         case EDestDelete:

   297         case EDestSetIcon:

   298             {

   299             ServiceDestinationL( aMessage );

   300             }

   301             break;

   302 

   303         case ECMGetConnMethodWithId:

   304         case ECMRefresh:

   305         case ECMCreateConnMethod:

   306         case ECMCreateConnMethodWithId:

   307         case ECMGetConnMethodFromDestWithIndex:

   308         case ECMGetConnMethodFromDestWithId:

   309         case ECMCreateConnMethodToDest:

   310         case ECMCreateConnMethodToDestWithId:

   311         case ECMCreateCopyOfExisting:

   312         case ECMCloseConnMethod:

   313         case ECMGetIntAttribute:

   314         case ECMGetBoolAttribute:

   315         case ECMGetStringAttribute:

   316         case ECMGetString8Attribute:

   317         case ECMIsEqual:

   318         case ECMSetIntAttribute:

   319         case ECMSetBoolAttribute:

   320         case ECMSetStringAttribute:

   321         case ECMSetString8Attribute:

   322         case ECMDelete:

   323         case ECMUpdate:

   324         case EDestGetEmbeddedDestination:

   325             {

   326             ServiceConnMethodL( aMessage );

   327             }

   328             break;

   329         default:

   330             {

   331             result = KErrNotSupported;

   332             }

   333             break;

   334         }

   335 

   336     aMessage.Complete( result );

   337 

   338     OstTraceFunctionExit0( CCMMSESSION_SERVICEL_EXIT );

   339     }

   340 

   341 // -----------------------------------------------------------------------------

   342 // Finds a connection method instance that belongs to this session and matches

   343 // the provided ID. Return NULL if no match is found.

   344 // -----------------------------------------------------------------------------

   345 //

   346 CCmmConnMethodInstance* CCmmSession::FindConnMethodInstanceById(

   347         const TUint32 aConnMethodId )

   348     {

   349     OstTraceFunctionEntry0( CCMMSESSION_FINDCONNMETHODINSTANCEBYID_ENTRY );

   350 

   351     CCmmConnMethodInstance* wantedConnMethodInstance( NULL );

   352 

   353     for ( TInt i = 0; i < iConnMethodObjects->Count(); i++ )

   354         {

   355         CCmmConnMethodInstance* connMethodInstance =

   356                 ( CCmmConnMethodInstance* )( ( *iConnMethodObjects )[i] );

   357         if ( connMethodInstance && connMethodInstance->GetId() == aConnMethodId )

   358             {

   359             wantedConnMethodInstance = connMethodInstance;

   360             break;

   361             }

   362         }

   363 

   364     OstTraceFunctionExit0( CCMMSESSION_FINDCONNMETHODINSTANCEBYID_EXIT );

   365     return wantedConnMethodInstance;

   366     }

   367 

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

   369 // Finds a destination instance that belongs to this session and matches

   370 // the provided handle.

   371 // -----------------------------------------------------------------------------

   372 //

   373 CCmmDestinationInstance* CCmmSession::FindDestinationInstanceByHandleL(

   374         const TInt aDestinationHandle )

   375     {

   376     OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYHANDLEL_ENTRY );

   377 

   378     return (CCmmDestinationInstance*)iDestinationObjects->AtL( aDestinationHandle );

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // Finds a destination instance that belongs to this session and matches

   383 // the provided ID. Return NULL if no match is found.

   384 // -----------------------------------------------------------------------------

   385 //

   386 CCmmDestinationInstance* CCmmSession::FindDestinationInstanceById(

   387         const TUint32 aDestinationId )

   388     {

   389     OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYID_ENTRY );

   390 

   391     CCmmDestinationInstance* wantedDestinationInstance( NULL );

   392 

   393     for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   394         {

   395         CCmmDestinationInstance* destinationInstance =

   396                 ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   397         if ( destinationInstance && destinationInstance->GetId() == aDestinationId )

   398             {

   399             wantedDestinationInstance = destinationInstance;

   400             break;

   401             }

   402         }

   403 

   404     OstTraceFunctionExit0( CCMMSESSION_FINDDESTINATIONINSTANCEBYID_EXIT );

   405     return wantedDestinationInstance;

   406     }

   407 

   408 // -----------------------------------------------------------------------------

   409 // Check from all open destination handles in this session if the given

   410 // connection method is inside any of them. The given destination is skipped.

   411 // -----------------------------------------------------------------------------

   412 //

   413 TBool CCmmSession::ConnMethodInOtherDestination(

   414         const TUint32 aConnMethodId,

   415         const TUint32 aDestinationId )

   416     {

   417     OstTraceFunctionEntry0( CCMMSESSION_CONNMETHODINOTHERDESTINATION_ENTRY );

   418 

   419     for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   420         {

   421         CCmmDestinationInstance* destinationInstance =

   422                 ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   423         if ( destinationInstance && destinationInstance->GetId() != aDestinationId )

   424             {

   425             for ( TInt j = 0; j < destinationInstance->iConnMethodItemArray.Count(); j++ )

   426                 {

   427                 if ( destinationInstance->iConnMethodItemArray[i].iId == aConnMethodId )

   428                     {

   429                     OstTraceFunctionExit0( CCMMSESSION_CONNMETHODINOTHERDESTINATION_EXIT );

   430                     return ETrue;

   431                     }

   432                 }

   433             }

   434         }

   435 

   436     OstTraceFunctionExit0( DUP1_CCMMSESSION_CONNMETHODINOTHERDESTINATION_EXIT );

   437     return EFalse;

   438     }

   439 

   440 // -----------------------------------------------------------------------------

   441 // Check for restrictions for adding an embedded destination from destination

   442 // instances of all clients.

   443 // - aDestinationId is the ID of the destination where a destination is beeing

   444 //   embedded.

   445 // - aEmbeddedDestinationId is the ID of the destination that is beeing

   446 //   embedded.

   447 // -----------------------------------------------------------------------------

   448 //

   449 TBool CCmmSession::EmbeddedDestinationConflictsFromAllSessions(

   450         const TUint32 aDestinationId,

   451         const TUint32 aEmbeddedDestinationId )

   452     {

   453     OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTSFROMALLSESSIONS_ENTRY );

   454 

   455     return iServer.EmbeddedDestinationConflictsFromAllSessions(

   456             aDestinationId,

   457             aEmbeddedDestinationId );

   458     }

   459 

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

   461 // Check for restrictions for adding an embedded destination from destination

   462 // instances of this session.

   463 // - aDestinationId is the ID of the destination where a destination is beeing

   464 //   embedded.

   465 // - aEmbeddedDestinationId is the ID of the destination that is beeing

   466 //   embedded.

   467 //

   468 // - Check that any destination instance does not contain aDestinationId as

   469 //   embedded destination.

   470 // - Check that any destination instance for aEmbeddedDestinationId does not

   471 //   contain an embedded destination.

   472 // -----------------------------------------------------------------------------

   473 //

   474 TBool CCmmSession::EmbeddedDestinationConflicts(

   475         const TUint32 aDestinationId,

   476         const TUint32 aEmbeddedDestinationId )

   477     {

   478     OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTS_ENTRY );

   479 

   480     TBool result( EFalse );

   481 

   482     for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   483         {

   484         CCmmDestinationInstance* destinationInstance =

   485                 ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   486         if ( destinationInstance )

   487             {

   488             if ( destinationInstance->HasEmbeddedWithId( aDestinationId ) ||

   489                     ( destinationInstance->GetId() == aEmbeddedDestinationId &&

   490                             destinationInstance->HasEmbedded() ) )

   491                 {

   492                 result = ETrue;

   493                 break;

   494                 }

   495             }

   496         }

   497 

   498     OstTraceFunctionExit0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTS_EXIT );

   499     return result;

   500     }

   501 

   502 // ---------------------------------------------------------------------------

   503 // After update to database, refresh temporary ID to real ID if necessary and

   504 // refresh status information for any related handles for all client sessions.

   505 // ---------------------------------------------------------------------------

   506 //

   507 void CCmmSession::RefreshHandlesForAllSessions( const TCmmIdStruct& aIdStruct )

   508     {

   509     OstTraceFunctionEntry0( CCMMSESSION_REFRESHHANDLESFORALLSESSIONS_ENTRY );

   510 

   511     // If the ID structure contains a temporary ID, we need to update the

   512     // temporary ID to the real ID for all relevant handles in this session and

   513     // cache.

   514     if ( aIdStruct.iTemporaryId )

   515         {

   516         // Real ID tells if this is a destination or connection method.

   517 

   518         if ( aIdStruct.iRealId < KCmmConnMethodIdIntervalMax )

   519             {

   520             // Connection method. Need to iterate through all destination and

   521             // connection method handles.

   522 

   523             // Update the ID of the connection method on session side.

   524             for ( TInt i = 0; i < iConnMethodObjects->Count(); i++ )

   525                 {

   526                 CCmmConnMethodInstance* connMethodInstance =

   527                         ( CCmmConnMethodInstance* )( ( *iConnMethodObjects )[i] );

   528                 if ( connMethodInstance &&

   529                         connMethodInstance->GetId() == aIdStruct.iTemporaryId )

   530                     {

   531                     connMethodInstance->SetId( aIdStruct.iRealId ); //TODO, need to set ID inside records?

   532                     break; // Can only be 1 match.

   533                     }

   534                 }

   535             // Update the ID of the connection method in cache side also.

   536             iCache.RefreshConnMethodId( aIdStruct );

   537 

   538             // Iterate all destinations. If the connection method is in them,

   539             // update the ID to real ID.

   540             for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   541                 {

   542                 CCmmDestinationInstance* destinationInstance =

   543                         ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   544                 if ( destinationInstance )

   545                     {

   546                     destinationInstance->RefreshConnMethodId( aIdStruct );

   547                     }

   548                 }

   549             }

   550         else

   551             {

   552             // Destination. Need to iterate through all destination handles.

   553             for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   554                 {

   555                 CCmmDestinationInstance* destinationInstance =

   556                         ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   557                 if ( destinationInstance &&

   558                         destinationInstance->GetId() == aIdStruct.iTemporaryId )

   559                     {

   560                     destinationInstance->SetId( aIdStruct.iRealId );

   561                     break; // Can only be 1 match.

   562                     }

   563                 }

   564             // Update the ID of the destination in cache side also.

   565             iCache.RefreshDestinationId( aIdStruct );

   566             }

   567         }

   568 

   569     // Update status information for all related destination/connection method

   570     // handles in all client sessions.

   571     iServer.RefreshHandlesForAllSessions( aIdStruct.iRealId );

   572 

   573     OstTraceFunctionExit0( CCMMSESSION_REFRESHHANDLESFORALLSESSIONS_EXIT );

   574     }

   575 

   576 // ---------------------------------------------------------------------------

   577 // Removes a connection method from any open destination handle in this

   578 // session.

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

   580 //

   581 void CCmmSession::RemoveConnMethodFromDestinationHandles(

   582         const TUint32 aConnMethodId )

   583     {

   584     OstTraceFunctionEntry0( CCMMSESSION_REMOVECONNMETHODFROMDESTINATIONHANDLES_ENTRY );

   585 

   586     for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   587         {

   588         CCmmDestinationInstance* destinationInstance =

   589                 ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   590         if ( destinationInstance )

   591             {

   592             for ( TInt j = 0; j < destinationInstance->iConnMethodItemArray.Count(); j++ )

   593                 {

   594                 if ( destinationInstance->iConnMethodItemArray[j].iId == aConnMethodId )

   595                     {

   596                     destinationInstance->iConnMethodItemArray.Remove( j );

   597                     break;

   598                     }

   599                 }

   600             }

   601         }

   602 

   603     OstTraceFunctionExit0( CCMMSESSION_REMOVECONNMETHODFROMDESTINATIONHANDLES_EXIT );

   604     }

   605 

   606 // ---------------------------------------------------------------------------

   607 // Notify this session destination/connection method handles about an

   608 // updated/deleted destination/connection method.

   609 // ---------------------------------------------------------------------------

   610 //

   611 void CCmmSession::RefreshHandles( const TUint32 aId ) const

   612     {

   613     OstTraceFunctionEntry0( CCMMSESSION_REFRESHHANDLES_ENTRY );

   614 

   615     // Destination or connection method.

   616     if ( aId < KCmmConnMethodIdIntervalMax )

   617         {

   618         // Connection method.

   619         for ( TInt i = 0; i < iConnMethodObjects->Count(); i++ )

   620             {

   621             CCmmConnMethodInstance* connMethodInstance =

   622                     ( CCmmConnMethodInstance* )( ( *iConnMethodObjects )[i] );

   623             if ( connMethodInstance && connMethodInstance->GetId() == aId )

   624                 {

   625                 connMethodInstance->SetStatus( ECmmConnMethodStatusChanged );

   626                 }

   627             }

   628         }

   629     else

   630         {

   631         // Destination.

   632         for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

   633             {

   634             CCmmDestinationInstance* destinationInstance =

   635                     ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

   636             if ( destinationInstance && destinationInstance->GetId() == aId )

   637                 {

   638                 destinationInstance->SetStatus( ECmmDestinationStatusChanged ); //TODO, any record status need be set?

   639                 }

   640             }

   641         }

   642 

   643     OstTraceFunctionExit0( CCMMSESSION_REFRESHHANDLES_EXIT );

   644     }

   645 

   646 // -----------------------------------------------------------------------------

   647 // CCmmSession::GetBearerInfoIntL

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

   649 //

   650 void CCmmSession::GetBearerInfoIntL( const RMessage2& aMessage )

   651     {

   652     OstTraceFunctionEntry0( CCMMSESSION_GETBEARERINFOINTL_ENTRY );

   653 

   654     TUint32 bearerType( aMessage.Int0() );

   655     TUint32 attribute( aMessage.Int1() );

   656 

   657     TUint32 result = iCache.GetBearerInfoIntL( bearerType, attribute );

   658     TPckg<TUint32> resultPckg( result );

   659     aMessage.WriteL( 2, resultPckg );

   660 

   661     OstTraceFunctionExit0( CCMMSESSION_GETBEARERINFOINTL_EXIT );

   662     }

   663 

   664 // -----------------------------------------------------------------------------

   665 // CCmmSession::GetBearerInfoBoolL

   666 // -----------------------------------------------------------------------------

   667 //

   668 void CCmmSession::GetBearerInfoBoolL( const RMessage2& aMessage )

   669     {

   670     OstTraceFunctionEntry0( CCMMSESSION_GETBEARERINFOBOOLL_ENTRY );

   671 

   672     TUint32 bearerType( aMessage.Int0() );

   673     TUint32 attribute( aMessage.Int1() );

   674 

   675     TBool result = iCache.GetBearerInfoBoolL( bearerType, attribute );

   676     TPckg<TBool> resultPckg( result );

   677     aMessage.WriteL( 2, resultPckg );

   678 

   679     OstTraceFunctionExit0( CCMMSESSION_GETBEARERINFOBOOLL_EXIT );

   680     }

   681 

   682 // -----------------------------------------------------------------------------

   683 // CCmmSession::GetBearerInfoStringL

   684 // -----------------------------------------------------------------------------

   685 //

   686 void CCmmSession::GetBearerInfoStringL( const RMessage2& aMessage )

   687     {

   688     OstTraceFunctionEntry0( CCMMSESSION_GETBEARERINFOSTRINGL_ENTRY );

   689 

   690     TUint32 bearerType( aMessage.Int0() );

   691     TUint32 attribute( aMessage.Int1() );

   692 

   693     HBufC* result = iCache.GetBearerInfoStringL( bearerType, attribute );

   694     if ( !result )

   695         {

   696         OstTraceFunctionExit0( CCMMSESSION_GETBEARERINFOSTRINGL_EXIT );

   697         return;

   698         }

   699     CleanupStack::PushL( result );

   700 

   701     TInt bufferLen = aMessage.GetDesMaxLength( 2 );

   702     if ( result->Length() > bufferLen )

   703         {

   704         User::Leave( KErrArgument );

   705         }

   706 

   707     TPtrC resultPtr = result->Des();

   708     aMessage.WriteL( 2, resultPtr );

   709     CleanupStack::PopAndDestroy( result );

   710 

   711     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETBEARERINFOSTRINGL_EXIT );

   712     }

   713 

   714 // -----------------------------------------------------------------------------

   715 // CCmmSession::GetBearerInfoString8L

   716 // -----------------------------------------------------------------------------

   717 //

   718 void CCmmSession::GetBearerInfoString8L( const RMessage2& aMessage )

   719     {

   720     OstTraceFunctionEntry0( CCMMSESSION_GETBEARERINFOSTRING8L_ENTRY );

   721 

   722     TUint32 bearerType( aMessage.Int0() );

   723     TUint32 attribute( aMessage.Int1() );

   724 

   725     HBufC8* result = iCache.GetBearerInfoString8L( bearerType, attribute );

   726     if ( !result )

   727         {

   728         OstTraceFunctionExit0( CCMMSESSION_GETBEARERINFOSTRING8L_EXIT );

   729         return;

   730         }

   731     CleanupStack::PushL( result );

   732 

   733     TInt bufferLen = aMessage.GetDesMaxLength( 2 );

   734     if ( result->Length() > bufferLen )

   735         {

   736         User::Leave( KErrArgument );

   737         }

   738 

   739     TPtrC8 resultPtr = result->Des();

   740     aMessage.WriteL( 2, resultPtr );

   741     CleanupStack::PopAndDestroy( result );

   742 

   743     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETBEARERINFOSTRING8L_EXIT );

   744     }

   745 

   746 // -----------------------------------------------------------------------------

   747 // CCmmSession::GetConnMethodInfoIntL

   748 // -----------------------------------------------------------------------------

   749 //

   750 void CCmmSession::GetConnMethodInfoIntL( const RMessage2& aMessage )

   751     {

   752     OstTraceFunctionEntry0( CCMMSESSION_GETCONNMETHODINFOINTL_ENTRY );

   753 

   754     TUint32 cmId( aMessage.Int0() );

   755     TUint32 attribute( aMessage.Int1() );

   756 

   757     TUint32 result = iCache.GetConnectionMethodInfoIntL( cmId, attribute );

   758     TPckg<TUint32> resultPckg( result );

   759     aMessage.WriteL( 2, resultPckg );

   760 

   761     OstTraceFunctionExit0( CCMMSESSION_GETCONNMETHODINFOINTL_EXIT );

   762     }

   763 

   764 // -----------------------------------------------------------------------------

   765 // CCmmSession::GetConnMethodInfoBoolL

   766 // -----------------------------------------------------------------------------

   767 //

   768 void CCmmSession::GetConnMethodInfoBoolL( const RMessage2& aMessage )

   769     {

   770     OstTraceFunctionEntry0( CCMMSESSION_GETCONNMETHODINFOBOOLL_ENTRY );

   771 

   772     TUint32 cmId( aMessage.Int0() );

   773     TUint32 attribute( aMessage.Int1() );

   774 

   775     TBool result = iCache.GetConnectionMethodInfoBoolL( cmId, attribute );

   776     TPckg<TBool> resultPckg( result );

   777     aMessage.WriteL( 2, resultPckg );

   778 

   779     OstTraceFunctionExit0( CCMMSESSION_GETCONNMETHODINFOBOOLL_EXIT );

   780     }

   781 

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

   783 // CCmmSession::GetConnMethodInfoStringL

   784 // -----------------------------------------------------------------------------

   785 //

   786 void CCmmSession::GetConnMethodInfoStringL( const RMessage2& aMessage )

   787     {

   788     OstTraceFunctionEntry0( CCMMSESSION_GETCONNMETHODINFOSTRINGL_ENTRY );

   789 

   790     TUint32 cmId( aMessage.Int0() );

   791     TUint32 attribute( aMessage.Int1() );

   792 

   793     HBufC* result = iCache.GetConnectionMethodInfoStringL( cmId, attribute );

   794     if ( !result )

   795         {

   796         OstTraceFunctionExit0( CCMMSESSION_GETCONNMETHODINFOSTRINGL_EXIT );

   797         return;

   798         }

   799     CleanupStack::PushL( result );

   800 

   801     TInt bufferLen = aMessage.GetDesMaxLength( 2 );

   802     if ( result->Length() > bufferLen )

   803         {

   804         User::Leave( KErrArgument );

   805         }

   806 

   807     TPtrC resultPtr = result->Des();

   808     aMessage.WriteL( 2, resultPtr );

   809     CleanupStack::PopAndDestroy( result );

   810 

   811     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETCONNMETHODINFOSTRINGL_EXIT );

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // CCmmSession::GetConnMethodInfoString8L

   816 // -----------------------------------------------------------------------------

   817 //

   818 void CCmmSession::GetConnMethodInfoString8L( const RMessage2& aMessage )

   819     {

   820     OstTraceFunctionEntry0( CCMMSESSION_GETCONNMETHODINFOSTRING8L_ENTRY );

   821 

   822     TUint32 cmId( aMessage.Int0() );

   823     TUint32 attribute( aMessage.Int1() );

   824 

   825     HBufC8* result = iCache.GetConnectionMethodInfoString8L( cmId, attribute );

   826     if ( !result )

   827         {

   828         OstTraceFunctionExit0( CCMMSESSION_GETCONNMETHODINFOSTRING8L_EXIT );

   829         return;

   830         }

   831     CleanupStack::PushL( result );

   832 

   833     TInt bufferLen = aMessage.GetDesMaxLength( 2 );

   834     if ( result->Length() > bufferLen )

   835         {

   836         User::Leave( KErrArgument );

   837         }

   838 

   839     TPtrC8 resultPtr = result->Des();

   840     aMessage.WriteL( 2, resultPtr );

   841     CleanupStack::PopAndDestroy( result );

   842 

   843     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETCONNMETHODINFOSTRING8L_EXIT );

   844     }

   845 

   846 // -----------------------------------------------------------------------------

   847 // CCmmSession::GetConnMethodArrayL

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

   849 //

   850 void CCmmSession::GetConnMethodArrayL( const RMessage2& aMessage )

   851     {

   852     OstTraceFunctionEntry0( CCMMSESSION_GETCONNMETHODARRAYL_ENTRY );

   853 

   854     // Read attribute flags from client request.

   855     TPckgBuf<TCmmIpcStructGetConnMethods> parametersPckg;

   856     aMessage.ReadL( 0, parametersPckg );

   857     TCmmIpcStructGetConnMethods attributes = parametersPckg();

   858 

   859     // Create connection method ID array.

   860     RArray<TUint32> cmArray;

   861     CleanupClosePushL( cmArray );

   862     iCache.GetAllConnMethodsL( cmArray, attributes.iCheckBearerType );

   863 

   864     // Check if only legacy connection methods are needed.

   865     if ( attributes.iLegacyOnly )

   866         {

   867         // Remove all referenced connection methods.

   868         for ( TInt i = cmArray.Count() - 1; i >= 0; i-- )

   869             {

   870             if ( iCache.DestinationsContainingConnMethod( cmArray[i] ) )

   871                 {

   872                 cmArray.Remove( i );

   873                 }

   874             }

   875         }

   876 

   877     // EasyWLAN handling.

   878     if ( !attributes.iEasyWlan )

   879         {

   880         // If there is an EasyWLAN IAP, the ID needs to be removed from the array.

   881         TUint32 easyWlanId = iCache.EasyWlanIdL();

   882         if ( easyWlanId != 0 )

   883             {

   884             TInt index = cmArray.Find( easyWlanId );

   885             if ( index != KErrNotFound )

   886                 {

   887                 cmArray.Remove( index );

   888                 }

   889             }

   890         }

   891 

   892     // Check connection method ID count.

   893     TInt connMethodCount = cmArray.Count();

   894     if ( connMethodCount > aMessage.GetDesMaxLengthL( 2 ) )

   895         {

   896         // Client buffer is too small to contain all the informarmation. Return

   897         // without any answer and the client side will ask again using a bigger

   898         // buffer.

   899         CleanupStack::PopAndDestroy( &cmArray );

   900         return;

   901         }

   902 

   903     TPckg<TInt> countPckg( connMethodCount );

   904     aMessage.WriteL( 1, countPckg );

   905 

   906     if ( connMethodCount == 0 )

   907         {

   908         CleanupStack::PopAndDestroy( &cmArray );

   909         return;

   910         }

   911 

   912     // Write connection method IDs to client.

   913     HBufC8* idBuf = HBufC8::NewLC( connMethodCount );

   914     TPtr8 bufPtr( idBuf->Des() );

   915     for ( TInt i = 0; i < connMethodCount; i++ )

   916         {

   917         bufPtr.Append( (TUint8)( cmArray[i] & 0x000000FF ) );

   918         }

   919     aMessage.WriteL( 2, bufPtr );

   920 

   921     CleanupStack::PopAndDestroy( idBuf );

   922     CleanupStack::PopAndDestroy( &cmArray );

   923 

   924     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETCONNMETHODARRAYL_EXIT );

   925     }

   926 

   927 // -----------------------------------------------------------------------------

   928 // CCmmSession::GetAllDestinationsL

   929 // -----------------------------------------------------------------------------

   930 //

   931 void CCmmSession::GetAllDestinationsL( const RMessage2& aMessage )

   932     {

   933     OstTraceFunctionEntry0( CCMMSESSION_GETALLDESTINATIONSL_ENTRY );

   934 

   935     TInt destCount = iCache.GetDestinationCount();

   936     if ( destCount > aMessage.GetDesMaxLengthL( 1 ) )

   937         {

   938         // Client buffer is too small to contain all the informarmation. Return

   939         // without any answer and the client side will ask again using a bigger

   940         // buffer.

   941         return;

   942         }

   943 

   944     // Write the destination count to client.

   945     TPckg<TInt> countPckg( destCount );

   946     aMessage.WriteL( 0, countPckg );

   947 

   948     if ( destCount == 0 )

   949         {

   950         return;

   951         }

   952 

   953     // Get the destination IDs from database cache.

   954     RArray<TUint32> destArray;

   955     CleanupClosePushL( destArray );

   956     iCache.GetDestinationsL( destArray );

   957 

   958     HBufC16* idBuf = HBufC16::NewLC( destCount );

   959     TPtr16 bufPtr( idBuf->Des() );

   960     for ( TInt i = 0; i < destCount; i++ )

   961         {

   962         bufPtr.Append( destArray[i] );

   963         }

   964 

   965     // Write the destination IDs to client.

   966     aMessage.WriteL( 1, bufPtr );

   967 

   968     CleanupStack::PopAndDestroy( idBuf );

   969     CleanupStack::PopAndDestroy( &destArray );

   970 

   971     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETALLDESTINATIONSL_EXIT );

   972     }

   973 

   974 // -----------------------------------------------------------------------------

   975 // CCmmSession::GetEasyWLANIdL

   976 // -----------------------------------------------------------------------------

   977 //

   978 void CCmmSession::GetEasyWLANIdL( const RMessage2& aMessage )

   979     {

   980     OstTraceFunctionEntry0( CCMMSESSION_GETEASYWLANIDL_ENTRY );

   981 

   982     TUint32 id = iCache.EasyWlanIdL();

   983     TPckg<TUint32> idPckg( id );

   984     aMessage.WriteL( 0, idPckg );

   985 

   986     OstTraceFunctionExit0( CCMMSESSION_GETEASYWLANIDL_EXIT );

   987     }

   988 

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

   990 // CCmmSession::GetSupportedBearersL

   991 // -----------------------------------------------------------------------------

   992 //

   993 void CCmmSession::GetSupportedBearersL( const RMessage2& aMessage )

   994     {

   995     OstTraceFunctionEntry0( CCMMSESSION_GETSUPPORTEDBEARERSL_ENTRY );

   996 

   997     // Get the supported bearer types.

   998     RArray<TUint32> bearerArray;

   999     CleanupClosePushL( bearerArray );

  1000     iServer.CmManager()->SupportedBearersL( bearerArray );

  1001 

  1002     // Write bearer count to client.

  1003     TInt bearerCount( bearerArray.Count() );

  1004     TInt neededBufferSize( bearerCount * sizeof( TUint32 ) );

  1005     TPckg<TInt> countPckg( bearerCount );

  1006     aMessage.WriteL( 0, countPckg );

  1007 

  1008     // Check the client buffer size.

  1009     if ( neededBufferSize > aMessage.GetDesMaxLengthL( 1 ) || bearerCount == 0 )

  1010         {

  1011         // Client buffer is too small to contain all the information. Return

  1012         // with only the bearer count information and the client side will ask

  1013         // again using a big enough buffer.

  1014         CleanupStack::PopAndDestroy( &bearerArray );

  1015         return;

  1016         }

  1017 

  1018     // Add the bearer types into a buffer.

  1019     HBufC8* bearerBuf = HBufC8::NewLC( neededBufferSize );

  1020     TPtr8 ptr( bearerBuf->Des() );

  1021     for ( TInt i = 0; i < bearerCount; i++ )

  1022         {

  1023         TUint32 a( bearerArray[i] );

  1024         ptr.Append( (TUint8*)&a, 4 );

  1025         }

  1026 

  1027     // Write the bearer types to client.

  1028     aMessage.WriteL( 1, ptr );

  1029 

  1030     CleanupStack::PopAndDestroy( bearerBuf );

  1031     CleanupStack::PopAndDestroy( &bearerArray );

  1032 

  1033     OstTraceFunctionExit0( DUP1_CCMMSESSION_GETSUPPORTEDBEARERSL_EXIT );

  1034     }

  1035 

  1036 // -----------------------------------------------------------------------------

  1037 // CCmmSession::GetUncategorizedIconL

  1038 // -----------------------------------------------------------------------------

  1039 //

  1040 void CCmmSession::GetUncategorizedIconL( const RMessage2& aMessage )

  1041     {

  1042     OstTraceFunctionEntry0( CCMMSESSION_GETUNCATEGORIZEDICONL_ENTRY );

  1043 

  1044     HBufC* result = KCmmUncategorizedIconName().AllocLC();

  1045 

  1046     TInt bufferLen = aMessage.GetDesMaxLength( 0 );

  1047     if ( result->Length() > bufferLen )

  1048         {

  1049         User::Leave( KErrArgument );

  1050         }

  1051 

  1052     TPtrC resultPtr = result->Des();

  1053     aMessage.WriteL( 0, resultPtr );

  1054     CleanupStack::PopAndDestroy( result );

  1055 

  1056     OstTraceFunctionExit0( CCMMSESSION_GETUNCATEGORIZEDICONL_EXIT );

  1057     }

  1058 

  1059 // -----------------------------------------------------------------------------

  1060 // CCmmSession::ReadDefaultConnectionL

  1061 // -----------------------------------------------------------------------------

  1062 //

  1063 void CCmmSession::ReadDefaultConnectionL( const RMessage2& aMessage )

  1064     {

  1065     OstTraceFunctionEntry0( CCMMSESSION_READDEFAULTCONNECTIONL_ENTRY );

  1066 

  1067     // Default connection is now simply the internet destination.

  1068     TCmDefConnValue defaultConnection;

  1069     defaultConnection.iType = ECmDefConnDestination;

  1070     defaultConnection.iId = 0;

  1071 

  1072     iCache.InternetDestinationIdL( defaultConnection.iId );

  1073     if ( defaultConnection.iId == 0 )

  1074         {

  1075         User::Leave( KErrNotFound );

  1076         }

  1077 

  1078     TPckgBuf<TCmDefConnValue> dcPckgBuf( defaultConnection );

  1079     aMessage.WriteL( 0, dcPckgBuf );

  1080 

  1081     OstTraceFunctionExit0( CCMMSESSION_READDEFAULTCONNECTIONL_EXIT );

  1082     }

  1083 

  1084 // -----------------------------------------------------------------------------

  1085 // CCmmSession::ReadGenConnSettingsL

  1086 // -----------------------------------------------------------------------------

  1087 //

  1088 void CCmmSession::ReadGenConnSettingsL( const RMessage2& aMessage )

  1089     {

  1090     OstTraceFunctionEntry0( CCMMSESSION_READGENCONNSETTINGSL_ENTRY );

  1091 

  1092     TCmGenConnSettings genConnSettings;

  1093     iCache.ReadGenConnSettingsL( genConnSettings );

  1094 

  1095     TPckgBuf<TCmGenConnSettings> genConnSettingsPckgBuf( genConnSettings );

  1096     aMessage.WriteL( 0, genConnSettingsPckgBuf );

  1097 

  1098     OstTraceFunctionExit0( CCMMSESSION_READGENCONNSETTINGSL_EXIT );

  1099     }

  1100 

  1101 // -----------------------------------------------------------------------------

  1102 // CCmmSession::WriteGenConnSettingsL

  1103 // -----------------------------------------------------------------------------

  1104 //

  1105 void CCmmSession::WriteGenConnSettingsL( const RMessage2& aMessage )

  1106     {

  1107     OstTraceFunctionEntry0( CCMMSESSION_WRITEGENCONNSETTINGSL_ENTRY );

  1108 

  1109     // Read data from client request.

  1110     TPckgBuf<TCmGenConnSettings> genConnSettingsPckgBuf;

  1111     aMessage.ReadL( 0, genConnSettingsPckgBuf );

  1112     TCmGenConnSettings genConnSettings = genConnSettingsPckgBuf();

  1113 

  1114     iCache.WriteGenConnSettingsL( genConnSettings );

  1115 

  1116     OstTraceFunctionExit0( CCMMSESSION_WRITEGENCONNSETTINGSL_EXIT );

  1117     }

  1118 

  1119 // -----------------------------------------------------------------------------

  1120 // CCmmSession::GetBearerPriorityArrayL

  1121 // -----------------------------------------------------------------------------

  1122 //

  1123 void CCmmSession::GetBearerPriorityArrayL( const RMessage2& aMessage )

  1124     {

  1125     OstTraceFunctionEntry0( CCMMSESSION_GETBEARERPRIORITYARRAYL_ENTRY );

  1126 

  1127     const TInt maxLength( aMessage.GetDesMaxLengthL( 0 ) );

  1128     if ( maxLength < 2 )

  1129         {

  1130         // Minimum length of 2 is needed to store count and needed length.

  1131         User::Leave( KErrArgument );

  1132         }

  1133 

  1134     RPointerArray<CCmmBearerPriority> bearerPriorityArray;