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 * Database cache manager.

    16 *

    17 */

    18 

    19 

    20 #include <e32base.h>

    21 #include <cmpluginbaseeng.h>

    22 #include <cmdefconnvalues.h>

    23 #include <cmpluginembdestinationdef.h>

    24 

    25 #include <es_sock.h>    // RSocketServ, RConnection

    26 #include <in_sock.h>    // KAfInet

    27 #include <es_enum.h>    // TConnectionInfo

    28 

    29 #include "cmmdestinationstruct.h"

    30 #include "cmmlistenermanager.h"

    31 #include "cmminstancemapping.h"

    32 

    33 #include "cmmcache.h"

    34 

    35 #include "cmmdestinationinstance.h"

    36 #include "cmmconnmethodinstance.h"

    37 

    38 #include "cmmtransactionhandler.h"

    39 #include "cmmanagerimpl.h"

    40 #include "cmmbearerprioritycache.h"

    41 

    42 #include "OstTraceDefinitions.h"

    43 #ifdef OST_TRACE_COMPILER_IN_USE

    44 #include "cmmcacheTraces.h"

    45 #endif

    46 

    47 

    48 // ---------------------------------------------------------------------------

    49 // Two phased construction.

    50 // ---------------------------------------------------------------------------

    51 //

    52 CCmmCache* CCmmCache::NewL(

    53         CCmManagerImpl* aCmManagerImpl,

    54         CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

    55     {

    56     OstTraceFunctionEntry0( CCMMCACHE_NEWL_ENTRY );

    57 

    58     CCmmCache* self = CCmmCache::NewLC( aCmManagerImpl, aPlugins );

    59     CleanupStack::Pop( self );

    60 

    61     OstTraceFunctionExit0( CCMMCACHE_NEWL_EXIT );

    62 

    63     return self;

    64     }

    65 

    66 // ---------------------------------------------------------------------------

    67 // Two phased construction.

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

    69 //

    70 CCmmCache* CCmmCache::NewLC(

    71         CCmManagerImpl* aCmManagerImpl,

    72         CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

    73     {

    74     OstTraceFunctionEntry0( CCMMCACHE_NEWLC_ENTRY );

    75 

    76     CCmmCache* self = new( ELeave ) CCmmCache( aCmManagerImpl, aPlugins );

    77     CleanupStack::PushL( self );

    78     self->ConstructL();

    79 

    80     OstTraceFunctionExit0( CCMMCACHE_NEWLC_EXIT );

    81 

    82     return self;

    83     }

    84 

    85 // ---------------------------------------------------------------------------

    86 // Destructor.

    87 // ---------------------------------------------------------------------------

    88 //

    89 CCmmCache::~CCmmCache()

    90     {

    91     OstTraceFunctionEntry0( CCMMCACHE_CCMMCACHE_ENTRY );

    92 

    93     delete iBearerPriorityCache;

    94     delete iListenerManager;

    95     delete iInstanceMapping;

    96 

    97     iConnMethodArray.ResetAndDestroy();

    98     iDestinationArray.ResetAndDestroy();

    99 

   100     iDeletedConnMethods.Close();

   101     iUpdatedConnMethods.Close();

   102     iUpdatedConnMethods2.Close(); // Does not own contents.

   103     iUpdatedDestinations.Close();

   104     iUpdatedDestinations2.Close(); // Does not own contents.

   105 

   106     OstTraceFunctionExit0( CCMMCACHE_CCMMCACHE_EXIT );

   107     }

   108 

   109 // ---------------------------------------------------------------------------

   110 // Constructor.

   111 // ---------------------------------------------------------------------------

   112 //

   113 CCmmCache::CCmmCache(

   114         CCmManagerImpl* aCmManagerImpl,

   115         CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

   116         :

   117         iPlugins( aPlugins ),

   118         iCmManagerImpl( aCmManagerImpl )

   119     {

   120     OstTraceFunctionEntry0( DUP1_CCMMCACHE_CCMMCACHE_ENTRY );

   121 

   122     iListenerManager = NULL;

   123     iInstanceMapping = NULL;

   124     iTrans = NULL;

   125     iBearerPriorityCache = NULL;

   126     iCurrentTemporaryId = KTemporaryIdCounterStart;

   127 

   128     iSnapTableId = 0;

   129     iSnapMetadataTableId = 0;

   130 

   131     OstTraceFunctionExit0( DUP1_CCMMCACHE_CCMMCACHE_EXIT );

   132     }

   133 

   134 // ---------------------------------------------------------------------------

   135 // Second phase constructor.

   136 // ---------------------------------------------------------------------------

   137 //

   138 void CCmmCache::ConstructL()

   139     {

   140     OstTraceFunctionEntry0( CCMMCACHE_CONSTRUCTL_ENTRY );

   141 

   142     iTrans = iCmManagerImpl->GetTransactionHandler();

   143 

   144     iBearerPriorityCache = CCmmBearerPriorityCache::NewL(

   145             iTrans,

   146             iCmManagerImpl->TableId( ECmmDbBearerPriorityRecord ) );

   147     iListenerManager = CCmmListenerManager::NewL( this );

   148     iInstanceMapping = CCmmInstanceMapping::NewL( *this );

   149 

   150     // Create CommsDat listeners to detect changes to the database from external sources.

   151     RArray<TUint32> tableIdArray;

   152     CleanupClosePushL( tableIdArray );

   153 

   154     iSnapTableId = iCmManagerImpl->TableId( ECmmDbSnapRecord );

   155     iSnapMetadataTableId = iCmManagerImpl->TableId( ECmmDestMetadataRecord );

   156 

   157     // Instancemapping needs notifications on following tables.

   158     tableIdArray.Append( CommsDat::KCDTIdIAPRecord );

   159     tableIdArray.Append( CommsDat::KCDTIdVPNServiceRecord );

   160     tableIdArray.Append( iSnapTableId );

   161     tableIdArray.Append( iSnapMetadataTableId );

   162 

   163     // Destinations need notifications on following tables.

   164     tableIdArray.Append( CommsDat::KCDTIdNetworkRecord );

   165     tableIdArray.Append( CommsDat::KCDTIdAccessPointRecord );

   166     // Destination metadata table was already added.

   167 

   168     // Connection methods need notifications on following tables.

   169     TInt pluginCount( iPlugins->Count() );

   170     if ( pluginCount )

   171         {

   172         ( *iPlugins )[0]->GetGenericTableIdsToBeObservedL( tableIdArray );

   173         for( TInt i = 0; i < pluginCount; i++ )

   174             {

   175             ( *iPlugins )[i]->GetBearerTableIdsToBeObservedL( tableIdArray );

   176             }

   177         }

   178 

   179     for ( TInt i = 0; i < tableIdArray.Count(); i++ )

   180         {

   181         iListenerManager->AddListenerL( tableIdArray[i] );

   182         }

   183     CleanupStack::PopAndDestroy( &tableIdArray );

   184 

   185     OstTraceFunctionExit0( CCMMCACHE_CONSTRUCTL_EXIT );

   186     }

   187 

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

   189 // Opens a destination with given ID (if not already opened), then copies the

   190 // relevant data to the session instance. Checks that destination ID is valid.

   191 // ---------------------------------------------------------------------------

   192 //

   193 void CCmmCache::OpenDestinationL(

   194         CCmmDestinationInstance& aDestinationInstance,

   195         const TUint32 aDestinationId )

   196     {

   197     OstTraceFunctionEntry0( CCMMCACHE_OPENDESTINATIONL_ENTRY );

   198 

   199     if ( !iInstanceMapping->ValidDestinationId( aDestinationId ) )

   200         {

   201         User::Leave( KErrNotFound );

   202         }

   203 

   204     TInt index = FindDestinationFromCache( aDestinationId );

   205     if ( index == KErrNotFound )

   206         {

   207         // Cache does not have a handle open to this destination. A new handle

   208         // needs to be created first.

   209         CCmmDestinationStruct* destination = CCmmDestinationStruct::NewLC(

   210                 this,

   211                 iTrans,

   212                 aDestinationId );

   213 

   214         // Now that cache has a handle on this destination, copy the relevant

   215         // data to the session instance.

   216         destination->CreateDestinationInstanceL( aDestinationInstance );

   217 

   218         iDestinationArray.AppendL( destination );

   219         CleanupStack::Pop( destination );

   220         }

   221     else

   222         {

   223         // Cache already has a handle on this destination. Copy the relevant

   224         // data to the session instance.

   225         iDestinationArray[index]->CreateDestinationInstanceL( aDestinationInstance );

   226         }

   227 

   228     // Add list of currently contained connection methods.

   229     iInstanceMapping->GetConnMethodsFromDestinationL(

   230             aDestinationId,

   231             aDestinationInstance.iConnMethodItemArray );

   232 

   233     OstTraceFunctionExit0( CCMMCACHE_OPENDESTINATIONL_EXIT );

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // Refresh the data contained in aDestinationInstance. This means reloading

   238 // the data from database if necessary. After this call the contents of

   239 // aDestinationInstance will reflect the current state in the database. 

   240 // ---------------------------------------------------------------------------

   241 //

   242 void CCmmCache::RefreshDestinationL( CCmmDestinationInstance& aDestinationInstance )

   243     {

   244     OstTraceFunctionEntry0( CCMMCACHE_REFRESHDESTINATIONL_ENTRY );

   245 

   246     TInt index = FindDestinationFromCache( aDestinationInstance.GetId() );

   247     if ( index == KErrNotFound )

   248         {

   249         index = FindNotSavedDestinationFromCacheL( aDestinationInstance.GetDestinationNameL(), 0 );

   250         if ( index == KErrNotFound )

   251             {

   252             User::Leave( KErrNotFound );

   253             }

   254         }

   255 

   256     // If this destination is a newly created one that doesn't yet exist in

   257     // database, just return silently.

   258     if ( iDestinationArray[index]->GetStatus() == ECmmDestinationStatusNotSaved )

   259         {

   260         OstTraceFunctionExit0( CCMMCACHE_REFRESHDESTINATIONL_EXIT );

   261         return;

   262         }

   263 

   264     iDestinationArray[index]->RefreshDestinationInstanceL( aDestinationInstance );

   265 

   266     OstTraceFunctionExit0( DUP1_CCMMCACHE_REFRESHDESTINATIONL_EXIT );

   267     }

   268 

   269 // ---------------------------------------------------------------------------

   270 // Create a new destination into cache (with name and ID) and copy the data

   271 // into session side handle.

   272 // ---------------------------------------------------------------------------

   273 //

   274 void CCmmCache::CreateDestinationL(

   275         CCmmDestinationInstance& aDestinationInstance,

   276         const TDesC& aName,

   277         const TUint32 aId )

   278     {

   279     OstTraceFunctionEntry0( CCMMCACHE_CREATEDESTINATIONL_ENTRY );

   280 

   281     // Create a new destination with given name.

   282     CCmmDestinationStruct* destination = CCmmDestinationStruct::NewLC( this, iTrans, aName, aId );

   283 

   284     destination->CreateDestinationInstanceL( aDestinationInstance );

   285 

   286     iDestinationArray.AppendL( destination );

   287     CleanupStack::Pop( destination );

   288 

   289     OstTraceFunctionExit0( CCMMCACHE_CREATEDESTINATIONL_EXIT );

   290     }

   291 

   292 // ---------------------------------------------------------------------------

   293 // Opens a connection method with given ID (if not already opened), then

   294 // creates and passes an instance of it to the caller.

   295 // If aDestinationInstance is not NULL, connection method is opened from

   296 // destination.

   297 // ---------------------------------------------------------------------------

   298 //

   299 void CCmmCache::OpenConnMethodL(

   300         CCmmConnMethodInstance& aConnMethodInstance,

   301         CCmmDestinationInstance* aDestinationInstance,

   302         const TUint32 aConnMethodId )

   303     {

   304     OstTraceFunctionEntry0( CCMMCACHE_OPENCONNMETHODL_ENTRY );

   305 

   306     // Check connection method ID.

   307     TBool validAttributes( EFalse );

   308     if ( !aDestinationInstance )

   309         {

   310         // Check connection method exists in database.

   311         // Embedded destinations not included.

   312         validAttributes = iInstanceMapping->ValidConnMethodId( aConnMethodId );

   313         }

   314     else

   315         {

   316         // Check connection method is inside the destination.

   317         if ( aDestinationInstance->

   318                 ValidConnMethodIdInDestinationIncludeEmbedded( aConnMethodId ) )

   319             {

   320             // Check connection method (can be embedded destination too)

   321             // exists in database.

   322             if ( iInstanceMapping->ValidConnMethodId( aConnMethodId ) ||

   323                     iInstanceMapping->ValidDestinationId( aConnMethodId ) )

   324                 {

   325                 validAttributes = ETrue;

   326                 }

   327             }

   328        }

   329     if ( !validAttributes )

   330         {

   331         User::Leave( KErrNotFound );

   332         }

   333 

   334     // Create the connection method instance.

   335 

   336     // Check if connection method is already opened in cache.

   337     TInt index = FindConnMethodFromCache( aConnMethodId );

   338     if ( index != KErrNotFound )

   339         {

   340         // Update data from commsdat if necessary.

   341         if ( iConnMethodArray[index]->GetRecordStatus() == ECmmRecordStatusExpired )

   342             {

   343             iConnMethodArray[index]->ReloadPluginDataIfNeededL();

   344             // CopyDataL() will set the internal state of aConnMethodInstance.

   345             }

   346 

   347         // Already open in cache. Copy the connection method data to session

   348         // instance.

   349         // Will increase reference counter.

   350         aConnMethodInstance.CopyDataL( iConnMethodArray[index] );

   351         }

   352     else

   353         {

   354         // Not yet open in cache, open now.

   355         OpenConnectionMethodInstanceL( aConnMethodInstance, aConnMethodId );

   356         }

   357 

   358     OstTraceFunctionExit0( CCMMCACHE_OPENCONNMETHODL_EXIT );

   359     }

   360 

   361 // ---------------------------------------------------------------------------

   362 // Refresh the data contained in aConnMethodInstance. This means reloading the

   363 // data from database if necessary. After this call the contents of

   364 // aConnMethodInstance will reflect the current state in the database. 

   365 // ---------------------------------------------------------------------------

   366 //

   367 void CCmmCache::RefreshConnMethodL( CCmmConnMethodInstance& aConnMethodInstance )

   368     {

   369     OstTraceFunctionEntry0( CCMMCACHE_REFRESHCONNMETHODL_ENTRY );

   370 

   371     // If embedded destination --> refresh through destination API.

   372     if ( aConnMethodInstance.IsEmbeddedDestination() )

   373         {

   374         return;

   375         }

   376 

   377     TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );

   378     if ( index == KErrNotFound )

   379         {

   380         User::Leave( KErrNotFound );

   381         }

   382 

   383     // If this connection method is a newly created one that doesn't yet exist

   384     // in database, just return silently.

   385     if ( iConnMethodArray[index]->GetStatus() == ECmmConnMethodStatusNotSaved )

   386         {

   387         OstTraceFunctionExit0( CCMMCACHE_REFRESHCONNMETHODL_EXIT );

   388         return;

   389         }

   390 

   391     iConnMethodArray[index]->ReloadPluginDataIfNeededL();

   392     if ( iConnMethodArray[index]->GetStatus() == ECmmConnMethodStatusValid

   393             || iConnMethodArray[index]->GetStatus() == ECmmConnMethodStatusToBeDeleted )

   394         {

   395         iConnMethodArray[index]->GetPlugin()->GetPluginDataL( 

   396                 aConnMethodInstance.GetPluginDataInstance() );

   397         }

   398     // Internal state need to be set to the same state as after a successfull update.

   399     aConnMethodInstance.UpdateSuccessful();

   400 

   401     OstTraceFunctionExit0( DUP1_CCMMCACHE_REFRESHCONNMETHODL_EXIT );

   402     }

   403 

   404 // ---------------------------------------------------------------------------

   405 // Creates a new connection method (not embedded destinations) into database

   406 // with the given bearer type and optionally ID, then creates and passes an

   407 // instance of it to the caller.

   408 // If destination instance is provided (not NULL), connection method is

   409 // created in that destination.

   410 // If connection method ID is provided, it's availability is verified.

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

   412 //

   413 void CCmmCache::CreateConnMethodL(

   414         CCmmConnMethodInstance& aConnMethodInstance,

   415         CCmmDestinationInstance* aDestinationInstance,

   416         const TUint32 aBearerType,

   417         const TUint32 aConnMethodId )

   418     {

   419     OstTraceFunctionEntry0( CCMMCACHE_CREATECONNMETHODL_ENTRY );

   420 

   421     // Check that the bearer type is not embedded destination.

   422     if ( aBearerType == KUidEmbeddedDestination )

   423         {

   424         User::Leave( KErrArgument );

   425         }

   426 

   427     TUint32 connMethodId( aConnMethodId );

   428     if ( aConnMethodId )

   429         {

   430         // Check if a connection method with given ID exists (or is already

   431         // created but not saved).

   432         if ( iInstanceMapping->ValidConnMethodId( aConnMethodId ) ||

   433                 ConnMethodOpenWithId( aConnMethodId ) )

   434             {

   435             User::Leave( KErrAlreadyExists );

   436             }

   437         }

   438     else

   439         {

   440         // Use a temporary ID until a real one is received from database.

   441         connMethodId = NextFreeTemporaryId();

   442         }

   443 

   444 

   445     // Check bearer type support and create plugin instance.

   446     CCmPluginBaseEng* plugin = NULL;

   447     for ( TInt i = 0; i < iPlugins->Count(); i++ )

   448         {

   449         if ( ( *iPlugins )[i]->GetBearerInfoIntL( CMManager::ECmBearerType ) == aBearerType )

   450             {

   451             TCmPluginInitParam pluginParams( Session() );

   452             plugin = ( *iPlugins )[i]->CreateInstanceL( pluginParams );

   453             CleanupStack::PushL( plugin );

   454             plugin->CreateNewL( aConnMethodId ); // Use aConnMethodId here, so ID is either a real ID or 0.

   455             break;

   456             }

   457         }

   458     if ( !plugin )

   459         {

   460         User::Leave( KErrArgument );

   461         }

   462 

   463 

   464     // Store the connection method into cache.

   465     // Use connMethodId here, so ID is either a real ID or a temporary ID.

   466     CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewL( connMethodId );

   467     connMethodStruct->SetPlugin( plugin, aBearerType, ECmmConnMethodStatusNotSaved );

   468     CleanupStack::Pop( plugin );

   469     CleanupStack::PushL( connMethodStruct );

   470     iConnMethodArray.AppendL( connMethodStruct );

   471     CleanupStack::Pop( connMethodStruct );

   472 

   473     // Copy the connection method data to session instance.

   474     aConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.

   475 

   476 

   477     if ( aDestinationInstance )

   478         {

   479         // Add connection method to destination.

   480         aDestinationInstance->AddConnMethodL( aConnMethodInstance );

   481         }

   482 

   483     OstTraceFunctionExit0( CCMMCACHE_CREATECONNMETHODL_EXIT );

   484     }

   485 

   486 // ---------------------------------------------------------------------------

   487 // Creates a new connection method into cache as a copy of an existing

   488 // connection method (exists in cache, not necessarily in database), and opens

   489 // a client side handle to it. The new connection method will get a new ID when

   490 // updated to database.

   491 // ---------------------------------------------------------------------------

   492 //

   493 void CCmmCache::CreateCopyOfConnMethodL(

   494         CCmmConnMethodInstance& aNewConnMethodInstance,

   495         CCmmConnMethodInstance& aConnMethodInstance )

   496     {

   497     OstTraceFunctionEntry0( CCMMCACHE_CREATECOPYOFCONNMETHODL_ENTRY );

   498 

   499     // Check bearer type support and create plugin instance.

   500     TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );

   501     if ( index == KErrNotFound )

   502         {

   503         User::Leave( index );

   504         }

   505 

   506     CCmPluginBaseEng* plugin = iConnMethodArray[index]->GetPlugin();

   507     if ( !plugin )

   508         {

   509         User::Leave( KErrNotFound );

   510         }

   511 

   512     CCmPluginBaseEng* pluginCopy =

   513             plugin->CreateCopyL( aConnMethodInstance.GetPluginDataInstance() );

   514     CleanupStack::PushL( pluginCopy );

   515 

   516     // Store the connection method into cache.

   517     CCmmConnMethodStruct* connMethodStruct =

   518             CCmmConnMethodStruct::NewL( NextFreeTemporaryId() );

   519     connMethodStruct->SetPlugin(

   520             pluginCopy,

   521             aConnMethodInstance.GetBearerType(),

   522             ECmmConnMethodStatusNotSaved );

   523     CleanupStack::Pop( pluginCopy );

   524     CleanupStack::PushL( connMethodStruct );

   525     iConnMethodArray.AppendL( connMethodStruct );

   526     CleanupStack::Pop( connMethodStruct );

   527 

   528     // Copy the connection method data to session instance.

   529     aNewConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.

   530 

   531     OstTraceFunctionExit0( CCMMCACHE_CREATECOPYOFCONNMETHODL_EXIT );

   532     }

   533 

   534 // ---------------------------------------------------------------------------

   535 // Reloads a destination record if needed and copies the latest version to

   536 // the session instance given as parameter.

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

   538 //

   539 void CCmmCache::LoadDestinationRecordL(

   540         CCmmDestinationInstance& aDestinationInstance,

   541         TCmmDbRecords aDestRecordType )

   542     {

   543     OstTraceFunctionEntry0( CCMMCACHE_LOADDESTINATIONRECORDL_ENTRY );

   544 

   545     TUint32 id = aDestinationInstance.GetId();

   546     // If ID is not in the valid range, it means the destination is a newly

   547     // created one, and doesn't yet exist in database. Thus, record data exists

   548     // only in session side and can't be loaded from cache. So this is an error.

   549     if ( id >= KTemporaryIdCounterStart )

   550         {

   551         User::Leave( KErrCorrupt );

   552         }

   553     TInt index = FindDestinationFromCache( id );

   554     if ( index < 0 )

   555         {

   556         User::Leave( index );

   557         }

   558 

   559     iDestinationArray[index]->LoadRecordL( aDestinationInstance, aDestRecordType );

   560 

   561     OstTraceFunctionExit0( CCMMCACHE_LOADDESTINATIONRECORDL_EXIT );

   562     }

   563 

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

   565 // Saves the modifications in aDestinationInstance into the database. Also all

   566 // connection methods inside this destination are updated (including any

   567 // embedded destination).

   568 // ---------------------------------------------------------------------------

   569 //

   570 void CCmmCache::UpdateDestinationL( CCmmDestinationInstance& aDestinationInstance )

   571     {

   572     OstTraceFunctionEntry0( CCMMCACHE_UPDATEDESTINATIONL_ENTRY );

   573 

   574     // Arrays to temporarily store information of updated destinations and

   575     // connection methods. Used to update status and ID information after

   576     // successful commit to database.

   577     if ( iTrans->GetReferenceCount() == 0 )

   578         {

   579         iDeletedConnMethods.Reset();

   580         iUpdatedConnMethods.Reset();

   581         iUpdatedConnMethods2.Reset();

   582         iUpdatedDestinations.Reset();

   583         iUpdatedDestinations2.Reset();

   584         }

   585 

   586     TInt index = FindDestinationFromCache( aDestinationInstance.GetId() );

   587     if ( index < 0 )

   588         {

   589         User::Leave( index );

   590         }

   591 

   592     iTrans->OpenTransactionLC();

   593 

   594     // Check that the connection methods marked for deletion can be deleted.

   595     for ( TInt i = 0; i < aDestinationInstance.iConnMethodsToBeDeleted.Count(); i++ )

   596         {

   597         TUint32 id = aDestinationInstance.iConnMethodsToBeDeleted[i];

   598 

   599         // Remove connection method from delete list if ID is not valid or if

   600         // referenced from any other destination (in database or in any other

   601         // client-side destination handles).

   602         if ( !iInstanceMapping->ValidConnMethodId( id ) ||

   603                 iInstanceMapping->ConnMethodInOtherDestination(

   604                         id,

   605                         aDestinationInstance.GetId() ) ||

   606                 aDestinationInstance.ConnMethodInOtherDestinationInSession( id, 0 ) )

   607             {

   608             aDestinationInstance.iConnMethodsToBeDeleted.Remove( i );

   609             i--; // Adjust array index counter.

   610             }

   611         else if ( iInstanceMapping->ConnMethodPointedToByVirtualIap( id ) )

   612             {

   613             aDestinationInstance.iConnMethodsToBeDeleted.Remove( i );

   614             User::Leave( KErrLocked );

   615             }

   616         else if ( CheckIfCmConnected( id ) )

   617             {

   618             User::Leave( KErrInUse );

   619             }

   620         }

   621     // Delete connection methods marked for deletion.

   622     for ( TInt i = 0; i < aDestinationInstance.iConnMethodsToBeDeleted.Count(); i++ )

   623         {

   624         DeleteConnMethodAsPartOfDestinationUpdateL(

   625                 aDestinationInstance.iConnMethodsToBeDeleted[i] );

   626         }

   627 

   628     // Update the connection methods inside this destination.

   629     for ( TInt i = 0; i < aDestinationInstance.iConnMethodItemArray.Count(); i++ )

   630         {

   631         if ( aDestinationInstance.iConnMethodItemArray[i].IsEmbedded() )

   632             {

   633             // Embedded destination.

   634 

   635             //TODO, Maybe check other restrictions on embedded destination.

   636             // - Only one embedded destination per destination. Check.

   637             // - No embedded destinations in embedded destination. Check.

   638 

   639             TUint32 id( aDestinationInstance.iConnMethodItemArray[i].iId );

   640             CCmmDestinationInstance* destinationInstance =

   641                     aDestinationInstance.FindDestinationInstanceFromSessionById( id );

   642 

   643             if ( destinationInstance )

   644                 {

   645                 // Client has a handle open to this destination, update it.

   646                 destinationInstance->UpdateL();

   647                 }

   648             else

   649                 {

   650                 // TODO: Or, should we update the embedded destination if the

   651                 // client has an open handle to any of the embedded

   652                 // destinations connection methods.

   653                 //

   654                 // Skip update since client doesn't have an open handle to this

   655                 // destination.

   656                 if ( id >= KTemporaryIdCounterStart ||

   657                         !iInstanceMapping->ValidDestinationId( id ) )

   658                     {

   659                     // Remove destination item from array if:

   660                     // - New destination, but client has already closed the handle for it.

   661                     // - Destination ID was valid before, but it does not exist anymore.

   662                     aDestinationInstance.iConnMethodItemArray.Remove( i );

   663                     i--; // Adjust array index counter.

   664                     }

   665                 }

   666             }

   667         else

   668             {

   669             TBool temporaryConnMethodInstance( EFalse );

   670             TBool connMethodProtectionMustBeSet( EFalse );

   671             TBool cmProtected( EFalse );

   672 

   673             TUint32 id( aDestinationInstance.iConnMethodItemArray[i].iId );

   674             CCmmConnMethodInstance* connMethodInstance =

   675                     aDestinationInstance.FindConnMethodInstanceFromSessionById( id );

   676 

   677             if ( !connMethodInstance )

   678                 {

   679                 // Remove connection method item from the array if it is a new

   680                 // connection method but client has already closed the handle

   681                 // for it, or the connection method ID was valid before but

   682                 // does not exist anymore.

   683                 if ( id >= KTemporaryIdCounterStart || !iInstanceMapping->ValidConnMethodId( id ) )

   684                     {

   685                     aDestinationInstance.iConnMethodItemArray.Remove( i );

   686                     i--; // Adjust array index counter.

   687                     continue; // Jump to next connection method.

   688                     }

   689                 }

   690 

   691             if ( aDestinationInstance.ProtectionChanged() )

   692                 {

   693                 // Check if the connection method protection level needs to be set.

   694                 switch ( aDestinationInstance.CurrentProtectionLevelL() )

   695                     {

   696                     case CMManager::EProtLevel0:

   697                     case CMManager::EProtLevel2:

   698                         {

   699                         if ( aDestinationInstance.LastProtectionLevel() ==

   700                                 CMManager::EProtLevel1 ||

   701                                 aDestinationInstance.LastProtectionLevel() ==

   702                                 CMManager::EProtLevel3 )

   703                             {

   704                             connMethodProtectionMustBeSet = ETrue;

   705                             cmProtected = EFalse;

   706                             }

   707                         }

   708                         break;

   709                     case CMManager::EProtLevel1:

   710                     case CMManager::EProtLevel3:

   711                         {

   712                         connMethodProtectionMustBeSet = ETrue;

   713                         cmProtected = ETrue;

   714                         }

   715                         break;

   716                     default:

   717                         break;

   718                     }

   719                 }

   720 

   721             if ( connMethodProtectionMustBeSet && !connMethodInstance )

   722                 {

   723                 // Client doesn't have an open handle to this connection method,

   724                 // but it still needs to be updated because the destination's

   725                 // protection level has been changed in such a way that

   726                 // requires a change in all contained connection methods also.

   727                 temporaryConnMethodInstance = ETrue;

   728                 connMethodInstance = CCmmConnMethodInstance::NewLC( NULL, this );

   729                 OpenConnMethodL( *connMethodInstance, NULL, id );

   730 

   731                 // Read current protection level.

   732                 TBool current = connMethodInstance->GetBoolAttributeL( CMManager::ECmProtected );

   733                 if ( cmProtected == current )

   734                     {

   735                     // If the connection method already has the correct

   736                     // protection setting, skip the unnecessary update.

   737                     connMethodProtectionMustBeSet = EFalse;

   738                     temporaryConnMethodInstance = EFalse;

   739                     CleanupStack::PopAndDestroy( connMethodInstance );

   740                     connMethodInstance = NULL;

   741                     }

   742                 }

   743 

   744             // Update the connection method.

   745             if ( connMethodInstance )

   746                 {

   747                 if ( connMethodProtectionMustBeSet )

   748                     {

   749                     connMethodInstance->SetBoolAttributeL( CMManager::ECmProtected, cmProtected );

   750                     }

   751                 connMethodInstance->UpdateL( temporaryConnMethodInstance );

   752                 }

   753 

   754             // Cleanup connection method handle, if it was temporary.

   755             if ( temporaryConnMethodInstance )

   756                 {

   757                 CleanupStack::PopAndDestroy( connMethodInstance );

   758                 }

   759             connMethodInstance = NULL;

   760             }

   761         }

   762     // All connection methods requiring update in the destination should have

   763     // been updated to database now.

   764 

   765     iDestinationArray[index]->UpdateL( aDestinationInstance, this );

   766     iTrans->CommitTransactionL();

   767 

   768     TCmmIdStruct idStruct( iDestinationArray[index]->GetRealId(), 0 );

   769     if ( aDestinationInstance.GetId() >= KTemporaryIdCounterStart )

   770         {

   771         idStruct.iTemporaryId = aDestinationInstance.GetId();

   772         }

   773     iUpdatedDestinations.AppendL( idStruct );

   774     iUpdatedDestinations2.AppendL( &aDestinationInstance );

   775 

   776     // Check transaction handler reference count.

   777     if ( iTrans->GetReferenceCount() == 0 )

   778         {

   779         // Successful commit to database. Refresh instance mapping and all

   780         // necessary status information.

   781         for ( TInt i = 0; i < iUpdatedConnMethods.Count(); i++ )

   782             {

   783             aDestinationInstance.RefreshHandlesForAllSessions( iUpdatedConnMethods[i] );

   784             }

   785         for ( TInt i = 0; i < iUpdatedConnMethods2.Count(); i++ )

   786             {

   787             iUpdatedConnMethods2[i]->UpdateSuccessful();

   788 

   789             TInt cacheIndex = FindConnMethodFromCache( iUpdatedConnMethods2[i]->GetId() );

   790             if ( cacheIndex >= 0 )

   791                 {

   792                 iConnMethodArray[cacheIndex]->UpdateSuccessful();

   793                 }

   794             }

   795         for ( TInt i = 0; i < iDeletedConnMethods.Count(); i++ )

   796             {

   797             TInt cacheIndex = FindConnMethodFromCache( iDeletedConnMethods[i].iRealId );

   798             if ( cacheIndex >= 0 )

   799                 {

   800                 aDestinationInstance.RefreshHandlesForAllSessions( iDeletedConnMethods[i] );

   801                 iConnMethodArray[cacheIndex]->SetStatus( ECmmConnMethodStatusToBeDeleted );

   802                 iInstanceMapping->AddConnMethodToDeletedListL( iDeletedConnMethods[i].iRealId );

   803                 }

   804             }

   805         for ( TInt i = 0; i < iUpdatedDestinations.Count(); i++ )

   806             {

   807             aDestinationInstance.RefreshHandlesForAllSessions( iUpdatedDestinations[i] );

   808             }

   809         for ( TInt i = 0; i < iUpdatedDestinations2.Count(); i++ )

   810             {

   811             iUpdatedDestinations2[i]->UpdateSuccessful();

   812 

   813             TInt cacheIndex = FindDestinationFromCache( iUpdatedDestinations2[i]->GetId() );

   814             if ( cacheIndex >= 0 )

   815                 {

   816                 iDestinationArray[cacheIndex]->UpdateSuccessful();

   817                 }

   818             }

   819         iDeletedConnMethods.Reset();

   820         iUpdatedConnMethods.Reset();

   821         iUpdatedConnMethods2.Reset();

   822         iUpdatedDestinations.Reset();

   823         iUpdatedDestinations2.Reset();

   824 

   825         iInstanceMapping->RefreshL();

   826         }

   827 

   828     OstTraceFunctionExit0( CCMMCACHE_UPDATEDESTINATIONL_EXIT );

   829     }

   830 

   831 // ---------------------------------------------------------------------------

   832 // Saves the modifications in aConnMethodInstance into database.

   833 // The second attribute aTemporaryHandle must be true if the connection method

   834 // instance is only a temporary one created for the duration of this update

   835 // process only.

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

   837 //

   838 void CCmmCache::UpdateConnMethodL(

   839         CCmmConnMethodInstance& aConnMethodInstance,

   840         TBool aTemporaryHandle )

   841     {

   842     OstTraceFunctionEntry0( CCMMCACHE_UPDATECONNMETHODL_ENTRY );

   843 

   844     // Embedded destinatios cannot be updated as connection methods.

   845     if ( aConnMethodInstance.IsEmbeddedDestination() )

   846         {

   847         User::Leave( KErrNotSupported );

   848         }

   849 

   850     // Find connection method from cache.

   851     TUint32 connMethodId( aConnMethodInstance.GetId() );

   852     TInt index = FindConnMethodFromCache( connMethodId );

   853     if ( index < 0 )

   854         {

   855         // Should never end up here.

   856         User::Leave( index );

   857         }

   858 

   859     iTrans->OpenTransactionLC();

   860     iConnMethodArray[index]->GetPlugin()->UpdateL( aConnMethodInstance.GetPluginDataInstance() );

   861     iTrans->CommitTransactionL();

   862 

   863     TCmmIdStruct idStruct( aConnMethodInstance.GetPluginDataInstance()->iIapId, 0 );

   864     if ( connMethodId >= KTemporaryIdCounterStart )

   865         {

   866         idStruct.iTemporaryId = connMethodId;

   867         }

   868 

   869     if ( iTrans->GetReferenceCount() == 0 )

   870         {

   871         // Writing to database is completed, refresh instance mapping and all

   872         // necessary status information.

   873         iInstanceMapping->RefreshL();

   874         aConnMethodInstance.RefreshHandlesForAllSessions( idStruct );

   875         aConnMethodInstance.UpdateSuccessful();

   876         iConnMethodArray[index]->UpdateSuccessful();

   877         }

   878     else

   879         {

   880         // Update request came from destination update. Add connection method

   881         // information to temporary arrays so it's status information can be

   882         // updated after successful commit to database.

   883         iUpdatedConnMethods.AppendL( idStruct );

   884         if ( !aTemporaryHandle )

   885             {

   886             // A temporary handle will be destroyed after update, and so won't

   887             // need any status updates after commit.

   888             iUpdatedConnMethods2.AppendL( &aConnMethodInstance );

   889             }

   890         }

   891 

   892     OstTraceFunctionExit0( CCMMCACHE_UPDATECONNMETHODL_EXIT );

   893     }

   894 

   895 // ---------------------------------------------------------------------------

   896 // Deletes the destination refered by aDestinationInstance from the database.

   897 // In case other sessions have open handles to the same destination, the status

   898 // is updated to deleted state, but it is not yet removed from database.

   899 // (ID must be kept reserved in commsdat until all handles are closed). The

   900 // same is done for the connection methods inside this destination.

   901 // ---------------------------------------------------------------------------

   902 //

   903 void CCmmCache::DeleteDestinationL(

   904         CCmmDestinationInstance& aDestinationInstance,

   905         TBool aForced ) //TODO, comment on aForced param?

   906     {

   907     OstTraceFunctionEntry0( CCMMCACHE_DELETEDESTINATIONL_ENTRY );

   908 

   909     TUint32 destinationId( aDestinationInstance.GetId() );

   910 

   911     // Array to temporarily store deleted connection method IDs. Status

   912     // information for these connection methods is updated after successful

   913     // commit to database.

   914     iDeletedConnMethods.Reset();

   915 

   916     // Find destination from cache.

   917     TInt index = FindDestinationFromCache( destinationId );

   918     if ( index == KErrNotFound )

   919         {

   920         User::Leave( KErrBadHandle );

   921         }

   922 

   923     // If not forced, check if the destination is already marked to be deleted.

   924     if ( !aForced && iDestinationArray[index]->GetStatus() == ECmmDestinationStatusToBeDeleted )

   925         {

   926         OstTraceFunctionExit0( CCMMCACHE_DELETEDESTINATIONL_EXIT );

   927         return;

   928         }

   929 

   930     // Check if there are any additional handles open. If yes, can't delete

   931     // detination from database just yet.

   932     if ( iDestinationArray[index]->GetReferenceCount() <= 1 )

   933         {

   934         // No other client handles open to this destination.

   935 

   936         // Get the connection methods in this destination, and then go through

   937         // them removing those that can't be deleted.

   938         RArray<TCmmConnMethodItem> connMethodArray;

   939         CleanupClosePushL( connMethodArray );

   940         if ( !aForced )

   941             {

   942             iInstanceMapping->GetConnMethodsFromDestinationL( destinationId, connMethodArray );

   943             }

   944         else

   945             {

   946             for ( TInt i = 0; i < aDestinationInstance.iConnMethodItemArray.Count() ; i++ )

   947                 {

   948                 connMethodArray.AppendL( aDestinationInstance.iConnMethodItemArray[i] );

   949                 }

   950             }

   951 

   952         // Remove embedded destination from list if found.

   953         TInt count( connMethodArray.Count() );

   954         if ( count )

   955             {

   956             if ( connMethodArray[count - 1].IsEmbedded() )

   957                 {

   958                 connMethodArray.Remove( count - 1 );

   959                 }

   960             }

   961         // Remove any connection method that belongs to any other destination.

   962         for ( TInt i = 0; i < connMethodArray.Count(); i++ )

   963             {

   964             if ( iInstanceMapping->ConnMethodInOtherDestination(

   965                     connMethodArray[i].iId,

   966                     destinationId ) )

   967                 {

   968                 connMethodArray.Remove( i );

   969                 i--;

   970                 }

   971             }

   972         // Remove any connection method that has a virtual IAP pointing to it.

   973         for ( TInt i = 0; i < connMethodArray.Count(); i++ )

   974             {

   975             if ( iInstanceMapping->ConnMethodPointedToByVirtualIap( connMethodArray[i].iId ) )

   976                 {

   977                 connMethodArray.Remove( i );

   978                 i--;

   979                 }

   980             }

   981 

   982         iTrans->OpenTransactionLC();

   983 

   984         // Delete each connection method inside this destination.

   985         for ( TInt i = 0; i < connMethodArray.Count(); i++ )

   986             {

   987             DeleteConnMethodAsPartOfDestinationDeleteL( connMethodArray[i].iId );

   988             }

   989 

   990         // Delete the destination.

   991         iDestinationArray[index]->DeleteL();

   992 

   993         iTrans->CommitTransactionL();

   994         CleanupStack::PopAndDestroy( &connMethodArray );

   995 

   996         for ( TInt i = 0; i < iDeletedConnMethods.Count(); i++ )

   997             {

   998             TInt index = FindConnMethodFromCache( iDeletedConnMethods[i].iRealId );

   999             if ( index == KErrNotFound )

  1000                 {

  1001                 // No handles open to this deleted connection method, so it was

  1002                 // removed from database. Remove it from instance mapping

  1003                 // structures. Refreshing instance mapping would do the same,

  1004                 // but more slowly.

  1005                 iInstanceMapping->RemoveConnMethod( iDeletedConnMethods[i].iRealId );

  1006                 }

  1007             else

  1008                 {

  1009                 // There is at least one handle open to this deleted connection

  1010                 // method, so it still exists in database for now. Remove it

  1011                 // from instance mapping structures and add it to the instance

  1012                 // mapping's deleted list, so the connection method is ignored

  1013                 // if refreshing structures from database. Also mark the

  1014                 // connection method handle on cache side as 'to be deleted'.

  1015                 //

  1016                 // If the connection method is updated from another existing

  1017                 // handle after this, the connection method is restored as

  1018                 // uncategorized.

  1019                 iInstanceMapping->AddConnMethodToDeletedListL( iDeletedConnMethods[i].iRealId );

  1020                 aDestinationInstance.RefreshHandlesForAllSessions( iDeletedConnMethods[i] );

  1021                 iConnMethodArray[index]->SetStatus( ECmmConnMethodStatusToBeDeleted );

  1022                 }

  1023             }

  1024         iInstanceMapping->RemoveDestination( destinationId );

  1025         }

  1026     else

  1027         {

  1028         // There are additional client handles open to this destination. Mark

  1029         // the destination as 'to be deleted'. When the other handles are

  1030         // closed and reference count goes to 0, the destination will be

  1031         // removed from database.

  1032         // If the destination is updated from another existing handle after

  1033         // this, the destination is restored to normal.

  1034         iDestinationArray[index]->SetStatus( ECmmDestinationStatusToBeDeleted );

  1035         iInstanceMapping->AddDestinationToDeletedListL( destinationId );

  1036         }

  1037 

  1038     // Update status for ALL related destination handles on client side to

  1039     // ECmmDestinationStatusChanged.

  1040     TCmmIdStruct idStruct( destinationId, 0 );

  1041     aDestinationInstance.RefreshHandlesForAllSessions( idStruct );

  1042 

  1043     iDeletedConnMethods.Reset();

  1044     OstTraceFunctionExit0( DUP1_CCMMCACHE_DELETEDESTINATIONL_EXIT );

  1045     }

  1046 

  1047 // ---------------------------------------------------------------------------

  1048 // Deletes a connection method as part of destination delete operation. It is

  1049 // already checked that the connection method given as parameter can be deleted

  1050 // and a transaction is already open.

  1051 // If there are client side handles open to the connection method, the

  1052 // connection method is marked as deleted, but the actual database removal will

  1053 // be done after the last handle is closed. Updating a connection method marked

  1054 // as deleted (through an already open handle) will restore it.

  1055 // ---------------------------------------------------------------------------

  1056 //

  1057 void CCmmCache::DeleteConnMethodAsPartOfDestinationDeleteL( const TUint32 aConnMethodId )

  1058     {

  1059     OstTraceFunctionEntry0( CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_ENTRY );

  1060 

  1061     // Find connection method from cache side.

  1062     TInt index = FindConnMethodFromCache( aConnMethodId );

  1063     if ( index == KErrNotFound )

  1064         {

  1065         // There is no open handles to this connection method. Open a temporary

  1066         // handle and delete it.

  1067 

  1068         // Find out the connection method bearer type.

  1069         TUint32 bearerType( 0 );

  1070         TInt err = iInstanceMapping->GetConnMethodBearerType( aConnMethodId, bearerType );

  1071         if ( err || bearerType == KUidEmbeddedDestination )

  1072             {

  1073             // If this is an embedded destination, or the bearer is not

  1074             // supported, skip. The connection method is simply removed from

  1075             // destination.

  1076             OstTraceFunctionExit0( CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );

  1077             return;

  1078             }

  1079 

  1080         // Check bearer type support, create plugin instance and delete the

  1081         // connection method.

  1082         CCmPluginBaseEng* plugin = NULL;

  1083         for ( TInt i = 0; i < iPlugins->Count(); i++ )

  1084             {

  1085             if ( ( *iPlugins )[i]->GetBearerInfoIntL( CMManager::ECmBearerType ) == bearerType )

  1086                 {

  1087                 TCmPluginInitParam pluginParams( Session() );

  1088                 plugin = ( *iPlugins )[i]->CreateInstanceL( pluginParams );

  1089                 CleanupStack::PushL( plugin );

  1090 

  1091                 // Transaction is already open.

  1092                 plugin->LoadL( aConnMethodId );

  1093                 plugin->DeleteL();

  1094 

  1095                 CleanupStack::Pop( plugin );

  1096                 break;

  1097                 }

  1098             }

  1099         if ( !plugin )

  1100             {

  1101             // Skip, if bearer is unsupported. Connection method is simply

  1102             // removed from destination.

  1103             OstTraceFunctionExit0( DUP1_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );

  1104             return;

  1105             }

  1106         delete plugin;

  1107         plugin = NULL;

  1108         }

  1109     else

  1110         {

  1111         // If the connection method is already open in cache side, we can't

  1112         // delete it from database just yet. It will only be marked as 'to be

  1113         // deleted' after a successful commit. When the other handles are

  1114         // closed and reference count goes to 0, the connection method will be

  1115         // removed from database.

  1116 

  1117         // Check destination status in cache.

  1118         switch ( iConnMethodArray[index]->GetStatus() )

  1119             {

  1120             case ECmmConnMethodStatusNotSaved:

  1121                 {

  1122                 // The connection methods that are deleted with the destination

  1123                 // are retrieved through instance mapping, so there can't be

  1124                 // any newly created unsaved connection methods among them.

  1125                 User::Leave( KErrCorrupt );

  1126                 }

  1127                 break;

  1128             case ECmmConnMethodStatusValid:

  1129                 // Proceed.

  1130                 break;

  1131             case ECmmConnMethodStatusToBeDeleted:

  1132                 // Connection method has already been deleted.

  1133                 OstTraceFunctionExit0( DUP2_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );

  1134                 return;