bumble 0.0.213__py3-none-any.whl → 0.0.215__py3-none-any.whl

bumble/tools/rtk_util.py

@@ -15,15 +15,15 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-import logging
 import asyncio
-import os
+import logging
 
 import click
 
-from bumble import transport
-from bumble.host import Host
+import bumble.logging
+from bumble import company_ids, hci, transport
 from bumble.drivers import rtk
+from bumble.host import Host
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -61,10 +61,22 @@ async def do_load(usb_transport, force):
         # Get the driver.
         driver = await rtk.Driver.for_host(host, force)
         if driver is None:
-            print("Firmware already loaded or no supported driver for this device.")
+            # Try to see if there's already a FW image loaded
+            firmware_version = await rtk.Driver.get_loaded_firmware_version(host)
+            if firmware_version is None:
+                print("Device not supported")
+                return
+
+            print(f"Firmware already loaded: 0x{firmware_version:08X}")
             return
 
-        await driver.download_firmware()
+        firmware_version = await driver.download_firmware()
+
+        if firmware_version is None:
+            print("Failed to load firmware")
+            return
+
+        print(f"Loaded firmware version 0x{firmware_version:08X}")
 
 
 # -----------------------------------------------------------------------------
@@ -106,13 +118,19 @@ async def do_info(usb_transport, force):
                 f"  Config:   {driver_info.config_name}\n"
             )
         else:
-            print("Firmware already loaded or no supported driver for this device.")
+            # Try to see if there's already a FW image loaded
+            firmware_version = await rtk.Driver.get_loaded_firmware_version(host)
+            if firmware_version is None:
+                print("Device not supported")
+                return
+
+            print(f"Firmware loaded: 0x{firmware_version:08X}")
 
 
 # -----------------------------------------------------------------------------
 @click.group()
 def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    bumble.logging.setup_basic_logging()
 
 
 @main.command

bumble/transport/__init__.py

@@ -15,18 +15,14 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from contextlib import asynccontextmanager
 import logging
 import os
+import re
 from typing import Optional
 
 from bumble import utils
-from bumble.transport.common import (
-    Transport,
-    SnoopingTransport,
-    TransportSpecError,
-)
 from bumble.snoop import create_snooper
+from bumble.transport.common import SnoopingTransport, Transport, TransportSpecError
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -48,8 +44,8 @@ def _wrap_transport(transport: Transport) -> Transport:
             return SnoopingTransport.create_with(
                 transport, create_snooper(snooper_spec)
             )
-        except Exception as exc:
-            logger.warning(f'Exception while creating snooper: {exc}')
+        except Exception:
+            logger.exception('Exception while creating snooper')
 
     return transport
 
@@ -88,12 +84,14 @@ async def open_transport(name: str) -> Transport:
     scheme, *tail = name.split(':', 1)
     spec = tail[0] if tail else None
     metadata = None
-    if spec:
-        # Metadata may precede the spec
-        if spec.startswith('['):
-            metadata_str, *tail = spec[1:].split(']')
-            spec = tail[0] if tail else None
-            metadata = dict([entry.split('=') for entry in metadata_str.split(',')])
+    if spec and (m := re.search(r'\[(\w+=\w+(?:,\w+=\w+)*,?)\]', spec)):
+        metadata_str = m.group(1)
+        if m.start() == 0:
+            # <metadata><spec>
+            spec = spec[m.end() :]
+        else:
+            spec = spec[: m.start()]
+        metadata = dict([entry.split('=') for entry in metadata_str.split(',')])
 
     transport = await _open_transport(scheme, spec)
     if metadata:
@@ -185,12 +183,18 @@ async def _open_transport(scheme: str, spec: Optional[str]) -> Transport:
 
         return await open_android_netsim_transport(spec)
 
-    if scheme == 'unix':
+    if scheme in ('unix', 'unix-client'):
         from bumble.transport.unix import open_unix_client_transport
 
         assert spec
         return await open_unix_client_transport(spec)
 
+    if scheme == 'unix-server':
+        from bumble.transport.unix import open_unix_server_transport
+
+        assert spec
+        return await open_unix_server_transport(spec)
+
     raise TransportSpecError('unknown transport scheme')
 
 

bumble/transport/android_emulator.py

@@ -16,28 +16,27 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-import grpc.aio
-
 from typing import Optional, Union
 
+import grpc.aio
+
 from bumble.transport.common import (
-    PumpedTransport,
-    PumpedPacketSource,
     PumpedPacketSink,
+    PumpedPacketSource,
+    PumpedTransport,
     Transport,
     TransportSpecError,
 )
 
 # pylint: disable=no-name-in-module
+from bumble.transport.grpc_protobuf.emulated_bluetooth_packets_pb2 import HCIPacket
 from bumble.transport.grpc_protobuf.emulated_bluetooth_pb2_grpc import (
     EmulatedBluetoothServiceStub,
 )
-from bumble.transport.grpc_protobuf.emulated_bluetooth_packets_pb2 import HCIPacket
 from bumble.transport.grpc_protobuf.emulated_bluetooth_vhci_pb2_grpc import (
     VhciForwardingServiceStub,
 )
 
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -77,21 +76,17 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
 
     # Parse the parameters
     mode = 'host'
-    server_host = 'localhost'
-    server_port = '8554'
+    server_address = 'localhost:8554'
     if spec:
         params = spec.split(',')
         for param in params:
             if param.startswith('mode='):
                 mode = param.split('=')[1]
-            elif ':' in param:
-                server_host, server_port = param.split(':')
             else:
-                raise TransportSpecError('invalid parameter')
+                server_address = param
 
     # Connect to the gRPC server
-    server_address = f'{server_host}:{server_port}'
-    logger.debug(f'connecting to gRPC server at {server_address}')
+    logger.debug('connecting to gRPC server at %s', server_address)
     channel = grpc.aio.insecure_channel(server_address)
 
     service: Union[EmulatedBluetoothServiceStub, VhciForwardingServiceStub]

bumble/transport/android_netsim.py

@@ -29,28 +29,27 @@ import grpc.aio
 import bumble
 from bumble.transport.common import (
     ParserSource,
-    PumpedTransport,
-    PumpedPacketSource,
     PumpedPacketSink,
+    PumpedPacketSource,
+    PumpedTransport,
     Transport,
-    TransportSpecError,
     TransportInitError,
+    TransportSpecError,
 )
 
 # pylint: disable=no-name-in-module
-from bumble.transport.grpc_protobuf.netsim.packet_streamer_pb2_grpc import (
-    PacketStreamerStub,
-    PacketStreamerServicer,
-    add_PacketStreamerServicer_to_server,
-)
+from bumble.transport.grpc_protobuf.netsim.common_pb2 import ChipKind
+from bumble.transport.grpc_protobuf.netsim.hci_packet_pb2 import HCIPacket
 from bumble.transport.grpc_protobuf.netsim.packet_streamer_pb2 import (
     PacketRequest,
     PacketResponse,
 )
-from bumble.transport.grpc_protobuf.netsim.hci_packet_pb2 import HCIPacket
+from bumble.transport.grpc_protobuf.netsim.packet_streamer_pb2_grpc import (
+    PacketStreamerServicer,
+    PacketStreamerStub,
+    add_PacketStreamerServicer_to_server,
+)
 from bumble.transport.grpc_protobuf.netsim.startup_pb2 import Chip, ChipInfo, DeviceInfo
-from bumble.transport.grpc_protobuf.netsim.common_pb2 import ChipKind
-
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -145,8 +144,6 @@ def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
 async def open_android_netsim_controller_transport(
     server_host: Optional[str], server_port: int, options: dict[str, str]
 ) -> Transport:
-    if not server_port:
-        raise TransportSpecError('invalid port')
     if server_host == '_' or not server_host:
         server_host = 'localhost'
 
@@ -168,14 +165,16 @@ async def open_android_netsim_controller_transport(
                 await self.pump_loop()
             except asyncio.CancelledError:
                 logger.debug('Pump task canceled')
-                self.done.set_result(None)
+                if not self.done.done():
+                    self.done.set_result(None)
 
         async def pump_loop(self):
             while True:
                 request = await self.context.read()
                 if request == grpc.aio.EOF:
                     logger.debug('End of request stream')
-                    self.done.set_result(None)
+                    if not self.done.done():
+                        self.done.set_result(None)
                     return
 
                 # If we're not initialized yet, wait for a init packet.
@@ -220,6 +219,8 @@ async def open_android_netsim_controller_transport(
         async def wait_for_termination(self):
             await self.done
 
+    server_address = f'{server_host}:{server_port}'
+
     class Server(PacketStreamerServicer, ParserSource):
         def __init__(self):
             PacketStreamerServicer.__init__(self)
@@ -230,8 +231,8 @@ async def open_android_netsim_controller_transport(
             # a server listening on that port, we get an exception.
             self.grpc_server = grpc.aio.server(options=(('grpc.so_reuseport', 0),))
             add_PacketStreamerServicer_to_server(self, self.grpc_server)
-            self.grpc_server.add_insecure_port(f'{server_host}:{server_port}')
-            logger.debug(f'gRPC server listening on {server_host}:{server_port}')
+            self.port = self.grpc_server.add_insecure_port(server_address)
+            logger.debug('gRPC server listening on %s', server_address)
 
         async def start(self):
             logger.debug('Starting gRPC server')
@@ -443,7 +444,7 @@ async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
     params = spec.split(',') if spec else []
     if params and ':' in params[0]:
         # Explicit <host>:<port>
-        host, port_str = params[0].split(':')
+        host, port_str = params[0].rsplit(':', maxsplit=1)
         port = int(port_str)
         params_offset = 1
     else:

bumble/transport/common.py

@@ -16,19 +16,18 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
-import contextlib
-import struct
+
 import asyncio
-import logging
+import contextlib
 import io
+import logging
+import struct
 from typing import Any, ContextManager, Optional, Protocol
 
-from bumble import core
-from bumble import hci
+from bumble import core, hci
 from bumble.colors import color
 from bumble.snoop import Snooper
 
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -90,8 +89,8 @@ class PacketPump:
             try:
                 # Deliver the packet to the sink
                 self.sink.on_packet(await self.reader.next_packet())
-            except Exception as error:
-                logger.warning(f'!!! {error}')
+            except Exception:
+                logger.exception('!!!')
 
 
 # -----------------------------------------------------------------------------
@@ -158,10 +157,8 @@ class PacketParser:
                     if self.sink:
                         try:
                             self.sink.on_packet(bytes(self.packet))
-                        except Exception as error:
-                            logger.exception(
-                                color(f'!!! Exception in on_packet: {error}', 'red')
-                            )
+                        except Exception:
+                            logger.exception(color('!!! Exception in on_packet', 'red'))
                     self.reset()
 
     def set_packet_sink(self, sink: TransportSink) -> None:
@@ -378,7 +375,7 @@ class PumpedPacketSource(ParserSource):
                         self.terminated.set_result(None)
                     break
                 except Exception as error:
-                    logger.warning(f'exception while waiting for packet: {error}')
+                    logger.exception('exception while waiting for packet')
                     if not self.terminated.done():
                         self.terminated.set_exception(error)
                     break
@@ -409,8 +406,8 @@ class PumpedPacketSink:
                 except asyncio.CancelledError:
                     logger.debug('sink pump task done')
                     break
-                except Exception as error:
-                    logger.warning(f'exception while sending packet: {error}')
+                except Exception:
+                    logger.exception('exception while sending packet')
                     break
 
         self.pump_task = asyncio.create_task(pump_packets())

bumble/transport/file.py

@@ -19,7 +19,7 @@ import asyncio
 import io
 import logging
 
-from bumble.transport.common import Transport, StreamPacketSource, StreamPacketSink
+from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/transport/hci_socket.py

@@ -16,17 +16,15 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
+import collections
+import ctypes
 import logging
-import struct
 import os
 import socket
-import ctypes
-import collections
-
+import struct
 from typing import Optional
 
-from bumble.transport.common import Transport, ParserSource
-
+from bumble.transport.common import ParserSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/transport/pty.py

@@ -16,16 +16,15 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
-import pty
-import tty
-import io
 import atexit
-import os
+import io
 import logging
-
+import os
+import pty
+import tty
 from typing import Optional
 
-from bumble.transport.common import Transport, StreamPacketSource, StreamPacketSink
+from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/transport/pyusb.py

@@ -19,20 +19,18 @@ import asyncio
 import logging
 import threading
 import time
+from typing import Optional
 
 import usb.core
 import usb.util
-
-from typing import Optional
 from usb.core import Device as UsbDevice
 from usb.core import USBError
-from usb.util import CTRL_TYPE_CLASS, CTRL_RECIPIENT_OTHER
-from usb.legacy import REQ_SET_FEATURE, REQ_CLEAR_FEATURE, CLASS_HUB
+from usb.legacy import CLASS_HUB, REQ_CLEAR_FEATURE, REQ_SET_FEATURE
+from usb.util import CTRL_RECIPIENT_OTHER, CTRL_TYPE_CLASS
 
-from bumble.transport.common import Transport, ParserSource, TransportInitError
 from bumble import hci
 from bumble.colors import color
-
+from bumble.transport.common import ParserSource, Transport, TransportInitError
 
 # -----------------------------------------------------------------------------
 # Constant
@@ -285,7 +283,7 @@ async def open_pyusb_transport(spec: str) -> Transport:
         try:
             device = await _power_cycle(device)  # type: ignore
         except Exception as e:
-            logging.debug(e)
+            logging.debug(e, stack_info=True)
             logging.info(f"Unable to power cycle {hex(device.idVendor)} {hex(device.idProduct)}")  # type: ignore
 
     # Collect the metadata
@@ -371,9 +369,8 @@ async def _power_cycle(device: UsbDevice) -> UsbDevice:
 
             # Device needs to be find again otherwise it will appear as disconnected
             return usb.core.find(idVendor=device.idVendor, idProduct=device.idProduct)  # type: ignore
-        except USBError as e:
-            logger.error(f"Adjustment needed: Please revise the udev rule for device {hex(device.idVendor)}:{hex(device.idProduct)} for proper recognition.")  # type: ignore
-            logger.error(e)
+        except USBError:
+            logger.exception(f"Adjustment needed: Please revise the udev rule for device {hex(device.idVendor)}:{hex(device.idProduct)} for proper recognition.")  # type: ignore
 
     return device
 

bumble/transport/serial.py

@@ -17,9 +17,10 @@
 # -----------------------------------------------------------------------------
 import asyncio
 import logging
+
 import serial_asyncio
 
-from bumble.transport.common import Transport, StreamPacketSource, StreamPacketSink
+from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/transport/tcp_client.py

@@ -18,7 +18,7 @@
 import asyncio
 import logging
 
-from bumble.transport.common import Transport, StreamPacketSource, StreamPacketSink
+from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -41,7 +41,7 @@ async def open_tcp_client_transport(spec: str) -> Transport:
             logger.debug(f'connection lost: {exc}')
             self.on_transport_lost()
 
-    remote_host, remote_port = spec.split(':')
+    remote_host, remote_port = spec.rsplit(':', maxsplit=1)
     tcp_transport, packet_source = await asyncio.get_running_loop().create_connection(
         TcpPacketSource,
         host=remote_host,

bumble/transport/tcp_server.py

@@ -16,11 +16,12 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+
 import asyncio
 import logging
 import socket
 
-from bumble.transport.common import Transport, StreamPacketSource
+from bumble.transport.common import StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -29,13 +30,6 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-
-
-# A pass-through function to ease mock testing.
-async def _create_server(*args, **kw_args):
-    await asyncio.get_running_loop().create_server(*args, **kw_args)
-
-
 async def open_tcp_server_transport(spec: str) -> Transport:
     '''
     Open a TCP server transport.
@@ -46,13 +40,15 @@ async def open_tcp_server_transport(spec: str) -> Transport:
 
     Example: _:9001
     '''
-    local_host, local_port = spec.split(':')
+    local_host, local_port = spec.rsplit(':', maxsplit=1)
     return await _open_tcp_server_transport_impl(
         host=local_host if local_host != '_' else None, port=int(local_port)
     )
 
 
-async def open_tcp_server_transport_with_socket(sock: socket.socket) -> Transport:
+async def open_tcp_server_transport_with_socket(
+    sock: socket.socket,
+) -> Transport:
     '''
     Open a TCP server transport with an existing socket.
 
@@ -63,8 +59,9 @@ async def open_tcp_server_transport_with_socket(sock: socket.socket) -> Transpor
 
 async def _open_tcp_server_transport_impl(**kwargs) -> Transport:
     class TcpServerTransport(Transport):
-        async def close(self):
-            await super().close()
+        def __init__(self, source, sink, server):
+            self.server = server
+            super().__init__(source, sink)
 
     class TcpServerProtocol(asyncio.BaseProtocol):
         def __init__(self, packet_source, packet_sink):
@@ -102,8 +99,8 @@ async def _open_tcp_server_transport_impl(**kwargs) -> Transport:
 
     packet_source = StreamPacketSource()
     packet_sink = TcpServerPacketSink()
-    await _create_server(
+    server = await asyncio.get_running_loop().create_server(
         lambda: TcpServerProtocol(packet_source, packet_sink), **kwargs
     )
 
-    return TcpServerTransport(packet_source, packet_sink)
+    return TcpServerTransport(packet_source, packet_sink, server)

bumble/transport/udp.py

@@ -18,7 +18,7 @@
 import asyncio
 import logging
 
-from bumble.transport.common import Transport, ParserSource
+from bumble.transport.common import ParserSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -51,8 +51,8 @@ async def open_udp_transport(spec: str) -> Transport:
             self.transport.close()
 
     local, remote = spec.split(',')
-    local_host, local_port = local.split(':')
-    remote_host, remote_port = remote.split(':')
+    local_host, local_port = local.rsplit(':', maxsplit=1)
+    remote_host, remote_port = remote.rsplit(':', maxsplit=1)
     (
         udp_transport,
         packet_source,

bumble/transport/unix.py

@@ -18,7 +18,7 @@
 import asyncio
 import logging
 
-from bumble.transport.common import Transport, StreamPacketSource, StreamPacketSink
+from bumble.transport.common import StreamPacketSink, StreamPacketSource, Transport
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -54,3 +54,69 @@ async def open_unix_client_transport(spec: str) -> Transport:
     packet_sink = StreamPacketSink(unix_transport)
 
     return Transport(packet_source, packet_sink)
+
+
+# -----------------------------------------------------------------------------
+async def open_unix_server_transport(spec: str) -> Transport:
+    '''Open a UNIX socket server transport.
+
+    The parameter is the path of unix socket. For abstract socket, the first character
+    needs to be '@'.
+
+    Example:
+        * /tmp/hci.socket
+        * @hci_socket
+    '''
+    # For abstract socket, the first character should be null character.
+    if spec.startswith('@'):
+        spec = '\0' + spec[1:]
+
+    class UnixServerTransport(Transport):
+        def __init__(self, source, sink, server):
+            self.server = server
+            super().__init__(source, sink)
+
+        async def close(self):
+            await super().close()
+
+    class UnixServerProtocol(asyncio.BaseProtocol):
+        def __init__(self, packet_source, packet_sink):
+            self.packet_source = packet_source
+            self.packet_sink = packet_sink
+
+        # Called when a new connection is established
+        def connection_made(self, transport):
+            peer_name = transport.get_extra_info('peer_name')
+            logger.debug('connection from %s', peer_name)
+            self.packet_sink.transport = transport
+
+        # Called when the client is disconnected
+        def connection_lost(self, error):
+            logger.debug('connection lost: %s', error)
+            self.packet_sink.transport = None
+
+        def eof_received(self):
+            logger.debug('connection end')
+            self.packet_sink.transport = None
+
+        # Called when data is received on the socket
+        def data_received(self, data):
+            self.packet_source.data_received(data)
+
+    class UnixServerPacketSink:
+        def __init__(self):
+            self.transport = None
+
+        def on_packet(self, packet):
+            if self.transport:
+                self.transport.write(packet)
+            else:
+                logger.debug('no client, dropping packet')
+
+    packet_source = StreamPacketSource()
+    packet_sink = UnixServerPacketSink()
+    server = await asyncio.get_running_loop().create_unix_server(
+        lambda: UnixServerProtocol(packet_source, packet_sink), spec
+    )
+
+    return UnixServerTransport(packet_source, packet_sink, server)