FCL/sf/mw/btservices: comparison bluetoothengine/btnotif/btnotifsrv/src/btnotifsecuritymanager.cpp

equal deleted inserted replaced

-:625f43ae9362
+:5ebadcda06cb
 // Symbian 2nd-phase constructor
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::ConstructL()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // Connect to pairing server for authentication & simple pairing
 // results directly from the BT stack.
 // Pairing server doesn't exist if we run BT 2.0 stack:
 iPairingServ = new (ELeave) RBluetoothPairingServer;
 TInt err = iPairingServ->Connect();
 iLocalAddrActive = CBtSimpleActive::NewL( *this, ERegistryGetLocalAddress );
 SubscribeLocalAddress();
 iPairNotifier = CBTNotifPairNotifier::NewL( *this );
 iDevRepository.AddObserverL( this );
 iServiceAuthorizer = CBTNotifServiceAuthorizer::NewL(*this);
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // NewL
 // ---------------------------------------------------------------------------
 // Destructor
 // ---------------------------------------------------------------------------
 //
 CBTNotifSecurityManager::~CBTNotifSecurityManager()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 delete iSSPResultActive;
 delete iAuthenResultActive;
 delete iPairNotifier;
 delete iPairingHandler;
 iPairedDevices.Close();
 if ( !iMessage.IsNull() )
 {
 iMessage.Complete( KErrCancel );
 }
 delete iServiceAuthorizer;
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Initialises the paired devices list.
 // If the local address is not available from the P&S key
 // new devices for new pairings.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::SubscribeLocalAddress()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // Check that we have the Bluetooth local address. If we don't then initialise anyway, but subscribe for an update.
 // This allows us to refresh our paired devices list to include updates made to the remote devices table of the
 // Bluetooth registry from a restore operation. We need to include these devices without mistaking them for new
 // pairings. We look solely at the P&S key for the address to avoid the condition whereby the address has been
 // entered into the reigstry but the Bluetooth Manager server has not begun the restore process yet. The signalling
 // Subscribe to local address property in case we need an update.
 iPropertyLocalAddr.Subscribe( iLocalAddrActive->iStatus );
 iLocalAddrActive->SetRequestId( ERegistryGetLocalAddress );
 iLocalAddrActive->GoActive();
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Tells whether the local address is available from the P&S key
 // KPropertyKeyBluetoothGetLocalDeviceAddress.
 // Handles pairing related requests from BTNotif clients.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::HandleBondingRequestL( const RMessage2& aMessage )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TInt opcode = aMessage.Function();
-TBTDevAddrPckgBuf addrPkg;
 switch( opcode )
 {
 case EBTNotifPairDevice:
 {
 if ( !iMessage.IsNull() )
 default:
 {
 User::Leave( KErrArgument );
 }
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Process a client message related to notifiers.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::HandleNotifierRequestL( const RMessage2& aMessage )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if(aMessage.Int0() == KBTManAuthNotifierUid.iUid)
 {
 iServiceAuthorizer->StartNotifierL( aMessage );
 }
 else
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::RenewPairingHandler(
 CBTNotifBasePairingHandler* aPairingHandler )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 delete iPairingHandler;
 iPairingHandler = aPairingHandler;
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Find the session who requested this and completes its request.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::OutgoingPairCompleted( TInt aErr )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // the meaning of KHCIErrorBase equals KErrNone. Hide this specific BT stack
 	// detail from clients:
 if ( !iMessage.IsNull()  )
 {
 iMessage.Complete( (aErr == KHCIErrorBase) ? KErrNone : aErr );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // A session will be ended, completes the pending request for this session.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::SessionClosed( CSession2* aSession )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 BOstrace1(TRACE_DEBUG,DUMMY_DEVLIST," session %x", aSession);
 if ( !iMessage.IsNull() && iMessage.Session() == aSession )
 {
 iMessage.Complete( KErrCancel );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Unpair the device from registry
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::UnpairDevice( const TBTDevAddr& aAddr )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TIdentityRelation<TBTNamelessDevice> addrComp( CompareDeviceByAddress );
 TBTNamelessDevice dev;
 dev.SetAddress( aAddr );
 // only do unpairing if the we have a link key with it.
 TInt index = iPairedDevices.Find( dev, addrComp );
 // status.Int() could be -1 if the device is not in registry
 // which is totally fine for us.
 (void) UpdateRegDevice( dev );
 }
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 void CBTNotifSecurityManager::BlockDevice( const TBTDevAddr& aAddr , TBool aBanned)
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TIdentityRelation<TBTNamelessDevice> addrComp( CompareDeviceByAddress );
 TBTNamelessDevice dev;
 dev.SetAddress( aAddr );
 TRequestStatus status( KRequestPending );
 // Unpair the device in registry (synchronously)
 security.SetNoAuthorise(EFalse);
 }
 dev.SetGlobalSecurity(security);
 (void)UpdateRegDevice(dev);
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 TInt CBTNotifSecurityManager::AddUiCookieJustWorksPaired( const TBTNamelessDevice& aDev )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TInt err( KErrNone );
 // There might be UI cookies used by other applications,
 // we should not overwrite them.
 TInt32 cookie = aDev.IsValidUiCookie() ? aDev.UiCookie() : EBTUiCookieUndefined;
 if ( !( cookie & EBTUiCookieJustWorksPaired ) )
 cookie |= EBTUiCookieJustWorksPaired;
 dev.SetUiCookie( cookie );
 err = UpdateRegDevice( dev );
 BOstrace1(TRACE_DEBUG,DUMMY_DEVLIST,"Outgoing Pairing write Ui cookie ret %d", err );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return err;
 }
 // ---------------------------------------------------------------------------
 // update a nameless device in registry
 // ---------------------------------------------------------------------------
 //
 TInt CBTNotifSecurityManager::UpdateRegDevice( const TBTNamelessDevice& aDev )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TRequestStatus status( KRequestPending );
 // update the device in registry synchronously
 iRegistry.ModifyDevice( aDev, status );
 User::WaitForRequest( status );
 BOstrace1(TRACE_DEBUG,DUMMY_DEVLIST,"UpdateRegDevice, ret %d", status.Int());
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return status.Int();
 }
 // ---------------------------------------------------------------------------
 // 0000 for outgoing pairing with a headset.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::GetPinCode(
 TBTPinCode& aPin, const TBTDevAddr& aAddr, TInt aMinPinLength )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if ( iPairingHandler )
 {
 iPairingHandler->GetPinCode( aPin, aAddr, aMinPinLength );
 }
 else
 {
 // make sure not to leave any text as PIN.
 aPin.Zero();
 aPin().iLength = 0;
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Ask server class the connection status of the specified device
 // ---------------------------------------------------------------------------
 //
 TBTEngConnectionStatus CBTNotifSecurityManager::ConnectStatus( const TBTDevAddr& aAddr )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 const CBtDevExtension* devExt = iDevRepository.Device(aAddr);
 TBTEngConnectionStatus status = EBTEngNotConnected;
 if ( devExt )
 {
 status = devExt->ServiceConnectionStatus();
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return status;
 }
 // ---------------------------------------------------------------------------
 // From class MBTNotifPairingAOObserver.
 // Checks if there is an authentication result.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::RequestCompletedL( CBtSimpleActive* aActive, TInt aStatus )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 BOstraceExt2(TRACE_DEBUG,DUMMY_DEVLIST,"aId: %d, aStatus: %d", aActive->RequestId(), aStatus);
 // Check which request is completed.
 switch( aActive->RequestId() )
 {
 case ESimplePairingResult:
 }
 default:
 // Should not be possible, but no need for handling.
 break;
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBTEngActiveObserver.
 // cancels an outstanding request according to the given id.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::CancelRequest( TInt aRequestId )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 switch ( aRequestId )
 {
 case ESimplePairingResult:
 {
 // Cancel listening Simple pairing result
 // cancel listening local address status change
 iPropertyLocalAddr.Cancel();
 break;
 }
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtSimpleActiveObserver.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::HandleError( CBtSimpleActive* aActive, TInt aError )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 BOstraceExt2(TRACE_DEBUG,DUMMY_DEVLIST,"request id: %d, error: %d", aActive->RequestId(), aError);
 (void) aActive;
 (void) aError;
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtDevRepositoryObserver.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::RepositoryInitialized()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TRAPD(err, UpdatePairedDeviceListL() );
 if ( !err && iPairingHandler )
 {
 // non-null pairing handler means we are involved in a
 // pairing operation already.
 // todo: is some handling for above case needed?
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtDevRepositoryObserver.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::DeletedFromRegistry( const TBTDevAddr& aAddr )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // We are only interested in the removal of a paired device.
 // thus check whether it is in our local paired list:
 TInt i = iPairedDevices.Find( aAddr, MatchDeviceAddress);
 if ( i > KErrNotFound )
 {
 iPairedDevices.Remove( i );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtDevRepositoryObserver.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::AddedToRegistry( const CBtDevExtension& aDevice )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // We are only interested in paired device.
 if ( CBtDevExtension::IsBonded( aDevice.Device().AsNamelessDevice() ) )
 {
 TRAP_IGNORE(
 HandleRegistryBondingL( aDevice.Device().AsNamelessDevice() ) );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtDevRepositoryObserver.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::ChangedInRegistry(
 const CBtDevExtension& aDevice, TUint aSimilarity )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 // We are only interested in paired device.
 // thus check whether it is in our local paired list:
 TInt i = iPairedDevices.Find( aDevice.Addr(), MatchDeviceAddress);
 TBool bonded = CBtDevExtension::IsBonded( aDevice.Device().AsNamelessDevice() );
 if ( i == KErrNotFound )
 {
+BOstrace0(TRACE_DEBUG,DUMMY_DEVLIST,"Not found");
 if ( bonded )
 {
+BOstrace0(TRACE_DEBUG,DUMMY_DEVLIST,"Not found but bonded");
 TRAP_IGNORE(
 HandleRegistryBondingL(
 aDevice.Device().AsNamelessDevice() ) );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return;
 }
 // Device was inregistry before, but we need to evaluate its bonding
 // status.
 // The given similarity will tell if the linkkey and paired is changed
 if ( ( pairingProperty & aSimilarity) == pairingProperty )
 {
 // no pairing or linkkey change. Nothing to do for pairing handling.
 // but we'd better update local copy just in case other data
 // of this device is needed by someone:
+BOstrace0(TRACE_DEBUG,DUMMY_DEVLIST,"No pairing or link key change");
 iPairedDevices[i] = aDevice.Device().AsNamelessDevice();
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return;
 }
-if ( !CBtDevExtension::IsBonded( aDevice.Device().AsNamelessDevice() ) )
+if ( !bonded )
 {
 // device is not user-bonded.
+UnTrustDevice(iPairedDevices[i].Address());
 iPairedDevices.Remove( i );
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return;
 }
 // it is a new paired device if its link-key has been upgraded
 if ( aDevice.Device().LinkKeyType() != ELinkKeyUnauthenticatedUpgradable )
 {
 iPairedDevices.Remove( i );
 TRAP_IGNORE(
 HandleRegistryBondingL(
 aDevice.Device().AsNamelessDevice() ) );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // From class MBtDevRepositoryObserver.
 // This class is not interested in such events.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::ServiceConnectionChanged(
 const CBtDevExtension& aDevice, TBool aConnected )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 (void) aDevice;
 (void) aConnected;
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Activate or deactivate a pairing handler
 // ---------------------------------------------------------------------------
 //
 TInt CBTNotifSecurityManager::SetPairObserver(const TBTDevAddr& aAddr, TBool aActivate)
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 BOstrace1(TRACE_DEBUG,DUMMY_DEVLIST,"%d", aActivate);
 BtTraceBtAddr0(TRACE_DEBUG,DUMMY_DEVLIST, aAddr );
 TInt err( KErrNone );
 if ( !aActivate )
 {
 if ( iPairingHandler )
 {
 iPairingHandler->StopPairHandling( aAddr );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return err;
 }
 if ( !iPairingHandler)
 {
 if ( iPairingHandler)
 {
 // let the handler decide what to do:
 err = iPairingHandler->ObserveIncomingPair( aAddr );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 return err;
 }
 // ---------------------------------------------------------------------------
 // Delegates the request to current pair handler
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::PairDeviceL( const TBTDevAddr& aAddr, TUint32 aCod )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if ( !iPairingHandler)
 {
 // no existing pair handling, create one:
 iPairingHandler = CBTNotifOutgoingPairingHandler::NewL( *this, aAddr );
 }
 // let pair handler decide what to do:
 iPairingHandler->HandleOutgoingPairL( aAddr, aCod );
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // cancel Subscribings to simple pairing result and authentication result from
 // Pairing Server
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::CancelSubscribePairingAuthenticate()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if( iSSPResultActive )
 {
 // Cancel listening Simple pairing result
 iSSPResultActive->Cancel();
 }
 if( iAuthenResultActive )
 {
 iAuthenResultActive->Cancel();
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Subscribes to simple pairing result from Pairing Server (if not already
 // subscribed).
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::SubscribeSspPairingResult()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if ( !iSSPResultActive->IsActive() )
 {
 iPairingResult.SimplePairingResult( iSimplePairingRemote, iSSPResultActive->RequestStatus() );
 iSSPResultActive->GoActive();
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Subscribes to authentication result from Pairing Server (if not already
 // subscribed).
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::SubscribeAuthenticateResult()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 if ( !iAuthenResultActive->IsActive() )
 {
 // Subscribe authentication result (which requires pairing for unpaired devices)
 iAuthenResult.AuthenticationResult( iAuthenticateRemote, iAuthenResultActive->RequestStatus() );
 iAuthenResultActive->GoActive();
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Handle a pairing result from the pairing server.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::HandlePairingResultL( const TBTDevAddr& aAddr, TInt aResult )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 BOstrace1(TRACE_DEBUG,DUMMY_DEVLIST,"result %d", aResult);
 BtTraceBtAddr0(TRACE_DEBUG,DUMMY_DEVLIST, aAddr );
 if ( !iPairingHandler && ( aResult == KErrNone || aResult == KHCIErrorBase ) )
 {
 {
 // No handler yet, create incoming pairing handler:
 iPairingHandler = CBTNotifIncomingPairingHandler::NewL( *this, aAddr );
 }
 }
 if ( iPairingHandler )
 {
 iPairingHandler->HandlePairServerResult( aAddr, aResult );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // copy the nameless devices to local array
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::UpdatePairedDeviceListL()
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 iPairedDevices.Reset();
 const RDevExtensionArray& alldevs = iDevRepository.AllDevices();
 for ( TInt i = 0; i < alldevs.Count(); i++ )
 {
 if ( CBtDevExtension::IsBonded( alldevs[i]->Device().AsNamelessDevice() ) )
 {
 iPairedDevices.AppendL( alldevs[i]->Device().AsNamelessDevice() );
 }
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 // ---------------------------------------------------------------------------
 // Create incoming pairing handler if no one exists yet.
 // ---------------------------------------------------------------------------
 //
 void CBTNotifSecurityManager::HandleRegistryBondingL(
 const TBTNamelessDevice& aNameless)
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TInt err = iPairedDevices.Append( aNameless );
 if ( !err && !iPairingHandler)
 {
 // New paired device, but no pairing handler yet.
 // this means an incoming pairing has occured:
 {
 // error could occur due to no memory,
 // let us try aborting pairing handling
 iPairingHandler->StopPairHandling( aNameless.Address() );
 }
+BOstraceFunctionExit0( DUMMY_DEVLIST);
 }
 void CBTNotifSecurityManager::TrustDevice( const TBTDevAddr& aAddr )
 {
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
 TIdentityRelation<TBTNamelessDevice> addrComp( CompareDeviceByAddress );
 TBTNamelessDevice dev;
 dev.SetAddress( aAddr );
 TRequestStatus status( KRequestPending );
 security.SetNoAuthorise(ETrue);
 security.SetBanned(EFalse);
 dev.SetGlobalSecurity(security);
 (void)UpdateRegDevice(dev);
 }
-}
+BOstraceFunctionExit0( DUMMY_DEVLIST);
+}
+void CBTNotifSecurityManager::UnTrustDevice( const TBTDevAddr& aAddr )
+{
+BOstraceFunctionEntry0( DUMMY_DEVLIST );
+TIdentityRelation<TBTNamelessDevice> addrComp( CompareDeviceByAddress );
+TBTNamelessDevice dev;
+dev.SetAddress( aAddr );
+TRequestStatus status( KRequestPending );
+iRegistry.GetDevice(dev,status);
+User::WaitForRequest( status );
+if(status == KErrNone)
+{
+TBTDeviceSecurity security = dev.GlobalSecurity();
+security.SetNoAuthorise(EFalse);
+dev.SetGlobalSecurity(security);
+(void)UpdateRegDevice(dev);
+}
+BOstraceFunctionExit0( DUMMY_DEVLIST);
+}
+CBTNotifBasePairingHandler* CBTNotifSecurityManager::PairingHandler()
+{
+return iPairingHandler;
+}

changeset 57	5ebadcda06cb
parent 47	9e2a905b887f
child 70	f5508c13dfe0