Allow proxy HCI packets to Home Assistant Bluetooth stack

custom_components/ble_monitor/__init__.py

@@ -1,18 +1,20 @@
 """Passive BLE monitor integration."""
 import asyncio
 import copy
+import importlib
 import json
 import logging
+import struct
 from threading import Thread
 
 import aioblescan as aiobs
 import janus
 import voluptuous as vol
 from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
-from homeassistant.const import (CONF_DEVICES, CONF_DISCOVERY, CONF_MAC,
-                                 CONF_NAME, CONF_TEMPERATURE_UNIT,
+from homeassistant.const import (ATTR_DEVICE_ID, CONF_DEVICES, CONF_DISCOVERY,
+                                 CONF_MAC, CONF_NAME, CONF_TEMPERATURE_UNIT,
                                  CONF_UNIQUE_ID, EVENT_HOMEASSISTANT_STOP)
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, async_get_hass
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import device_registry, entity_registry
 from homeassistant.util import dt
@@ -29,7 +31,7 @@
                     CONF_DEVICE_TRACK, CONF_DEVICE_TRACKER_CONSIDER_HOME,
                     CONF_DEVICE_TRACKER_SCAN_INTERVAL, CONF_DEVICE_USE_MEDIAN,
                     CONF_GATEWAY_ID, CONF_HCI_INTERFACE, CONF_LOG_SPIKES,
-                    CONF_PACKET, CONF_PERIOD, CONF_REPORT_UNKNOWN,
+                    CONF_PACKET, CONF_PERIOD, CONF_PROXY, CONF_REPORT_UNKNOWN,
                     CONF_RESTORE_STATE, CONF_USE_MEDIAN, CONF_UUID,
                     CONFIG_IS_FLOW, DEFAULT_ACTIVE_SCAN, DEFAULT_BATT_ENTITIES,
                     DEFAULT_BT_AUTO_RESTART, DEFAULT_DEVICE_REPORT_UNKNOWN,
@@ -130,7 +132,9 @@
 SERVICE_PARSE_DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_PACKET): cv.string,
-        vol.Optional(CONF_GATEWAY_ID): cv.string
+        vol.Optional(ATTR_DEVICE_ID, default=None): cv.string,
+        vol.Optional(CONF_GATEWAY_ID, default=DOMAIN): cv.string,
+        vol.Optional(CONF_PROXY, default=False): cv.boolean
     }
 )
 
@@ -423,8 +427,10 @@ async def async_parse_data_service(hass: HomeAssistant, service_data):
     blemonitor: BLEmonitor = hass.data[DOMAIN]["blemonitor"]
     if blemonitor:
         blemonitor.dumpthread.process_hci_events(
-            bytes.fromhex(service_data["packet"]),
-            service_data[CONF_GATEWAY_ID] if CONF_GATEWAY_ID in service_data else DOMAIN
+            data=bytes.fromhex(service_data["packet"]),
+            device_id=service_data[ATTR_DEVICE_ID],
+            gateway_id=service_data[CONF_GATEWAY_ID],
+            proxy=service_data[CONF_PROXY]
         )
 
 
@@ -506,6 +512,11 @@ def __init__(self, config, dataqueue):
         self.report_unknown = False
         self.report_unknown_whitelist = []
         self.last_bt_reset = dt.now()
+        self.scanners = {}
+        try:
+            self.bluetooth = importlib.import_module("homeassistant.components.bluetooth")
+        except ImportError:
+            self.bluetooth = None
         if self.config[CONF_REPORT_UNKNOWN]:
             if self.config[CONF_REPORT_UNKNOWN] != "Off":
                 self.report_unknown = self.config[CONF_REPORT_UNKNOWN]
@@ -578,11 +589,118 @@ def __init__(self, config, dataqueue):
             aeskeys=self.aeskeys,
         )
 
-    def process_hci_events(self, data, gateway_id=DOMAIN):
+    def hci_packet_on_advertisement(self, scanner, packet):
+        def _format_uuid(uuid: bytes) -> str:
+            if len(uuid) == 2 or len(uuid) == 4:
+                return "{:08x}-0000-1000-8000-00805f9b34fb".format(
+                    struct.unpack('<H' if len(uuid) == 2 else '<I', bytes(uuid))[0]
+                )
+            elif len(uuid) == 16:
+                reversed_uuid = uuid[::-1]
+                return '-'.join([
+                    ''.join(format(x, '02x') for x in reversed_uuid[:4]),
+                    ''.join(format(x, '02x') for x in reversed_uuid[4:6]),
+                    ''.join(format(x, '02x') for x in reversed_uuid[6:8]),
+                    ''.join(format(x, '02x') for x in reversed_uuid[8:10]),
+                    ''.join(format(x, '02x') for x in reversed_uuid[10:])
+                ])
+            else:
+                raise Exception(f"Wrong UUID size {len(uuid)}")
+
+        packet_size = packet[2] + 3
+        is_ext_packet = packet[3] == 0x0D
+        if packet_size != len(packet):
+            raise Exception(f"Wrong packet size {packet_size}, expected {len(packet)}")
+        payload_start = 29 if is_ext_packet else 14
+        if payload_start > packet_size:
+            raise Exception(f"Wrong payload start index {payload_start}")
+        payload_size = packet[payload_start - 1]
+        payload_packet_size = payload_start + payload_size + (0 if is_ext_packet else 1)
+        if packet_size != payload_packet_size:
+            raise Exception(f"Wrong packet size {packet_size}, expected {payload_packet_size}")
+
+        tx_power = None
+        rssi = packet[18 if is_ext_packet else packet_size - 1]
+        if rssi < 128:
+            raise Exception(f"Positive RSSI {rssi}")
+        rssi -= 256
+
+        address_index = 8 if is_ext_packet else 7
+        address_type = packet[address_index - 1]
+        address = ':'.join(f'{i:02X}' for i in packet[address_index:address_index + 6][::-1])
+        local_name = None
+        service_uuids = []
+        service_data = {}
+        manufacturer_data = {}
+
+        while payload_size > 1:
+            record_size = packet[payload_start] + 1
+            if 1 < record_size <= payload_size:
+                record = packet[payload_start:payload_start + record_size]
+                if record[0] != record_size - 1:
+                    raise Exception(f"Wrong record size {record[0]}, expected {record_size - 1}")
+                record_type = record[1]
+                record = record[2:]
+                # Incomplete/Complete List of 16/32/128-bit Service Class UUIDs
+                if record_type in [0x02, 0x03, 0x04, 0x05, 0x06, 0x07]:
+                    service_uuids.append(_format_uuid(record))
+                # Shortened/Complete local name
+                elif record_type in [0x08, 0x09]:
+                    name = record.decode("utf-8", errors="replace")
+                    if local_name is None or len(name) > len(local_name):
+                        local_name = name
+                # TX Power
+                elif record_type == 0x0A:
+                    tx_power = record[0]
+                # Service Data of 16/32/128-bit UUID
+                elif record_type in [0x16, 0x20, 0x21]:
+                    record_type_sizes = {0x16: 2, 0x20: 4, 0x21: 16}
+                    uuid_size = record_type_sizes[record_type]
+                    if len(record) < uuid_size:
+                        raise Exception("Wrong service data 0x{:02X} size {}, expected {}".format(
+                            record_type, len(record), record_type_sizes[record_type]))
+                    service_data[_format_uuid(record[:uuid_size])] = record[uuid_size:]
+                # Manufacturer Specific Data
+                elif record_type == 0xFF:
+                    manufacturer_data[(record[1] << 8) | record[0]] = record[2:]
+            payload_size -= record_size
+            payload_start += record_size
+
+        scanner._async_on_advertisement(
+            address=address,
+            rssi=rssi,
+            local_name=local_name,
+            service_uuids=service_uuids,
+            service_data=service_data,
+            manufacturer_data=manufacturer_data,
+            tx_power=tx_power,
+            details={"address_type": address_type},
+            advertisement_monotonic_time=self.bluetooth.MONOTONIC_TIME(),
+        )
+
+    def process_hci_events(self, data, device_id=None, gateway_id=DOMAIN, proxy=False):
         """Parse HCI events."""
         self.evt_cnt += 1
         if len(data) < 12:
             return
+        if self.bluetooth is not None and proxy:
+            try:
+                scanner_name = device_id or gateway_id
+                scanner, _ = self.scanners.get(scanner_name, (None, None))
+                if not scanner:
+                    hass = async_get_hass()
+                    device = hass.data["device_registry"].devices.get(device_id) if device_id \
+                        else next((entry for entry in hass.data["device_registry"].devices.data.values()
+                                   if entry.name.lower() == gateway_id.lower()), None)
+                    source = next((connection[1] for connection in device.connections if
+                                   connection[0] in ["mac", "bluetooth"]), gateway_id) if device else gateway_id
+                    scanner = self.bluetooth.BaseHaRemoteScanner(source, gateway_id, None, False)
+                    self.scanners[scanner_name] = (scanner, [
+                        self.bluetooth.async_register_scanner(hass, scanner),
+                        scanner.async_setup()])
+                self.hci_packet_on_advertisement(scanner, data)
+            except Exception as e:
+                _LOGGER.error("%s: %s: %s", gateway_id, e, data.hex().upper())
         sensor_msg, tracker_msg = self.ble_parser.parse_raw_data(data)
         if sensor_msg:
             measurements = list(sensor_msg.keys())
@@ -736,6 +854,9 @@ def run(self):
             _LOGGER.debug("%i HCI events processed for previous period", self.evt_cnt)
             self.evt_cnt = 0
         self._event_loop.close()
+        for _, unload_callbacks in self.scanners.values():
+            for callback in unload_callbacks:
+                callback()
         _LOGGER.debug("HCIdump thread: Run finished")
 
     def join(self, timeout=10):

custom_components/ble_monitor/const.py

@@ -47,6 +47,7 @@
 CONF_DEVICE_DELETE_DEVICE = "delete device"
 CONF_PACKET = "packet"
 CONF_GATEWAY_ID = "gateway_id"
+CONF_PROXY = "proxy"
 CONF_UUID = "uuid"
 CONFIG_IS_FLOW = "is_flow"