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

equal deleted inserted replaced

-:f10336de0cd6
+:faa5ef4f80da
 * Description:
 * Handles client requests.
 *
 */
+#include <sysutil.h>
 #include <cmconnectionmethoddef.h>
 #include <cmpluginembdestinationdef.h>
 #include <cmdefconnvalues.h>
 #include "cmmserver.h"
 // -----------------------------------------------------------------------------
 //
 CCmmSession::CCmmSession( CCmmServer& aServer, CCmmCache& aCache )
 :
 iServer( aServer ),
-iCache( aCache )
+iCache( aCache ),
+iFsConnected( EFalse )
 {
 OstTraceFunctionEntry0( CCMMSESSION_CCMMSESSION_ENTRY );
 iDestinationContainer = NULL;
 iDestinationObjects = NULL;
 if ( iConnMethodContainer != 0 )
 {
 iServer.RemoveContainer( iConnMethodContainer );
 iConnMethodContainer = NULL;
 }
+if ( iFsConnected )
+{
+iFs.Close();
+iFsConnected = EFalse;
+}
 OstTraceFunctionExit0( DUP1_CCMMSESSION_CCMMSESSION_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CCmmSession::ServiceL
 }
 break;
 case ECmmGetSupportedBearers:
 {
 GetSupportedBearersL( aMessage );
+}
+break;
+case ECmmGetUncategorizedIcon:
+{
+GetUncategorizedIconL( aMessage );
 }
 break;
 case ECmmReadDefaultConnection:
 {
 ReadDefaultConnectionL( aMessage );
 case EDestMetadata:
 case EDestGetProtectionLevel:
 case EDestIsConnected:
 case EDestIsHidden:
 case EDestIsEqual:
+case EDestGetIcon:
 case EDestAddConnMethod:
 case EDestAddEmbeddedDestination:
 case EDestDeleteConnMethod:
 case EDestRemoveConnMethod:
 case EDestModifyPriority:
 case EDestSetMetadata:
 case EDestSetProtection:
 case EDestSetHidden:
 case EDestUpdate:
 case EDestDelete:
+case EDestSetIcon:
 {
 ServiceDestinationL( aMessage );
 }
 break;
 // Finds a connection method instance that belongs to this session and matches
 // the provided ID. Return NULL if no match is found.
 // -----------------------------------------------------------------------------
 //
 CCmmConnMethodInstance* CCmmSession::FindConnMethodInstanceById(
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_FINDCONNMETHODINSTANCEBYID_ENTRY );
 CCmmConnMethodInstance* wantedConnMethodInstance( NULL );
 // Finds a destination instance that belongs to this session and matches
 // the provided handle.
 // -----------------------------------------------------------------------------
 //
 CCmmDestinationInstance* CCmmSession::FindDestinationInstanceByHandleL(
-const TInt& aDestinationHandle )
+const TInt aDestinationHandle )
 {
 OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYHANDLEL_ENTRY );
 return (CCmmDestinationInstance*)iDestinationObjects->AtL( aDestinationHandle );
 }
 // Finds a destination instance that belongs to this session and matches
 // the provided ID. Return NULL if no match is found.
 // -----------------------------------------------------------------------------
 //
 CCmmDestinationInstance* CCmmSession::FindDestinationInstanceById(
-const TUint32& aDestinationId )
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYID_ENTRY );
 CCmmDestinationInstance* wantedDestinationInstance( NULL );
 // Check from all open destination handles in this session if the given
 // connection method is inside any of them. The given destination is skipped.
 // -----------------------------------------------------------------------------
 //
 TBool CCmmSession::ConnMethodInOtherDestination(
-const TUint32& aConnMethodId,
+const TUint32 aConnMethodId,
-const TUint32& aDestinationId )
+const TUint32 aDestinationId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_CONNMETHODINOTHERDESTINATION_ENTRY );
 for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )
 {
 // - aEmbeddedDestinationId is the ID of the destination that is beeing
 //   embedded.
 // -----------------------------------------------------------------------------
 //
 TBool CCmmSession::EmbeddedDestinationConflictsFromAllSessions(
-const TUint32& aDestinationId,
+const TUint32 aDestinationId,
-const TUint32& aEmbeddedDestinationId )
+const TUint32 aEmbeddedDestinationId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTSFROMALLSESSIONS_ENTRY );
-return iServer.EmbeddedDestinationConflictsFromAllSessions( aDestinationId, aEmbeddedDestinationId );
+return iServer.EmbeddedDestinationConflictsFromAllSessions(
+aDestinationId,
+aEmbeddedDestinationId );
 }
 // -----------------------------------------------------------------------------
 // Check for restrictions for adding an embedded destination from destination
 // instances of this session.
 // - Check that any destination instance for aEmbeddedDestinationId does not
 //   contain an embedded destination.
 // -----------------------------------------------------------------------------
 //
 TBool CCmmSession::EmbeddedDestinationConflicts(
-const TUint32& aDestinationId,
+const TUint32 aDestinationId,
-const TUint32& aEmbeddedDestinationId )
+const TUint32 aEmbeddedDestinationId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTS_ENTRY );
 TBool result( EFalse );
 // Removes a connection method from any open destination handle in this
 // session.
 // ---------------------------------------------------------------------------
 //
 void CCmmSession::RemoveConnMethodFromDestinationHandles(
-const TUint32& aConnMethodId )
+const TUint32 aConnMethodId )
 {
 OstTraceFunctionEntry0( CCMMSESSION_REMOVECONNMETHODFROMDESTINATIONHANDLES_ENTRY );
 for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )
 {
 // ---------------------------------------------------------------------------
 // Notify this session destination/connection method handles about an
 // updated/deleted destination/connection method.
 // ---------------------------------------------------------------------------
 //
-void CCmmSession::RefreshHandles( const TUint32& aId ) const
+void CCmmSession::RefreshHandles( const TUint32 aId ) const
 {
 OstTraceFunctionEntry0( CCMMSESSION_REFRESHHANDLES_ENTRY );
 // Destination or connection method.
 if ( aId < KCmmConnMethodIdIntervalMax )
 return;
 }
 CleanupStack::PushL( result );
 TInt bufferLen = aMessage.GetDesMaxLength( 2 );
-if ( result && result->Length() > bufferLen )
+if ( result->Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 TPtrC resultPtr = result->Des();
 return;
 }
 CleanupStack::PushL( result );
 TInt bufferLen = aMessage.GetDesMaxLength( 2 );
-if ( result && result->Length() > bufferLen )
+if ( result->Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 TPtrC8 resultPtr = result->Des();
 return;
 }
 CleanupStack::PushL( result );
 TInt bufferLen = aMessage.GetDesMaxLength( 2 );
-if ( result && result->Length() > bufferLen )
+if ( result->Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 TPtrC resultPtr = result->Des();
 return;
 }
 CleanupStack::PushL( result );
 TInt bufferLen = aMessage.GetDesMaxLength( 2 );
-if ( result && result->Length() > bufferLen )
+if ( result->Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 TPtrC8 resultPtr = result->Des();
 OstTraceFunctionExit0( DUP1_CCMMSESSION_GETSUPPORTEDBEARERSL_EXIT );
 }
 // -----------------------------------------------------------------------------
+// CCmmSession::GetUncategorizedIconL
+// -----------------------------------------------------------------------------
+//
+void CCmmSession::GetUncategorizedIconL( const RMessage2& aMessage )
+{
+OstTraceFunctionEntry0( CCMMSESSION_GETUNCATEGORIZEDICONL_ENTRY );
+HBufC* result = KCmmUncategorizedIconName().AllocLC();
+TInt bufferLen = aMessage.GetDesMaxLength( 0 );
+if ( result->Length() > bufferLen )
+{
+User::Leave( KErrArgument );
+}
+TPtrC resultPtr = result->Des();
+aMessage.WriteL( 0, resultPtr );
+CleanupStack::PopAndDestroy( result );
+OstTraceFunctionExit0( CCMMSESSION_GETUNCATEGORIZEDICONL_EXIT );
+}
+// -----------------------------------------------------------------------------
 // CCmmSession::ReadDefaultConnectionL
 // -----------------------------------------------------------------------------
 //
 void CCmmSession::ReadDefaultConnectionL( const RMessage2& aMessage )
 {
 TInt maxBufLen( 2 );
 // Check the length needed for serializing.
 for ( TInt i = 0; i < bearerCountInArray; i++ )
 {
 // Skip if service type is not valid.
-if ( bearerPriorityArray[i]->ServiceType() && bearerPriorityArray[i]->ServiceType()->Length() > 0 )
+if ( bearerPriorityArray[i]->ServiceType() &&
+bearerPriorityArray[i]->ServiceType()->Length() > 0 )
 {
 maxBufLen += KCmmBearerPriorityHeaderLength; // Priorities and servicetype length.
 maxBufLen += bearerPriorityArray[i]->ServiceType()->Length();
 }
 else
 bufferPtr.Append( maxBufLen );
 for ( TInt i = 0; i < bearerCountInArray; i++ )
 {
 // Skip if service type is not valid.
-if ( bearerPriorityArray[i]->ServiceType() && bearerPriorityArray[i]->ServiceType()->Length() > 0 )
+if ( bearerPriorityArray[i]->ServiceType() &&
+bearerPriorityArray[i]->ServiceType()->Length() > 0 )
 {
 TUint32 priority = bearerPriorityArray[i]->Priority();
 TUint32 uiPriority = bearerPriorityArray[i]->UiPriority();
 const HBufC* serviceType = bearerPriorityArray[i]->ServiceType();
 // -----------------------------------------------------------------------------
 //
 void CCmmSession::UpdateBearerPriorityArrayL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_UPDATEBEARERPRIORITYARRAYL_ENTRY );
+// Check the disk space.
+if ( CheckSpaceBelowCriticalLevelL() )
+{
+User::Leave( KErrDiskFull );
+}
 HBufC* bearerPriorityBuf = HBufC::NewLC( aMessage.GetDesMaxLengthL( 0 ) );
 TPtr bearerPriorityBufPtr( bearerPriorityBuf->Des() );
 aMessage.ReadL( 0, bearerPriorityBufPtr );
 HBufC* serviceName = HBufC::NewLC( stringLength );
 serviceName->Des().Append( &( bearerPriorityBufPtr[position] ), stringLength );
 position += stringLength;
 TPtrC tempServiceType( serviceName->Des() );
-CCmmBearerPriority* item = CCmmBearerPriority::NewLC( tempServiceType, priority, uiPriority );
+CCmmBearerPriority* item = CCmmBearerPriority::NewLC(
+tempServiceType,
+priority,
+uiPriority );
 bearerPriorityArray.AppendL( item );
 CleanupStack::Pop( item );
 CleanupStack::PopAndDestroy( serviceName );
 }
 //
 void CCmmSession::CopyConnMethodL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_COPYCONNMETHODL_ENTRY );
-CCmmDestinationInstance* destination = ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int0() );
+// Check the disk space.
-CCmmConnMethodInstance* connMethod = ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int1() );
+if ( CheckSpaceBelowCriticalLevelL() )
+{
+User::Leave( KErrDiskFull );
+}
+CCmmDestinationInstance* destination =
+( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int0() );
+CCmmConnMethodInstance* connMethod =
+( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int1() );
 // Can't add an embedded destination this way.
 if ( connMethod->IsEmbeddedDestination() )
 {
 User::Leave( KErrArgument );
 }
-//TODO, capability check, what to do if anything is protected.
+// Check the protection level of the destination.
+// And based on that check the needed capabilities from the client.
+CMManager::TProtectionLevel protLevel( CMManager::EProtLevel0 );
+destination->GetProtectionL( protLevel );
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+if ( protLevel == CMManager::EProtLevel1 )
+{
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+}
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
 // Add connection method into destination.
 TInt index = destination->AddConnMethodL( *connMethod );
 // Update destination into database.
 // -----------------------------------------------------------------------------
 //
 void CCmmSession::MoveConnMethodL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_MOVECONNMETHODL_ENTRY );
+// Check the disk space.
+if ( CheckSpaceBelowCriticalLevelL() )
+{
+User::Leave( KErrDiskFull );
+}
 // Read data from client request.
 TPckgBuf<TCmmIpcStructMoveConnMethod> attributesPckg;
 aMessage.ReadL( 0, attributesPckg );
 TCmmIpcStructMoveConnMethod attributes = attributesPckg();
 if ( iCache.CheckIfCmConnected( connMethodId ) )
 {
 User::Leave( KErrInUse );
 }
-//TODO, capability checks, what to do if anything is protected.
+// Check the protection level of the source and target destination.
+// And based on those check the needed capabilities from the client.
+TBool protectionExists( EFalse );
+CMManager::TProtectionLevel protLevelSource( CMManager::EProtLevel0 );
+sourceDestination->GetProtectionL( protLevelSource );
+if ( protLevelSource == CMManager::EProtLevel1
+|| protLevelSource == CMManager::EProtLevel3 )
+{
+protectionExists = ETrue;
+}
+// If source destination is not protected check the target destination.
+if ( !protectionExists )
+{
+CMManager::TProtectionLevel protLevelTarget( CMManager::EProtLevel0 );
+targetDestination->GetProtectionL( protLevelTarget );
+if ( protLevelTarget == CMManager::EProtLevel1 )
+{
+protectionExists = ETrue;
+}
+}
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+if ( protectionExists )
+{
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+}
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
 // Add connection method into target destination and update it.
 attributesPckg().iIndex = targetDestination->AddConnMethodL( *connMethod );
 targetDestination->UpdateL();
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int0() );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int1() );
-//TODO, capability checks
+// Check the protection level of the destination.
+// And based on that check the needed capabilities from the client.
+CMManager::TProtectionLevel protLevel( CMManager::EProtLevel0 );
+destinationInstance->GetProtectionL( protLevel );
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+if ( protLevel == CMManager::EProtLevel1 || protLevel == CMManager::EProtLevel3 )
+{
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+}
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
 destinationInstance->RemoveConnMethodFromDestinationL( *connMethodInstance );
 destinationInstance->UpdateL();
 OstTraceFunctionExit0( CCMMSESSION_REMOVECONNMETHODL_EXIT );
 OstTraceFunctionEntry0( CCMMSESSION_REMOVEALLREFERENCESL_ENTRY );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int0() );
+TBool capabilityCheckNeeded( EFalse );
+iCache.CheckIfConnMethodBelongsToProtectedDestinationL(
+*connMethodInstance,
+capabilityCheckNeeded );
+if ( capabilityCheckNeeded )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 iCache.CheckIfConnMethodReferencesCanBeRemovedL( *connMethodInstance );
 iCache.RemoveAllReferencesToConnMethodL( *connMethodInstance );
 OstTraceFunctionExit0( CCMMSESSION_REMOVEALLREFERENCESL_EXIT );
 }
 case EDestIsEqual:
 {
 DestinationIsEqualL( aMessage );
 }
 break;
+case EDestGetIcon:
+{
+GetDestinationIconL( aMessage );
+}
+break;
 case EDestAddConnMethod:
 {
 DestAddConnMethodL( aMessage );
 }
 break;
 }
 break;
 case EDestDelete:
 {
 DeleteDestinationL( aMessage );
+}
+break;
+case EDestSetIcon:
+{
+SetDestinationIconL( aMessage );
 }
 break;
 default:
 {
 User::Leave( KErrNotSupported );
 {
 User::Leave( KErrArgument );
 }
 // Check if a destination with given ID exists (or is already created but not saved).
-if ( iCache.DestinationExistsWithId( destinationId ) ||
+//TODO, Implement one single method for this check in CCmmCache-class, and call that. CCmmCache::DestinationOpenWithId() can be removed after that.
-iCache.DestinationOpenWithId( destinationId ) )
+if ( iCache.DestinationExistsWithId( destinationId ) || iCache.DestinationOpenWithId( destinationId ) )
 {
 User::Leave( KErrAlreadyExists );
+//TODO: Destination ID is decided based on network record ID. Connection methods also use network records.
+//TODO: Add a check here too see that the necessary network record ID is also available.
 }
 // Load and check name.
 TInt destNameLength = aMessage.GetDesLength( 0 );
 if ( destNameLength <= 0 )
 // Leave if given connection method is not inside this destination.
 User::LeaveIfError( index );
 // Check if the connection method is an embedded destination.
-if ( connMethodInstance->GetBearerType() == KUidEmbeddedDestination )
+if ( connMethodInstance->IsEmbeddedDestination() )
 {
 index = CMManager::KDataMobilitySelectionPolicyPriorityWildCard;
 }
-//TODO, what if CM is virtual?
+// If this is a virtual IAP that doesn't link to an IAP, the priority is wildcard.
+else if ( connMethodInstance->GetBoolAttributeL( CMManager::ECmVirtual ) )
+{
+if ( connMethodInstance->GetIntAttributeL( CMManager::ECmNextLayerIapId ) == 0 )
+{
+index = CMManager::KDataMobilitySelectionPolicyPriorityWildCard;
+}
+}
 TUint priority = ( TUint )index;
 TPckg<TUint> priorityPckg( priority );
 aMessage.WriteL( 1, priorityPckg );
 aMessage.WriteL( 0, namePtr );
 CleanupStack::PopAndDestroy( name );
 OstTraceFunctionExit0( CCMMSESSION_GETDESTINATIONNAMEL_EXIT );
+}
+// -----------------------------------------------------------------------------
+// CCmmSession::GetDestinationIconL
+// -----------------------------------------------------------------------------
+//
+void CCmmSession::GetDestinationIconL( const RMessage2& aMessage )
+{
+OstTraceFunctionEntry0( CCMMSESSION_GETDESTINATIONICONL_ENTRY );
+CCmmDestinationInstance* destinationInstance =
+( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+HBufC* icon = destinationInstance->GetDestinationIconL();
+CleanupStack::PushL( icon );
+TPtrC iconPtr( icon->Des() );
+TInt bufferLen = aMessage.GetDesMaxLength( 0 );
+if ( iconPtr.Length() > bufferLen )
+{
+User::Leave( KErrArgument );
+}
+aMessage.WriteL( 0, iconPtr );
+CleanupStack::PopAndDestroy( icon );
+OstTraceFunctionExit0( CCMMSESSION_GETDESTINATIONICONL_EXIT );
 }
 // -----------------------------------------------------------------------------
 // CCmmSession::GetDestinationIdL
 // -----------------------------------------------------------------------------
 {
 OstTraceFunctionEntry0( CCMMSESSION_DESTADDCONNMETHODL_ENTRY );
 CCmmDestinationInstance* destination =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destination->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CCmmConnMethodInstance* connMethod =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int0() );
 if ( connMethod->IsEmbeddedDestination() )
 {
 //
 void CCmmSession::DestAddEmbeddedDestinationL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_DESTADDEMBEDDEDDESTINATIONL_ENTRY );
-CCmmDestinationInstance* destination =
+CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CCmmDestinationInstance* embeddedDestination =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int0() );
-TInt index = destination->AddEmbeddedDestinationL( *embeddedDestination );
+TInt index = destinationInstance->AddEmbeddedDestinationL( *embeddedDestination );
 TPckg<TInt> indexPckg( index );
 aMessage.WriteL( 1, indexPckg );
 OstTraceFunctionExit0( CCMMSESSION_DESTADDEMBEDDEDDESTINATIONL_EXIT );
 }
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int0() );
-//TODO, capability checks
+// Check the protection of destination and if protected check the needed
+// capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel3 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
+// Check the protection of CM and if protected check the needed
+// capabilities.
+CheckCapabilitiesForProtectedCML( aMessage, connMethodInstance );
 destinationInstance->DeleteConnMethodFromDestinationL( *connMethodInstance );
 OstTraceFunctionExit0( CCMMSESSION_DESTDELETECONNMETHODL_EXIT );
 }
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int0() );
-//TODO, capability checks
+// Check the protection of destination and if protected check the needed
+// capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel3 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 destinationInstance->RemoveConnMethodFromDestinationL( *connMethodInstance );
 OstTraceFunctionExit0( CCMMSESSION_DESTREMOVECONNMETHODL_EXIT );
 }
 {
 OstTraceFunctionEntry0( CCMMSESSION_MODIFYCONNMETHODPRIORITYL_ENTRY );
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection of destination and if protected check the needed
+// capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel3 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int0() );
-//TODO, capability checks
 // Index values start from 0 (0 meaning highest priority).
 TUint index( ( TUint )aMessage.Int1() );
 destinationInstance->ModifyConnMethodPriorityL( *connMethodInstance, index );
 {
 OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONNAMEL_ENTRY );
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check that client does not try to change the name of the Internet Destination.
+TUint32 metadata( 0 );
+destinationInstance->GetMetadataL( CMManager::ESnapMetadataPurpose, metadata );
+if ( metadata == CMManager::ESnapPurposeInternet )
+{
+User::Leave( KErrPermissionDenied );
+}
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 // Load and check name.
 TInt destNameLength = aMessage.GetDesLength( 0 );
 if ( destNameLength <= 0 )
 {
 OstTraceFunctionExit0( CCMMSESSION_SETDESTINATIONNAMEL_EXIT );
 }
 // -----------------------------------------------------------------------------
-// CCmmSession::SetDestinationMetadataL
+// CCmmSession::SetDestinationIconL
 // -----------------------------------------------------------------------------
 //
-void CCmmSession::SetDestinationMetadataL( const RMessage2& aMessage )
+void CCmmSession::SetDestinationIconL( const RMessage2& aMessage )
 {
-OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONMETADATAL_ENTRY );
+OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONICONL_ENTRY );
-//TODO, Capability check. Protection level or Internet destination.
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
+// Load and check name.
+TInt destIconNameLength = aMessage.GetDesLength( 0 );
+if ( destIconNameLength < 0 || destIconNameLength > KCmmStringLengthMax )
+{
+User::Leave( KErrArgument );
+}
+HBufC* newIconName = HBufC::NewLC( destIconNameLength );
+TPtr ptrNewIconName = newIconName->Des();
+aMessage.ReadL( 0, ptrNewIconName );
+destinationInstance->SetDestinationIconL( *newIconName );
+CleanupStack::PopAndDestroy( newIconName );
+OstTraceFunctionExit0( CCMMSESSION_SETDESTINATIONICONL_EXIT );
+}
+// -----------------------------------------------------------------------------
+// CCmmSession::SetDestinationMetadataL
+// -----------------------------------------------------------------------------
+//
+void CCmmSession::SetDestinationMetadataL( const RMessage2& aMessage )
+{
+OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONMETADATAL_ENTRY );
+CCmmDestinationInstance* destinationInstance =
+( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CMManager::TSnapMetadataField metadataField =
 ( CMManager::TSnapMetadataField )aMessage.Int0();
 TUint32 metadata = aMessage.Int1();
 //
 void CCmmSession::SetDestinationProtectionL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONPROTECTIONL_ENTRY );
-//TODO, Capability check: ECapabilityNetworkControl
+// Check the needed capabilities.
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
 CMManager::TProtectionLevel protLevel =
 ( CMManager::TProtectionLevel )aMessage.Int0();
 OstTraceFunctionEntry0( CCMMSESSION_SETDESTINATIONHIDDENL_ENTRY );
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 TBool hidden = aMessage.Int0();
 destinationInstance->SetMetadataL( CMManager::ESnapMetadataHiddenAgent, hidden );
 OstTraceFunctionExit0( CCMMSESSION_SETDESTINATIONHIDDENL_EXIT );
 }
 //
 void CCmmSession::UpdateDestinationL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_UPDATEDESTINATIONL_ENTRY );
+// Check the disk space.
+if ( CheckSpaceBelowCriticalLevelL() )
+{
+User::Leave( KErrDiskFull );
+}
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection and if protected check the needed capabilities
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 ||
+protLevel == CMManager::EProtLevel3 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 destinationInstance->UpdateL();
 OstTraceFunctionExit0( CCMMSESSION_UPDATEDESTINATIONL_EXIT );
 }
 {
 OstTraceFunctionEntry0( CCMMSESSION_DELETEDESTINATIONL_ENTRY );
 CCmmDestinationInstance* destinationInstance =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( aMessage.Int3() );
+// Check the protection of destination and if protected check the needed
+// capabilities.
+CMManager::TProtectionLevel protLevel =
+destinationInstance->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 ||
+protLevel == CMManager::EProtLevel2 ||
+protLevel == CMManager::EProtLevel3 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 iCache.CheckIfDestinationCanBeDeletedL( *destinationInstance );
 iCache.DeleteDestinationL( *destinationInstance );
 // Close the destination handle. Destination instance destructor will
 {
 OstTraceFunctionEntry0( CCMMSESSION_CREATECONNMETHODL_ENTRY );
 TUint32 bearerType( aMessage.Int0() );
-CCmmConnMethodInstance* connMethod = CCmmConnMethodInstance::NewLC( this, &iCache );
+CCmmConnMethodInstance* connMethodInstance =
-iCache.CreateConnMethodL( *connMethod, NULL, bearerType, 0 );
+CCmmConnMethodInstance::NewLC( this, &iCache );
+iCache.CreateConnMethodL( *connMethodInstance, NULL, bearerType, 0 );
-iConnMethodContainer->AddL( ( CObject* ) connMethod );
-TInt handle = iConnMethodObjects->AddL( ( CObject* ) connMethod );
+iConnMethodContainer->AddL( ( CObject* ) connMethodInstance );
-connMethod->SetHandle( handle );
+TInt handle = iConnMethodObjects->AddL( ( CObject* ) connMethodInstance );
-CleanupStack::Pop( connMethod );
+connMethodInstance->SetHandle( handle );
+CleanupStack::Pop( connMethodInstance );
 TPckg<TInt> handlePckg( handle );
 TInt error = aMessage.Write( 3, handlePckg );
 if ( error )
 {
 //
 void CCmmSession::UpdateConnMethodL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_UPDATECONNMETHODL_ENTRY );
-CCmmConnMethodInstance* connMethod =
+// Check the disk space.
+if ( CheckSpaceBelowCriticalLevelL() )
+{
+User::Leave( KErrDiskFull );
+}
+CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
-connMethod->UpdateL();
+// Check if the Client has capabilities to modify this CM.
+CheckCapabilitiesForProtectedCML( aMessage, connMethodInstance );
+connMethodInstance->UpdateL();
 OstTraceFunctionExit0( CCMMSESSION_UPDATECONNMETHODL_EXIT );
 }
 // -----------------------------------------------------------------------------
 OstTraceFunctionExit0( CCMMSESSION_CLOSECONNMETHOD_EXIT );
 }
 // -----------------------------------------------------------------------------
-// CCmmSession::ConnMethodUpdateL
+// CCmmSession::DeleteConnMethodL
 // -----------------------------------------------------------------------------
 //
 void CCmmSession::DeleteConnMethodL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_DELETECONNMETHODL_ENTRY );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
+// Embedded destinations cannot be deleted through connection method handle.
+if ( connMethodInstance->IsEmbeddedDestination() )
+{
+User::Leave( KErrNotSupported );
+}
+// Check if the Client has capabilities to delete this CM.
+CheckCapabilitiesForProtectedCML( aMessage, connMethodInstance );
 iCache.CheckIfConnMethodCanBeDeletedL( *connMethodInstance );
 iCache.DeleteConnMethodL( *connMethodInstance );
 // Ignore the boolean return value. It is always true, or the
 // DeleteL()-call leaves.
 return;
 }
 CleanupStack::PushL( value );
 TPtrC valuePtr = value->Des();
-// check the buffer length of the given buffer
+// Check the buffer length of the given buffer.
 TInt bufferLen = aMessage.GetDesMaxLength( 1 );
 if ( valuePtr.Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 return;
 }
 CleanupStack::PushL( value );
 TPtrC8 valuePtr = value->Des();
-// check the buffer length of the given buffer
+// Check the buffer length of the given buffer.
 TInt bufferLen = aMessage.GetDesMaxLength( 1 );
 if ( valuePtr.Length() > bufferLen )
 {
 User::Leave( KErrArgument );
 }
 OstTraceFunctionEntry0( CCMMSESSION_SETINTATTRIBUTEL_ENTRY );
 CCmmConnMethodInstance* cm =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
+// Check the capability needed if protected CM
+// ECapabilityWriteDeviceData is checked earlier already.
+CheckCapabilitiesForProtectedCML( aMessage, cm );
 TUint32 attribute( aMessage.Int0() );
 TUint32 value( aMessage.Int1() );
 cm->SetIntAttributeL( attribute, value );
 OstTraceFunctionEntry0( CCMMSESSION_SETBOOLATTRIBUTEL_ENTRY );
 CCmmConnMethodInstance* cm =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
+// Check the capability needed if protected CM
+// ECapabilityWriteDeviceData is checked earlier already.
+CheckCapabilitiesForProtectedCML( aMessage, cm );
 TUint32 attribute( aMessage.Int0() );
 TBool value( aMessage.Int1() );
 cm->SetBoolAttributeL( attribute, value );
 {
 OstTraceFunctionEntry0( CCMMSESSION_SETSTRINGATTRIBUTEL_ENTRY );
 CCmmConnMethodInstance* cm =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
+// Check the capability needed if protected CM
+// ECapabilityWriteDeviceData is checked earlier already.
+CheckCapabilitiesForProtectedCML( aMessage, cm );
 TUint32 attribute( aMessage.Int0() );
 HBufC* value = HBufC::NewLC( aMessage.GetDesLengthL( 1 ) );
 TPtr valuePtr( value->Des() );
 {
 OstTraceFunctionEntry0( CCMMSESSION_SETSTRING8ATTRIBUTEL_ENTRY );
 CCmmConnMethodInstance* cm =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
+// Check the capability needed if protected CM
+// ECapabilityWriteDeviceData is checked earlier already.
+CheckCapabilitiesForProtectedCML( aMessage, cm );
 TUint32 attribute( aMessage.Int0() );
 HBufC8* value = HBufC8::NewLC( aMessage.GetDesLengthL( 1 ) );
 TPtr8 valuePtr( value->Des() );
 TUint32 bearerType( aMessage.Int1() );
 CCmmDestinationInstance* destination =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( destinationHandle );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destination->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CCmmConnMethodInstance* connMethod = CCmmConnMethodInstance::NewLC( this, &iCache );
 iCache.CreateConnMethodL( *connMethod, destination, bearerType, 0 );
 iConnMethodContainer->AddL( ( CObject* ) connMethod );
 TInt handle = iConnMethodObjects->AddL( ( CObject* ) connMethod );
 TUint32 connMethodId( aMessage.Int2() );
 CCmmDestinationInstance* destination =
 ( CCmmDestinationInstance* )iDestinationObjects->AtL( destinationHandle );
+// Check the protection and if protected check the needed capabilities.
+CMManager::TProtectionLevel protLevel =
+destination->CurrentProtectionLevelL();
+if ( protLevel == CMManager::EProtLevel1 )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
 CCmmConnMethodInstance* connMethod =
 CCmmConnMethodInstance::NewLC( this, &iCache );
 // Will check if ID is available.
 iCache.CreateConnMethodL( *connMethod, destination, bearerType, connMethodId );
 OstTraceFunctionExit0( CCMMSESSION_CREATECOPYOFEXISTINGL_EXIT );
 }
 // -----------------------------------------------------------------------------
-// Creates a copy of an existing connection method and opens a handle to it.
+// Opens a destination handle to the embedded destination that the provided
+// connection method handle represents.
 // -----------------------------------------------------------------------------
 //
 void CCmmSession::GetEmbeddedDestinationL( const RMessage2& aMessage )
 {
 OstTraceFunctionEntry0( CCMMSESSION_GETEMBEDDEDDESTINATIONL_ENTRY );
 CCmmConnMethodInstance* connMethodInstance =
 ( CCmmConnMethodInstance* )iConnMethodObjects->AtL( aMessage.Int3() );
-if ( connMethodInstance->GetBearerType() != KUidEmbeddedDestination )
+// Check this connection method realy represents an embedded destination.
+if ( !connMethodInstance->IsEmbeddedDestination() )
 {
 User::Leave( KErrNotSupported );
 }
 TUint32 destinationId = connMethodInstance->GetId();
 {
 // Removes from object index and destroys the object.
 iDestinationObjects->Remove( handle );
 User::Leave( error );
 }
 OstTraceFunctionExit0( CCMMSESSION_GETEMBEDDEDDESTINATIONL_EXIT );
 }
+// -----------------------------------------------------------------------------
+// Check if CM is protected and if so then check the needed capabilities.
+// -----------------------------------------------------------------------------
+//
+void CCmmSession::CheckCapabilitiesForProtectedCML(
+const RMessage2& aMessage,
+CCmmConnMethodInstance* aConnectionMethodInstance )
+{
+OstTraceFunctionEntry0( CCMMSESSION_CHECKCAPABILITIESFORPROTECTEDCML_ENTRY );
+TBool prot = aConnectionMethodInstance->GetBoolAttributeL( CMManager::ECmProtected );
+if ( prot )
+{
+CPolicyServer::TCustomResult capabilities( CPolicyServer::EPass );
+capabilities = iServer.CapabilityCheckWithProtection( aMessage );
+if ( capabilities == CPolicyServer::EFail )
+{
+User::Leave( KErrPermissionDenied );
+}
+}
+OstTraceFunctionExit0( CCMMSESSION_CHECKCAPABILITIESFORPROTECTEDCML_EXIT );
+}
+// ---------------------------------------------------------------------------
+// Check if there is space enough in the disk.
+// ---------------------------------------------------------------------------
+//
+TBool CCmmSession::CheckSpaceBelowCriticalLevelL()
+{
+if ( !iFsConnected )
+{
+TInt err = iFs.Connect();
+if ( err )
+{
+// Error happened in connect --> disk space cannot be checked,
+// --> return information that everything is ok.
+return EFalse;
+}
+iFsConnected = ETrue;
+}
+TBool belowCL = SysUtil::FFSSpaceBelowCriticalLevelL( &iFs, KMinimumDiskSpace );
+return belowCL;
+}
 // End of file

branch	GCC_SURGE
changeset 49	faa5ef4f80da
parent 46	95d45f234cf3