fix merge issues

apps/bench.py

@@ -82,11 +82,10 @@ SPEED_RX_UUID = '016A2CC7-E14B-4819-935F-1F56EAE4098D'
 DEFAULT_RFCOMM_UUID = 'E6D55659-C8B4-4B85-96BB-B1143AF6D3AE'
 DEFAULT_L2CAP_PSM = 1234
 DEFAULT_L2CAP_MAX_CREDITS = 128
-DEFAULT_L2CAP_MTU = 1024
-DEFAULT_L2CAP_MPS = 1022
+DEFAULT_L2CAP_MTU = 1022
+DEFAULT_L2CAP_MPS = 1024
 
 DEFAULT_LINGER_TIME = 1.0
-DEFAULT_POST_CONNECTION_WAIT_TIME = 1.0
 
 DEFAULT_RFCOMM_CHANNEL = 8
 
@@ -953,10 +952,6 @@ class Central(Connection.Listener):
 
             await self.device.power_on()
 
-            if self.classic:
-                await self.device.set_discoverable(False)
-                await self.device.set_connectable(False)
-
             print(color(f'### Connecting to {self.peripheral_address}...', 'cyan'))
             try:
                 self.connection = await self.device.connect(
@@ -977,11 +972,6 @@ class Central(Connection.Listener):
             self.connection.listener = self
             print_connection(self.connection)
 
-            # Wait a bit after the connection, some controllers aren't very good when
-            # we start sending data right away while some connection parameters are
-            # updated post connection
-            await asyncio.sleep(DEFAULT_POST_CONNECTION_WAIT_TIME)
-
             # Request a new data length if requested
             if self.extended_data_length:
                 print(color('+++ Requesting extended data length', 'cyan'))
@@ -1108,15 +1098,6 @@ class Peripheral(Device.Listener, Connection.Listener):
         self.connection = connection
         self.connected.set()
 
-        # Stop being discoverable and connectable
-        if self.classic:
-
-            async def stop_being_discoverable_connectable():
-                await self.device.set_discoverable(False)
-                await self.device.set_connectable(False)
-
-            AsyncRunner.spawn(stop_being_discoverable_connectable())
-
         # Request a new data length if needed
         if self.extended_data_length:
             print("+++ Requesting extended data length")

apps/controller_info.py

@@ -24,6 +24,10 @@ from bumble.company_ids import COMPANY_IDENTIFIERS
 from bumble.colors import color
 from bumble.core import name_or_number
 from bumble.hci import (
+    HCI_READ_LOCAL_EXTENDED_FEATURES_COMMAND,
+    HCI_READ_LOCAL_SUPPORTED_FEATURES_COMMAND,
+    HCI_Read_Local_Extended_Features_Command,
+    HCI_Read_Local_Supported_Features_Command,
     map_null_terminated_utf8_string,
     HCI_SUCCESS,
     HCI_LE_SUPPORTED_FEATURES_NAMES,
@@ -32,14 +36,10 @@ from bumble.hci import (
     HCI_Command,
     HCI_Command_Complete_Event,
     HCI_Command_Status_Event,
-    HCI_READ_BUFFER_SIZE_COMMAND,
-    HCI_Read_Buffer_Size_Command,
     HCI_READ_BD_ADDR_COMMAND,
     HCI_Read_BD_ADDR_Command,
     HCI_READ_LOCAL_NAME_COMMAND,
     HCI_Read_Local_Name_Command,
-    HCI_LE_READ_BUFFER_SIZE_COMMAND,
-    HCI_LE_Read_Buffer_Size_Command,
     HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Maximum_Data_Length_Command,
     HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND,
@@ -63,7 +63,37 @@ def command_succeeded(response):
 
 
 # -----------------------------------------------------------------------------
-async def get_classic_info(host: Host) -> None:
+async def get_common_info(host):
+    if host.supports_command(HCI_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
+        response = await host.send_command(HCI_Read_Local_Supported_Features_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print()
+            print(color('LMP Features:', 'yellow'))
+            # TODO: support printing discrete enum values
+            print('  ', response.return_parameters.lmp_features.hex())
+
+    if host.supports_command(HCI_READ_LOCAL_EXTENDED_FEATURES_COMMAND):
+        response = await host.send_command(
+            HCI_Read_Local_Extended_Features_Command(page_number=0)
+        )
+        if response.return_parameters.status == HCI_SUCCESS:
+            if response.return_parameters.max_page_number > 0:
+                print()
+                print(color('Extended LMP Features:', 'yellow'))
+
+            for page in range(1, response.return_parameters.max_page_number + 1):
+                response = await host.send_command(
+                    HCI_Read_Local_Extended_Features_Command(page_number=page)
+                )
+
+                if response.return_parameters.status == HCI_SUCCESS:
+                    # TODO: support printing discrete enum values
+                    print(f'  Page {page}:')
+                    print('  ', response.return_parameters.extended_lmp_features.hex())
+
+
+# -----------------------------------------------------------------------------
+async def get_classic_info(host):
     if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
         response = await host.send_command(HCI_Read_BD_ADDR_Command())
         if command_succeeded(response):
@@ -84,7 +114,7 @@ async def get_classic_info(host: Host) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def get_le_info(host: Host) -> None:
+async def get_le_info(host):
     print()
 
     if host.supports_command(HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND):
@@ -140,31 +170,6 @@ async def get_le_info(host: Host) -> None:
         print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
 
 
-# -----------------------------------------------------------------------------
-async def get_acl_flow_control_info(host: Host) -> None:
-    print()
-
-    if host.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_acl_data_packet_length}',
-        )
-
-    if host.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_LE_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('LE ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_le_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_le_acl_data_packet_length}',
-        )
-
-
 # -----------------------------------------------------------------------------
 async def async_main(transport):
     print('<<< connecting to HCI...')
@@ -191,15 +196,15 @@ async def async_main(transport):
         )
         print(color('  LMP Subversion:', 'green'), host.local_version.lmp_subversion)
 
+        # Get the common info
+        await get_common_info(host)
+
         # Get the Classic info
         await get_classic_info(host)
 
         # Get the LE info
         await get_le_info(host)
 
-        # Print the ACL flow control info
-        await get_acl_flow_control_info(host)
-
         # Print the list of commands supported by the controller
         print()
         print(color('Supported Commands:', 'yellow'))

apps/controllers.py

@@ -17,31 +17,25 @@
 # -----------------------------------------------------------------------------
 import logging
 import asyncio
-import sys
 import os
 
-from bumble.controller import Controller
+import click
+
+from bumble.controller import Controller, Options
 from bumble.link import LocalLink
 from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def async_main():
-    if len(sys.argv) != 3:
-        print(
-            'Usage: controllers.py <hci-transport-1> <hci-transport-2> '
-            '[<hci-transport-3> ...]'
-        )
-        print('example: python controllers.py pty:ble1 pty:ble2')
-        return
-
+async def async_main(extended_advertising, transport_names):
     # Create a local link to attach the controllers to
     link = LocalLink()
 
     # Create a transport and controller for all requested names
     transports = []
     controllers = []
-    for index, transport_name in enumerate(sys.argv[1:]):
+    options = Options(extended_advertising=extended_advertising)
+    for index, transport_name in enumerate(transport_names):
         transport = await open_transport_or_link(transport_name)
         transports.append(transport)
         controller = Controller(
@@ -49,6 +43,7 @@ async def async_main():
             host_source=transport.source,
             host_sink=transport.sink,
             link=link,
+            options=options,
         )
         controllers.append(controller)
 
@@ -61,9 +56,14 @@ async def async_main():
 
 
 # -----------------------------------------------------------------------------
-def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    asyncio.run(async_main())
+@click.command()
+@click.option(
+    '--extended-advertising', is_flag=True, help="Enable extended advertising"
+)
+@click.argument('transports', nargs=-1, required=True)
+def main(extended_advertising, transports):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+    asyncio.run(async_main(extended_advertising, transports))
 
 
 # -----------------------------------------------------------------------------

apps/link_relay/link_relay.py

@@ -253,7 +253,7 @@ class Relay:
 
 
 # ----------------------------------------------------------------------------
-def main():
+async def async_main():
     # Check the Python version
     if sys.version_info < (3, 6, 1):
         print('ERROR: Python 3.6.1 or higher is required')
@@ -280,8 +280,13 @@ def main():
 
     # Start a relay
     relay = Relay(args.port)
-    asyncio.get_event_loop().run_until_complete(relay.start())
-    asyncio.get_event_loop().run_forever()
+    async with relay.start():
+        await asyncio.Future()
+
+
+# ----------------------------------------------------------------------------
+def main():
+    asyncio.run(async_main())
 
 
 # ----------------------------------------------------------------------------

bumble/hci.py

@@ -3266,7 +3266,9 @@ class HCI_Read_Local_Supported_Commands_Command(HCI_Command):
 
 
 # -----------------------------------------------------------------------------
-@HCI_Command.command()
+@HCI_Command.command(
+    return_parameters_fields=[('status', STATUS_SPEC), ('lmp_features', 8)]
+)
 class HCI_Read_Local_Supported_Features_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.4.3 Read Local Supported Features Command
@@ -3279,7 +3281,7 @@ class HCI_Read_Local_Supported_Features_Command(HCI_Command):
     return_parameters_fields=[
         ('status', STATUS_SPEC),
         ('page_number', 1),
-        ('maximum_page_number', 1),
+        ('max_page_number', 1),
         ('extended_lmp_features', 8),
     ],
 )
@@ -3448,7 +3450,9 @@ class HCI_LE_Set_Advertising_Parameters_Command(HCI_Command):
 
 
 # -----------------------------------------------------------------------------
-@HCI_Command.command()
+@HCI_Command.command(
+    return_parameters_fields=[('status', STATUS_SPEC), ('tx_power_level', 1)]
+)
 class HCI_LE_Read_Advertising_Physical_Channel_Tx_Power_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.8.6 LE Read Advertising Physical Channel Tx Power Command
@@ -5829,7 +5833,7 @@ class HCI_Inquiry_Result_With_RSSI_Event(HCI_Event):
         ('status', STATUS_SPEC),
         ('connection_handle', 2),
         ('page_number', 1),
-        ('maximum_page_number', 1),
+        ('max_page_number', 1),
         ('extended_lmp_features', 8),
     ]
 )

bumble/hid.py

@@ -402,7 +402,7 @@ class Device(HID):
         report_type = pdu[0] & 0x03
         buffer_flag = (pdu[0] & 0x08) >> 3
         report_id = pdu[1]
-        logger.debug(f"buffer_flag: {buffer_flag}")
+        logger.debug("buffer_flag: " + str(buffer_flag))
         if buffer_flag == 1:
             buffer_size = (pdu[3] << 8) | pdu[2]
         else:

bumble/host.py

@@ -21,7 +21,7 @@ import collections
 import logging
 import struct
 
-from typing import Any, Awaitable, Callable, Deque, Dict, Optional, cast, TYPE_CHECKING
+from typing import Any, Awaitable, Callable, Dict, Optional, Union, cast, TYPE_CHECKING
 
 from bumble.colors import color
 from bumble.l2cap import L2CAP_PDU
@@ -91,49 +91,16 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-class AclPacketQueue:
-    max_packet_size: int
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
 
-    def __init__(
-        self,
-        max_packet_size: int,
-        max_in_flight: int,
-        send: Callable[[HCI_Packet], None],
-    ) -> None:
-        self.max_packet_size = max_packet_size
-        self.max_in_flight = max_in_flight
-        self.in_flight = 0
-        self.send = send
-        self.packets: Deque[HCI_AclDataPacket] = collections.deque()
+HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH = 27
+HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS     = 1
+HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH    = 27
+HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS        = 1
 
-    def enqueue(self, packet: HCI_AclDataPacket) -> None:
-        self.packets.appendleft(packet)
-        self.check_queue()
-
-        if self.packets:
-            logger.debug(
-                f'{self.in_flight} ACL packets in flight, '
-                f'{len(self.packets)} in queue'
-            )
-
-    def check_queue(self) -> None:
-        while self.packets and self.in_flight < self.max_in_flight:
-            packet = self.packets.pop()
-            self.send(packet)
-            self.in_flight += 1
-
-    def on_packets_completed(self, packet_count: int) -> None:
-        if packet_count > self.in_flight:
-            logger.warning(
-                color(
-                    '!!! {packet_count} completed but only '
-                    f'{self.in_flight} in flight'
-                )
-            )
-            packet_count = self.in_flight
-
-        self.in_flight -= packet_count
-        self.check_queue()
+# fmt: on
 
 
 # -----------------------------------------------------------------------------
@@ -144,13 +111,6 @@ class Connection:
         self.peer_address = peer_address
         self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
         self.transport = transport
-        acl_packet_queue: Optional[AclPacketQueue] = (
-            host.le_acl_packet_queue
-            if transport == BT_LE_TRANSPORT
-            else host.acl_packet_queue
-        )
-        assert acl_packet_queue
-        self.acl_packet_queue = acl_packet_queue
 
     def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
         self.assembler.feed_packet(packet)
@@ -163,8 +123,7 @@ class Connection:
 # -----------------------------------------------------------------------------
 class Host(AbortableEventEmitter):
     connections: Dict[int, Connection]
-    acl_packet_queue: Optional[AclPacketQueue] = None
-    le_acl_packet_queue: Optional[AclPacketQueue] = None
+    acl_packet_queue: collections.deque[HCI_AclDataPacket]
     hci_sink: Optional[TransportSink] = None
     hci_metadata: Dict[str, Any]
     long_term_key_provider: Optional[
@@ -184,6 +143,12 @@ class Host(AbortableEventEmitter):
         self.connections = {}  # Connections, by connection handle
         self.pending_command = None
         self.pending_response = None
+        self.hc_le_acl_data_packet_length = HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH
+        self.hc_total_num_le_acl_data_packets = HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS
+        self.hc_acl_data_packet_length = HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH
+        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 = None
         self.local_supported_commands = bytes(64)
         self.local_le_features = 0
@@ -289,54 +254,46 @@ class Host(AbortableEventEmitter):
             response = await self.send_command(
                 HCI_Read_Buffer_Size_Command(), check_result=True
             )
-            hc_acl_data_packet_length = (
+            self.hc_acl_data_packet_length = (
                 response.return_parameters.hc_acl_data_packet_length
             )
-            hc_total_num_acl_data_packets = (
+            self.hc_total_num_acl_data_packets = (
                 response.return_parameters.hc_total_num_acl_data_packets
             )
 
             logger.debug(
                 'HCI ACL flow control: '
-                f'hc_acl_data_packet_length={hc_acl_data_packet_length},'
-                f'hc_total_num_acl_data_packets={hc_total_num_acl_data_packets}'
+                f'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}'
             )
 
-            self.acl_packet_queue = AclPacketQueue(
-                max_packet_size=hc_acl_data_packet_length,
-                max_in_flight=hc_total_num_acl_data_packets,
-                send=self.send_hci_packet,
-            )
-
-        hc_le_acl_data_packet_length = 0
-        hc_total_num_le_acl_data_packets = 0
         if self.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(
                 HCI_LE_Read_Buffer_Size_Command(), check_result=True
             )
-            hc_le_acl_data_packet_length = (
+            self.hc_le_acl_data_packet_length = (
                 response.return_parameters.hc_le_acl_data_packet_length
             )
-            hc_total_num_le_acl_data_packets = (
+            self.hc_total_num_le_acl_data_packets = (
                 response.return_parameters.hc_total_num_le_acl_data_packets
             )
 
             logger.debug(
                 'HCI LE ACL flow control: '
-                f'hc_le_acl_data_packet_length={hc_le_acl_data_packet_length},'
-                f'hc_total_num_le_acl_data_packets={hc_total_num_le_acl_data_packets}'
+                f'hc_le_acl_data_packet_length={self.hc_le_acl_data_packet_length},'
+                'hc_total_num_le_acl_data_packets='
+                f'{self.hc_total_num_le_acl_data_packets}'
             )
 
-        if hc_le_acl_data_packet_length == 0 or hc_total_num_le_acl_data_packets == 0:
-            # LE and Classic share the same queue
-            self.le_acl_packet_queue = self.acl_packet_queue
-        else:
-            # Create a separate queue for LE
-            self.le_acl_packet_queue = AclPacketQueue(
-                max_packet_size=hc_le_acl_data_packet_length,
-                max_in_flight=hc_total_num_le_acl_data_packets,
-                send=self.send_hci_packet,
-            )
+            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
+                )
 
         if self.supports_command(
             HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
@@ -375,13 +332,14 @@ class Host(AbortableEventEmitter):
         self.hci_metadata = getattr(source, 'metadata', self.hci_metadata)
 
     def send_hci_packet(self, packet: HCI_Packet) -> None:
-        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {packet}')
         if self.snooper:
             self.snooper.snoop(bytes(packet), Snooper.Direction.HOST_TO_CONTROLLER)
         if self.hci_sink:
             self.hci_sink.on_packet(bytes(packet))
 
     async def send_command(self, command, check_result=False):
+        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {command}')
+
         # Wait until we can send (only one pending command at a time)
         async with self.command_semaphore:
             assert self.pending_command is None
@@ -429,17 +387,6 @@ class Host(AbortableEventEmitter):
         asyncio.create_task(send_command(command))
 
     def send_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes) -> None:
-        if not (connection := self.connections.get(connection_handle)):
-            logger.warning(f'connection 0x{connection_handle:04X} not found')
-            return
-        packet_queue = connection.acl_packet_queue
-        if packet_queue is None:
-            logger.warning(
-                f'no ACL packet queue for connection 0x{connection_handle:04X}'
-            )
-            return
-
-        # Create a PDU
         l2cap_pdu = bytes(L2CAP_PDU(cid, pdu))
 
         # Send the data to the controller via ACL packets
@@ -447,7 +394,8 @@ class Host(AbortableEventEmitter):
         offset = 0
         pb_flag = 0
         while bytes_remaining:
-            data_total_length = min(bytes_remaining, packet_queue.max_packet_size)
+            # 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,
                 pb_flag=pb_flag,
@@ -455,12 +403,34 @@ class Host(AbortableEventEmitter):
                 data_total_length=data_total_length,
                 data=l2cap_pdu[offset : offset + data_total_length],
             )
-            logger.debug(f'>>> ACL packet enqueue: (CID={cid}) {acl_packet}')
-            packet_queue.enqueue(acl_packet)
+            logger.debug(
+                f'{color("### HOST -> CONTROLLER", "blue")}: (CID={cid}) {acl_packet}'
+            )
+            self.queue_acl_packet(acl_packet)
             pb_flag = 1
             offset += data_total_length
             bytes_remaining -= data_total_length
 
+    def queue_acl_packet(self, acl_packet: HCI_AclDataPacket) -> None:
+        self.acl_packet_queue.appendleft(acl_packet)
+        self.check_acl_packet_queue()
+
+        if len(self.acl_packet_queue):
+            logger.debug(
+                f'{self.acl_packets_in_flight} ACL packets in flight, '
+                f'{len(self.acl_packet_queue)} in queue'
+            )
+
+    def check_acl_packet_queue(self) -> None:
+        # Send all we can (TODO: support different LE/Classic limits)
+        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.acl_packets_in_flight += 1
+            self.send_hci_packet(packet)
+
     def supports_command(self, command):
         # Find the support flag position for this command
         for octet, flags in enumerate(HCI_SUPPORTED_COMMANDS_FLAGS):
@@ -583,7 +553,7 @@ class Host(AbortableEventEmitter):
             # This is used just for the Num_HCI_Command_Packets field, not related to
             # an actual command
             logger.debug('no-command event')
-            return
+            return None
 
         return self.on_command_processed(event)
 
@@ -591,17 +561,18 @@ class Host(AbortableEventEmitter):
         return self.on_command_processed(event)
 
     def on_hci_number_of_completed_packets_event(self, event):
-        for connection_handle, num_completed_packets in zip(
-            event.connection_handles, event.num_completed_packets
-        ):
-            if not (connection := self.connections.get(connection_handle)):
-                logger.warning(
-                    'received packet completion event for unknown handle '
-                    f'0x{connection_handle:04X}'
+        total_packets = sum(event.num_completed_packets)
+        if total_packets <= self.acl_packets_in_flight:
+            self.acl_packets_in_flight -= total_packets
+            self.check_acl_packet_queue()
+        else:
+            logger.warning(
+                color(
+                    f'!!! {total_packets} completed but only '
+                    f'{self.acl_packets_in_flight} in flight'
                 )
-                continue
-
-            connection.acl_packet_queue.on_packets_completed(num_completed_packets)
+            )
+            self.acl_packets_in_flight = 0
 
     # Classic only
     def on_hci_connection_request_event(self, event):

bumble/l2cap.py

@@ -151,8 +151,8 @@ L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_CREDITS             = 65535
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU                 = 23
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MPS                 = 23
 L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MPS                 = 65533
-L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2048
-L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2046
+L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2046
+L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2048
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_INITIAL_CREDITS = 256
 
 L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE = 0x01

bumble/link.py

@@ -95,11 +95,21 @@ class LocalLink:
     def on_address_changed(self, controller):
         pass
 
-    def send_advertising_data(self, sender_address, data):
+    def send_advertising_data(self, sender_address, data, scan_response):
         # Send the advertising data to all controllers, except the sender
         for controller in self.controllers:
             if controller.random_address != sender_address:
-                controller.on_link_advertising_data(sender_address, data)
+                controller.on_link_advertising_data(sender_address, data, scan_response)
+
+    def send_extended_advertising_data(
+        self, sender_address, event_type, data, scan_response
+    ):
+        # Send the advertising data to all controllers, except the sender
+        for controller in self.controllers:
+            if controller.random_address != sender_address:
+                controller.on_link_extended_advertising_data(
+                    sender_address, event_type, data, scan_response
+                )
 
     def send_acl_data(self, sender_controller, destination_address, transport, data):
         # Send the data to the first controller with a matching address
@@ -151,30 +161,34 @@ class LocalLink:
         asyncio.get_running_loop().call_soon(self.on_connection_complete)
 
     def on_disconnection_complete(
-        self, central_address, peripheral_address, disconnect_command
+        self, initiator_address, peer_address, disconnect_command
     ):
         # Find the controller that initiated the disconnection
-        if not (central_controller := self.find_controller(central_address)):
+        if not (initiator_controller := self.find_controller(initiator_address)):
             logger.warning('!!! Initiating controller not found')
             return
 
         # Disconnect from the first controller with a matching address
-        if peripheral_controller := self.find_controller(peripheral_address):
-            peripheral_controller.on_link_central_disconnected(
-                central_address, disconnect_command.reason
+        if peer_controller := self.find_controller(peer_address):
+            peer_controller.on_link_peer_disconnected(
+                initiator_address, disconnect_command.reason
             )
 
-        central_controller.on_link_peripheral_disconnection_complete(
+        initiator_controller.on_link_initiated_disconnection_complete(
             disconnect_command, HCI_SUCCESS
         )
 
-    def disconnect(self, central_address, peripheral_address, disconnect_command):
+    def disconnect(self, initiator_address, peer_address, disconnect_command):
         logger.debug(
-            f'$$$ DISCONNECTION {central_address} -> '
-            f'{peripheral_address}: reason = {disconnect_command.reason}'
+            f'$$$ DISCONNECTION {initiator_address} -> '
+            f'{peer_address}: reason = {disconnect_command.reason}'
+        )
+        asyncio.get_running_loop().call_soon(
+            self.on_disconnection_complete,
+            initiator_address,
+            peer_address,
+            disconnect_command,
         )
-        args = [central_address, peripheral_address, disconnect_command]
-        asyncio.get_running_loop().call_soon(self.on_disconnection_complete, *args)
 
     # pylint: disable=too-many-arguments
     def on_connection_encrypted(
@@ -360,11 +374,11 @@ class RemoteLink:
 
     async def on_left_received(self, address):
         if address in self.central_connections:
-            self.controller.on_link_peripheral_disconnected(Address(address))
+            self.controller.on_link_connection_lost(Address(address))
             self.central_connections.remove(address)
 
         if address in self.peripheral_connections:
-            self.controller.on_link_central_disconnected(
+            self.controller.on_link_peer_disconnected(
                 address, HCI_CONNECTION_TIMEOUT_ERROR
             )
             self.peripheral_connections.remove(address)
@@ -384,7 +398,7 @@ class RemoteLink:
     async def on_advertisement_message_received(self, sender, advertisement):
         try:
             self.controller.on_link_advertising_data(
-                Address(sender), bytes.fromhex(advertisement)
+                Address(sender), bytes.fromhex(advertisement), b''
             )
         except Exception:
             logger.exception('exception')
@@ -424,7 +438,7 @@ class RemoteLink:
         # Notify the controller
         params = parse_parameters(message)
         reason = int(params.get('reason', str(HCI_CONNECTION_TIMEOUT_ERROR)))
-        self.controller.on_link_central_disconnected(Address(sender), reason)
+        self.controller.on_link_peer_disconnected(Address(sender), reason)
 
         # Forget the connection
         if sender in self.peripheral_connections:
@@ -471,7 +485,7 @@ class RemoteLink:
     async def send_advertising_data_to_relay(self, data):
         await self.send_targeted_message('*', f'advertisement:{data.hex()}')
 
-    def send_advertising_data(self, _, data):
+    def send_advertising_data(self, _, data, scan_response):
         self.execute(partial(self.send_advertising_data_to_relay, data))
 
     async def send_acl_data_to_relay(self, peer_address, data):

bumble/rfcomm.py

@@ -118,8 +118,8 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_WINDOW_SIZE    = 16
-RFCOMM_DEFAULT_MAX_FRAME_SIZE = 2000
+RFCOMM_DEFAULT_INITIAL_RX_CREDITS = 7
+RFCOMM_DEFAULT_PREFERRED_MTU      = 1280
 
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_START = 1
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
@@ -438,16 +438,14 @@ class DLC(EventEmitter):
         multiplexer: Multiplexer,
         dlci: int,
         max_frame_size: int,
-        window_size: int,
+        initial_tx_credits: int,
     ) -> None:
         super().__init__()
         self.multiplexer = multiplexer
         self.dlci = dlci
-        self.max_frame_size = max_frame_size
-        self.window_size = window_size
-        self.rx_credits = window_size
-        self.rx_threshold = window_size // 2
-        self.tx_credits = window_size
+        self.rx_credits = RFCOMM_DEFAULT_INITIAL_RX_CREDITS
+        self.rx_threshold = self.rx_credits // 2
+        self.tx_credits = initial_tx_credits
         self.tx_buffer = b''
         self.state = DLC.State.INIT
         self.role = multiplexer.role
@@ -539,11 +537,11 @@ class DLC(EventEmitter):
         if len(data) and self.sink:
             self.sink(data)  # pylint: disable=not-callable
 
-            # Update the credits
-            if self.rx_credits > 0:
-                self.rx_credits -= 1
-            else:
-                logger.warning(color('!!! received frame with no rx credits', 'red'))
+        # Update the credits
+        if self.rx_credits > 0:
+            self.rx_credits -= 1
+        else:
+            logger.warning(color('!!! received frame with no rx credits', 'red'))
 
         # Check if there's anything to send (including credits)
         self.process_tx()
@@ -582,9 +580,9 @@ class DLC(EventEmitter):
             cl=0xE0,
             priority=7,
             ack_timer=0,
-            max_frame_size=self.max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            window_size=self.window_size,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
         mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=0, data=bytes(pn))
         logger.debug(f'>>> PN Response: {pn}')
@@ -593,7 +591,7 @@ class DLC(EventEmitter):
 
     def rx_credits_needed(self) -> int:
         if self.rx_credits <= self.rx_threshold:
-            return self.window_size - self.rx_credits
+            return RFCOMM_DEFAULT_INITIAL_RX_CREDITS - self.rx_credits
 
         return 0
 
@@ -845,12 +843,7 @@ class Multiplexer(EventEmitter):
         )
         await self.disconnection_result
 
-    async def open_dlc(
-        self,
-        channel: int,
-        max_frame_size: int = RFCOMM_DEFAULT_MAX_FRAME_SIZE,
-        window_size: int = RFCOMM_DEFAULT_WINDOW_SIZE,
-    ) -> DLC:
+    async def open_dlc(self, channel: int) -> DLC:
         if self.state != Multiplexer.State.CONNECTED:
             if self.state == Multiplexer.State.OPENING:
                 raise InvalidStateError('open already in progress')
@@ -862,9 +855,9 @@ class Multiplexer(EventEmitter):
             cl=0xF0,
             priority=7,
             ack_timer=0,
-            max_frame_size=max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            window_size=window_size,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
         mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=1, data=bytes(pn))
         logger.debug(f'>>> Sending MCC: {pn}')

bumble/transport/usb.py

@@ -108,7 +108,7 @@ async def open_usb_transport(spec: str) -> Transport:
         USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
     )
 
-    READ_SIZE = 4096
+    READ_SIZE = 1024
 
     class UsbPacketSink:
         def __init__(self, device, acl_out):

examples/run_hid_device.py

@@ -590,12 +590,12 @@ async def main():
     def on_set_protocol_cb(protocol: int):
         retValue = hid_device.GetSetStatus()
         # We do not support SET_PROTOCOL.
-        print(f"SET_PROTOCOL report_id: {protocol}")
+        print("SET_PROTOCOL report_id: " + str(protocol))
         retValue.status = hid_device.GetSetReturn.ERR_UNSUPPORTED_REQUEST
         return retValue
 
     def on_virtual_cable_unplug_cb():
-        print('Received Virtual Cable Unplug')
+        print(f'Received Virtual Cable Unplug')
         asyncio.create_task(handle_virtual_cable_unplug())
 
     print('<<< connecting to HCI...')

extras/android/BtBench/app/src/main/java/com/github/google/bumble/btbench/L2capClient.kt

@@ -28,8 +28,8 @@ private val Log = Logger.getLogger("btbench.l2cap-client")
 
 class L2capClient(
     private val viewModel: AppViewModel,
-    private val bluetoothAdapter: BluetoothAdapter,
-    private val context: Context
+    val bluetoothAdapter: BluetoothAdapter,
+    val context: Context
 ) {
     @SuppressLint("MissingPermission")
     fun run() {
@@ -80,10 +80,6 @@ class L2capClient(
                             BluetoothDevice.PHY_OPTION_NO_PREFERRED
                         )
                         gatt.readPhy()
-
-                        // Request an MTU update, even though we don't use GATT, because Android
-                        // won't request a larger link layer maximum data length otherwise.
-                        gatt.requestMtu(517)
                     }
                 }
             },

extras/android/BtBench/app/src/main/java/com/github/google/bumble/btbench/Model.kt

@@ -23,7 +23,7 @@ import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
 import java.util.UUID
 
-val DEFAULT_RFCOMM_UUID: UUID = UUID.fromString("E6D55659-C8B4-4B85-96BB-B1143AF6D3AE")
+val DEFAULT_RFCOMM_UUID = UUID.fromString("E6D55659-C8B4-4B85-96BB-B1143AF6D3AE")
 const val DEFAULT_PEER_BLUETOOTH_ADDRESS = "AA:BB:CC:DD:EE:FF"
 const val DEFAULT_SENDER_PACKET_COUNT = 100
 const val DEFAULT_SENDER_PACKET_SIZE = 1024
@@ -31,11 +31,11 @@ const val DEFAULT_SENDER_PACKET_SIZE = 1024
 class AppViewModel : ViewModel() {
     private var preferences: SharedPreferences? = null
     var peerBluetoothAddress by mutableStateOf(DEFAULT_PEER_BLUETOOTH_ADDRESS)
-    var l2capPsm by mutableIntStateOf(0)
+    var l2capPsm by mutableStateOf(0)
     var use2mPhy by mutableStateOf(true)
-    var mtu by mutableIntStateOf(0)
-    var rxPhy by mutableIntStateOf(0)
-    var txPhy by mutableIntStateOf(0)
+    var mtu by mutableStateOf(0)
+    var rxPhy by mutableStateOf(0)
+    var txPhy by mutableStateOf(0)
     var senderPacketCountSlider by mutableFloatStateOf(0.0F)
     var senderPacketSizeSlider by mutableFloatStateOf(0.0F)
     var senderPacketCount by mutableIntStateOf(DEFAULT_SENDER_PACKET_COUNT)
@@ -79,18 +79,18 @@ class AppViewModel : ViewModel() {
     }
 
     fun updateSenderPacketCountSlider() {
-        senderPacketCountSlider = if (senderPacketCount <= 10) {
-            0.0F
+        if (senderPacketCount <= 10) {
+            senderPacketCountSlider = 0.0F
         } else if (senderPacketCount <= 50) {
-            0.2F
+            senderPacketCountSlider = 0.2F
         } else if (senderPacketCount <= 100) {
-            0.4F
+            senderPacketCountSlider = 0.4F
         } else if (senderPacketCount <= 500) {
-            0.6F
+            senderPacketCountSlider = 0.6F
         } else if (senderPacketCount <= 1000) {
-            0.8F
+            senderPacketCountSlider = 0.8F
         } else {
-            1.0F
+            senderPacketCountSlider = 1.0F
         }
 
         with(preferences!!.edit()) {
@@ -100,18 +100,18 @@ class AppViewModel : ViewModel() {
     }
 
     fun updateSenderPacketCount() {
-        senderPacketCount = if (senderPacketCountSlider < 0.1F) {
-            10
+        if (senderPacketCountSlider < 0.1F) {
+            senderPacketCount = 10
         } else if (senderPacketCountSlider < 0.3F) {
-            50
+            senderPacketCount = 50
         } else if (senderPacketCountSlider < 0.5F) {
-            100
+            senderPacketCount = 100
         } else if (senderPacketCountSlider < 0.7F) {
-            500
+            senderPacketCount = 500
         } else if (senderPacketCountSlider < 0.9F) {
-            1000
+            senderPacketCount = 1000
         } else {
-            10000
+            senderPacketCount = 10000
         }
 
         with(preferences!!.edit()) {
@@ -121,18 +121,18 @@ class AppViewModel : ViewModel() {
     }
 
     fun updateSenderPacketSizeSlider() {
-        senderPacketSizeSlider = if (senderPacketSize <= 16) {
-            0.0F
+        if (senderPacketSize <= 16) {
+            senderPacketSizeSlider = 0.0F
         } else if (senderPacketSize <= 256) {
-            0.02F
+            senderPacketSizeSlider = 0.02F
         } else if (senderPacketSize <= 512) {
-            0.4F
+            senderPacketSizeSlider = 0.4F
         } else if (senderPacketSize <= 1024) {
-            0.6F
+            senderPacketSizeSlider = 0.6F
         } else if (senderPacketSize <= 2048) {
-            0.8F
+            senderPacketSizeSlider = 0.8F
         } else {
-            1.0F
+            senderPacketSizeSlider = 1.0F
         }
 
         with(preferences!!.edit()) {
@@ -142,18 +142,18 @@ class AppViewModel : ViewModel() {
     }
 
     fun updateSenderPacketSize() {
-        senderPacketSize = if (senderPacketSizeSlider < 0.1F) {
-            16
+        if (senderPacketSizeSlider < 0.1F) {
+            senderPacketSize = 16
         } else if (senderPacketSizeSlider < 0.3F) {
-            256
+            senderPacketSize = 256
         } else if (senderPacketSizeSlider < 0.5F) {
-            512
+            senderPacketSize = 512
         } else if (senderPacketSizeSlider < 0.7F) {
-            1024
+            senderPacketSize = 1024
         } else if (senderPacketSizeSlider < 0.9F) {
-            2048
+            senderPacketSize = 2048
         } else {
-            4096
+            senderPacketSize = 4096
         }
 
         with(preferences!!.edit()) {

extras/android/RemoteHCI/app/src/main/java/com/github/google/bumble/remotehci/HciServer.java

@@ -42,7 +42,6 @@ public class HciServer {
         try (ServerSocket serverSocket = new ServerSocket(mPort)) {
             mListener.onMessage("Waiting for connection on port " + serverSocket.getLocalPort());
             try (Socket clientSocket = serverSocket.accept()) {
-                clientSocket.setTcpNoDelay(true);
                 mListener.onHostConnectionState(true);
                 mListener.onMessage("Connected");
                 HciParser parser = new HciParser(mListener);

tests/controller_test.py

@@ -0,0 +1,138 @@
+# Copyright 2023 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.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import os
+import pytest
+from typing import List, Optional
+from unittest.mock import MagicMock
+
+from bumble.device import Connection, Device
+from bumble.host import Host
+from bumble.link import LocalLink
+from bumble.controller import Controller
+from bumble.hci import (
+    Address,
+    HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR,
+    HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR,
+)
+from bumble.transport import AsyncPipeSink
+
+
+# -----------------------------------------------------------------------------
+class TwoDevices:
+    connections: List[Optional[Connection]]
+
+    def __init__(self) -> None:
+        self.connections = [None, None]
+
+        self.link = LocalLink()
+        self.controllers = [
+            Controller('C1', link=self.link),
+            Controller('C2', link=self.link),
+        ]
+        self.devices = [
+            Device(
+                address=Address('F0:F1:F2:F3:F4:F5'),
+                host=Host(self.controllers[0], AsyncPipeSink(self.controllers[0])),
+            ),
+            Device(
+                address=Address('F5:F4:F3:F2:F1:F0'),
+                host=Host(self.controllers[1], AsyncPipeSink(self.controllers[1])),
+            ),
+        ]
+
+        self.paired = [None, None]
+
+    def on_connection(self, which, connection):
+        self.connections[which] = connection
+        connection.on(
+            'disconnection', lambda reason: self.on_disconnection(which, reason)
+        )
+
+    def on_disconnection(self, which, _):
+        self.connections[which] = None
+
+    async def setup(self):
+        self.devices[0].on(
+            'connection', lambda connection: self.on_connection(0, connection)
+        )
+        self.devices[1].on(
+            'connection', lambda connection: self.on_connection(1, connection)
+        )
+
+        await self.devices[0].power_on()
+        await self.devices[1].power_on()
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_self_connection():
+    two_devices = TwoDevices()
+    await two_devices.setup()
+
+    await two_devices.devices[0].connect(two_devices.devices[1].random_address)
+
+    assert two_devices.connections[0] is not None
+    assert two_devices.connections[1] is not None
+
+    mock0 = MagicMock()
+    mock1 = MagicMock()
+    two_devices.connections[0].once('disconnection', mock0)
+    two_devices.connections[1].once('disconnection', mock1)
+    await two_devices.connections[0].disconnect(
+        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
+    )
+    mock0.assert_called_once_with(HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR)
+    mock1.assert_called_once_with(
+        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
+    )
+
+    assert two_devices.connections[0] is None
+    assert two_devices.connections[1] is None
+
+    await two_devices.devices[0].connect(two_devices.devices[1].random_address)
+
+    assert two_devices.connections[0] is not None
+    assert two_devices.connections[1] is not None
+
+    mock0 = MagicMock()
+    mock1 = MagicMock()
+    two_devices.connections[0].once('disconnection', mock0)
+    two_devices.connections[1].once('disconnection', mock1)
+    await two_devices.connections[1].disconnect(
+        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
+    )
+    mock1.assert_called_once_with(HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR)
+    mock0.assert_called_once_with(
+        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
+    )
+
+    assert two_devices.connections[0] is None
+    assert two_devices.connections[1] is None
+
+
+# -----------------------------------------------------------------------------
+async def run_test_controller():
+    await test_self_connection()
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(run_test_controller())

tests/device_test.py

@@ -29,7 +29,7 @@ from bumble.core import (
     ConnectionParameters,
 )
 from bumble.device import Connection, Device
-from bumble.host import AclPacketQueue, Host
+from bumble.host import Host
 from bumble.hci import (
     HCI_ACCEPT_CONNECTION_REQUEST_COMMAND,
     HCI_COMMAND_STATUS_PENDING,
@@ -73,13 +73,6 @@ async def test_device_connect_parallel():
     d1 = Device(host=Host(None, None))
     d2 = Device(host=Host(None, None))
 
-    def _send(packet):
-        pass
-
-    d0.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
-    d1.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
-    d2.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
-
     # enable classic
     d0.classic_enabled = True
     d1.classic_enabled = True