bumble 0.0.201__tar.gz → 0.0.202__tar.gz

{bumble-0.0.201 → bumble-0.0.202}/.github/workflows/code-check.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
       fail-fast: false
 
     steps:

{bumble-0.0.201 → bumble-0.0.202}/.github/workflows/python-build-test.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: ['ubuntu-latest', 'macos-latest', 'windows-latest']
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
       fail-fast: false
 
     steps:
@@ -46,7 +46,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ "3.8", "3.9", "3.10", "3.11", "3.12" ]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
         rust-version: [ "1.76.0", "stable" ]
       fail-fast: false
     steps:

{bumble-0.0.201 → bumble-0.0.202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bumble
-Version: 0.0.201
+Version: 0.0.202
 Summary: Bluetooth Stack for Apps, Emulation, Test and Experimentation
 Home-page: https://github.com/google/bumble
 Author: Google
@@ -37,9 +37,10 @@ Provides-Extra: development
 Requires-Dist: black==24.3; extra == "development"
 Requires-Dist: grpcio-tools>=1.62.1; extra == "development"
 Requires-Dist: invoke>=1.7.3; extra == "development"
-Requires-Dist: mypy==1.10.0; extra == "development"
+Requires-Dist: mobly>=1.12.2; extra == "development"
+Requires-Dist: mypy==1.12.0; extra == "development"
 Requires-Dist: nox>=2022; extra == "development"
-Requires-Dist: pylint==3.1.0; extra == "development"
+Requires-Dist: pylint==3.3.1; extra == "development"
 Requires-Dist: pyyaml>=6.0; extra == "development"
 Requires-Dist: types-appdirs>=1.4.3; extra == "development"
 Requires-Dist: types-invoke>=1.7.3; extra == "development"

{bumble-0.0.201 → bumble-0.0.202}/apps/bench.py

@@ -19,6 +19,7 @@ import asyncio
 import enum
 import logging
 import os
+import statistics
 import struct
 import time
 
@@ -194,17 +195,19 @@ def make_sdp_records(channel):
     }
 
 
-def log_stats(title, stats):
+def log_stats(title, stats, precision=2):
     stats_min = min(stats)
     stats_max = max(stats)
-    stats_avg = sum(stats) / len(stats)
+    stats_avg = statistics.mean(stats)
+    stats_stdev = statistics.stdev(stats)
     logging.info(
         color(
             (
                 f'### {title} stats: '
-                f'min={stats_min:.2f}, '
-                f'max={stats_max:.2f}, '
-                f'average={stats_avg:.2f}'
+                f'min={stats_min:.{precision}f}, '
+                f'max={stats_max:.{precision}f}, '
+                f'average={stats_avg:.{precision}f}, '
+                f'stdev={stats_stdev:.{precision}f}'
             ),
             'cyan',
         )
@@ -448,9 +451,9 @@ class Ping:
         self.repeat_delay = repeat_delay
         self.pace = pace
         self.done = asyncio.Event()
-        self.current_packet_index = 0
-        self.ping_sent_time = 0.0
-        self.latencies = []
+        self.ping_times = []
+        self.rtts = []
+        self.next_expected_packet_index = 0
         self.min_stats = []
         self.max_stats = []
         self.avg_stats = []
@@ -477,60 +480,57 @@ class Ping:
             logging.info(color('=== Sending RESET', 'magenta'))
             await self.packet_io.send_packet(bytes([PacketType.RESET]))
 
-            self.current_packet_index = 0
-            self.latencies = []
-            await self.send_next_ping()
+            packet_interval = self.pace / 1000
+            start_time = time.time()
+            self.next_expected_packet_index = 0
+            for i in range(self.tx_packet_count):
+                target_time = start_time + (i * packet_interval)
+                now = time.time()
+                if now < target_time:
+                    await asyncio.sleep(target_time - now)
+
+                packet = struct.pack(
+                    '>bbI',
+                    PacketType.SEQUENCE,
+                    (PACKET_FLAG_LAST if i == self.tx_packet_count - 1 else 0),
+                    i,
+                ) + bytes(self.tx_packet_size - 6)
+                logging.info(color(f'Sending packet {i}', 'yellow'))
+                self.ping_times.append(time.time())
+                await self.packet_io.send_packet(packet)
 
             await self.done.wait()
 
-            min_latency = min(self.latencies)
-            max_latency = max(self.latencies)
-            avg_latency = sum(self.latencies) / len(self.latencies)
+            min_rtt = min(self.rtts)
+            max_rtt = max(self.rtts)
+            avg_rtt = statistics.mean(self.rtts)
+            stdev_rtt = statistics.stdev(self.rtts)
             logging.info(
                 color(
-                    '@@@ Latencies: '
-                    f'min={min_latency:.2f}, '
-                    f'max={max_latency:.2f}, '
-                    f'average={avg_latency:.2f}'
+                    '@@@ RTTs: '
+                    f'min={min_rtt:.2f}, '
+                    f'max={max_rtt:.2f}, '
+                    f'average={avg_rtt:.2f}, '
+                    f'stdev={stdev_rtt:.2f}'
                 )
             )
 
-            self.min_stats.append(min_latency)
-            self.max_stats.append(max_latency)
-            self.avg_stats.append(avg_latency)
+            self.min_stats.append(min_rtt)
+            self.max_stats.append(max_rtt)
+            self.avg_stats.append(avg_rtt)
 
             run_counter = f'[{run + 1} of {self.repeat + 1}]' if self.repeat else ''
             logging.info(color(f'=== {run_counter} Done!', 'magenta'))
 
             if self.repeat:
-                log_stats('Min Latency', self.min_stats)
-                log_stats('Max Latency', self.max_stats)
-                log_stats('Average Latency', self.avg_stats)
+                log_stats('Min RTT', self.min_stats)
+                log_stats('Max RTT', self.max_stats)
+                log_stats('Average RTT', self.avg_stats)
 
         if self.repeat:
             logging.info(color('--- End of runs', 'blue'))
 
-    async def send_next_ping(self):
-        if self.pace:
-            await asyncio.sleep(self.pace / 1000)
-
-        packet = struct.pack(
-            '>bbI',
-            PacketType.SEQUENCE,
-            (
-                PACKET_FLAG_LAST
-                if self.current_packet_index == self.tx_packet_count - 1
-                else 0
-            ),
-            self.current_packet_index,
-        ) + bytes(self.tx_packet_size - 6)
-        logging.info(color(f'Sending packet {self.current_packet_index}', 'yellow'))
-        self.ping_sent_time = time.time()
-        await self.packet_io.send_packet(packet)
-
     def on_packet_received(self, packet):
-        elapsed = time.time() - self.ping_sent_time
-
         try:
             packet_type, packet_data = parse_packet(packet)
         except ValueError:
@@ -542,21 +542,23 @@ class Ping:
             return
 
         if packet_type == PacketType.ACK:
-            latency = elapsed * 1000
-            self.latencies.append(latency)
+            elapsed = time.time() - self.ping_times[packet_index]
+            rtt = elapsed * 1000
+            self.rtts.append(rtt)
             logging.info(
                 color(
-                    f'<<< Received ACK [{packet_index}], latency={latency:.2f}ms',
+                    f'<<< Received ACK [{packet_index}], RTT={rtt:.2f}ms',
                     'green',
                 )
             )
 
-            if packet_index == self.current_packet_index:
-                self.current_packet_index += 1
+            if packet_index == self.next_expected_packet_index:
+                self.next_expected_packet_index += 1
             else:
                 logging.info(
                     color(
-                        f'!!! Unexpected packet, expected {self.current_packet_index} '
+                        f'!!! Unexpected packet, '
+                        f'expected {self.next_expected_packet_index} '
                         f'but received {packet_index}'
                     )
                 )
@@ -565,8 +567,6 @@ class Ping:
             self.done.set()
             return
 
-        AsyncRunner.spawn(self.send_next_ping())
-
 
 # -----------------------------------------------------------------------------
 # Pong
@@ -583,8 +583,11 @@ class Pong:
 
     def reset(self):
         self.expected_packet_index = 0
+        self.receive_times = []
 
     def on_packet_received(self, packet):
+        self.receive_times.append(time.time())
+
         try:
             packet_type, packet_data = parse_packet(packet)
         except ValueError:
@@ -599,10 +602,16 @@ class Pong:
             packet_flags, packet_index = parse_packet_sequence(packet_data)
         except ValueError:
             return
+        interval = (
+            self.receive_times[-1] - self.receive_times[-2]
+            if len(self.receive_times) >= 2
+            else 0
+        )
         logging.info(
             color(
                 f'<<< Received packet {packet_index}: '
-                f'flags=0x{packet_flags:02X}, {len(packet)} bytes',
+                f'flags=0x{packet_flags:02X}, {len(packet)} bytes, '
+                f'interval={interval:.4f}',
                 'green',
             )
         )
@@ -623,8 +632,35 @@ class Pong:
             )
         )
 
-        if packet_flags & PACKET_FLAG_LAST and not self.linger:
-            self.done.set()
+        if packet_flags & PACKET_FLAG_LAST:
+            if len(self.receive_times) >= 3:
+                # Show basic stats
+                intervals = [
+                    self.receive_times[i + 1] - self.receive_times[i]
+                    for i in range(len(self.receive_times) - 1)
+                ]
+                log_stats('Packet intervals', intervals, 3)
+
+                # Show a histogram
+                bin_count = 20
+                bins = [0] * bin_count
+                interval_min = min(intervals)
+                interval_max = max(intervals)
+                interval_range = interval_max - interval_min
+                bin_thresholds = [
+                    interval_min + i * (interval_range / bin_count)
+                    for i in range(bin_count)
+                ]
+                for interval in intervals:
+                    for i in reversed(range(bin_count)):
+                        if interval >= bin_thresholds[i]:
+                            bins[i] += 1
+                            break
+                for i in range(bin_count):
+                    logging.info(f'@@@ >= {bin_thresholds[i]:.4f}: {bins[i]}')
+
+            if not self.linger:
+                self.done.set()
 
     async def run(self):
         await self.done.wait()
@@ -942,9 +978,12 @@ class RfcommClient(StreamedPacketIO):
             channel = await bumble.rfcomm.find_rfcomm_channel_with_uuid(
                 connection, self.uuid
             )
-            logging.info(color(f'@@@ Channel number = {channel}', 'cyan'))
-            if channel == 0:
-                logging.info(color('!!! No RFComm service with this UUID found', 'red'))
+            if channel:
+                logging.info(color(f'@@@ Channel number = {channel}', 'cyan'))
+            else:
+                logging.warning(
+                    color('!!! No RFComm service with this UUID found', 'red')
+                )
                 await connection.disconnect()
                 return
 
@@ -1054,6 +1093,8 @@ class RfcommServer(StreamedPacketIO):
         if self.credits_threshold is not None:
             dlc.rx_credits_threshold = self.credits_threshold
 
+        self.ready.set()
+
     async def drain(self):
         assert self.dlc
         await self.dlc.drain()
@@ -1068,7 +1109,7 @@ class Central(Connection.Listener):
         transport,
         peripheral_address,
         classic,
-        role_factory,
+        scenario_factory,
         mode_factory,
         connection_interval,
         phy,
@@ -1081,7 +1122,7 @@ class Central(Connection.Listener):
         self.transport = transport
         self.peripheral_address = peripheral_address
         self.classic = classic
-        self.role_factory = role_factory
+        self.scenario_factory = scenario_factory
         self.mode_factory = mode_factory
         self.authenticate = authenticate
         self.encrypt = encrypt or authenticate
@@ -1134,7 +1175,7 @@ class Central(Connection.Listener):
                 DEFAULT_CENTRAL_NAME, central_address, hci_source, hci_sink
             )
             mode = self.mode_factory(self.device)
-            role = self.role_factory(mode)
+            scenario = self.scenario_factory(mode)
             self.device.classic_enabled = self.classic
 
             # Set up a pairing config factory with minimal requirements.
@@ -1215,7 +1256,7 @@ class Central(Connection.Listener):
 
             await mode.on_connection(self.connection)
 
-            await role.run()
+            await scenario.run()
             await asyncio.sleep(DEFAULT_LINGER_TIME)
             await self.connection.disconnect()
 
@@ -1246,7 +1287,7 @@ class Peripheral(Device.Listener, Connection.Listener):
     def __init__(
         self,
         transport,
-        role_factory,
+        scenario_factory,
         mode_factory,
         classic,
         extended_data_length,
@@ -1254,11 +1295,11 @@ class Peripheral(Device.Listener, Connection.Listener):
     ):
         self.transport = transport
         self.classic = classic
-        self.role_factory = role_factory
+        self.scenario_factory = scenario_factory
         self.mode_factory = mode_factory
         self.extended_data_length = extended_data_length
         self.role_switch = role_switch
-        self.role = None
+        self.scenario = None
         self.mode = None
         self.device = None
         self.connection = None
@@ -1278,7 +1319,7 @@ class Peripheral(Device.Listener, Connection.Listener):
             )
             self.device.listener = self
             self.mode = self.mode_factory(self.device)
-            self.role = self.role_factory(self.mode)
+            self.scenario = self.scenario_factory(self.mode)
             self.device.classic_enabled = self.classic
 
             # Set up a pairing config factory with minimal requirements.
@@ -1315,7 +1356,7 @@ class Peripheral(Device.Listener, Connection.Listener):
             print_connection(self.connection)
 
             await self.mode.on_connection(self.connection)
-            await self.role.run()
+            await self.scenario.run()
             await asyncio.sleep(DEFAULT_LINGER_TIME)
 
     def on_connection(self, connection):
@@ -1344,7 +1385,7 @@ class Peripheral(Device.Listener, Connection.Listener):
     def on_disconnection(self, reason):
         logging.info(color(f'!!! Disconnection: reason={reason}', 'red'))
         self.connection = None
-        self.role.reset()
+        self.scenario.reset()
 
         if self.classic:
             AsyncRunner.spawn(self.device.set_discoverable(True))
@@ -1426,13 +1467,13 @@ def create_mode_factory(ctx, default_mode):
 
 
 # -----------------------------------------------------------------------------
-def create_role_factory(ctx, default_role):
-    role = ctx.obj['role']
-    if role is None:
-        role = default_role
+def create_scenario_factory(ctx, default_scenario):
+    scenario = ctx.obj['scenario']
+    if scenario is None:
+        scenarion = default_scenario
 
-    def create_role(packet_io):
-        if role == 'sender':
+    def create_scenario(packet_io):
+        if scenario == 'send':
             return Sender(
                 packet_io,
                 start_delay=ctx.obj['start_delay'],
@@ -1443,10 +1484,10 @@ def create_role_factory(ctx, default_role):
                 packet_count=ctx.obj['packet_count'],
             )
 
-        if role == 'receiver':
+        if scenario == 'receive':
             return Receiver(packet_io, ctx.obj['linger'])
 
-        if role == 'ping':
+        if scenario == 'ping':
             return Ping(
                 packet_io,
                 start_delay=ctx.obj['start_delay'],
@@ -1457,12 +1498,12 @@ def create_role_factory(ctx, default_role):
                 packet_count=ctx.obj['packet_count'],
             )
 
-        if role == 'pong':
+        if scenario == 'pong':
             return Pong(packet_io, ctx.obj['linger'])
 
-        raise ValueError('invalid role')
+        raise ValueError('invalid scenario')
 
-    return create_role
+    return create_scenario
 
 
 # -----------------------------------------------------------------------------
@@ -1470,7 +1511,7 @@ def create_role_factory(ctx, default_role):
 # -----------------------------------------------------------------------------
 @click.group()
 @click.option('--device-config', metavar='FILENAME', help='Device configuration file')
-@click.option('--role', type=click.Choice(['sender', 'receiver', 'ping', 'pong']))
+@click.option('--scenario', type=click.Choice(['send', 'receive', 'ping', 'pong']))
 @click.option(
     '--mode',
     type=click.Choice(
@@ -1503,7 +1544,7 @@ def create_role_factory(ctx, default_role):
     '--rfcomm-channel',
     type=int,
     default=DEFAULT_RFCOMM_CHANNEL,
-    help='RFComm channel to use',
+    help='RFComm channel to use (specify 0 for channel discovery via SDP)',
 )
 @click.option(
     '--rfcomm-uuid',
@@ -1565,7 +1606,7 @@ def create_role_factory(ctx, default_role):
     metavar='SIZE',
     type=click.IntRange(8, 8192),
     default=500,
-    help='Packet size (client or ping role)',
+    help='Packet size (send or ping scenario)',
 )
 @click.option(
     '--packet-count',
@@ -1573,7 +1614,7 @@ def create_role_factory(ctx, default_role):
     metavar='COUNT',
     type=int,
     default=10,
-    help='Packet count (client or ping role)',
+    help='Packet count (send or ping scenario)',
 )
 @click.option(
     '--start-delay',
@@ -1581,7 +1622,7 @@ def create_role_factory(ctx, default_role):
     metavar='SECONDS',
     type=int,
     default=1,
-    help='Start delay (client or ping role)',
+    help='Start delay (send or ping scenario)',
 )
 @click.option(
     '--repeat',
@@ -1589,7 +1630,7 @@ def create_role_factory(ctx, default_role):
     type=int,
     default=0,
     help=(
-        'Repeat the run N times (client and ping roles)'
+        'Repeat the run N times (send and ping scenario)'
         '(0, which is the fault, to run just once) '
     ),
 )
@@ -1613,13 +1654,13 @@ def create_role_factory(ctx, default_role):
 @click.option(
     '--linger',
     is_flag=True,
-    help="Don't exit at the end of a run (server and pong roles)",
+    help="Don't exit at the end of a run (receive and pong scenarios)",
 )
 @click.pass_context
 def bench(
     ctx,
     device_config,
-    role,
+    scenario,
     mode,
     att_mtu,
     extended_data_length,
@@ -1645,7 +1686,7 @@ def bench(
 ):
     ctx.ensure_object(dict)
     ctx.obj['device_config'] = device_config
-    ctx.obj['role'] = role
+    ctx.obj['scenario'] = scenario
     ctx.obj['mode'] = mode
     ctx.obj['att_mtu'] = att_mtu
     ctx.obj['rfcomm_channel'] = rfcomm_channel
@@ -1699,7 +1740,7 @@ def central(
     ctx, transport, peripheral_address, connection_interval, phy, authenticate, encrypt
 ):
     """Run as a central (initiates the connection)"""
-    role_factory = create_role_factory(ctx, 'sender')
+    scenario_factory = create_scenario_factory(ctx, 'send')
     mode_factory = create_mode_factory(ctx, 'gatt-client')
     classic = ctx.obj['classic']
 
@@ -1708,7 +1749,7 @@ def central(
             transport,
             peripheral_address,
             classic,
-            role_factory,
+            scenario_factory,
             mode_factory,
             connection_interval,
             phy,
@@ -1726,13 +1767,13 @@ def central(
 @click.pass_context
 def peripheral(ctx, transport):
     """Run as a peripheral (waits for a connection)"""
-    role_factory = create_role_factory(ctx, 'receiver')
+    scenario_factory = create_scenario_factory(ctx, 'receive')
     mode_factory = create_mode_factory(ctx, 'gatt-server')
 
     async def run_peripheral():
         await Peripheral(
             transport,
-            role_factory,
+            scenario_factory,
             mode_factory,
             ctx.obj['classic'],
             ctx.obj['extended_data_length'],
@@ -1743,7 +1784,11 @@ def peripheral(ctx, transport):
 
 
 def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    logging.basicConfig(
+        level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper(),
+        format="[%(asctime)s.%(msecs)03d] %(levelname)s:%(name)s:%(message)s",
+        datefmt="%H:%M:%S",
+    )
     bench()
 
 

{bumble-0.0.201 → bumble-0.0.202}/apps/rfcomm_bridge.py

@@ -237,6 +237,7 @@ class ClientBridge:
         address: str,
         tcp_host: str,
         tcp_port: int,
+        authenticate: bool,
         encrypt: bool,
     ):
         self.channel = channel
@@ -245,6 +246,7 @@ class ClientBridge:
         self.address = address
         self.tcp_host = tcp_host
         self.tcp_port = tcp_port
+        self.authenticate = authenticate
         self.encrypt = encrypt
         self.device: Optional[Device] = None
         self.connection: Optional[Connection] = None
@@ -274,6 +276,11 @@ class ClientBridge:
         print(color(f"@@@ Bluetooth connection: {self.connection}", "blue"))
         self.connection.on("disconnection", self.on_disconnection)
 
+        if self.authenticate:
+            print(color("@@@ Authenticating Bluetooth connection", "blue"))
+            await self.connection.authenticate()
+            print(color("@@@ Bluetooth connection authenticated", "blue"))
+
         if self.encrypt:
             print(color("@@@ Encrypting Bluetooth connection", "blue"))
             await self.connection.encrypt()
@@ -491,8 +498,9 @@ def server(context, tcp_host, tcp_port):
 @click.argument("bluetooth-address")
 @click.option("--tcp-host", help="TCP host", default="_")
 @click.option("--tcp-port", help="TCP port", default=DEFAULT_CLIENT_TCP_PORT)
+@click.option("--authenticate", is_flag=True, help="Authenticate the connection")
 @click.option("--encrypt", is_flag=True, help="Encrypt the connection")
-def client(context, bluetooth_address, tcp_host, tcp_port, encrypt):
+def client(context, bluetooth_address, tcp_host, tcp_port, authenticate, encrypt):
     bridge = ClientBridge(
         context.obj["channel"],
         context.obj["uuid"],
@@ -500,6 +508,7 @@ def client(context, bluetooth_address, tcp_host, tcp_port, encrypt):
         bluetooth_address,
         tcp_host,
         tcp_port,
+        authenticate,
         encrypt,
     )
     asyncio.run(run(context.obj["device_config"], context.obj["hci_transport"], bridge))

{bumble-0.0.201 → bumble-0.0.202}/bumble/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.201'
-__version_tuple__ = version_tuple = (0, 0, 201)
+__version__ = version = '0.0.202'
+__version_tuple__ = version_tuple = (0, 0, 202)

{bumble-0.0.201 → bumble-0.0.202}/bumble/avc.py

@@ -134,6 +134,8 @@ class Frame:
                 opcode_offset = 3
         elif subunit_id == 6:
             raise core.InvalidPacketError("reserved subunit ID")
+        else:
+            raise core.InvalidPacketError("invalid subunit ID")
 
         opcode = Frame.OperationCode(data[opcode_offset])
         operands = data[opcode_offset + 1 :]

{bumble-0.0.201 → bumble-0.0.202}/bumble/gatt_client.py

@@ -898,6 +898,12 @@ class Client:
                 ) and subscriber in subscribers:
                     subscribers.remove(subscriber)
 
+                    # The characteristic itself is added as subscriber. If it is the
+                    # last remaining subscriber, we remove it, such that the clean up
+                    # works correctly. Otherwise the CCCD never is set back to 0.
+                    if len(subscribers) == 1 and characteristic in subscribers:
+                        subscribers.remove(characteristic)
+
                     # Cleanup if we removed the last one
                     if not subscribers:
                         del subscriber_set[characteristic.handle]

{bumble-0.0.201 → bumble-0.0.202}/bumble/l2cap.py

@@ -1911,6 +1911,7 @@ class ChannelManager:
             data = sum(1 << cid for cid in self.fixed_channels).to_bytes(8, 'little')
         else:
             result = L2CAP_Information_Response.NOT_SUPPORTED
+            data = b''
 
         self.send_control_frame(
             connection,

{bumble-0.0.201 → bumble-0.0.202}/bumble/link.py

@@ -122,6 +122,8 @@ class LocalLink:
         elif transport == BT_BR_EDR_TRANSPORT:
             destination_controller = self.find_classic_controller(destination_address)
             source_address = sender_controller.public_address
+        else:
+            raise ValueError("unsupported transport type")
 
         if destination_controller is not None:
             destination_controller.on_link_acl_data(source_address, transport, data)