bumble 0.0.220__py3-none-any.whl → 0.0.221__py3-none-any.whl

bumble/link.py

@@ -19,9 +19,12 @@ import asyncio
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
 
-from bumble import controller, core, hci, lmp
+from bumble import core, hci, ll, lmp
+
+if TYPE_CHECKING:
+    from bumble import controller
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -29,11 +32,6 @@ from bumble import controller, core, hci, lmp
 logger = logging.getLogger(__name__)
 
 
-# -----------------------------------------------------------------------------
-# Utils
-# -----------------------------------------------------------------------------
-
-
 # -----------------------------------------------------------------------------
 # TODO: add more support for various LL exchanges
 # (see Vol 6, Part B - 2.4 DATA CHANNEL PDU)
@@ -47,7 +45,6 @@ class LocalLink:
 
     def __init__(self):
         self.controllers = set()
-        self.pending_connection = None
         self.pending_classic_connection = None
 
     ############################################################
@@ -61,23 +58,21 @@ class LocalLink:
     def remove_controller(self, controller: controller.Controller):
         self.controllers.remove(controller)
 
-    def find_controller(self, address: hci.Address) -> controller.Controller | None:
+    def find_le_controller(self, address: hci.Address) -> controller.Controller | None:
         for controller in self.controllers:
-            if controller.random_address == address:
-                return controller
+            for connection in controller.le_connections.values():
+                if connection.self_address == address:
+                    return controller
         return None
 
     def find_classic_controller(
         self, address: hci.Address
-    ) -> Optional[controller.Controller]:
+    ) -> controller.Controller | None:
         for controller in self.controllers:
             if controller.public_address == address:
                 return controller
         return None
 
-    def get_pending_connection(self):
-        return self.pending_connection
-
     ############################################################
     # LE handlers
     ############################################################
@@ -85,12 +80,6 @@ class LocalLink:
     def on_address_changed(self, controller):
         pass
 
-    def send_advertising_data(self, sender_address: hci.Address, data: bytes):
-        # 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)
-
     def send_acl_data(
         self,
         sender_controller: controller.Controller,
@@ -100,7 +89,7 @@ class LocalLink:
     ):
         # Send the data to the first controller with a matching address
         if transport == core.PhysicalTransport.LE:
-            destination_controller = self.find_controller(destination_address)
+            destination_controller = self.find_le_controller(destination_address)
             source_address = sender_controller.random_address
         elif transport == core.PhysicalTransport.BR_EDR:
             destination_controller = self.find_classic_controller(destination_address)
@@ -115,152 +104,30 @@ class LocalLink:
                 )
             )
 
-    def on_connection_complete(self) -> None:
-        # Check that we expect this call
-        if not self.pending_connection:
-            logger.warning('on_connection_complete with no pending connection')
-            return
-
-        central_address, le_create_connection_command = self.pending_connection
-        self.pending_connection = None
-
-        # Find the controller that initiated the connection
-        if not (central_controller := self.find_controller(central_address)):
-            logger.warning('!!! Initiating controller not found')
-            return
-
-        # Connect to the first controller with a matching address
-        if peripheral_controller := self.find_controller(
-            le_create_connection_command.peer_address
-        ):
-            central_controller.on_link_peripheral_connection_complete(
-                le_create_connection_command, hci.HCI_SUCCESS
-            )
-            peripheral_controller.on_link_central_connected(central_address)
-            return
-
-        # No peripheral found
-        central_controller.on_link_peripheral_connection_complete(
-            le_create_connection_command, hci.HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR
-        )
-
-    def connect(
+    def send_advertising_pdu(
         self,
-        central_address: hci.Address,
-        le_create_connection_command: hci.HCI_LE_Create_Connection_Command,
+        sender_controller: controller.Controller,
+        packet: ll.AdvertisingPdu,
     ):
-        logger.debug(
-            f'$$$ CONNECTION {central_address} -> '
-            f'{le_create_connection_command.peer_address}'
-        )
-        self.pending_connection = (central_address, le_create_connection_command)
-        asyncio.get_running_loop().call_soon(self.on_connection_complete)
+        loop = asyncio.get_running_loop()
+        for c in self.controllers:
+            if c != sender_controller:
+                loop.call_soon(c.on_ll_advertising_pdu, packet)
 
-    def on_disconnection_complete(
+    def send_ll_control_pdu(
         self,
-        initiating_address: hci.Address,
-        target_address: hci.Address,
-        disconnect_command: hci.HCI_Disconnect_Command,
+        sender_address: hci.Address,
+        receiver_address: hci.Address,
+        packet: ll.ControlPdu,
     ):
-        # Find the controller that initiated the disconnection
-        if not (initiating_controller := self.find_controller(initiating_address)):
-            logger.warning('!!! Initiating controller not found')
-            return
-
-        # Disconnect from the first controller with a matching address
-        if target_controller := self.find_controller(target_address):
-            target_controller.on_link_disconnected(
-                initiating_address, disconnect_command.reason
+        if not (receiver_controller := self.find_le_controller(receiver_address)):
+            raise core.InvalidArgumentError(
+                f"Unable to find controller for address {receiver_address}"
             )
-
-        initiating_controller.on_link_disconnection_complete(
-            disconnect_command, hci.HCI_SUCCESS
-        )
-
-    def disconnect(
-        self,
-        initiating_address: hci.Address,
-        target_address: hci.Address,
-        disconnect_command: hci.HCI_Disconnect_Command,
-    ):
-        logger.debug(
-            f'$$$ DISCONNECTION {initiating_address} -> '
-            f'{target_address}: reason = {disconnect_command.reason}'
-        )
         asyncio.get_running_loop().call_soon(
-            lambda: self.on_disconnection_complete(
-                initiating_address, target_address, disconnect_command
-            )
+            lambda: receiver_controller.on_ll_control_pdu(sender_address, packet)
         )
 
-    def on_connection_encrypted(
-        self,
-        central_address: hci.Address,
-        peripheral_address: hci.Address,
-        rand: bytes,
-        ediv: int,
-        ltk: bytes,
-    ):
-        logger.debug(f'*** ENCRYPTION {central_address} -> {peripheral_address}')
-
-        if central_controller := self.find_controller(central_address):
-            central_controller.on_link_encrypted(peripheral_address, rand, ediv, ltk)
-
-        if peripheral_controller := self.find_controller(peripheral_address):
-            peripheral_controller.on_link_encrypted(central_address, rand, ediv, ltk)
-
-    def create_cis(
-        self,
-        central_controller: controller.Controller,
-        peripheral_address: hci.Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Request {central_controller.random_address} -> {peripheral_address}'
-        )
-        if peripheral_controller := self.find_controller(peripheral_address):
-            asyncio.get_running_loop().call_soon(
-                peripheral_controller.on_link_cis_request,
-                central_controller.random_address,
-                cig_id,
-                cis_id,
-            )
-
-    def accept_cis(
-        self,
-        peripheral_controller: controller.Controller,
-        central_address: hci.Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Accept {peripheral_controller.random_address} -> {central_address}'
-        )
-        if central_controller := self.find_controller(central_address):
-            loop = asyncio.get_running_loop()
-            loop.call_soon(central_controller.on_link_cis_established, cig_id, cis_id)
-            loop.call_soon(
-                peripheral_controller.on_link_cis_established, cig_id, cis_id
-            )
-
-    def disconnect_cis(
-        self,
-        initiator_controller: controller.Controller,
-        peer_address: hci.Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Disconnect {initiator_controller.random_address} -> {peer_address}'
-        )
-        if peer_controller := self.find_controller(peer_address):
-            loop = asyncio.get_running_loop()
-            loop.call_soon(
-                initiator_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
-            loop.call_soon(peer_controller.on_link_cis_disconnected, cig_id, cis_id)
-
     ############################################################
     # Classic handlers
     ############################################################

bumble/ll.py

@@ -0,0 +1,200 @@
+# Copyright 2021-2025 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
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+
+import dataclasses
+from typing import ClassVar
+
+from bumble import hci
+
+
+# -----------------------------------------------------------------------------
+# Advertising PDU
+# -----------------------------------------------------------------------------
+class AdvertisingPdu:
+    """Base Advertising Physical Channel PDU class.
+
+    See Core Spec 6.0, Volume 6, Part B, 2.3. Advertising physical channel PDU.
+
+    Currently these messages don't really follow the LL spec, because LL protocol is
+    context-aware and we don't have real physical transport.
+    """
+
+
+@dataclasses.dataclass
+class ConnectInd(AdvertisingPdu):
+    initiator_address: hci.Address
+    advertiser_address: hci.Address
+    interval: int
+    latency: int
+    timeout: int
+
+
+@dataclasses.dataclass
+class AdvInd(AdvertisingPdu):
+    advertiser_address: hci.Address
+    data: bytes
+
+
+@dataclasses.dataclass
+class AdvDirectInd(AdvertisingPdu):
+    advertiser_address: hci.Address
+    target_address: hci.Address
+
+
+@dataclasses.dataclass
+class AdvNonConnInd(AdvertisingPdu):
+    advertiser_address: hci.Address
+    data: bytes
+
+
+@dataclasses.dataclass
+class AdvExtInd(AdvertisingPdu):
+    advertiser_address: hci.Address
+    data: bytes
+
+    target_address: hci.Address | None = None
+    adi: int | None = None
+    tx_power: int | None = None
+
+
+# -----------------------------------------------------------------------------
+# LL Control PDU
+# -----------------------------------------------------------------------------
+class ControlPdu:
+    """Base LL Control PDU Class.
+
+    See Core Spec 6.0, Volume 6, Part B, 2.4.2. LL Control PDU.
+
+    Currently these messages don't really follow the LL spec, because LL protocol is
+    context-aware and we don't have real physical transport.
+    """
+
+    class Opcode(hci.SpecableEnum):
+        LL_CONNECTION_UPDATE_IND = 0x00
+        LL_CHANNEL_MAP_IND = 0x01
+        LL_TERMINATE_IND = 0x02
+        LL_ENC_REQ = 0x03
+        LL_ENC_RSP = 0x04
+        LL_START_ENC_REQ = 0x05
+        LL_START_ENC_RSP = 0x06
+        LL_UNKNOWN_RSP = 0x07
+        LL_FEATURE_REQ = 0x08
+        LL_FEATURE_RSP = 0x09
+        LL_PAUSE_ENC_REQ = 0x0A
+        LL_PAUSE_ENC_RSP = 0x0B
+        LL_VERSION_IND = 0x0C
+        LL_REJECT_IND = 0x0D
+        LL_PERIPHERAL_FEATURE_REQ = 0x0E
+        LL_CONNECTION_PARAM_REQ = 0x0F
+        LL_CONNECTION_PARAM_RSP = 0x10
+        LL_REJECT_EXT_IND = 0x11
+        LL_PING_REQ = 0x12
+        LL_PING_RSP = 0x13
+        LL_LENGTH_REQ = 0x14
+        LL_LENGTH_RSP = 0x15
+        LL_PHY_REQ = 0x16
+        LL_PHY_RSP = 0x17
+        LL_PHY_UPDATE_IND = 0x18
+        LL_MIN_USED_CHANNELS_IND = 0x19
+        LL_CTE_REQ = 0x1A
+        LL_CTE_RSP = 0x1B
+        LL_PERIODIC_SYNC_IND = 0x1C
+        LL_CLOCK_ACCURACY_REQ = 0x1D
+        LL_CLOCK_ACCURACY_RSP = 0x1E
+        LL_CIS_REQ = 0x1F
+        LL_CIS_RSP = 0x20
+        LL_CIS_IND = 0x21
+        LL_CIS_TERMINATE_IND = 0x22
+        LL_POWER_CONTROL_REQ = 0x23
+        LL_POWER_CONTROL_RSP = 0x24
+        LL_POWER_CHANGE_IND = 0x25
+        LL_SUBRATE_REQ = 0x26
+        LL_SUBRATE_IND = 0x27
+        LL_CHANNEL_REPORTING_IND = 0x28
+        LL_CHANNEL_STATUS_IND = 0x29
+        LL_PERIODIC_SYNC_WR_IND = 0x2A
+        LL_FEATURE_EXT_REQ = 0x2B
+        LL_FEATURE_EXT_RSP = 0x2C
+        LL_CS_SEC_RSP = 0x2D
+        LL_CS_CAPABILITIES_REQ = 0x2E
+        LL_CS_CAPABILITIES_RSP = 0x2F
+        LL_CS_CONFIG_REQ = 0x30
+        LL_CS_CONFIG_RSP = 0x31
+        LL_CS_REQ = 0x32
+        LL_CS_RSP = 0x33
+        LL_CS_IND = 0x34
+        LL_CS_TERMINATE_REQ = 0x35
+        LL_CS_FAE_REQ = 0x36
+        LL_CS_FAE_RSP = 0x37
+        LL_CS_CHANNEL_MAP_IND = 0x38
+        LL_CS_SEC_REQ = 0x39
+        LL_CS_TERMINATE_RSP = 0x3A
+        LL_FRAME_SPACE_REQ = 0x3B
+        LL_FRAME_SPACE_RSP = 0x3C
+
+    opcode: ClassVar[Opcode]
+
+
+@dataclasses.dataclass
+class TerminateInd(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_TERMINATE_IND
+
+    error_code: int
+
+
+@dataclasses.dataclass
+class EncReq(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_ENC_REQ
+
+    rand: bytes
+    ediv: int
+    ltk: bytes
+
+
+@dataclasses.dataclass
+class CisReq(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_CIS_REQ
+
+    cig_id: int
+    cis_id: int
+
+
+@dataclasses.dataclass
+class CisRsp(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_CIS_REQ
+
+    cig_id: int
+    cis_id: int
+
+
+@dataclasses.dataclass
+class CisInd(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_CIS_REQ
+
+    cig_id: int
+    cis_id: int
+
+
+@dataclasses.dataclass
+class CisTerminateInd(ControlPdu):
+    opcode = ControlPdu.Opcode.LL_CIS_TERMINATE_IND
+
+    cig_id: int
+    cis_id: int
+    error_code: int

bumble/pairing.py

@@ -20,7 +20,6 @@ from __future__ import annotations
 import enum
 import secrets
 from dataclasses import dataclass
-from typing import Optional
 
 from bumble import hci
 from bumble.core import AdvertisingData, LeRole
@@ -45,16 +44,16 @@ from bumble.smp import (
 class OobData:
     """OOB data that can be sent from one device to another."""
 
-    address: Optional[hci.Address] = None
-    role: Optional[LeRole] = None
-    shared_data: Optional[OobSharedData] = None
-    legacy_context: Optional[OobLegacyContext] = None
+    address: hci.Address | None = None
+    role: LeRole | None = None
+    shared_data: OobSharedData | None = None
+    legacy_context: OobLegacyContext | None = None
 
     @classmethod
     def from_ad(cls, ad: AdvertisingData) -> OobData:
         instance = cls()
-        shared_data_c: Optional[bytes] = None
-        shared_data_r: Optional[bytes] = None
+        shared_data_c: bytes | None = None
+        shared_data_r: bytes | None = None
         for ad_type, ad_data in ad.ad_structures:
             if ad_type == AdvertisingData.LE_BLUETOOTH_DEVICE_ADDRESS:
                 instance.address = hci.Address(ad_data)
@@ -181,14 +180,14 @@ class PairingDelegate:
         """Compare two numbers."""
         return True
 
-    async def get_number(self) -> Optional[int]:
+    async def get_number(self) -> int | None:
         """
         Return an optional number as an answer to a passkey request.
         Returning `None` will result in a negative reply.
         """
         return 0
 
-    async def get_string(self, max_length: int) -> Optional[str]:
+    async def get_string(self, max_length: int) -> str | None:
         """
         Return a string whose utf-8 encoding is up to max_length bytes.
         """
@@ -239,18 +238,18 @@ class PairingConfig:
     class OobConfig:
         """Config for OOB pairing."""
 
-        our_context: Optional[OobContext]
-        peer_data: Optional[OobSharedData]
-        legacy_context: Optional[OobLegacyContext]
+        our_context: OobContext | None
+        peer_data: OobSharedData | None
+        legacy_context: OobLegacyContext | None
 
     def __init__(
         self,
         sc: bool = True,
         mitm: bool = True,
         bonding: bool = True,
-        delegate: Optional[PairingDelegate] = None,
-        identity_address_type: Optional[AddressType] = None,
-        oob: Optional[OobConfig] = None,
+        delegate: PairingDelegate | None = None,
+        identity_address_type: AddressType | None = None,
+        oob: OobConfig | None = None,
     ) -> None:
         self.sc = sc
         self.mitm = mitm

bumble/pandora/__init__.py

@@ -19,7 +19,7 @@ This module implement the Pandora Bluetooth test APIs for the Bumble stack.
 
 __version__ = "0.0.1"
 
-from typing import Callable, List, Optional
+from collections.abc import Callable
 
 import grpc
 import grpc.aio
@@ -58,7 +58,7 @@ def register_servicer_hook(
 async def serve(
     bumble: PandoraDevice,
     config: Config = Config(),
-    grpc_server: Optional[grpc.aio.Server] = None,
+    grpc_server: grpc.aio.Server | None = None,
     port: int = 0,
 ) -> None:
     # initialize a gRPC server if not provided.

bumble/pandora/device.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from bumble import transport
 from bumble.core import (
@@ -54,7 +54,7 @@ class PandoraDevice:
 
     # HCI transport name & instance.
     _hci_name: str
-    _hci: Optional[transport.Transport]  # type: ignore[name-defined]
+    _hci: transport.Transport | None  # type: ignore[name-defined]
 
     def __init__(self, config: dict[str, Any]) -> None:
         self.config = config
@@ -74,7 +74,9 @@ class PandoraDevice:
 
         # open HCI transport & set device host.
         self._hci = await transport.open_transport(self._hci_name)
-        self.device.host = Host(controller_source=self._hci.source, controller_sink=self._hci.sink)  # type: ignore[no-untyped-call]
+        self.device.host = Host(
+            controller_source=self._hci.source, controller_sink=self._hci.sink
+        )  # type: ignore[no-untyped-call]
 
         # power-on.
         await self.device.power_on()
@@ -96,7 +98,7 @@ class PandoraDevice:
         await self.close()
         await self.open()
 
-    def info(self) -> Optional[dict[str, str]]:
+    def info(self) -> dict[str, str] | None:
         return {
             'public_bd_address': str(self.device.public_address),
             'random_address': str(self.device.random_address),

bumble/pandora/host.py

@@ -17,12 +17,15 @@ from __future__ import annotations
 import asyncio
 import logging
 import struct
-from typing import AsyncGenerator, Optional, cast
+from collections.abc import AsyncGenerator
+from typing import cast
 
 import grpc
 import grpc.aio
-from google.protobuf import any_pb2  # pytype: disable=pyi-error
-from google.protobuf import empty_pb2  # pytype: disable=pyi-error
+from google.protobuf import (
+    any_pb2,  # pytype: disable=pyi-error
+    empty_pb2,  # pytype: disable=pyi-error
+)
 from pandora import host_pb2
 from pandora.host_grpc_aio import HostServicer
 from pandora.host_pb2 import (
@@ -302,7 +305,9 @@ class HostService(HostServicer):
                 await disconnection_future
                 self.log.debug("Disconnected")
             finally:
-                connection.remove_listener(connection.EVENT_DISCONNECTION, on_disconnection)  # type: ignore
+                connection.remove_listener(
+                    connection.EVENT_DISCONNECTION, on_disconnection
+                )  # type: ignore
 
         return empty_pb2.Empty()
 
@@ -539,7 +544,7 @@ class HostService(HostServicer):
                 await bumble.utils.cancel_on_event(
                     self.device, 'flush', self.device.stop_advertising()
                 )
-            except:
+            except Exception:
                 pass
 
     @utils.rpc
@@ -609,7 +614,7 @@ class HostService(HostServicer):
                 await bumble.utils.cancel_on_event(
                     self.device, 'flush', self.device.stop_scanning()
                 )
-            except:
+            except Exception:
                 pass
 
     @utils.rpc
@@ -619,7 +624,7 @@ class HostService(HostServicer):
         self.log.debug('Inquiry')
 
         inquiry_queue: asyncio.Queue[
-            Optional[tuple[Address, int, AdvertisingData, int]]
+            tuple[Address, int, AdvertisingData, int] | None
         ] = asyncio.Queue()
         complete_handler = self.device.on(
             self.device.EVENT_INQUIRY_COMPLETE, lambda: inquiry_queue.put_nowait(None)
@@ -644,14 +649,18 @@ class HostService(HostServicer):
                 )
 
         finally:
-            self.device.remove_listener(self.device.EVENT_INQUIRY_COMPLETE, complete_handler)  # type: ignore
-            self.device.remove_listener(self.device.EVENT_INQUIRY_RESULT, result_handler)  # type: ignore
+            self.device.remove_listener(
+                self.device.EVENT_INQUIRY_COMPLETE, complete_handler
+            )  # type: ignore
+            self.device.remove_listener(
+                self.device.EVENT_INQUIRY_RESULT, result_handler
+            )  # type: ignore
             try:
                 self.log.debug('Stop inquiry')
                 await bumble.utils.cancel_on_event(
                     self.device, 'flush', self.device.stop_discovery()
                 )
-            except:
+            except Exception:
                 pass
 
     @utils.rpc