FCL/sf/mw/ipconnmgmt: comparison cmmanager/cmmgr/cmmserver/src/cmmcache.cpp

equal deleted inserted replaced

-:f10336de0cd6
+:faa5ef4f80da
 // relevant data to the session instance. Checks that destination ID is valid.
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::OpenDestinationL(
 CCmmDestinationInstance& aDestinationInstance,
-const TUint32& aDestinationId )
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_OPENDESTINATIONL_ENTRY );
 if ( !iInstanceMapping->ValidDestinationId( aDestinationId ) )
 {
 iTrans,
 aDestinationId );
 // Now that cache has a handle on this destination, copy the relevant
 // data to the session instance.
-destination->CreateSessionInstanceL( aDestinationInstance );
+destination->CreateDestinationInstanceL( aDestinationInstance );
 iDestinationArray.AppendL( destination );
 CleanupStack::Pop( destination );
 }
 else
 {
 // Cache already has a handle on this destination. Copy the relevant
 // data to the session instance.
-iDestinationArray[index]->CreateSessionInstanceL( aDestinationInstance );
+iDestinationArray[index]->CreateDestinationInstanceL( aDestinationInstance );
 }
 // Add list of currently contained connection methods.
 iInstanceMapping->GetConnMethodsFromDestinationL(
 aDestinationId,
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::CreateDestinationL(
 CCmmDestinationInstance& aDestinationInstance,
 const TDesC& aName,
-const TUint32& aId )
+const TUint32 aId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_CREATEDESTINATIONL_ENTRY );
 // Create a new destination with given name.
 CCmmDestinationStruct* destination = CCmmDestinationStruct::NewLC( this, iTrans, aName, aId );
-destination->CreateSessionInstanceL( aDestinationInstance );
+destination->CreateDestinationInstanceL( aDestinationInstance );
 iDestinationArray.AppendL( destination );
 CleanupStack::Pop( destination );
 OstTraceFunctionExit0( CCMMCACHE_CREATEDESTINATIONL_EXIT );
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::OpenConnMethodL(
 CCmmConnMethodInstance& aConnMethodInstance,
 CCmmDestinationInstance* aDestinationInstance,
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_OPENCONNMETHODL_ENTRY );
 // Check connection method ID.
 TBool validAttributes( EFalse );
 //
 void CCmmCache::RefreshConnMethodL( CCmmConnMethodInstance& aConnMethodInstance )
 {
 OstTraceFunctionEntry0( CCMMCACHE_REFRESHCONNMETHODL_ENTRY );
-//TODO, what to do with embedded?
+// If embedded destination --> refresh through destination API.
+if ( aConnMethodInstance.IsEmbeddedDestination() )
+{
+return;
+}
 TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );
 if ( index == KErrNotFound )
 {
 User::Leave( KErrNotFound );
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::CreateConnMethodL(
 CCmmConnMethodInstance& aConnMethodInstance,
 CCmmDestinationInstance* aDestinationInstance,
-const TUint32& aBearerType,
+const TUint32 aBearerType,
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_CREATECONNMETHODL_ENTRY );
 // Check that the bearer type is not embedded destination.
 if ( aBearerType == KUidEmbeddedDestination )
 User::Leave( KErrArgument );
 }
 // Store the connection method into cache.
-CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewLC( connMethodId ); // Use connMethodId here, so ID is either a real ID or a temporary ID.
+// Use connMethodId here, so ID is either a real ID or a temporary ID.
+CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewL( connMethodId );
 connMethodStruct->SetPlugin( plugin, aBearerType, ECmmConnMethodStatusNotSaved );
+CleanupStack::Pop( plugin );
+CleanupStack::PushL( connMethodStruct );
 iConnMethodArray.AppendL( connMethodStruct );
 CleanupStack::Pop( connMethodStruct );
-CleanupStack::Pop( plugin ); //TODO, pop after SetPlugin()-call?
 // Copy the connection method data to session instance.
 aConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.
 if ( aDestinationInstance )
 {
 // Add connection method to destination.
 aDestinationInstance->AddConnMethodL( aConnMethodInstance );
 }
 OstTraceFunctionExit0( CCMMCACHE_CREATECONNMETHODL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Creates a new connection method into cache as a copy of an existing
 if ( !plugin )
 {
 User::Leave( KErrNotFound );
 }
-CCmPluginBaseEng* pluginCopy = plugin->CreateCopyL( aConnMethodInstance.GetPluginDataInstance() );
+CCmPluginBaseEng* pluginCopy =
+plugin->CreateCopyL( aConnMethodInstance.GetPluginDataInstance() );
 CleanupStack::PushL( pluginCopy );
 // Store the connection method into cache.
-CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewLC( NextFreeTemporaryId() );
+CCmmConnMethodStruct* connMethodStruct =
-connMethodStruct->SetPlugin( pluginCopy, aConnMethodInstance.GetBearerType(), ECmmConnMethodStatusNotSaved );
+CCmmConnMethodStruct::NewL( NextFreeTemporaryId() );
+connMethodStruct->SetPlugin(
+pluginCopy,
+aConnMethodInstance.GetBearerType(),
+ECmmConnMethodStatusNotSaved );
+CleanupStack::Pop( pluginCopy );
+CleanupStack::PushL( connMethodStruct );
 iConnMethodArray.AppendL( connMethodStruct );
 CleanupStack::Pop( connMethodStruct );
-CleanupStack::Pop( pluginCopy ); //TODO, pop after SetPlugin()-call?
 // Copy the connection method data to session instance.
 aNewConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.
 OstTraceFunctionExit0( CCMMCACHE_CREATECOPYOFCONNMETHODL_EXIT );
 // Remove connection method from delete list if ID is not valid or if
 // referenced from any other destination (in database or in any other
 // client-side destination handles).
 if ( !iInstanceMapping->ValidConnMethodId( id ) ||
-iInstanceMapping->ConnMethodInOtherDestination( id, aDestinationInstance.GetId() ) ||
+iInstanceMapping->ConnMethodInOtherDestination(
+id,
+aDestinationInstance.GetId() ) ||
 aDestinationInstance.ConnMethodInOtherDestinationInSession( id, 0 ) )
 {
 aDestinationInstance.iConnMethodsToBeDeleted.Remove( i );
 i--; // Adjust array index counter.
 }
 }
 // Update the connection methods inside this destination.
 for ( TInt i = 0; i < aDestinationInstance.iConnMethodItemArray.Count(); i++ )
 {
-if ( aDestinationInstance.iConnMethodItemArray[i].iBearerType == KUidEmbeddedDestination )
+if ( aDestinationInstance.iConnMethodItemArray[i].IsEmbedded() )
 {
 // Embedded destination.
 //TODO, Maybe check other restrictions on embedded destination.
 // - Only one embedded destination per destination. Check.
 // client has an open handle to any of the embedded
 // destinations connection methods.
 //
 // Skip update since client doesn't have an open handle to this
 // destination.
-if ( id >= KTemporaryIdCounterStart || !iInstanceMapping->ValidDestinationId( id ) )
+if ( id >= KTemporaryIdCounterStart ||
+!iInstanceMapping->ValidDestinationId( id ) )
 {
 // Remove destination item from array if:
 // - New destination, but client has already closed the handle for it.
 // - Destination ID was valid before, but it does not exist anymore.
 aDestinationInstance.iConnMethodItemArray.Remove( i );
 }
 if ( aDestinationInstance.ProtectionChanged() )
 {
 // Check if the connection method protection level needs to be set.
-switch ( aDestinationInstance.CurrentProtectionLevel() )
+switch ( aDestinationInstance.CurrentProtectionLevelL() )
 {
 case CMManager::EProtLevel0:
 case CMManager::EProtLevel2:
 {
-if ( aDestinationInstance.LastProtectionLevel() == CMManager::EProtLevel1 ||
+if ( aDestinationInstance.LastProtectionLevel() ==
-aDestinationInstance.LastProtectionLevel() == CMManager::EProtLevel3 )
+CMManager::EProtLevel1 ||
+aDestinationInstance.LastProtectionLevel() ==
+CMManager::EProtLevel3 )
 {
 connMethodProtectionMustBeSet = ETrue;
 cmProtected = EFalse;
 }
 }
 CCmmConnMethodInstance& aConnMethodInstance,
 TBool aTemporaryHandle )
 {
 OstTraceFunctionEntry0( CCMMCACHE_UPDATECONNMETHODL_ENTRY );
+// Embedded destinatios cannot be updated as connection methods.
+if ( aConnMethodInstance.IsEmbeddedDestination() )
+{
+User::Leave( KErrNotSupported );
+}
 // Find connection method from cache.
 TUint32 connMethodId( aConnMethodInstance.GetId() );
 TInt index = FindConnMethodFromCache( connMethodId );
 if ( index < 0 )
 {
 // is updated to deleted state, but it is not yet removed from database.
 // (ID must be kept reserved in commsdat until all handles are closed). The
 // same is done for the connection methods inside this destination.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::DeleteDestinationL( CCmmDestinationInstance& aDestinationInstance, TBool aForced )
+void CCmmCache::DeleteDestinationL(
+CCmmDestinationInstance& aDestinationInstance,
+TBool aForced ) //TODO, comment on aForced param?
 {
 OstTraceFunctionEntry0( CCMMCACHE_DELETEDESTINATIONL_ENTRY );
 TUint32 destinationId( aDestinationInstance.GetId() );
 // Remove embedded destination from list if found.
 TInt count( connMethodArray.Count() );
 if ( count )
 {
-if ( connMethodArray[count - 1].iBearerType == KUidEmbeddedDestination )
+if ( connMethodArray[count - 1].IsEmbedded() )
 {
 connMethodArray.Remove( count - 1 );
 }
 }
 // Remove any connection method that belongs to any other destination.
 for ( TInt i = 0; i < connMethodArray.Count(); i++ )
 {
-if ( iInstanceMapping->ConnMethodInOtherDestination( connMethodArray[i].iId, destinationId ) )
+if ( iInstanceMapping->ConnMethodInOtherDestination(
+connMethodArray[i].iId,
+destinationId ) )
 {
 connMethodArray.Remove( i );
 i--;
 }
 }
 // connection method is marked as deleted, but the actual database removal will
 // be done after the last handle is closed. Updating a connection method marked
 // as deleted (through an already open handle) will restore it.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::DeleteConnMethodAsPartOfDestinationDeleteL( const TUint32& aConnMethodId )
+void CCmmCache::DeleteConnMethodAsPartOfDestinationDeleteL( const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_ENTRY );
 // Find connection method from cache side.
 TInt index = FindConnMethodFromCache( aConnMethodId );
 case ECmmConnMethodStatusValid:
 // Proceed.
 break;
 case ECmmConnMethodStatusToBeDeleted:
 // Connection method has already been deleted.
+OstTraceFunctionExit0( DUP2_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );
 return;
 case ECmmConnMethodStatusChanged:
 default:
 {
 ASSERT( 0 ); // Error, illegal status.
 // Add connection method ID to temporary array so it's status information
 // can be updated after successful commit to database.
 TCmmIdStruct idStruct( aConnMethodId, 0 );
 iDeletedConnMethods.AppendL( idStruct );
-OstTraceFunctionExit0( DUP2_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );
+OstTraceFunctionExit0( DUP3_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONDELETEL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Deletes a connection method as part of destination update operation. It is
 // already checked that the connection method given as parameter can be deleted
 // be done after the last handle is closed. Updating a connection method marked
 // as deleted (through an already open handle) will restore it.
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::DeleteConnMethodAsPartOfDestinationUpdateL(
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONUPDATEL_ENTRY );
 // Find connection method from cache side. If not found, open a temporary handle.
 TInt index = FindConnMethodFromCache( aConnMethodId );
 case ECmmConnMethodStatusValid:
 // Proceed.
 break;
 case ECmmConnMethodStatusToBeDeleted:
 // Connection method has already been deleted.
+OstTraceFunctionExit0( DUP2_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONUPDATEL_EXIT );
 return;
 case ECmmConnMethodStatusChanged:
 default:
 {
 ASSERT( 0 ); // Error, illegal status.
 // information can be updated after successful commit to database.
 TCmmIdStruct idStruct( aConnMethodId, 0 );
 iDeletedConnMethods.AppendL( idStruct );
 }
-OstTraceFunctionExit0( DUP2_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONUPDATEL_EXIT );
+OstTraceFunctionExit0( DUP3_CCMMCACHE_DELETECONNMETHODASPARTOFDESTINATIONUPDATEL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Basic connection method delete. Removes a connection method from any
 // destination it might belong to, and then deletes it.
 // ---------------------------------------------------------------------------
 // Check if the given ID belongs to a valid existing destination. Attribute
 // aId needs to be in the current valid range (0x1001 - 0x10FF atm).
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationExistsWithId( const TUint32& aId )
+TBool CCmmCache::DestinationExistsWithId( const TUint32 aId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONEXISTSWITHID_ENTRY );
 TBool exists = iInstanceMapping->ValidDestinationId( aId );
 // ---------------------------------------------------------------------------
 // Check if the given name belongs to an existing destination.
 // If a destination ID is given, that destination is skipped.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationExistsWithNameL( const TDesC& aName, const TUint32& aDestinationId )
+TBool CCmmCache::DestinationExistsWithNameL( const TDesC& aName, const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONEXISTSWITHNAMEL_ENTRY );
 TBool found( EFalse );
 }
 CleanupStack::PopAndDestroy( snapRecord );
 }
 OstTraceFunctionExit0( CCMMCACHE_DESTINATIONEXISTSWITHNAMEL_EXIT );
 return found;
 }
 // ---------------------------------------------------------------------------
 // Check if the given ID belongs to a destination that the cache has an open
 // are not yet saved to database.
 // With this check, we can prevent two clients from creating a new destination
 // with the same ID (The UpdateL() operation would fail for one of them anyway).
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationOpenWithId( const TUint32& aId )
+TBool CCmmCache::DestinationOpenWithId( const TUint32 aId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONOPENWITHID_ENTRY );
 TBool result( EFalse );
 TInt index = FindDestinationFromCache( aId );
 if ( index != KErrNotFound )
 {
 result = ETrue;
 }
 OstTraceFunctionExit0( CCMMCACHE_DESTINATIONOPENWITHID_EXIT );
 return result;
 }
 // ---------------------------------------------------------------------------
 // Check if the given name belongs to any new unsaved destinations in the
 // anyway).
 // ---------------------------------------------------------------------------
 //
 TBool CCmmCache::NotSavedDestinationOpenWithNameL(
 const TDesC& aName,
-const TUint32& aDestinationId )
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_NOTSAVEDDESTINATIONOPENWITHNAMEL_ENTRY );
 TBool res( EFalse );
 TInt index = FindNotSavedDestinationFromCacheL( aName, aDestinationId );
 if ( index != KErrNotFound )
 {
 res = ETrue;
 }
 OstTraceFunctionExit0( CCMMCACHE_NOTSAVEDDESTINATIONOPENWITHNAMEL_EXIT );
 return res;
 }
 // ---------------------------------------------------------------------------
 // Check if the given ID belongs to a valid existing connection method.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::ConnMethodExistsWithId( const TUint32& aConnMethodId )
+TBool CCmmCache::ConnMethodExistsWithId( const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODEXISTSWITHID_ENTRY );
 TBool exists = iInstanceMapping->ValidConnMethodId( aConnMethodId );
 OstTraceFunctionExit0( CCMMCACHE_CONNMETHODEXISTSWITHID_EXIT );
 return exists;
 }
 // ---------------------------------------------------------------------------
 // Check if the given ID belongs to a connection method that the cache has an
 // With this check, we can prevent two clients from creating a new connection
 // method with the same ID (The UpdateL() operation would fail for one of them
 // anyway).
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::ConnMethodOpenWithId( const TUint32& aConnMethodId )
+TBool CCmmCache::ConnMethodOpenWithId( const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODOPENWITHID_ENTRY );
 TBool result( EFalse );
 TInt index = FindConnMethodFromCache( aConnMethodId );
 if ( index != KErrNotFound )
 {
 result = ETrue;
 }
 OstTraceFunctionExit0( CCMMCACHE_CONNMETHODOPENWITHID_EXIT );
 return result;
 }
 // ---------------------------------------------------------------------------
 // Checks if there are any destinations with metadata localization
 // The destination connected to parameter aDestinationInstance is skipped.
 // ---------------------------------------------------------------------------
 //
 TBool CCmmCache::DestinationExistsWithMetadataLocalizedL(
 CCmmDestinationInstance& aDestinationInstance,
-const TUint32& aValue )
+const TUint32 aValue )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONEXISTSWITHMETADATALOCALIZEDL_ENTRY );
 TBool result( EFalse );
 }
 }
 }
 CleanupStack::PopAndDestroy( metaSet );
 }
 OstTraceFunctionExit0( CCMMCACHE_DESTINATIONEXISTSWITHMETADATALOCALIZEDL_EXIT );
 return result;
 }
 // ---------------------------------------------------------------------------
 // Checks if there are any destinations with metadata purpose
 // The destination connected to parameter aDestinationInstance is skipped.
 // ---------------------------------------------------------------------------
 //
 TBool CCmmCache::DestinationExistsWithMetadataPurposeL(
 CCmmDestinationInstance& aDestinationInstance,
-const TUint32& aValue )
+const TUint32 aValue )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONEXISTSWITHMETADATAPURPOSEL_ENTRY );
 TBool result( EFalse );
 }
 }
 }
 CleanupStack::PopAndDestroy( metaSet );
 }
 OstTraceFunctionExit0( CCMMCACHE_DESTINATIONEXISTSWITHMETADATAPURPOSEL_EXIT );
 return result;
 }
 // ---------------------------------------------------------------------------
 // Tells the cache that a database table has changed. If the SNAP/IAP structure
 // has possibly changed, the cache will refresh that information immediately.
 // For other database tables, the tables are flagged and will be refreshed when
 // needed.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::DbChangeDetected( const TUint32& aTableId )
+void CCmmCache::DbChangeDetected( const TUint32 aTableId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DBCHANGEDETECTED_ENTRY );
 (void)aTableId; //TODO
 // Flag the table as: currently not up-to-date
 // Tells the cache that an error has occured with a database listener. Any
 // reads to this table need go through the database, since cache can't know if
 // it has up-to-date information.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::DbChangeError( const TUint32& aTableId )
+void CCmmCache::DbChangeError( const TUint32 aTableId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_DBCHANGEERROR_ENTRY );
 (void)aTableId; //TODO
 // Flag the table as: permanently not up-to-date
 TInt index = FindDestinationFromCache( aDestinationInstance.GetId() );
 if ( index >= 0 )
 {
-TInt remainingSessionInstances = iDestinationArray[index]->SessionInstanceClosed();
+TInt remainingSessionInstances = iDestinationArray[index]->DestinationInstanceClosed();
 if ( remainingSessionInstances <= 0)
 {
 // If status is 'to be deleted', then the last handle keeping this
 // destination 'alive' was closed and it can now be deleted from
 // database.
 TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );
 if ( index >= 0 )
 {
-TInt remainingSessionInstances = iConnMethodArray[index]->SessionInstanceClosed();
+TInt remainingSessionInstances = iConnMethodArray[index]->ConnMethodInstanceClosed();
 if ( remainingSessionInstances <= 0 )
 {
 // If status is 'to be deleted', then the last handle keeping this
 // connection method 'alive' was closed and it can now be deleted
 // from database.
 // Returns a reference to the CommsDat session.
 //-----------------------------------------------------------------------------
 //
 CommsDat::CMDBSession& CCmmCache::Session() const
 {
-OstTraceFunctionEntry0( CCMMCACHE_SESSION_ENTRY );
+// No traces.
 return iTrans->Session();
 }
 //-----------------------------------------------------------------------------
 // Finds out the bearer type and priority of the service type from given IAP
-// record.
+// record. performs LoadL()-call on the provided IAP record.
 //-----------------------------------------------------------------------------
 //
 void CCmmCache::BearerInfoFromIapRecordL(
 CommsDat::CCDIAPRecord* aIapRecord,
 TUint32& aBearerType,
 TUint& aBearerPriority ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_BEARERINFOFROMIAPRECORDL_ENTRY );
-// Load the IAP record from IAP table. This is an optimization that plugins
+// Load the IAP record from IAP table. This is an optimization so that
-// doesn't have to do it every time the CanHandleIapIdL() is called.
+// plugins don't have to do it every time the CanHandleIapIdL() is called.
 aIapRecord->LoadL( Session() );
 BearerPriorityFromIapRecordL( aIapRecord, aBearerPriority );
 BearerTypeFromIapRecordL( aIapRecord, aBearerType );
 OstTraceFunctionExit0( CCMMCACHE_BEARERINFOFROMIAPRECORDL_EXIT );
 TInt foundIndex( KErrNotFound );
 // Check which bearer handles the given IAP ID.
 for ( TInt i = 0; i < iPlugins->Count(); i++ )
 {
-TRAP( err, canHandle = (*iPlugins)[i]->CanHandleIapIdL( aIapRecord ) ); //TODO, check leave, trap needed?
+TRAP( err, canHandle = (*iPlugins)[i]->CanHandleIapIdL( aIapRecord ) );
 if ( !err && canHandle )
 {
 TUint32 thisExtLevel = (*iPlugins)[i]->GetBearerInfoIntL( ECmExtensionLevel );
 if ( extLevel < thisExtLevel )
 {
 User::Leave( KErrNotSupported );
 }
 aBearerType = (*iPlugins)[foundIndex]->GetBearerInfoIntL( CMManager::ECmBearerType );
 OstTraceFunctionExit0( CCMMCACHE_BEARERTYPEFROMIAPRECORDL_EXIT );
+}
+// ---------------------------------------------------------------------------
+// Find and return a copy of a connection method item matching the given ID.
+// Returns KErrNotFound, if the connection method is not found.
+// ---------------------------------------------------------------------------
+//
+TInt CCmmCache::GetConnMethodItem(
+const TUint32 aConnMethodId,
+TCmmConnMethodItem& aConnMethodItem ) const
+{
+OstTraceFunctionEntry0( CCMMCACHE_GETCONNMETHODITEM_ENTRY );
+TInt result = iInstanceMapping->GetConnMethodItem( aConnMethodId, aConnMethodItem );
+OstTraceFunctionExit0( CCMMCACHE_GETCONNMETHODITEM_EXIT );
+return result;
 }
 //-----------------------------------------------------------------------------
 // Returns all conenction method IDs. Unsupported connection methods are
 // included if aCheckBearerType is set to EFalse.
 //-----------------------------------------------------------------------------
 // Returns the number of destinations the provided connection method belongs to.
 //-----------------------------------------------------------------------------
 //
-TInt CCmmCache::DestinationsContainingConnMethod( const TUint32& aConnMethodId ) const
+TInt CCmmCache::DestinationsContainingConnMethod( const TUint32 aConnMethodId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODREFERENCECOUNT_ENTRY );
 TInt count = iInstanceMapping->DestinationsContainingConnMethod( aConnMethodId );
 //-----------------------------------------------------------------------------
 // Returns all the valid connection methods under given destination.
 //-----------------------------------------------------------------------------
 //
 void CCmmCache::GetConnMethodsFromDestinationL(
-const TUint32& aDestinationId,
+const TUint32 aDestinationId,
 RArray<TCmmConnMethodItem>& aConnMethodArray ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETCONNMETHODSFROMDESTINATIONL_ENTRY );
 iInstanceMapping->GetConnMethodsFromDestinationL(
 // Check from database if the given connection method belongs to any other
 // destination than the one provided.
 //-----------------------------------------------------------------------------
 //
 TBool CCmmCache::ConnMethodInOtherDestination(
-const TUint32& aConnMethodId,
+const TUint32 aConnMethodId,
-const TUint32& aDestinationId )
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODINOTHERDESTINATION_ENTRY );
 TBool cmInOtherDestination = iInstanceMapping->
 ConnMethodInOtherDestination( aConnMethodId, aDestinationId );
 //-----------------------------------------------------------------------------
 // Find an open destination matching the give ID from cache.
 // Returns either a valid array index or KErrNotFound.
 //-----------------------------------------------------------------------------
 //
-TInt CCmmCache::FindDestinationFromCache( const TUint32& aId )
+TInt CCmmCache::FindDestinationFromCache( const TUint32 aId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_FINDDESTINATIONFROMCACHE_ENTRY );
 TInt result( KErrNotFound );
 // Find an open destination matching the given name from cache. If a destination
 // ID is provided, the search will exclude the relevant destination.
 // Returns either a valid array index or KErrNotFound.
 //-----------------------------------------------------------------------------
 //
-TInt CCmmCache::FindNotSavedDestinationFromCacheL( const TDesC& aName, const TUint32& aDestinationId )
+TInt CCmmCache::FindNotSavedDestinationFromCacheL(
+const TDesC& aName,
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_FINDNOTSAVEDDESTINATIONFROMCACHEL_ENTRY );
 TInt result( KErrNotFound );
 //-----------------------------------------------------------------------------
 // Find an open connection method matching the given ID from cache.
 // Returns either a valid array index or KErrNotFound.
 //-----------------------------------------------------------------------------
 //
-TInt CCmmCache::FindConnMethodFromCache( const TUint32& aConnMethodId )
+TInt CCmmCache::FindConnMethodFromCache( const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_FINDCONNMETHODFROMCACHE_ENTRY );
 TInt result( KErrNotFound );
 // Loads and initializes a connection method instance.
 //-----------------------------------------------------------------------------
 //
 void CCmmCache::OpenConnectionMethodInstanceL(
 CCmmConnMethodInstance& aConnMethodInstance,
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMCACHE_OPENCONNECTIONMETHODINSTANCEL_ENTRY );
 // Find out the connection method bearer type.
 TUint32 bearerType( 0 );
 {
 User::Leave( KErrNotSupported );
 }
 // Store the connection method into cache.
-CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewLC( aConnMethodId );
+CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewL( aConnMethodId );
 connMethodStruct->SetPlugin( plugin, bearerType, ECmmConnMethodStatusValid );
+CleanupStack::Pop( plugin );
+CleanupStack::PushL( connMethodStruct );
 iConnMethodArray.AppendL( connMethodStruct );
 CleanupStack::Pop( connMethodStruct );
-CleanupStack::Pop( plugin ); //TODO, pop after SetPlugin()-call?
 // Copy the connection method data to session instance.
 aConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.
 OstTraceFunctionExit0( CCMMCACHE_OPENCONNECTIONMETHODINSTANCEL_EXIT );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetConnectionMethodInfoIntL
 //-----------------------------------------------------------------------------
 //
 TUint32 CCmmCache::GetConnectionMethodInfoIntL(
-const TUint32& aCmId,
+const TUint32 aCmId,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETCONNECTIONMETHODINFOINTL_ENTRY );
 TUint32 retVal( 0 );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetConnectionMethodInfoBoolL
 //-----------------------------------------------------------------------------
 //
 TBool CCmmCache::GetConnectionMethodInfoBoolL(
-const TUint32& aCmId,
+const TUint32 aCmId,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETCONNECTIONMETHODINFOBOOLL_ENTRY );
 TBool retVal( EFalse );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetConnectionMethodInfoStringL
 //-----------------------------------------------------------------------------
 //
 HBufC* CCmmCache::GetConnectionMethodInfoStringL(
-const TUint32& aCmId,
+const TUint32 aCmId,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETCONNECTIONMETHODINFOSTRINGL_ENTRY );
 HBufC* retVal( NULL );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetConnectionMethodInfoString8L
 //-----------------------------------------------------------------------------
 //
 HBufC8* CCmmCache::GetConnectionMethodInfoString8L(
-const TUint32& aCmId,
+const TUint32 aCmId,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETCONNECTIONMETHODINFOSTRING8L_ENTRY );
 HBufC8* retVal( NULL );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetBearerInfoIntL
 //-----------------------------------------------------------------------------
 //
 TUint32 CCmmCache::GetBearerInfoIntL(
-const TUint32& aBearerType,
+const TUint32 aBearerType,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETBEARERINFOINTL_ENTRY );
 TUint32 retVal( 0 );
 TBool found( EFalse );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetBearerInfoBoolL
 //-----------------------------------------------------------------------------
 //
 TBool CCmmCache::GetBearerInfoBoolL(
-const TUint32& aBearerType,
+const TUint32 aBearerType,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETBEARERINFOBOOLL_ENTRY );
 TBool retVal( EFalse );
 TBool found( EFalse );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetBearerInfoStringL
 //-----------------------------------------------------------------------------
 //
 HBufC* CCmmCache::GetBearerInfoStringL(
-const TUint32& aBearerType,
+const TUint32 aBearerType,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETBEARERINFOSTRINGL_ENTRY );
 HBufC* retVal( NULL );
 TBool found( EFalse );
 //-----------------------------------------------------------------------------
 // CCmmCache::GetBearerInfoString8L
 //-----------------------------------------------------------------------------
 //
 HBufC8* CCmmCache::GetBearerInfoString8L(
-const TUint32& aBearerType,
+const TUint32 aBearerType,
-const TUint32& aAttribute )
+const TUint32 aAttribute )
 {
 OstTraceFunctionEntry0( CCMMCACHE_GETBEARERINFOSTRING8L_ENTRY );
 HBufC8* retVal( NULL );
 TBool found( EFalse );
 }
 else
 {
 iTrans->OpenTransactionLC();
-TUint defConnType( 0 );
-TUint internetSnapId( 0 );
-iInstanceMapping->InternetDestinationIdL( internetSnapId );
-if ( internetSnapId )
-{
-defConnType = ECmDefConnDestination;
-}
 aGenConnSettings.iUsageOfWlan = ECmUsageOfWlanKnown;
 aGenConnSettings.iCellularDataUsageHome = ECmCellularDataUsageAutomatic;
 aGenConnSettings.iCellularDataUsageVisitor = ECmCellularDataUsageConfirm;
 defConnRecord->SetRecordId( KCDNewRecordRequest );
-defConnRecord->iDefConnType = defConnType;
-defConnRecord->iDefConnUid = internetSnapId;
 defConnRecord->iUsageOfWlan = ( TUint )aGenConnSettings.iUsageOfWlan;
-defConnRecord->iCellularDataUsageHome = ( TUint )aGenConnSettings.iCellularDataUsageHome;
+defConnRecord->iCellularDataUsageHome =
-defConnRecord->iCellularDataUsageVisitor = ( TUint )aGenConnSettings.iCellularDataUsageVisitor;
+( TUint )aGenConnSettings.iCellularDataUsageHome;
+defConnRecord->iCellularDataUsageVisitor =
+( TUint )aGenConnSettings.iCellularDataUsageVisitor;
 defConnRecord->StoreL( Session() );
 iTrans->CommitTransactionL();
 }
 // ---------------------------------------------------------------------------
 // Enumerates connections and checks if the given connection method is
 // connected.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::CheckIfCmConnected( const TUint32& aCmId ) const
+TBool CCmmCache::CheckIfCmConnected( const TUint32 aCmId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_CHECKIFCMCONNECTED_ENTRY );
 TBool result( EFalse );
 RSocketServ ss;
 connMethodArray.AppendL( aDestinationInstance->iConnMethodItemArray[i] );
 }
 }
 else
 {
-iInstanceMapping->GetConnMethodsFromDestinationL( aDestinationId, connMethodArray );
+iInstanceMapping->GetConnMethodsFromDestinationL(
+aDestinationId,
+connMethodArray );
 }
 // Iterate through all connections.
 TPckgBuf<TConnectionInfo> connInfo;
 for ( TUint i = 1; i <= connectionCount; i++ )
 // ---------------------------------------------------------------------------
 // Check from database if the given destination is an embedded destination in
 // any other destination.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationIsEmbedded( const TUint32& aDestinationId ) const
+TBool CCmmCache::DestinationIsEmbedded( const TUint32 aDestinationId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONISEMBEDDED_ENTRY );
 TBool isEmbedded = iInstanceMapping->DestinationIsEmbedded( aDestinationId );
 // ---------------------------------------------------------------------------
 // Check from database if the given destination has an embedded destination.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationHasEmbedded( const TUint32& aDestinationId ) const
+TBool CCmmCache::DestinationHasEmbedded( const TUint32 aDestinationId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONHASEMBEDDED_ENTRY );
 TBool hasEmbedded = iInstanceMapping->DestinationHasEmbedded( aDestinationId );
 // ---------------------------------------------------------------------------
 // Check from database if the given destination is pointed to by any virtual
 // IAP.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::DestinationPointedToByVirtualIap( const TUint32& aDestinationId ) const
+TBool CCmmCache::DestinationPointedToByVirtualIap( const TUint32 aDestinationId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_DESTINATIONPOINTEDTOBYVIRTUALIAP_ENTRY );
 TBool pointedByVirtual =
 iInstanceMapping->DestinationPointedToByVirtualIap( aDestinationId );
 // ---------------------------------------------------------------------------
 // Check from database if the given connection method is pointed to by any
 // virtual IAP.
 // ---------------------------------------------------------------------------
 //
-TBool CCmmCache::ConnMethodPointedToByVirtualIap( const TUint32& aConnMethodId ) const
+TBool CCmmCache::ConnMethodPointedToByVirtualIap( const TUint32 aConnMethodId ) const
 {
+OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODPOINTEDTOBYVIRTUALIAP_ENTRY );
-TBool pointedByVirtual =
+TBool pointedToByVirtual =
 iInstanceMapping->ConnMethodPointedToByVirtualIap( aConnMethodId );
-return pointedByVirtual;
+OstTraceFunctionExit0( CCMMCACHE_CONNMETHODPOINTEDTOBYVIRTUALIAP_EXIT );
+return pointedToByVirtual;
 }
 // ---------------------------------------------------------------------------
 // Check if the given connection method is the only connection method in the
 // given destination and if a virtual IAP points to that destination.
 // ---------------------------------------------------------------------------
 //
 TBool CCmmCache::ConnMethodInDestinationButLocked(
-const TUint32& aConnMethodId, const TUint32& aDestinationId ) const
+const TUint32 aConnMethodId,
+const TUint32 aDestinationId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_CONNMETHODINDESTINATIONBUTLOCKED_ENTRY );
 TBool inAndlocked = iInstanceMapping->
 ConnMethodInDestinationButLocked( aConnMethodId, aDestinationId );
 // IDs for any newly created connection methods. These real IDs are held in the
 // temporary array iUpdatedConnMethods until successful commit to database.
 // This method is used to find out those real IDs before that.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::TranslateTemporaryId( const TUint32& aTemporaryId, TUint32& aRealId ) const
+void CCmmCache::TranslateTemporaryId( const TUint32 aTemporaryId, TUint32& aRealId ) const
 {
 OstTraceFunctionEntry0( CCMMCACHE_TRANSLATETEMPORARYID_ENTRY );
 aRealId = 0;
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::CheckIfConnMethodReferencesCanBeRemovedL(
 const CCmmConnMethodInstance& aConnMethodInstance )
 {
+OstTraceFunctionEntry0( CCMMCACHE_CHECKIFCONNMETHODREFERENCESCANBEREMOVEDL_ENTRY );
 TUint32 connMethodId( aConnMethodInstance.GetId() );
 // Check that connection method exists in database.
 if ( !iInstanceMapping->ValidConnMethodId( connMethodId ) )
 {
 // Can't remove an embedded destination this way.
 if ( aConnMethodInstance.IsEmbeddedDestination() )
 {
 User::Leave( KErrArgument );
 }
-//TODO, what if protected?
 // Iterate all destinations in database and check if possible reference can
 // be removed.
 RArray<TUint32> dbDestinations;
 CleanupClosePushL( dbDestinations );
 iInstanceMapping->GetDestinationsL( dbDestinations );
 for ( TInt i = 0; i < dbDestinations.Count(); i++ )
 {
-if ( iInstanceMapping->ConnMethodInDestinationButLocked( connMethodId, dbDestinations[i] ) )
+if ( iInstanceMapping->ConnMethodInDestinationButLocked(
+connMethodId,
+dbDestinations[i] ) )
 {
 User::Leave( KErrLocked );
 }
 }
 CleanupStack::PopAndDestroy( &dbDestinations );
 // Can't remove a connection method that is in use.
 if ( CheckIfCmConnected( connMethodId ) )
 {
 User::Leave( KErrInUse );
 }
+OstTraceFunctionExit0( CCMMCACHE_CHECKIFCONNMETHODREFERENCESCANBEREMOVEDL_EXIT );
+}
+// ---------------------------------------------------------------------------
+// Check if given connection method is referenced from any protected destination.
+// ---------------------------------------------------------------------------
+//
+void CCmmCache::CheckIfConnMethodBelongsToProtectedDestinationL(
+const CCmmConnMethodInstance& aConnMethodInstance,
+TBool& aBelongsToProtectedDestination )
+{
+OstTraceFunctionEntry0( CCMMCACHE_CHECKIFCONNMETHODBELONGSTOPROTECTEDDESTINATIONL_ENTRY );
+TUint32 connMethodId( aConnMethodInstance.GetId() );
+// Check that connection method exists in database.
+if ( !iInstanceMapping->ValidConnMethodId( connMethodId ) )
+{
+User::Leave( KErrNotFound );
+}
+aBelongsToProtectedDestination = EFalse;
+// Get destinations which have references to connection method passed as parameter.
+RArray<TUint32> dbDestinations;
+CleanupClosePushL( dbDestinations );
+iInstanceMapping->DestinationsContainingConnMethodL( connMethodId, dbDestinations );
+TUint32 metadata( 0 );
+for ( TInt i = 0; i < dbDestinations.Count(); i++ )
+{
+// Check if any of destinations is protected.
+metadata = iInstanceMapping->DestinationMetadata( dbDestinations[i] );
+TUint32 protlevel =
+( metadata & KDestProtectionLevelMask ) >> KBitsToShiftDestProtectionLevel;
+if ( protlevel == CMManager::EProtLevel1 || protlevel == CMManager::EProtLevel3 )
+{
+aBelongsToProtectedDestination = ETrue;
+break;
+}
+}
+CleanupStack::PopAndDestroy( &dbDestinations );
+OstTraceFunctionExit0( CCMMCACHE_CHECKIFCONNMETHODBELONGSTOPROTECTEDDESTINATIONL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Check if the given connection method can be deleted.
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::CheckIfConnMethodCanBeDeletedL(
 const CCmmConnMethodInstance& aConnMethodInstance )
 {
+OstTraceFunctionEntry0( CCMMCACHE_CHECKIFCONNMETHODCANBEDELETEDL_ENTRY );
 TUint32 connMethodId( aConnMethodInstance.GetId() );
 // Find connection method from cache.
 TInt index = FindConnMethodFromCache( connMethodId );
 if ( index == KErrNotFound )
 // Check that no virtual IAP points to this connection method.
 if ( iInstanceMapping->ConnMethodPointedToByVirtualIap( connMethodId ) )
 {
 User::Leave( KErrLocked );
 }
+OstTraceFunctionExit0( CCMMCACHE_CHECKIFCONNMETHODCANBEDELETEDL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Check if the given destination can be deleted.
 // ---------------------------------------------------------------------------
 //
 void CCmmCache::CheckIfDestinationCanBeDeletedL(
 const CCmmDestinationInstance& aDestinationInstance )
 {
+OstTraceFunctionEntry0( CCMMCACHE_CHECKIFDESTINATIONCANBEDELETEDL_ENTRY );
 TUint32 destinationId( aDestinationInstance.GetId() );
 // Find destination from cache.
 TInt index = FindDestinationFromCache( destinationId );
 if ( index == KErrNotFound )
 // Check if any of the connection methods in this destination are currently in use.
 if ( DestinationConnectedL( destinationId ) )
 {
 User::Leave( KErrInUse );
 }
+OstTraceFunctionExit0( CCMMCACHE_CHECKIFDESTINATIONCANBEDELETEDL_EXIT );
 }
 // ---------------------------------------------------------------------------
 // Return the requested table ID.
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Initiate the deletion of given destination if none of the connection
 // methods inside it are connected.
 // ---------------------------------------------------------------------------
 //
-void CCmmCache::DeleteDestinationForcedL( CCmmDestinationInstance& aDestinationInstance ) //TODO, OST
+void CCmmCache::DeleteDestinationForcedL( CCmmDestinationInstance& aDestinationInstance )
 {
-//TODO
+OstTraceFunctionEntry0( CCMMCACHE_DELETEDESTINATIONFORCEDL_ENTRY );
 if ( !DestinationConnectedL( 0, &aDestinationInstance ) )
 {
 DeleteDestinationL( aDestinationInstance, ETrue );
 }
+OstTraceFunctionExit0( CCMMCACHE_DELETEDESTINATIONFORCEDL_EXIT );
 }
 // End of file

branch	GCC_SURGE
changeset 49	faa5ef4f80da
parent 46	95d45f234cf3
child 53	4af712113915