fix imports

.github/workflows/python-build-test.yml

@@ -29,11 +29,11 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install ".[build,test,development,documentation]"
+        python -m pip install ".[test,development,documentation]"
     - name: Test with pytest
       run: |
         pytest
     - name: Build
       run: |
         inv build
-        inv build.mkdocs
+        inv mkdocs

README.md

@@ -9,7 +9,7 @@
 Bluetooth Stack for Apps, Emulation, Test and Experimentation
 =============================================================
 
-<img src="docs/mkdocs/src/images/logo_framed.png" alt="Logo" width="200" height="200"/>
+<img src="docs/mkdocs/src/images/logo_framed.png" alt="drawing" width="200" height="200"/>
 
 Bumble is a full-featured Bluetooth stack written entirely in Python. It supports most of the common Bluetooth Low Energy (BLE) and Bluetooth Classic (BR/EDR) protocols and profiles, including GAP, L2CAP, ATT, GATT, SMP, SDP, RFCOMM, HFP, HID and A2DP. The stack can be used with physical radios via HCI over USB, UART, or the Linux VHCI, as well as virtual radios, including the virtual Bluetooth support of the Android emulator.
 
@@ -38,20 +38,12 @@ python -m pip install ".[test,development,documentation]"
 
 ### Examples
 
-Refer to the [Examples Documentation](examples/README.md) for details on the included example scripts and how to run them.
+Refer to the [Example Documentation](examples/README.md) for details on the included example scripts and how to run them.
 
 The complete [list of Examples](/docs/mkdocs/src/examples/index.md), and what they are designed to do is here.
 
 There are also a set of [Apps and Tools](docs/mkdocs/src/apps_and_tools/index.md) that show the utility of Bumble.
 
-### Using Bumble With a USB Dongle
-
-Bumble is easiest to use with a dedicated USB dongle.
-This is because internal Bluetooth interfaces tend to be locked down by the operating system.
-You can use the [usb_probe](/docs/mkdocs/src/apps_and_tools/usb_probe.md) tool (all platforms) or `lsusb` (Linux or macOS) to list the available USB devices on your system.
-
-See the [USB Transport](/docs/mkdocs/src/transports/usb.md) page for details on how to refer to USB devices.
-
 ## License
 
 Licensed under the [Apache 2.0](LICENSE) License.

apps/usb_probe.py

@@ -1,157 +0,0 @@
-# Copyright 2021-2022 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# This tool lists all the USB devices, with details about each device.
-# For each device, the different possible Bumble transport strings that can
-# refer to it are listed. If the device is known to be a Bluetooth HCI device,
-# its identifier is printed in reverse colors, and the transport names in cyan color.
-# For other devices, regardless of their type, the transport names are printed
-# in red. Whether that device is actually a Bluetooth device or not depends on
-# whether it is a Bluetooth device that uses a non-standard Class, or some other
-# type of device (there's no way to tell).
-# -----------------------------------------------------------------------------
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import os
-import logging
-import usb1
-from colors import color
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-USB_DEVICE_CLASS_WIRELESS_CONTROLLER             = 0xE0
-USB_DEVICE_SUBCLASS_RF_CONTROLLER                = 0x01
-USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER = 0x01
-
-USB_DEVICE_CLASSES = {
-    0x00: 'Device',
-    0x01: 'Audio',
-    0x02: 'Communications and CDC Control',
-    0x03: 'Human Interface Device',
-    0x05: 'Physical',
-    0x06: 'Still Imaging',
-    0x07: 'Printer',
-    0x08: 'Mass Storage',
-    0x09: 'Hub',
-    0x0A: 'CDC Data',
-    0x0B: 'Smart Card',
-    0x0D: 'Content Security',
-    0x0E: 'Video',
-    0x0F: 'Personal Healthcare',
-    0x10: 'Audio/Video',
-    0x11: 'Billboard',
-    0x12: 'USB Type-C Bridge',
-    0x3C: 'I3C',
-    0xDC: 'Diagnostic',
-    USB_DEVICE_CLASS_WIRELESS_CONTROLLER: (
-        'Wireless Controller',
-        {
-            0x01: {
-                0x01: 'Bluetooth',
-                0x02: 'UWB',
-                0x03: 'Remote NDIS',
-                0x04: 'Bluetooth AMP'
-            }
-        }
-    ),
-    0xEF: 'Miscellaneous',
-    0xFE: 'Application Specific',
-    0xFF: 'Vendor Specific'
-}
-
-
-# -----------------------------------------------------------------------------
-def main():
-    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-
-    with usb1.USBContext() as context:
-        bluetooth_device_count = 0
-        devices = {}
-
-        for device in context.getDeviceIterator(skip_on_error=True):
-            device_class    = device.getDeviceClass()
-            device_subclass = device.getDeviceSubClass()
-            device_protocol = device.getDeviceProtocol()
-
-            device_id = (device.getVendorID(), device.getProductID())
-
-            device_is_bluetooth_hci = (
-                device_class    == USB_DEVICE_CLASS_WIRELESS_CONTROLLER and
-                device_subclass == USB_DEVICE_SUBCLASS_RF_CONTROLLER and
-                device_protocol == USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER
-            )
-
-            device_class_details = ''
-            device_class_info    = USB_DEVICE_CLASSES.get(device_class)
-            if device_class_info is not None:
-                if type(device_class_info) is tuple:
-                    device_class = device_class_info[0]
-                    device_subclass_info = device_class_info[1].get(device_subclass)
-                    if device_subclass_info:
-                        device_class_details = f' [{device_subclass_info.get(device_protocol)}]'
-                else:
-                    device_class = device_class_info
-
-            if device_is_bluetooth_hci:
-                bluetooth_device_count += 1
-                fg_color = 'black'
-                bg_color = 'yellow'
-            else:
-                fg_color = 'yellow'
-                bg_color = 'black'
-
-            # Compute the different ways this can be referenced as a Bumble transport
-            bumble_transport_names = []
-            basic_transport_name = f'usb:{device.getVendorID():04X}:{device.getProductID():04X}'
-
-            if device_is_bluetooth_hci:
-                bumble_transport_names.append(f'usb:{bluetooth_device_count - 1}')
-
-            serial_number_collision = False
-            if device_id in devices:
-                for device_serial in devices[device_id]:
-                    if device_serial == device.getSerialNumber():
-                        serial_number_collision = True
-
-            if device_id not in devices:
-                bumble_transport_names.append(basic_transport_name)
-            else:
-                bumble_transport_names.append(f'{basic_transport_name}#{len(devices[device_id])}')
-
-            if device.getSerialNumber() and not serial_number_collision:
-                bumble_transport_names.append(f'{basic_transport_name}/{device.getSerialNumber()}')
-
-            print(color(f'ID {device.getVendorID():04X}:{device.getProductID():04X}', fg=fg_color, bg=bg_color))
-            if bumble_transport_names:
-                print(color('  Bumble Transport Names:', 'blue'), ' or '.join(color(x, 'cyan' if device_is_bluetooth_hci else 'red') for x in bumble_transport_names))
-            print(color('  Bus/Device:            ', 'green'), f'{device.getBusNumber():03}/{device.getDeviceAddress():03}')
-            if device.getSerialNumber():
-                print(color('  Serial:                ', 'green'), device.getSerialNumber())
-            print(color('  Class:                 ', 'green'), device_class)
-            print(color('  Subclass/Protocol:     ', 'green'), f'{device_subclass}/{device_protocol}{device_class_details}')
-            print(color('  Manufacturer:          ', 'green'), device.getManufacturer())
-            print(color('  Product:               ', 'green'), device.getProduct())
-            print()
-
-            devices.setdefault(device_id, []).append(device.getSerialNumber())
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

bumble/att.py

@@ -700,26 +700,16 @@ class Attribute(EventEmitter):
         else:
             self.value = value
 
-    def encode_value(self, value):
-        return value
-
-    def decode_value(self, value_bytes):
-        return value_bytes
-
     def read_value(self, connection):
         if read := getattr(self.value, 'read', None):
             try:
-                value = read(connection)
+                return read(connection)
             except ATT_Error as error:
                 raise ATT_Error(error_code=error.error_code, att_handle=self.handle)
         else:
-            value = self.value
-
-        return self.encode_value(value)
-
-    def write_value(self, connection, value_bytes):
-        value = self.decode_value(value_bytes)
+            return self.value
 
+    def write_value(self, connection, value):
         if write := getattr(self.value, 'write', None):
             try:
                 write(connection, value)
@@ -731,11 +721,7 @@ class Attribute(EventEmitter):
         self.emit('write', connection, value)
 
     def __repr__(self):
-        if type(self.value) is bytes:
-            value_str = self.value.hex()
-        else:
-            value_str = str(self.value)
-        if value_str:
+        if len(self.value) > 0:
             value_string = f', value={self.value.hex()}'
         else:
             value_string = ''

bumble/device.py

@@ -315,8 +315,6 @@ class DeviceConfiguration:
         self.le_simultaneous_enabled  = True
         self.classic_sc_enabled       = True
         self.classic_ssp_enabled      = True
-        self.connectable              = True
-        self.discoverable             = True
         self.advertising_data = bytes(
             AdvertisingData([(AdvertisingData.COMPLETE_LOCAL_NAME, bytes(self.name, 'utf-8'))])
         )
@@ -335,8 +333,6 @@ class DeviceConfiguration:
         self.le_simultaneous_enabled  = config.get('le_simultaneous_enabled', self.le_simultaneous_enabled)
         self.classic_sc_enabled       = config.get('classic_sc_enabled', self.classic_sc_enabled)
         self.classic_ssp_enabled      = config.get('classic_ssp_enabled', self.classic_ssp_enabled)
-        self.connectable              = config.get('connectable', self.connectable)
-        self.discoverable             = config.get('discoverable', self.discoverable)
 
         # Load or synthesize an IRK
         irk = config.get('irk')
@@ -450,8 +446,7 @@ class Device(CompositeEventEmitter):
         self.command_timeout          = 10  # seconds
         self.gatt_server              = gatt_server.Server(self)
         self.sdp_server               = sdp.Server(self)
-        self.l2cap_channel_manager    = l2cap.ChannelManager(
-            [l2cap.L2CAP_Information_Request.EXTENDED_FEATURE_FIXED_CHANNELS])
+        self.l2cap_channel_manager    = l2cap.ChannelManager()
         self.advertisement_data       = {}
         self.scanning                 = False
         self.discovering              = False
@@ -459,6 +454,8 @@ class Device(CompositeEventEmitter):
         self.disconnecting            = False
         self.connections              = {}  # Connections, by connection handle
         self.classic_enabled          = False
+        self.discoverable             = False
+        self.connectable              = False
         self.inquiry_response         = None
         self.address_resolver         = None
 
@@ -479,8 +476,6 @@ class Device(CompositeEventEmitter):
         self.le_simultaneous_enabled  = config.le_simultaneous_enabled
         self.classic_ssp_enabled      = config.classic_ssp_enabled
         self.classic_sc_enabled       = config.classic_sc_enabled
-        self.discoverable             = config.discoverable
-        self.connectable              = config.connectable
 
         # If a name is passed, override the name from the config
         if name:
@@ -495,10 +490,6 @@ class Device(CompositeEventEmitter):
         # Setup SMP
         # TODO: allow using a public address
         self.smp_manager = smp.Manager(self, self.random_address)
-        self.l2cap_channel_manager.register_fixed_channel(
-            smp.SMP_CID, self.on_smp_pdu)
-        self.l2cap_channel_manager.register_fixed_channel(
-            smp.SMP_BR_CID, self.on_smp_pdu)
 
         # Register the SDP server with the L2CAP Channel Manager
         self.sdp_server.register(self.l2cap_channel_manager)
@@ -506,7 +497,6 @@ class Device(CompositeEventEmitter):
         # Add a GAP Service if requested
         if generic_access_service:
             self.gatt_server.add_service(GenericAccessService(self.name))
-        self.l2cap_channel_manager.register_fixed_channel(ATT_CID, self.on_gatt_pdu)
 
         # Forward some events
         setup_event_forwarding(self.gatt_server, self, 'characteristic_subscription')
@@ -584,12 +574,11 @@ class Device(CompositeEventEmitter):
             logger.debug(color(f'BD_ADDR: {response.return_parameters.bd_addr}', 'yellow'))
             self.public_address = response.return_parameters.bd_addr
 
-        if self.host.supports_command(HCI_WRITE_LE_HOST_SUPPORT_COMMAND):
-            await self.send_command(HCI_Write_LE_Host_Support_Command(
-                le_supported_host    = int(self.le_enabled),
-                simultaneous_le_host = int(self.le_simultaneous_enabled),
-            ))
 
+        await self.send_command(HCI_Write_LE_Host_Support_Command(
+            le_supported_host = int(self.le_enabled),
+            simultaneous_le_host = int(self.le_simultaneous_enabled),
+        ))
         if self.le_enabled:
             # Set the controller address
             await self.send_command(HCI_LE_Set_Random_Address_Command(
@@ -634,8 +623,6 @@ class Device(CompositeEventEmitter):
                 HCI_Write_Secure_Connections_Host_Support_Command(
                     secure_connections_host_support=int(self.classic_sc_enabled))
             )
-            await self.set_connectable(self.connectable)
-            await self.set_discoverable(self.discoverable)
 
         # Let the SMP manager know about the address
         # TODO: allow using a public address
@@ -1210,17 +1197,17 @@ class Device(CompositeEventEmitter):
     def add_services(self, services):
         self.gatt_server.add_services(services)
 
-    async def notify_subscriber(self, connection, attribute, value=None, force=False):
-        await self.gatt_server.notify_subscriber(connection, attribute, value, force)
+    async def notify_subscriber(self, connection, attribute, force=False):
+        await self.gatt_server.notify_subscriber(connection, attribute, force)
 
-    async def notify_subscribers(self, attribute, value=None, force=False):
-        await self.gatt_server.notify_subscribers(attribute, value, force)
+    async def notify_subscribers(self, attribute, force=False):
+        await self.gatt_server.notify_subscribers(attribute, force)
 
-    async def indicate_subscriber(self, connection, attribute, value=None, force=False):
-        await self.gatt_server.indicate_subscriber(connection, attribute, value, force)
+    async def indicate_subscriber(self, connection, attribute, force=False):
+        await self.gatt_server.indicate_subscriber(connection, attribute, force)
 
-    async def indicate_subscribers(self, attribute, value=None, force=False):
-        await self.gatt_server.indicate_subscribers(attribute, value, force)
+    async def indicate_subscribers(self, attribute):
+        await self.gatt_server.indicate_subscribers(attribute)
 
     @host_event_handler
     def on_connection(self, connection_handle, transport, peer_address, peer_resolvable_address, role, connection_parameters):
@@ -1510,6 +1497,7 @@ class Device(CompositeEventEmitter):
     def on_pairing_failure(self, connection, reason):
         connection.emit('pairing_failure', reason)
 
+    @host_event_handler
     @with_connection_from_handle
     def on_gatt_pdu(self, connection, pdu):
         # Parse the L2CAP payload into an ATT PDU object
@@ -1528,6 +1516,7 @@ class Device(CompositeEventEmitter):
                 return
             connection.gatt_server.on_gatt_pdu(connection, att_pdu)
 
+    @host_event_handler
     @with_connection_from_handle
     def on_smp_pdu(self, connection, pdu):
         self.smp_manager.on_smp_pdu(connection, pdu)

bumble/gatt.py

@@ -303,7 +303,6 @@ class CharacteristicAdapter:
     '''
     def __init__(self, characteristic):
         self.wrapped_characteristic = characteristic
-        self.subscribers = {}  # Map from subscriber to proxy subscriber
 
         if (
             asyncio.iscoroutinefunction(characteristic.read_value) and
@@ -318,21 +317,11 @@ class CharacteristicAdapter:
         if hasattr(self.wrapped_characteristic, 'subscribe'):
             self.subscribe = self.wrapped_subscribe
 
-        if hasattr(self.wrapped_characteristic, 'unsubscribe'):
-            self.unsubscribe = self.wrapped_unsubscribe
-
     def __getattr__(self, name):
         return getattr(self.wrapped_characteristic, name)
 
     def __setattr__(self, name, value):
-        if name in {
-            'wrapped_characteristic',
-            'subscribers',
-            'read_value',
-            'write_value',
-            'subscribe',
-            'unsubscribe'
-        }:
+        if name in {'wrapped_characteristic', 'read_value', 'write_value', 'subscribe'}:
             super().__setattr__(name, value)
         else:
             setattr(self.wrapped_characteristic, name, value)
@@ -356,26 +345,9 @@ class CharacteristicAdapter:
         return value
 
     def wrapped_subscribe(self, subscriber=None):
-        if subscriber is not None:
-            if subscriber in self.subscribers:
-                # We already have a proxy subscriber
-                subscriber = self.subscribers[subscriber]
-            else:
-                # Create and register a proxy that will decode the value
-                original_subscriber = subscriber
-
-                def on_change(value):
-                    original_subscriber(self.decode_value(value))
-                self.subscribers[subscriber] = on_change
-                subscriber = on_change
-
-        return self.wrapped_characteristic.subscribe(subscriber)
-
-    def wrapped_unsubscribe(self, subscriber=None):
-        if subscriber in self.subscribers:
-            subscriber = self.subscribers.pop(subscriber)
-
-        return self.wrapped_characteristic.unsubscribe(subscriber)
+        return self.wrapped_characteristic.subscribe(
+            None if subscriber is None else lambda value: subscriber(self.decode_value(value))
+        )
 
     def __str__(self):
         wrapped = str(self.wrapped_characteristic)

bumble/gatt_client.py

@@ -58,16 +58,10 @@ class AttributeProxy(EventEmitter):
         self.type             = attribute_type
 
     async def read_value(self, no_long_read=False):
-        return self.decode_value(await self.client.read_value(self.handle, no_long_read))
+        return await self.client.read_value(self.handle, no_long_read)
 
     async def write_value(self, value, with_response=False):
-        return await self.client.write_value(self.handle, self.encode_value(value), with_response)
-
-    def encode_value(self, value):
-        return value
-
-    def decode_value(self, value_bytes):
-        return value_bytes
+        return await self.client.write_value(self.handle, value, with_response)
 
     def __str__(self):
         return f'Attribute(handle=0x{self.handle:04X}, type={self.uuid})'
@@ -104,7 +98,6 @@ class CharacteristicProxy(AttributeProxy):
         self.properties             = properties
         self.descriptors            = []
         self.descriptors_discovered = False
-        self.subscribers            = {}  # Map from subscriber to proxy subscriber
 
     def get_descriptor(self, descriptor_type):
         for descriptor in self.descriptors:
@@ -115,25 +108,9 @@ class CharacteristicProxy(AttributeProxy):
         return await self.client.discover_descriptors(self)
 
     async def subscribe(self, subscriber=None):
-        if subscriber is not None:
-            if subscriber in self.subscribers:
-                # We already have a proxy subscriber
-                subscriber = self.subscribers[subscriber]
-            else:
-                # Create and register a proxy that will decode the value
-                original_subscriber = subscriber
-
-                def on_change(value):
-                    original_subscriber(self.decode_value(value))
-                self.subscribers[subscriber] = on_change
-                subscriber = on_change
-
         return await self.client.subscribe(self, subscriber)
 
     async def unsubscribe(self, subscriber=None):
-        if subscriber in self.subscribers:
-            subscriber = self.subscribers.pop(subscriber)
-
         return await self.client.unsubscribe(self, subscriber)
 
     def __str__(self):
@@ -593,18 +570,12 @@ class Client:
                 subscribers = subscriber_set.get(characteristic.handle, [])
                 if subscriber in subscribers:
                     subscribers.remove(subscriber)
-
-                    # Cleanup if we removed the last one
-                    if not subscribers:
-                        subscriber_set.remove(characteristic.handle)
         else:
             # Remove all subscribers for this attribute from the sets!
             self.notification_subscribers.pop(characteristic.handle, None)
             self.indication_subscribers.pop(characteristic.handle, None)
 
-        if not self.notification_subscribers and not self.indication_subscribers:
-            # No more subscribers left
-            await self.write_value(cccd, b'\x00\x00', with_response=True)
+        await self.write_value(cccd, b'\x00\x00', with_response=True)
 
     async def read_value(self, attribute, no_long_read=False):
         '''

bumble/gatt_server.py

@@ -169,7 +169,7 @@ class Server(EventEmitter):
         logger.debug(f'GATT Response from server: [0x{connection.handle:04X}] {response}')
         self.send_gatt_pdu(connection.handle, response.to_bytes())
 
-    async def notify_subscriber(self, connection, attribute, value=None, force=False):
+    async def notify_subscriber(self, connection, attribute, force=False):
         # Check if there's a subscriber
         if not force:
             subscribers = self.subscribers.get(connection.handle)
@@ -184,8 +184,8 @@ class Server(EventEmitter):
                 logger.debug(f'not notifying, cccd={cccd.hex()}')
                 return
 
-        # Get or encode the value
-        value = attribute.read_value(connection) if value is None else attribute.encode_value(value)
+        # Get the value
+        value = attribute.read_value(connection)
 
         # Truncate if needed
         mtu = self.get_mtu(connection)
@@ -198,9 +198,27 @@ class Server(EventEmitter):
             attribute_value  = value
         )
         logger.debug(f'GATT Notify from server: [0x{connection.handle:04X}] {notification}')
-        self.send_gatt_pdu(connection.handle, bytes(notification))
+        self.send_gatt_pdu(connection.handle, notification.to_bytes())
 
-    async def indicate_subscriber(self, connection, attribute, value=None, force=False):
+    async def notify_subscribers(self, attribute, force=False):
+        # Get all the connections for which there's at least one subscription
+        connections = [
+            connection for connection in [
+                self.device.lookup_connection(connection_handle)
+                for (connection_handle, subscribers) in self.subscribers.items()
+                if force or subscribers.get(attribute.handle)
+            ]
+            if connection is not None
+        ]
+
+        # Notify for each connection
+        if connections:
+            await asyncio.wait([
+                self.notify_subscriber(connection, attribute, force)
+                for connection in connections
+            ])
+
+    async def indicate_subscriber(self, connection, attribute, force=False):
         # Check if there's a subscriber
         if not force:
             subscribers = self.subscribers.get(connection.handle)
@@ -215,8 +233,8 @@ class Server(EventEmitter):
                 logger.debug(f'not indicating, cccd={cccd.hex()}')
                 return
 
-        # Get or encode the value
-        value = attribute.read_value(connection) if value is None else attribute.encode_value(value)
+        # Get the value
+        value = attribute.read_value(connection)
 
         # Truncate if needed
         mtu = self.get_mtu(connection)
@@ -246,31 +264,24 @@ class Server(EventEmitter):
             finally:
                 self.pending_confirmations[connection.handle] = None
 
-    async def notify_or_indicate_subscribers(self, indicate, attribute, value=None, force=False):
+    async def indicate_subscribers(self, attribute):
         # Get all the connections for which there's at least one subscription
         connections = [
             connection for connection in [
                 self.device.lookup_connection(connection_handle)
                 for (connection_handle, subscribers) in self.subscribers.items()
-                if force or subscribers.get(attribute.handle)
+                if subscribers.get(attribute.handle)
             ]
             if connection is not None
         ]
 
-        # Indicate or notify for each connection
+        # Indicate for each connection
         if connections:
-            coroutine = self.indicate_subscriber if indicate else self.notify_subscriber
             await asyncio.wait([
-                asyncio.create_task(coroutine(connection, attribute, value, force))
+                self.indicate_subscriber(connection, attribute)
                 for connection in connections
             ])
 
-    async def notify_subscribers(self, attribute, value=None, force=False):
-        return await self.notify_or_indicate_subscribers(False, attribute, value, force)
-
-    async def indicate_subscribers(self, attribute, value=None, force=False):
-        return await self.notify_or_indicate_subscribers(True, attribute, value, force)
-
     def on_disconnection(self, connection):
         if connection.handle in self.mtus:
             del self.mtus[connection.handle]

bumble/helpers.py

@@ -18,8 +18,6 @@
 import logging
 from colors import color
 
-from bumble.smp import SMP_CID, SMP_Command
-
 from .core import name_or_number
 from .gatt import ATT_PDU, ATT_CID
 from .l2cap import (
@@ -75,9 +73,6 @@ class PacketTracer:
             if l2cap_pdu.cid == ATT_CID:
                 att_pdu = ATT_PDU.from_bytes(l2cap_pdu.payload)
                 self.analyzer.emit(att_pdu)
-            elif l2cap_pdu.cid == SMP_CID:
-                smp_command = SMP_Command.from_bytes(l2cap_pdu.payload)
-                self.analyzer.emit(smp_command)
             elif l2cap_pdu.cid == L2CAP_SIGNALING_CID or l2cap_pdu.cid == L2CAP_LE_SIGNALING_CID:
                 control_frame = L2CAP_Control_Frame.from_bytes(l2cap_pdu.payload)
                 self.analyzer.emit(control_frame)

bumble/host.py

@@ -44,20 +44,25 @@ HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS        = 1
 
 # -----------------------------------------------------------------------------
 class Connection:
-    def __init__(self, host, handle, role, peer_address, transport):
+    def __init__(self, host, handle, role, peer_address):
         self.host                  = host
         self.handle                = handle
         self.role                  = role
         self.peer_address          = peer_address
         self.assembler             = HCI_AclDataPacketAssembler(self.on_acl_pdu)
-        self.transport             = transport
 
     def on_hci_acl_data_packet(self, packet):
         self.assembler.feed_packet(packet)
 
     def on_acl_pdu(self, pdu):
         l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
-        self.host.on_l2cap_pdu(self, l2cap_pdu.cid, l2cap_pdu.payload)
+
+        if l2cap_pdu.cid == ATT_CID:
+            self.host.on_gatt_pdu(self, l2cap_pdu.payload)
+        elif l2cap_pdu.cid == SMP_CID:
+            self.host.on_smp_pdu(self, l2cap_pdu.payload)
+        else:
+            self.host.on_l2cap_pdu(self, l2cap_pdu.cid, l2cap_pdu.payload)
 
 
 # -----------------------------------------------------------------------------
@@ -76,7 +81,7 @@ class Host(EventEmitter):
         self.hc_total_num_acl_data_packets    = HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS
         self.acl_packet_queue                 = collections.deque()
         self.acl_packets_in_flight            = 0
-        self.local_version                    = HCI_VERSION_BLUETOOTH_CORE_4_0
+        self.local_version                    = None
         self.local_supported_commands         = bytes(64)
         self.local_le_features                = 0
         self.command_semaphore                = asyncio.Semaphore(1)
@@ -94,18 +99,17 @@ class Host(EventEmitter):
         await self.send_command(HCI_Reset_Command())
         self.ready = True
 
+        await self.send_command(HCI_Set_Event_Mask_Command(event_mask = bytes.fromhex('FFFFFFFFFFFFFFFF')))
+        await self.send_command(HCI_LE_Set_Event_Mask_Command(le_event_mask = bytes.fromhex('FFFFF00000000000')))
+
         response = await self.send_command(HCI_Read_Local_Supported_Commands_Command())
         if response.return_parameters.status == HCI_SUCCESS:
             self.local_supported_commands = response.return_parameters.supported_commands
         else:
             logger.warn(f'HCI_Read_Local_Supported_Commands_Command failed: {response.return_parameters.status}')
 
-        if self.supports_command(HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
-            response = await self.send_command(HCI_LE_Read_Local_Supported_Features_Command())
-            if response.return_parameters.status == HCI_SUCCESS:
-                self.local_le_features = struct.unpack('<Q', response.return_parameters.le_features)[0]
-            else:
-                logger.warn(f'HCI_LE_Read_Supported_Features_Command failed: {response.return_parameters.status}')
+        if self.supports_command(HCI_WRITE_LE_HOST_SUPPORT_COMMAND):
+            await self.send_command(HCI_Write_LE_Host_Support_Command(le_supported_host = 1, simultaneous_le_host = 0))
 
         if self.supports_command(HCI_READ_LOCAL_VERSION_INFORMATION_COMMAND):
             response = await self.send_command(HCI_Read_Local_Version_Information_Command())
@@ -114,44 +118,32 @@ class Host(EventEmitter):
             else:
                 logger.warn(f'HCI_Read_Local_Version_Information_Command failed: {response.return_parameters.status}')
 
-        await self.send_command(HCI_Set_Event_Mask_Command(event_mask = bytes.fromhex('FFFFFFFFFFFFFF3F')))
-
-        if self.local_version.hci_version <= HCI_VERSION_BLUETOOTH_CORE_4_0:
-            # Some older controllers don't like event masks with bits they don't understand
-            le_event_mask = bytes.fromhex('1F00000000000000')
-        else:
-            le_event_mask = bytes.fromhex('FFFFF00000000000')
-        await self.send_command(HCI_LE_Set_Event_Mask_Command(le_event_mask = le_event_mask))
-
-        if self.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
-            response = await self.send_command(HCI_Read_Buffer_Size_Command())
-            if response.return_parameters.status == HCI_SUCCESS:
-                self.hc_acl_data_packet_length     = response.return_parameters.hc_acl_data_packet_length
-                self.hc_total_num_acl_data_packets = response.return_parameters.hc_total_num_acl_data_packets
-            else:
-                logger.warn(f'HCI_Read_Buffer_Size_Command failed: {response.return_parameters.status}')
-
         if self.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(HCI_LE_Read_Buffer_Size_Command())
             if response.return_parameters.status == HCI_SUCCESS:
-                self.hc_le_acl_data_packet_length     = response.return_parameters.hc_le_acl_data_packet_length
+                self.hc_le_acl_data_packet_length = response.return_parameters.hc_le_acl_data_packet_length
                 self.hc_total_num_le_acl_data_packets = response.return_parameters.hc_total_num_le_acl_data_packets
+                logger.debug(f'HCI LE ACL flow control: hc_le_acl_data_packet_length={response.return_parameters.hc_le_acl_data_packet_length}, hc_total_num_le_acl_data_packets={response.return_parameters.hc_total_num_le_acl_data_packets}')
             else:
                 logger.warn(f'HCI_LE_Read_Buffer_Size_Command failed: {response.return_parameters.status}')
+            if response.return_parameters.hc_le_acl_data_packet_length == 0 or response.return_parameters.hc_total_num_le_acl_data_packets == 0:
+                # Read the non-LE-specific values
+                response = await self.send_command(HCI_Read_Buffer_Size_Command())
+                if response.return_parameters.status == HCI_SUCCESS:
+                    self.hc_acl_data_packet_length        = response.return_parameters.hc_le_acl_data_packet_length
+                    self.hc_le_acl_data_packet_length     = self.hc_le_acl_data_packet_length or self.hc_acl_data_packet_length
+                    self.hc_total_num_acl_data_packets    = response.return_parameters.hc_total_num_le_acl_data_packets
+                    self.hc_total_num_le_acl_data_packets = self.hc_total_num_le_acl_data_packets or self.hc_total_num_acl_data_packets
+                    logger.debug(f'HCI LE ACL flow control: hc_le_acl_data_packet_length={self.hc_le_acl_data_packet_length}, hc_total_num_le_acl_data_packets={self.hc_total_num_le_acl_data_packets}')
+                else:
+                    logger.warn(f'HCI_Read_Buffer_Size_Command failed: {response.return_parameters.status}')
 
-        if response.return_parameters.hc_le_acl_data_packet_length == 0 or response.return_parameters.hc_total_num_le_acl_data_packets == 0:
-            # LE and Classic share the same values
-            self.hc_le_acl_data_packet_length     = self.hc_acl_data_packet_length
-            self.hc_total_num_le_acl_data_packets = self.hc_total_num_acl_data_packets
-
-        logger.debug(
-            f'HCI ACL flow control: hc_acl_data_packet_length={self.hc_acl_data_packet_length},'
-            f'hc_total_num_acl_data_packets={self.hc_total_num_acl_data_packets}'
-        )
-        logger.debug(
-            f'HCI LE ACL flow control: hc_le_acl_data_packet_length={self.hc_le_acl_data_packet_length},'
-            f'hc_total_num_le_acl_data_packets={self.hc_total_num_le_acl_data_packets}'
-        )
+        if self.supports_command(HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
+            response = await self.send_command(HCI_LE_Read_Local_Supported_Features_Command())
+            if response.return_parameters.status == HCI_SUCCESS:
+                self.local_le_features = struct.unpack('<Q', response.return_parameters.le_features)[0]
+            else:
+                logger.warn(f'HCI_LE_Read_Supported_Features_Command failed: {response.return_parameters.status}')
 
         self.reset_done = True
 
@@ -176,8 +168,8 @@ class Host(EventEmitter):
 
         # Wait until we can send (only one pending command at a time)
         async with self.command_semaphore:
-            assert self.pending_command is None
-            assert self.pending_response is None
+            assert(self.pending_command is None)
+            assert(self.pending_response is None)
 
             # Create a future value to hold the eventual response
             self.pending_response = asyncio.get_running_loop().create_future()
@@ -210,7 +202,6 @@ class Host(EventEmitter):
         offset = 0
         pb_flag = 0
         while bytes_remaining:
-            # TODO: support different LE/Classic lengths
             data_total_length = min(bytes_remaining, self.hc_le_acl_data_packet_length)
             acl_packet = HCI_AclDataPacket(
                 connection_handle  = connection_handle,
@@ -233,7 +224,7 @@ class Host(EventEmitter):
             logger.debug(f'{self.acl_packets_in_flight} ACL packets in flight, {len(self.acl_packet_queue)} in queue')
 
     def check_acl_packet_queue(self):
-        # Send all we can (TODO: support different LE/Classic limits)
+        # Send all we can
         while len(self.acl_packet_queue) > 0 and self.acl_packets_in_flight < self.hc_total_num_le_acl_data_packets:
             packet = self.acl_packet_queue.pop()
             self.send_hci_packet(packet)
@@ -308,6 +299,12 @@ class Host(EventEmitter):
         if connection := self.connections.get(packet.connection_handle):
             connection.on_hci_acl_data_packet(packet)
 
+    def on_gatt_pdu(self, connection, pdu):
+        self.emit('gatt_pdu', connection.handle, pdu)
+
+    def on_smp_pdu(self, connection, pdu):
+        self.emit('smp_pdu', connection.handle, pdu)
+
     def on_l2cap_pdu(self, connection, cid, pdu):
         self.emit('l2cap_pdu', connection.handle, cid, pdu)
 
@@ -365,7 +362,7 @@ class Host(EventEmitter):
 
             connection = self.connections.get(event.connection_handle)
             if connection is None:
-                connection = Connection(self, event.connection_handle, event.role, event.peer_address, BT_LE_TRANSPORT)
+                connection = Connection(self, event.connection_handle, event.role, event.peer_address)
                 self.connections[event.connection_handle] = connection
 
             # Notify the client
@@ -400,7 +397,7 @@ class Host(EventEmitter):
 
             connection = self.connections.get(event.connection_handle)
             if connection is None:
-                connection = Connection(self, event.connection_handle, BT_CENTRAL_ROLE, event.bd_addr, BT_BR_EDR_TRANSPORT)
+                connection = Connection(self, event.connection_handle, BT_CENTRAL_ROLE, event.bd_addr)
                 self.connections[event.connection_handle] = connection
 
             # Notify the client

bumble/l2cap.py

@@ -414,18 +414,6 @@ class L2CAP_Information_Request(L2CAP_Control_Frame):
     EXTENDED_FEATURES_SUPPORTED = 0x0002
     FIXED_CHANNELS_SUPPORTED    = 0x0003
 
-    EXTENDED_FEATURE_FLOW_MODE_CONTROL                 = 0x0001
-    EXTENDED_FEATURE_RETRANSMISSION_MODE               = 0x0002
-    EXTENDED_FEATURE_BIDIRECTIONAL_QOS                 = 0x0004
-    EXTENDED_FEATURE_ENHANCED_RETRANSMISSION_MODE      = 0x0008
-    EXTENDED_FEATURE_STREAMING_MODE                    = 0x0010
-    EXTENDED_FEATURE_FCS_OPTION                        = 0x0020
-    EXTENDED_FEATURE_EXTENDED_FLOW_SPEC                = 0x0040
-    EXTENDED_FEATURE_FIXED_CHANNELS                    = 0x0080
-    EXTENDED_FEATURE_EXTENDED_WINDOW_SIZE              = 0x0100
-    EXTENDED_FEATURE_UNICAST_CONNECTIONLESS_DATA       = 0x0200
-    EXTENDED_FEATURE_ENHANCED_CREDIT_BASE_FLOW_CONTROL = 0x0400
-
     INFO_TYPE_NAMES = {
         CONNECTIONLESS_MTU:          'CONNECTIONLESS_MTU',
         EXTENDED_FEATURES_SUPPORTED: 'EXTENDED_FEATURES_SUPPORTED',
@@ -829,16 +817,11 @@ class Channel(EventEmitter):
 
 # -----------------------------------------------------------------------------
 class ChannelManager:
-    def __init__(self, extended_features=None, connectionless_mtu=1024):
-        self.host               = None
-        self.channels           = {}  # Channels, mapped by connection and cid
-        # Fixed channel handlers, mapped by cid
-        self.fixed_channels     = {
-            L2CAP_SIGNALING_CID: None, L2CAP_LE_SIGNALING_CID: None}
-        self.identifiers        = {}  # Incrementing identifier values by connection
-        self.servers            = {}  # Servers accepting connections, by PSM
-        self.extended_features  = [] if extended_features is None else extended_features
-        self.connectionless_mtu = connectionless_mtu
+    def __init__(self):
+        self.host        = None
+        self.channels    = {}  # Channels, mapped by connection and cid
+        self.identifiers = {}  # Incrementing identifier values by connection
+        self.servers     = {}  # Servers accepting connections, by PSM
 
     def find_channel(self, connection_handle, cid):
         if connection_channels := self.channels.get(connection_handle):
@@ -857,13 +840,6 @@ class ChannelManager:
         identifier = (self.identifiers.setdefault(connection.handle, 0) + 1) % 256
         self.identifiers[connection.handle] = identifier
         return identifier
-    
-    def register_fixed_channel(self, cid, handler):
-        self.fixed_channels[cid] = handler
-    
-    def deregister_fixed_channel(self, cid):
-        if cid in self.fixed_channels:
-            del self.fixed_channels[cid]
 
     def register_server(self, psm, server):
         self.servers[psm] = server
@@ -879,8 +855,6 @@ class ChannelManager:
             control_frame = L2CAP_Control_Frame.from_bytes(pdu)
 
             self.on_control_frame(connection, cid, control_frame)
-        elif cid in self.fixed_channels:
-            self.fixed_channels[cid](connection.handle, pdu)
         else:
             if (channel := self.find_channel(connection.handle, cid)) is None:
                 logger.warn(color(f'channel not found for 0x{connection.handle:04X}:{cid}', 'red'))
@@ -1025,13 +999,13 @@ class ChannelManager:
     def on_l2cap_information_request(self, connection, cid, request):
         if request.info_type == L2CAP_Information_Request.CONNECTIONLESS_MTU:
             result = L2CAP_Information_Response.SUCCESS
-            data = self.connectionless_mtu.to_bytes(2, 'little')
+            data = struct.pack('<H', 1024)  # TODO: don't use a fixed value
         elif request.info_type == L2CAP_Information_Request.EXTENDED_FEATURES_SUPPORTED:
             result = L2CAP_Information_Response.SUCCESS
-            data = sum(self.extended_features).to_bytes(4, 'little')
+            data = bytes.fromhex('00000000')  # TODO: don't use a fixed value
         elif request.info_type == L2CAP_Information_Request.FIXED_CHANNELS_SUPPORTED:
             result = L2CAP_Information_Response.SUCCESS
-            data = sum(1 << cid for cid in self.fixed_channels).to_bytes(8, 'little')
+            data = bytes.fromhex('FFFFFFFFFFFFFFFF')  # TODO: don't use a fixed value
         else:
             result = L2CAP_Information_Request.NO_SUPPORTED
 

bumble/smp.py

@@ -44,7 +44,6 @@ logger = logging.getLogger(__name__)
 # Constants
 # -----------------------------------------------------------------------------
 SMP_CID = 0x06
-SMP_BR_CID = 0x07
 
 SMP_PAIRING_REQUEST_COMMAND               = 0x01
 SMP_PAIRING_RESPONSE_COMMAND              = 0x02
@@ -153,8 +152,6 @@ SMP_CT2_AUTHREQ      = 0b00100000
 
 # Crypto salt
 SMP_CTKD_H7_LEBR_SALT = bytes.fromhex('00000000000000000000000000000000746D7031')
-SMP_CTKD_H7_BRLE_SALT = bytes.fromhex('00000000000000000000000000000000746D7032')
-
 
 # -----------------------------------------------------------------------------
 # Utils
@@ -601,7 +598,6 @@ class Session:
         self.pairing_config              = pairing_config
         self.wait_before_continuing      = None
         self.completed                   = False
-        self.ctkd_task                   = None
 
         # Decide if we're the initiator or the responder
         self.is_initiator = (connection.role == BT_CENTRAL_ROLE)
@@ -881,21 +877,10 @@ class Session:
             )
         )
 
-    async def derive_ltk(self):
-        link_key = await self.manager.device.get_link_key(self.connection.peer_address)
-        assert link_key is not None
-        ilk = crypto.h7(
-            salt=SMP_CTKD_H7_BRLE_SALT,
-            w=link_key) if self.ct2 else crypto.h6(link_key, b'tmp2')
-        self.ltk = crypto.h6(ilk, b'brle')
-
     def distribute_keys(self):
         # Distribute the keys as required
         if self.is_initiator:
-            # CTKD: Derive LTK from LinkKey
-            if self.connection.transport == BT_BR_EDR_TRANSPORT and self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
-                self.ctkd_task = asyncio.create_task(self.derive_ltk())
-            elif not self.sc:
+            if not self.sc:
                 # Distribute the LTK, EDIV and RAND
                 if self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
                     self.send_command(SMP_Encryption_Information_Command(long_term_key=self.ltk))
@@ -915,7 +900,7 @@ class Session:
             csrk = bytes(16)  # FIXME: testing
             if self.initiator_key_distribution & SMP_SIGN_KEY_DISTRIBUTION_FLAG:
                 self.send_command(SMP_Signing_Information_Command(signature_key=csrk))
-
+            
             # CTKD, calculate BR/EDR link key
             if self.initiator_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
                 ilk = crypto.h7(
@@ -924,11 +909,8 @@ class Session:
                 self.link_key = crypto.h6(ilk, b'lebr')
 
         else:
-            # CTKD: Derive LTK from LinkKey
-            if self.connection.transport == BT_BR_EDR_TRANSPORT and self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
-                self.ctkd_task = asyncio.create_task(self.derive_ltk())
             # Distribute the LTK, EDIV and RAND
-            elif not self.sc:
+            if not self.sc:
                 if self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG:
                     self.send_command(SMP_Encryption_Information_Command(long_term_key=self.ltk))
                     self.send_command(SMP_Master_Identification_Command(ediv=self.ltk_ediv, rand=self.ltk_rand))
@@ -947,7 +929,7 @@ class Session:
             csrk = bytes(16)  # FIXME: testing
             if self.responder_key_distribution & SMP_SIGN_KEY_DISTRIBUTION_FLAG:
                 self.send_command(SMP_Signing_Information_Command(signature_key=csrk))
-
+            
             # CTKD, calculate BR/EDR link key
             if self.responder_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
                 ilk = crypto.h7(
@@ -958,7 +940,7 @@ class Session:
     def compute_peer_expected_distributions(self, key_distribution_flags):
         # Set our expectations for what to wait for in the key distribution phase
         self.peer_expected_distributions = []
-        if not self.sc and self.connection.transport == BT_LE_TRANSPORT:
+        if not self.sc:
             if (key_distribution_flags & SMP_ENC_KEY_DISTRIBUTION_FLAG != 0):
                 self.peer_expected_distributions.append(SMP_Encryption_Information_Command)
                 self.peer_expected_distributions.append(SMP_Master_Identification_Command)
@@ -981,7 +963,12 @@ class Session:
             self.peer_expected_distributions.remove(command_class)
             logger.debug(f'remaining distributions: {[c.__name__ for c in self.peer_expected_distributions]}')
             if not self.peer_expected_distributions:
-                self.on_peer_key_distribution_complete()
+                # The initiator can now send its keys
+                if self.is_initiator:
+                    self.distribute_keys()
+
+                # Nothing left to expect, we're done
+                self.on_pairing()
         else:
             logger.warn(color(f'!!! unexpected key distribution command: {command_class.__name__}', 'red'))
             self.send_pairing_failed(SMP_UNSPECIFIED_REASON_ERROR)
@@ -1002,28 +989,17 @@ class Session:
         self.connection.remove_listener('connection_encryption_key_refresh', self.on_connection_encryption_key_refresh)
         self.manager.on_session_end(self)
 
-    def on_peer_key_distribution_complete(self):
-        # The initiator can now send its keys
-        if self.is_initiator:
-            self.distribute_keys()
-
-        asyncio.create_task(self.on_pairing())
-
     def on_connection_encryption_change(self):
         if self.connection.is_encrypted:
             if self.is_responder:
                 # The responder distributes its keys first, the initiator later
                 self.distribute_keys()
 
-            # If we're not expecting key distributions from the peer, we're done
-            if not self.peer_expected_distributions:
-                self.on_peer_key_distribution_complete()
-
     def on_connection_encryption_key_refresh(self):
         # Do as if the connection had just been encrypted
         self.on_connection_encryption_change()
 
-    async def on_pairing(self):
+    def on_pairing(self):
         logger.debug('pairing complete')
 
         if self.completed:
@@ -1040,16 +1016,11 @@ class Session:
         else:
             peer_address = self.connection.peer_address
 
-        # Wait for link key fetch and key derivation
-        if self.ctkd_task is not None:
-            await self.ctkd_task
-            self.ctkd_task = None
-
         # Create an object to hold the keys
         keys = PairingKeys()
         keys.address_type = peer_address.address_type
         authenticated = self.pairing_method != self.JUST_WORKS
-        if self.sc or self.connection.transport == BT_BR_EDR_TRANSPORT:
+        if self.sc:
             keys.ltk = PairingKeys.Key(
                 value         = self.ltk,
                 authenticated = authenticated
@@ -1088,6 +1059,7 @@ class Session:
                 value         = self.link_key,
                 authenticated = authenticated
             )
+
         self.manager.on_pairing(self, peer_address, keys)
 
     def on_pairing_failure(self, reason):
@@ -1165,12 +1137,6 @@ class Session:
         # Respond
         self.send_pairing_response_command()
 
-        # Vol 3, Part C, 5.2.2.1.3
-        # CTKD over BR/EDR should happen after the connection has been encrypted,
-        # so when receiving pairing requests, responder should start distributing keys
-        if self.connection.transport == BT_BR_EDR_TRANSPORT and self.connection.is_encrypted and self.is_responder and accepted:
-            self.distribute_keys()
-
     def on_smp_pairing_response_command(self, command):
         if self.is_responder:
             logger.warn(color('received pairing response as a responder', 'red'))
@@ -1496,8 +1462,7 @@ class Manager(EventEmitter):
 
     def send_command(self, connection, command):
         logger.debug(f'>>> Sending SMP Command on connection [0x{connection.handle:04X}] {connection.peer_address}: {command}')
-        cid = SMP_BR_CID if connection.transport == BT_BR_EDR_TRANSPORT else SMP_CID
-        connection.send_l2cap_pdu(cid, command.to_bytes())
+        connection.send_l2cap_pdu(SMP_CID, command.to_bytes())
 
     def on_smp_pdu(self, connection, pdu):
         # Look for a session with this connection, and create one if none exists

bumble/transport/usb.py

@@ -37,20 +37,16 @@ async def open_usb_transport(spec):
     '''
     Open a USB transport.
     The parameter string has this syntax:
-    either <index> or
-    <vendor>:<product> or
-    <vendor>:<product>/<serial-number>] or
-    <vendor>:<product>#<index>
+    either <index> or <vendor>:<product>[/<serial-number>]
     With <index> as the 0-based index to select amongst all the devices that appear
     to be supporting Bluetooth HCI (0 being the first one), or
     Where <vendor> and <product> are the vendor ID and product ID in hexadecimal. The
-    /<serial-number> suffix or #<index> suffix max be specified when more than one device with
-    the same vendor and product identifiers are present.
+    /<serial-number> suffix max be specified when more than one device with the same
+    vendor and product identifiers are present.
 
     Examples:
     0 --> the first BT USB dongle
     04b4:f901 --> the BT USB dongle with vendor=04b4 and product=f901
-    04b4:f901#2 --> the third USB device with vendor=04b4 and product=f901
     04b4:f901/00E04C239987 --> the BT USB dongle with vendor=04b4 and product=f901 and serial number 00E04C239987
     '''
 
@@ -194,7 +190,7 @@ async def open_usb_transport(spec):
         def on_packet_received(self, transfer):
             packet_type = transfer.getUserData()
             status = transfer.getStatus()
-            # logger.debug(f'<<< USB IN transfer callback: status={status} packet_type={packet_type} length={transfer.getActualLength()}')
+            # logger.debug(f'<<< USB IN transfer callback: status={status} packet_type={packet_type}')
 
             if status == usb1.TRANSFER_COMPLETED:
                 packet = bytes([packet_type]) + transfer.getBuffer()[:transfer.getActualLength()]
@@ -275,25 +271,19 @@ async def open_usb_transport(spec):
         found = None
         if ':' in spec:
             vendor_id, product_id = spec.split(':')
-            serial_number = None
-            device_index = 0
             if '/' in product_id:
                 product_id, serial_number = product_id.split('/')
-            elif '#' in product_id:
-                product_id, device_index_str = product_id.split('#')
-                device_index = int(device_index_str)
-
-            for device in context.getDeviceIterator(skip_on_error=True):
-                if (
-                    device.getVendorID() == int(vendor_id, 16) and
-                    device.getProductID() == int(product_id, 16) and
-                    (serial_number is None or device.getSerialNumber() == serial_number)
-                ):
-                    if device_index == 0:
+                for device in context.getDeviceIterator(skip_on_error=True):
+                    if (
+                        device.getVendorID() == int(vendor_id, 16) and
+                        device.getProductID() == int(product_id, 16) and
+                        device.getSerialNumber() == serial_number
+                    ):
                         found = device
                         break
-                    device_index -= 1
-                device.close()
+                    device.close()
+            else:
+                found = context.getByVendorIDAndProductID(int(vendor_id, 16), int(product_id, 16), skip_on_error=True)
         else:
             device_index = int(spec)
             for device in context.getDeviceIterator(skip_on_error=True):
@@ -315,6 +305,17 @@ async def open_usb_transport(spec):
         logger.debug(f'USB Device: {found}')
         device = found.open()
 
+        # Set the configuration if needed
+        try:
+            configuration = device.getConfiguration()
+            logger.debug(f'current configuration = {configuration}')
+        except usb1.USBError:
+            try:
+                logger.debug('setting configuration 1')
+                device.setConfiguration(1)
+            except usb1.USBError:
+                logger.debug('failed to set configuration 1')
+
         # Use the first interface
         interface = 0
 
@@ -327,20 +328,6 @@ async def open_usb_transport(spec):
             except usb1.USBError:
                 pass
 
-        # Set the configuration if needed
-        try:
-            configuration = device.getConfiguration()
-            logger.debug(f'current configuration = {configuration}')
-        except usb1.USBError:
-            configuration = 0
-
-        if configuration != 1:
-            try:
-                logger.debug('setting configuration 1')
-                device.setConfiguration(1)
-            except usb1.USBError:
-                logger.warning('failed to set configuration 1')
-
         source = UsbPacketSource(context, device)
         sink   = UsbPacketSink(device)
         return UsbTransport(context, device, interface, source, sink)

docs/mkdocs/src/apps_and_tools/usb_probe.md

@@ -1,38 +0,0 @@
-USB PROBE TOOL
-==============
-
-This tool lists all the USB devices, with details about each device.
-For each device, the different possible Bumble transport strings that can
-refer to it are listed. 
-If the device is known to be a Bluetooth HCI device, its identifier is printed 
-in reverse colors, and the transport names in cyan color.
-For other devices, regardless of their type, the transport names are printed
-in red. Whether that device is actually a Bluetooth device or not depends on
-whether it is a Bluetooth device that uses a non-standard Class, or some other
-type of device (there's no way to tell).
-
-## Usage
-
-This command line tool takes no arguments.
-When installed from PyPI, run as
-```
-$ bumble-usb-probe
-```
-
-When running from the source distribution:
-```
-$ python3 apps/usb-probe.py
-```
-
-!!! example
-    ```
-    $ python3 apps/usb_probe.py 
-
-    ID 0A12:0001
-    Bumble Transport Names: usb:0 or usb:0A12:0001
-    Bus/Device:             020/034
-    Class:                  Wireless Controller
-    Subclass/Protocol:      1/1 [Bluetooth]
-    Manufacturer:           None
-    Product:                USB2.0-BT
-    ```

docs/mkdocs/src/transports/usb.md

@@ -4,56 +4,16 @@ USB TRANSPORT
 The USB transport interfaces with a local Bluetooth USB dongle.
 
 ## Moniker
-The moniker for a USB transport is either:
-  * `usb:<index>`
-  * `usb:<vendor>:<product>`
-  * `usb:<vendor>:<product>/<serial-number>`
-  * `usb:<vendor>:<product>#<index>`
+The moniker for a USB transport is either `usb:<index>` or `usb:<vendor>:<product>`
+with `<index>` as the 0-based index to select amongst all the devices that appear to be supporting Bluetooth HCI (0 being the first one), or where `<vendor>` and `<product>` are a vendor ID and product ID in hexadecimal.
 
-with `<index>` as a 0-based index (0 being the first one) to select amongst all the matching devices when there are more than one.
-In the `usb:<index>` form, matching devices are the ones supporting Bluetooth HCI, as declared by their Class, Subclass and Protocol.
-In the `usb:<vendor>:<product>#<index>` form, matching devices are the ones with the specified `<vendor>` and `<product>` identification.
-
-`<vendor>` and `<product>` are a vendor ID and product ID in hexadecimal.
-
-!!! examples
+!!! example
     `usb:04b4:f901`  
-    The USB dongle with `<vendor>` equal to `04b4` and `<product>` equal to `f901`
+    Use the USB dongle with `vendor` equal to `04b4` and `product` equal to `f901`
 
     `usb:0`  
-    The first Bluetooth HCI dongle that's declared as such by Class/Subclass/Protocol
-
-    `usb:04b4:f901/0016A45B05D8`
-    The USB dongle with `<vendor>` equal to `04b4`, `<product>` equal to `f901` and `<serial>` equal to `0016A45B05D8`
-
-    `usb:04b4:f901/#1`
-    The second USB dongle with `<vendor>` equal to `04b4` and `<product>` equal to `f901`
+    Use the first Bluetooth dongle
 
 ## Alternative
 The library includes two different implementations of the USB transport, implemented using different python bindings for `libusb`.
 Using the transport prefix `pyusb:` instead of `usb:` selects the implementation based on  [PyUSB](https://pypi.org/project/pyusb/), using the synchronous API of `libusb`, whereas the default implementation is based on [libusb1](https://pypi.org/project/libusb1/), using the asynchronous API of `libusb`. In order to use the alternative PyUSB-based implementation, you need to ensure that you have installed that python module, as it isn't installed by default as a dependency of Bumble.
-
-## Listing Available USB Devices
-
-### With `usb_probe`
-You can use the [`usb_probe`](../apps_and_tools/usb_probe.md) tool to list all the USB devices attached to your host computer.
-The tool will also show the `usb:XXX` transport name(s) you can use to reference each device.
-
-
-### With `lsusb`
-On Linux and macOS, the `lsusb` tool serves a similar purpose to Bumble's own `usb_probe` tool (without the Bumble specifics)
-
-#### Installing lsusb
-
-On Mac: `brew install lsusb`
-On Linux: `sudo apt-get install usbutils`
-
-#### Using lsusb
-
-```
-$ lsusb
-Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
-Bus 003 Device 014: ID 0b05:17cb ASUSTek Computer, Inc. Broadcom BCM20702A0 Bluetooth
-```
-
-The device id for the Bluetooth interface in this case is `0b05:17cb`.

setup.cfg

@@ -54,17 +54,15 @@ console_scripts =
     bumble-scan = bumble.apps.scan:main
     bumble-show = bumble.apps.show:main
     bumble-unbond = bumble.apps.unbond:main
-    bumble-usb-probe = bumble.apps.usb_probe:main
     bumble-link-relay = bumble.apps.link_relay.link_relay:main
 
 [options.extras_require]
-build =
-    build >= 0.7
 test =
     pytest >= 6.2
     pytest-asyncio >= 0.17
 development =
     invoke >= 1.4
+    build >= 0.7
     nox >= 2022
 documentation =
     mkdocs >= 1.2.3

tasks.py

@@ -23,52 +23,35 @@ ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
 
 ns = Collection()
 
-# Building
 build_tasks = Collection()
-ns.add_collection(build_tasks, name="build")
+ns.add_collection(build_tasks, name='build')
+
 
 @task
-def build(ctx, install=False):
-    if install:
-        ctx.run('python -m pip install .[build]')
+def build(ctx):
+    ctx.run('python -m build')
 
-    ctx.run("python -m build")
+build_tasks.add_task(build, default=True, name='build')
 
-build_tasks.add_task(build, default=True)
-
-@task
-def release_build(ctx):
-    build(ctx, install=True)
-
-build_tasks.add_task(release_build, name="release")
-
-@task
-def mkdocs(ctx):
-    ctx.run("mkdocs build -f docs/mkdocs/mkdocs.yml")
-
-build_tasks.add_task(mkdocs, name="mkdocs")
-
-# Testing
 test_tasks = Collection()
-ns.add_collection(test_tasks, name="test")
+ns.add_collection(test_tasks, name='test')
 
 @task
-def test(ctx, filter=None, junit=False, install=False):
-    # Install the package before running the tests
-    if install:
-        ctx.run("python -m pip install .[test]")
-
+def test(ctx, filter=None, junit=False):
     args = ""
     if junit:
         args += "--junit-xml test-results.xml"
     if filter is not None:
         args += " -k '{}'".format(filter)
-    ctx.run("python -m pytest {} {}".format(os.path.join(ROOT_DIR, "tests"), args))
+    ctx.run('python -m pytest {} {}'
+            .format(os.path.join(ROOT_DIR, "tests"), args))
+
+test_tasks.add_task(test, name='test', default=True)
 
-test_tasks.add_task(test, default=True)
 
 @task
-def release_test(ctx):
-    test(ctx, install=True)
+def mkdocs(ctx):
+    ctx.run('mkdocs build -f docs/mkdocs/mkdocs.yml')
 
-test_tasks.add_task(release_test, name="release")
+
+ns.add_task(mkdocs)

tests/gatt_test.py

@@ -22,7 +22,6 @@ import struct
 import pytest
 
 from bumble.controller import Controller
-from bumble.gatt_client import CharacteristicProxy
 from bumble.link import LocalLink
 from bumble.device import Device, Peer
 from bumble.host import Host
@@ -54,29 +53,29 @@ def basic_check(x):
     parsed = ATT_PDU.from_bytes(pdu)
     x_str = str(x)
     parsed_str = str(parsed)
-    assert x_str == parsed_str
+    assert(x_str == parsed_str)
 
 
 # -----------------------------------------------------------------------------
 def test_UUID():
     u = UUID.from_16_bits(0x7788)
-    assert str(u) == 'UUID-16:7788'
+    assert(str(u) == 'UUID-16:7788')
     u = UUID.from_32_bits(0x11223344)
-    assert str(u) == 'UUID-32:11223344'
+    assert(str(u) == 'UUID-32:11223344')
     u = UUID('61A3512C-09BE-4DDC-A6A6-0B03667AAFC6')
-    assert str(u) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6'
+    assert(str(u) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6')
     v = UUID(str(u))
-    assert str(v) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6'
+    assert(str(v) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6')
     w = UUID.from_bytes(v.to_bytes())
-    assert str(w) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6'
+    assert(str(w) == '61A3512C-09BE-4DDC-A6A6-0B03667AAFC6')
 
     u1 = UUID.from_16_bits(0x1234)
     b1 = u1.to_bytes(force_128 = True)
     u2 = UUID.from_bytes(b1)
-    assert u1 == u2
+    assert(u1 == u2)
 
     u3 = UUID.from_16_bits(0x180a)
-    assert str(u3) == 'UUID-16:180A (Device Information)'
+    assert(str(u3) == 'UUID-16:180A (Device Information)')
 
 
 # -----------------------------------------------------------------------------
@@ -99,122 +98,6 @@ def test_ATT_Read_By_Group_Type_Request():
     basic_check(pdu)
 
 
-# -----------------------------------------------------------------------------
-@pytest.mark.asyncio
-async def test_characteristic_encoding():
-    class Foo(Characteristic):
-        def encode_value(self, value):
-            return bytes([value])
-
-        def decode_value(self, value_bytes):
-            return value_bytes[0]
-
-    c = Foo(GATT_BATTERY_LEVEL_CHARACTERISTIC, Characteristic.READ, Characteristic.READABLE, 123)
-    x = c.read_value(None)
-    assert x == bytes([123])
-    c.write_value(None, bytes([122]))
-    assert c.value == 122
-
-    class FooProxy(CharacteristicProxy):
-        def __init__(self, characteristic):
-            super().__init__(
-                characteristic.client,
-                characteristic.handle,
-                characteristic.end_group_handle,
-                characteristic.uuid,
-                characteristic.properties
-            )
-
-        def encode_value(self, value):
-            return bytes([value])
-
-        def decode_value(self, value_bytes):
-            return value_bytes[0]
-
-    [client, server] = TwoDevices().devices
-
-    characteristic = Characteristic(
-        'FDB159DB-036C-49E3-B3DB-6325AC750806',
-        Characteristic.READ | Characteristic.WRITE | Characteristic.NOTIFY,
-        Characteristic.READABLE | Characteristic.WRITEABLE,
-        bytes([123])
-    )
-
-    service = Service(
-        '3A657F47-D34F-46B3-B1EC-698E29B6B829',
-        [characteristic]
-    )
-    server.add_service(service)
-
-    await client.power_on()
-    await server.power_on()
-    connection = await client.connect(server.random_address)
-    peer = Peer(connection)
-
-    await peer.discover_services()
-    await peer.discover_characteristics()
-    c = peer.get_characteristics_by_uuid(characteristic.uuid)
-    assert len(c) == 1
-    c = c[0]
-    cp = FooProxy(c)
-
-    v = await cp.read_value()
-    assert v == 123
-    await cp.write_value(124)
-    await async_barrier()
-    assert characteristic.value == bytes([124])
-
-    last_change = None
-
-    def on_change(value):
-        nonlocal last_change
-        last_change = value
-
-    await c.subscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change == characteristic.value
-    last_change = None
-
-    await server.notify_subscribers(characteristic, value=bytes([125]))
-    await async_barrier()
-    assert last_change == bytes([125])
-    last_change = None
-
-    await c.unsubscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change is None
-
-    await cp.subscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change == characteristic.value[0]
-    last_change = None
-
-    await server.notify_subscribers(characteristic, value=bytes([126]))
-    await async_barrier()
-    assert last_change == 126
-    last_change = None
-
-    await cp.unsubscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change is None
-
-    cd = DelegatedCharacteristicAdapter(c, decode=lambda x: x[0])
-    await cd.subscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change == characteristic.value[0]
-    last_change = None
-
-    await cd.unsubscribe(on_change)
-    await server.notify_subscribers(characteristic)
-    await async_barrier()
-    assert last_change is None
-
-
 # -----------------------------------------------------------------------------
 def test_CharacteristicAdapter():
     # Check that the CharacteristicAdapter base class is transparent
@@ -223,21 +106,21 @@ def test_CharacteristicAdapter():
     a = CharacteristicAdapter(c)
 
     value = a.read_value(None)
-    assert value == v
+    assert(value == v)
 
     v = bytes([3, 4, 5])
     a.write_value(None, v)
-    assert c.value == v
+    assert(c.value == v)
 
     # Simple delegated adapter
     a = DelegatedCharacteristicAdapter(c, lambda x: bytes(reversed(x)), lambda x: bytes(reversed(x)))
 
     value = a.read_value(None)
-    assert value == bytes(reversed(v))
+    assert(value == bytes(reversed(v)))
 
     v = bytes([3, 4, 5])
     a.write_value(None, v)
-    assert a.value == bytes(reversed(v))
+    assert(a.value == bytes(reversed(v)))
 
     # Packed adapter with single element format
     v = 1234
@@ -246,10 +129,10 @@ def test_CharacteristicAdapter():
     a = PackedCharacteristicAdapter(c, '>H')
 
     value = a.read_value(None)
-    assert value == pv
+    assert(value == pv)
     c.value = None
     a.write_value(None, pv)
-    assert a.value == v
+    assert(a.value == v)
 
     # Packed adapter with multi-element format
     v1 = 1234
@@ -259,10 +142,10 @@ def test_CharacteristicAdapter():
     a = PackedCharacteristicAdapter(c, '>HH')
 
     value = a.read_value(None)
-    assert value == pv
+    assert(value == pv)
     c.value = None
     a.write_value(None, pv)
-    assert a.value == (v1, v2)
+    assert(a.value == (v1, v2))
 
     # Mapped adapter
     v1 = 1234
@@ -273,10 +156,10 @@ def test_CharacteristicAdapter():
     a = MappedCharacteristicAdapter(c, '>HH', ('v1', 'v2'))
 
     value = a.read_value(None)
-    assert value == pv
+    assert(value == pv)
     c.value = None
     a.write_value(None, pv)
-    assert a.value == mapped
+    assert(a.value == mapped)
 
     # UTF-8 adapter
     v = 'Hello π'
@@ -285,10 +168,10 @@ def test_CharacteristicAdapter():
     a = UTF8CharacteristicAdapter(c)
 
     value = a.read_value(None)
-    assert value == ev
+    assert(value == ev)
     c.value = None
     a.write_value(None, ev)
-    assert a.value == v
+    assert(a.value == v)
 
 
 # -----------------------------------------------------------------------------
@@ -296,13 +179,13 @@ def test_CharacteristicValue():
     b = bytes([1, 2, 3])
     c = CharacteristicValue(read=lambda _: b)
     x = c.read(None)
-    assert x == b
+    assert(x == b)
 
     result = []
     c = CharacteristicValue(write=lambda connection, value: result.append((connection, value)))
     z = object()
     c.write(z, b)
-    assert result == [(z, b)]
+    assert(result == [(z, b)])
 
 
 # -----------------------------------------------------------------------------
@@ -382,35 +265,35 @@ async def test_read_write():
     await peer.discover_services()
     await peer.discover_characteristics()
     c = peer.get_characteristics_by_uuid(characteristic1.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c1 = c[0]
     c = peer.get_characteristics_by_uuid(characteristic2.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c2 = c[0]
 
     v1 = await peer.read_value(c1)
-    assert v1 == b''
+    assert(v1 == b'')
     b = bytes([1, 2, 3])
     await peer.write_value(c1, b)
     await async_barrier()
-    assert characteristic1.value == b
+    assert(characteristic1.value == b)
     v1 = await peer.read_value(c1)
-    assert v1 == b
-    assert type(characteristic1._last_value is tuple)
-    assert len(characteristic1._last_value) == 2
-    assert str(characteristic1._last_value[0].peer_address) == str(client.random_address)
-    assert characteristic1._last_value[1] == b
+    assert(v1 == b)
+    assert(type(characteristic1._last_value) is tuple)
+    assert(len(characteristic1._last_value) == 2)
+    assert(str(characteristic1._last_value[0].peer_address) == str(client.random_address))
+    assert(characteristic1._last_value[1] == b)
     bb = bytes([3, 4, 5, 6])
     characteristic1.value = bb
     v1 = await peer.read_value(c1)
-    assert v1 == bb
+    assert(v1 == bb)
 
     await peer.write_value(c2, b)
     await async_barrier()
-    assert type(characteristic2._last_value is tuple)
-    assert len(characteristic2._last_value) == 2
-    assert str(characteristic2._last_value[0].peer_address) == str(client.random_address)
-    assert characteristic2._last_value[1] == b
+    assert(type(characteristic2._last_value) is tuple)
+    assert(len(characteristic2._last_value) == 2)
+    assert(str(characteristic2._last_value[0].peer_address) == str(client.random_address))
+    assert(characteristic2._last_value[1] == b)
 
 
 # -----------------------------------------------------------------------------
@@ -441,26 +324,26 @@ async def test_read_write2():
 
     await peer.discover_services()
     c = peer.get_services_by_uuid(service1.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     s = c[0]
     await s.discover_characteristics()
     c = s.get_characteristics_by_uuid(characteristic1.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c1 = c[0]
 
     v1 = await c1.read_value()
-    assert v1 == v
+    assert(v1 == v)
 
     a1 = PackedCharacteristicAdapter(c1, '>I')
     v1 = await a1.read_value()
-    assert v1 == struct.unpack('>I', v)[0]
+    assert(v1 == struct.unpack('>I', v)[0])
 
     b = bytes([0x55, 0x66, 0x77, 0x88])
     await a1.write_value(struct.unpack('>I', b)[0])
     await async_barrier()
-    assert characteristic1.value == b
+    assert(characteristic1.value == b)
     v1 = await a1.read_value()
-    assert v1 == struct.unpack('>I', b)[0]
+    assert(v1 == struct.unpack('>I', b)[0])
 
 
 # -----------------------------------------------------------------------------
@@ -527,13 +410,13 @@ async def test_subscribe_notify():
     await peer.discover_services()
     await peer.discover_characteristics()
     c = peer.get_characteristics_by_uuid(characteristic1.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c1 = c[0]
     c = peer.get_characteristics_by_uuid(characteristic2.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c2 = c[0]
     c = peer.get_characteristics_by_uuid(characteristic3.uuid)
-    assert len(c) == 1
+    assert(len(c) == 1)
     c3 = c[0]
 
     c1._called = False
@@ -546,32 +429,23 @@ async def test_subscribe_notify():
     c1.on('update', on_c1_update)
     await peer.subscribe(c1)
     await async_barrier()
-    assert server._last_subscription[1] == characteristic1
-    assert server._last_subscription[2]
-    assert not server._last_subscription[3]
-    assert characteristic1._last_subscription[1]
-    assert not characteristic1._last_subscription[2]
+    assert(server._last_subscription[1] == characteristic1)
+    assert(server._last_subscription[2])
+    assert(not server._last_subscription[3])
+    assert(characteristic1._last_subscription[1])
+    assert(not characteristic1._last_subscription[2])
     await server.indicate_subscribers(characteristic1)
     await async_barrier()
-    assert not c1._called
+    assert(not c1._called)
     await server.notify_subscribers(characteristic1)
     await async_barrier()
-    assert c1._called
-    assert c1._last_update == characteristic1.value
-
-    c1._called = False
-    c1._last_update = None
-    c1_value = characteristic1.value
-    await server.notify_subscribers(characteristic1, bytes([0, 1, 2]))
-    await async_barrier()
-    assert c1._called
-    assert c1._last_update == bytes([0, 1, 2])
-    assert characteristic1.value == c1_value
+    assert(c1._called)
+    assert(c1._last_update == characteristic1.value)
 
     c1._called = False
     await peer.unsubscribe(c1)
     await server.notify_subscribers(characteristic1)
-    assert not c1._called
+    assert(not c1._called)
 
     c2._called = False
     c2._last_update = None
@@ -584,17 +458,17 @@ async def test_subscribe_notify():
     await async_barrier()
     await server.notify_subscriber(characteristic2._last_subscription[0], characteristic2)
     await async_barrier()
-    assert not c2._called
+    assert(not c2._called)
     await server.indicate_subscriber(characteristic2._last_subscription[0], characteristic2)
     await async_barrier()
-    assert c2._called
-    assert c2._last_update == characteristic2.value
+    assert(c2._called)
+    assert(c2._last_update == characteristic2.value)
 
     c2._called = False
     await peer.unsubscribe(c2, on_c2_update)
     await server.indicate_subscriber(characteristic2._last_subscription[0], characteristic2)
     await async_barrier()
-    assert not c2._called
+    assert(not c2._called)
 
     def on_c3_update(value):
         c3._called = True
@@ -609,17 +483,17 @@ async def test_subscribe_notify():
     await async_barrier()
     await server.notify_subscriber(characteristic3._last_subscription[0], characteristic3)
     await async_barrier()
-    assert c3._called
-    assert c3._last_update == characteristic3.value
-    assert c3._called_2
-    assert c3._last_update_2 == characteristic3.value
+    assert(c3._called)
+    assert(c3._last_update == characteristic3.value)
+    assert(c3._called_2)
+    assert(c3._last_update_2 == characteristic3.value)
     characteristic3.value = bytes([1, 2, 3])
     await server.indicate_subscriber(characteristic3._last_subscription[0], characteristic3)
     await async_barrier()
-    assert c3._called
-    assert c3._last_update == characteristic3.value
-    assert c3._called_2
-    assert c3._last_update_2 == characteristic3.value
+    assert(c3._called)
+    assert(c3._last_update == characteristic3.value)
+    assert(c3._called_2)
+    assert(c3._last_update_2 == characteristic3.value)
 
     c3._called = False
     c3._called_2 = False
@@ -627,8 +501,8 @@ async def test_subscribe_notify():
     await server.notify_subscriber(characteristic3._last_subscription[0], characteristic3)
     await server.indicate_subscriber(characteristic3._last_subscription[0], characteristic3)
     await async_barrier()
-    assert not c3._called
-    assert not c3._called_2
+    assert(not c3._called)
+    assert(not c3._called_2)
 
 
 # -----------------------------------------------------------------------------
@@ -636,8 +510,6 @@ async def async_main():
     await test_read_write()
     await test_read_write2()
     await test_subscribe_notify()
-    await test_characteristic_encoding()
-
 
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':

tests/self_test.py

@@ -246,7 +246,8 @@ IO_CAP = [
 SC = [False, True]
 MITM = [False, True]
 # Key distribution is a 4-bit bitmask
-KEY_DIST = range(16)
+# IdKey is necessary for current SMP structure
+KEY_DIST = [i for i in range(16) if (i & SMP_ID_KEY_DISTRIBUTION_FLAG)]
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize('io_cap, sc, mitm, key_dist',