casambi-bt-revamped 0.3.12.dev3__py3-none-any.whl → 0.3.12.dev5__py3-none-any.whl

CasambiBt/_client.py

@@ -100,6 +100,8 @@ class CasambiClient:
         # Determined at runtime by inspecting GATT services/characteristics.
         self._protocolMode: ProtocolMode | None = None
         self._dataCharUuid: str | None = None
+        # EVO only: protocolVersion from the device-provided NodeInfo (byte1).
+        self._deviceProtocolVersion: int | None = None
 
         # Classic protocol state
         self._classicConnHash8: bytes | None = None
@@ -119,14 +121,29 @@ class CasambiClient:
     def protocolMode(self) -> ProtocolMode | None:
         return self._protocolMode
 
-    def _checkProtocolVersion(self, version: int) -> None:
+    def _checkProtocolVersion(self, version: int, *, source: str = "unknown") -> None:
+        strict = os.getenv("CASAMBI_BT_STRICT_PROTOCOL_VERSION", "").strip() in {
+            "1",
+            "true",
+            "TRUE",
+            "yes",
+            "YES",
+        }
         if version < MIN_VERSION:
-            raise UnsupportedProtocolVersion(
-                f"Legacy version aren't supported currently. Your network version is {version}. Minimum version is {MIN_VERSION}."
+            # Legacy protocol versions are intentionally allowed. We keep this check as a warning
+            # because packet layouts/handshakes may differ and we want actionable tester logs.
+            msg = (
+                f"Legacy protocol version detected ({source}={version}). "
+                f"Versions < {MIN_VERSION} are not fully verified; attempting to continue."
             )
+            if strict:
+                raise UnsupportedProtocolVersion(msg)
+            self._logger.warning(msg)
+            return
         if version > MAX_VERSION:
             self._logger.warning(
-                "Version too new. Your network version is %i. Highest supported version is %i. Continue at your own risk.",
+                "Version too new (%s=%i). Highest supported version is %i. Continue at your own risk.",
+                source,
                 version,
                 MAX_VERSION,
             )
@@ -207,19 +224,57 @@ class CasambiClient:
         self._logger.info(f"Connected to {self.address}")
         self._connectionState = ConnectionState.CONNECTED
 
-        # Detect protocol mode by available characteristics.
-        services = await self._gattClient.get_services()
+        # Detect protocol mode.
+        #
+        # Important: Home Assistant wraps BleakClient (HaBleakClientWrapper) which does not implement
+        # `get_services()`. Therefore we use "try-read" probing instead of enumerating GATT services.
+        #
+        # Order:
+        #  1) Classic "non-conformant": CA51 (hash) + CA52 (data channel)
+        #  2) EVO: auth char read starts with 0x01 (NodeInfo)
+        #  3) Classic "conformant": auth char read returns connection hash (first 8 bytes used)
+
+        cloud_protocol = getattr(self._network, "protocolVersion", None)
+        ca51_prefix: bytes | None = None
+        ca51_err: str | None = None
+        auth_prefix: bytes | None = None
+        auth_err: str | None = None
+        device_nodeinfo_protocol: int | None = None
+
+        def _log_probe_summary(mode: str) -> None:
+            # One stable, high-signal line for testers.
+            self._logger.info(
+                "[CASAMBI_PROTOCOL_PROBE] address=%s mode=%s cloud_protocol=%s device_nodeinfo_protocol=%s "
+                "data_uuid=%s classic_hash8_present=%s auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s",
+                self.address,
+                mode,
+                cloud_protocol,
+                device_nodeinfo_protocol,
+                self._dataCharUuid,
+                bool(classic_hash and len(classic_hash) >= 8),
+                auth_prefix,
+                ca51_prefix,
+                ca51_err,
+                auth_err,
+            )
 
-        def _has_char(uuid: str) -> bool:
-            uuid_l = uuid.lower()
-            for s in services:
-                for c in s.characteristics:
-                    if c.uuid.lower() == uuid_l:
-                        return True
-            return False
+        classic_hash: bytes | None = None
+        try:
+            classic_hash = await self._gattClient.read_gatt_char(CASA_CLASSIC_HASH_CHAR_UUID)
+            ca51_prefix = b2a(classic_hash[:10]) if classic_hash else None
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_GATT_PROBE] read ca51 ok len=%d prefix=%s",
+                    0 if classic_hash is None else len(classic_hash),
+                    ca51_prefix,
+                )
+        except Exception as e:
+            classic_hash = None
+            ca51_err = type(e).__name__
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] read ca51 fail err=%s", ca51_err)
 
-        # Classic (non-conformant) uses CA51 (connection hash) + CA52 (data channel).
-        if _has_char(CASA_CLASSIC_HASH_CHAR_UUID) and _has_char(CASA_CLASSIC_DATA_CHAR_UUID):
+        if classic_hash and len(classic_hash) >= 8:
             if os.getenv("CASAMBI_BT_DISABLE_CLASSIC", "").strip() in {"1", "true", "TRUE", "yes", "YES"}:
                 raise ProtocolError("Classic protocol detected but disabled via CASAMBI_BT_DISABLE_CLASSIC=1")
 
@@ -232,7 +287,7 @@ class CasambiClient:
             self._dataCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
 
             # Read connection hash (first 8 bytes are used for CMAC signing).
-            raw_hash = await self._gattClient.read_gatt_char(CASA_CLASSIC_HASH_CHAR_UUID)
+            raw_hash = classic_hash
             if raw_hash is None or len(raw_hash) < 8:
                 raise ClassicHandshakeError(
                     f"Classic connection hash read failed/too short (len={0 if raw_hash is None else len(raw_hash)})."
@@ -247,34 +302,105 @@ class CasambiClient:
             notify_params = inspect.signature(self._gattClient.start_notify).parameters
             if "bluez" in notify_params:
                 notify_kwargs["bluez"] = {"use_start_notify": True}
-            await self._gattClient.start_notify(
-                CASA_CLASSIC_DATA_CHAR_UUID,
-                self._queueCallback,
-                **notify_kwargs,
-            )
+            try:
+                await self._gattClient.start_notify(
+                    CASA_CLASSIC_DATA_CHAR_UUID,
+                    self._queueCallback,
+                    **notify_kwargs,
+                )
+            except Exception as e:
+                # Some firmwares may expose Classic signing on the EVO UUID instead.
+                # Fall through to auth-char probing if CA52 isn't available.
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] start_notify ca52 fail err=%s; trying auth UUID probing.",
+                        type(e).__name__,
+                        exc_info=True,
+                    )
+                self._protocolMode = None
+                self._dataCharUuid = None
+                self._classicConnHash8 = None
+                # continue detection below
+            else:
+                # Classic has no EVO-style key exchange/auth; we can send immediately.
+                self._connectionState = ConnectionState.AUTHENTICATED
+                self._logger.info("Protocol mode selected: CLASSIC")
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug("[CASAMBI_GATT_PROBE] start_notify ca52 ok")
+                    self._logger.debug(
+                        "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
+                        len(self._classicConnHash8),
+                        b2a(self._classicConnHash8),
+                    )
+                _log_probe_summary("CLASSIC")
+                return
 
-            # Classic has no EVO-style key exchange/auth; we can send immediately.
-            self._connectionState = ConnectionState.AUTHENTICATED
-            self._logger.info("Protocol mode selected: CLASSIC")
+        # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
+        first: bytes | None = None
+        try:
+            first = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
+            auth_prefix = b2a(first[:10]) if first else None
             if self._logger.isEnabledFor(logging.DEBUG):
                 self._logger.debug(
-                    "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
-                    len(self._classicConnHash8),
-                    b2a(self._classicConnHash8),
+                    "[CASAMBI_GATT_PROBE] read auth ok len=%d first_byte=%s prefix=%s",
+                    0 if first is None else len(first),
+                    None if not first else f"0x{first[0]:02x}",
+                    auth_prefix,
                 )
-            return
+        except Exception as e:
+            first = None
+            auth_err = type(e).__name__
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] read auth fail err=%s", auth_err)
+
+        if first and len(first) >= 2 and first[0] == 0x01:
+            # EVO NodeInfo packet starts with 0x01.
+            device_nodeinfo_protocol = first[1]
+            self._deviceProtocolVersion = device_nodeinfo_protocol
+            mtu = unit = flags = None
+            nonce_prefix = None
+            if len(first) >= 23:
+                try:
+                    mtu, unit, flags, nonce = struct.unpack_from(">BHH16s", first, 2)
+                    nonce_prefix = b2a(nonce[:8])
+                except Exception:
+                    if self._logger.isEnabledFor(logging.DEBUG):
+                        self._logger.debug("Failed to parse NodeInfo fields for logging.", exc_info=True)
 
-        # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
-        if _has_char(CASA_AUTH_CHAR_UUID):
-            first = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
-            if first and len(first) >= 2 and first[0] == 0x01:
-                # EVO NodeInfo packet starts with 0x01.
-                self._protocolMode = ProtocolMode.EVO
-                self._dataCharUuid = CASA_AUTH_CHAR_UUID
-                self._checkProtocolVersion(self._network.protocolVersion)
-                self._logger.info("Protocol mode selected: EVO")
-                return
+            self._logger.info(
+                "[CASAMBI_EVO_NODEINFO] cloud_protocol=%s device_protocol=%s mtu=%s unit=%s flags=%s nonce_prefix=%s len=%d prefix=%s",
+                cloud_protocol,
+                device_nodeinfo_protocol,
+                mtu,
+                unit,
+                None if flags is None else f"0x{flags:04x}",
+                nonce_prefix,
+                len(first),
+                b2a(first[: min(len(first), 32)]),
+            )
+            if cloud_protocol is not None and device_nodeinfo_protocol != cloud_protocol:
+                self._logger.warning(
+                    "[CASAMBI_EVO_NODEINFO_MISMATCH] cloud_protocol=%s device_protocol=%s",
+                    cloud_protocol,
+                    device_nodeinfo_protocol,
+                )
+            if len(first) < 23:
+                self._logger.warning(
+                    "[CASAMBI_EVO_NODEINFO_SHORT] len=%d cloud_protocol=%s device_protocol=%s prefix=%s",
+                    len(first),
+                    cloud_protocol,
+                    device_nodeinfo_protocol,
+                    b2a(first[: min(len(first), 32)]),
+                )
+
+            self._protocolMode = ProtocolMode.EVO
+            self._dataCharUuid = CASA_AUTH_CHAR_UUID
+            self._checkProtocolVersion(device_nodeinfo_protocol, source="device_nodeinfo")
+            self._logger.info("Protocol mode selected: EVO")
+            _log_probe_summary("EVO")
+            return
 
+        if first is not None:
             # Otherwise, treat as Classic conformant: read provides connection hash.
             if os.getenv("CASAMBI_BT_DISABLE_CLASSIC", "").strip() in {"1", "true", "TRUE", "yes", "YES"}:
                 raise ProtocolError("Classic protocol detected but disabled via CASAMBI_BT_DISABLE_CLASSIC=1")
@@ -282,9 +408,9 @@ class CasambiClient:
                 raise ClassicKeysMissingError(
                     "Classic protocol detected but network has no visitorKey/managerKey."
                 )
-            if first is None or len(first) < 8:
+            if len(first) < 8:
                 raise ClassicHandshakeError(
-                    f"Classic connection hash read failed/too short (len={0 if first is None else len(first)})."
+                    f"Classic connection hash read failed/too short (len={len(first)})."
                 )
 
             self._protocolMode = ProtocolMode.CLASSIC
@@ -305,15 +431,17 @@ class CasambiClient:
             self._connectionState = ConnectionState.AUTHENTICATED
             self._logger.info("Protocol mode selected: CLASSIC")
             if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
                 self._logger.debug(
                     "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
                     len(self._classicConnHash8),
                     b2a(self._classicConnHash8),
                 )
+            _log_probe_summary("CLASSIC")
             return
 
         raise ProtocolError(
-            "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic conformant auth char)."
+            "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic-conformant auth char)."
         )
 
     def _on_disconnect(self, client: BleakClient) -> None:
@@ -333,15 +461,54 @@ class CasambiClient:
         try:
             # Initiate communication with device
             firstResp = await self._gattClient.read_gatt_char(CASA_AUTH_CHAR_UUID)
-            self._logger.debug(f"Got {b2a(firstResp)}")
+            if self._logger.isEnabledFor(logging.DEBUG):
+                self._logger.debug(
+                    "[CASAMBI_EVO_NODEINFO_RAW] len=%d prefix=%s",
+                    len(firstResp),
+                    b2a(firstResp[: min(len(firstResp), 32)]),
+                )
+
+            cloud_protocol = getattr(self._network, "protocolVersion", None)
+            expected_protocol = self._deviceProtocolVersion or cloud_protocol
+
+            # EVO key exchange expects the NodeInfo packet (0x01 ...).
+            if len(firstResp) < 2 or firstResp[0] != 0x01:
+                self._logger.error(
+                    "[CASAMBI_EVO_NODEINFO_UNEXPECTED] expected_prefix=01 len=%d prefix=%s",
+                    len(firstResp),
+                    b2a(firstResp[: min(len(firstResp), 32)]),
+                )
+                raise ProtocolError("Unexpected NodeInfo response while starting key exchange.")
+
+            device_protocol = firstResp[1]
+            self._deviceProtocolVersion = device_protocol
+            self._checkProtocolVersion(device_protocol, source="device_nodeinfo")
+
+            if expected_protocol is not None and device_protocol != expected_protocol:
+                self._logger.warning(
+                    "[CASAMBI_EVO_NODEINFO_MISMATCH] expected_protocol=%s cloud_protocol=%s device_protocol=%s",
+                    expected_protocol,
+                    cloud_protocol,
+                    device_protocol,
+                )
+            elif cloud_protocol is not None and device_protocol != cloud_protocol:
+                # Keep this separate to catch cloud/device mismatches even if we didn't have an expected protocol set.
+                self._logger.warning(
+                    "[CASAMBI_EVO_NODEINFO_MISMATCH] expected_protocol=%s cloud_protocol=%s device_protocol=%s",
+                    expected_protocol,
+                    cloud_protocol,
+                    device_protocol,
+                )
 
-            # Check type and protocol version
-            if not (
-                firstResp[0] == 0x1 and firstResp[1] == self._network.protocolVersion
-            ):
+            if len(firstResp) < 23:
                 self._logger.error(
-                    "Unexpected answer from device! Wrong device or protocol version? Trying to continue."
+                    "[CASAMBI_EVO_NODEINFO_SHORT] len=%d cloud_protocol=%s device_protocol=%s prefix=%s",
+                    len(firstResp),
+                    cloud_protocol,
+                    device_protocol,
+                    b2a(firstResp[: min(len(firstResp), 32)]),
                 )
+                raise ProtocolError("NodeInfo response too short while starting key exchange.")
 
             # Parse device info
             self._mtu, self._unit, self._flags, self._nonce = struct.unpack_from(

{casambi_bt_revamped-0.3.12.dev3.dist-info → casambi_bt_revamped-0.3.12.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev3
+Version: 0.3.12.dev5
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.12.dev3.dist-info → casambi_bt_revamped-0.3.12.dev5.dist-info}/RECORD

@@ -2,7 +2,7 @@ CasambiBt/__init__.py,sha256=TW445xSu5PV3TyMjJfwaA1JoWvQQ8LXhZgGdDTfWf3s,302
 CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
 CasambiBt/_casambi.py,sha256=TN4ecgjm95nSJ4h9TsKayNn577Y82fdsGK4IGUZF23Q,40666
 CasambiBt/_classic_crypto.py,sha256=6DcCOdjLQo7k2cOOutNdUKupykOG_E2TDDwg6fH-ODM,998
-CasambiBt/_client.py,sha256=nOOvs9qyQdc8D37DRejOY-15iTcSolK2EAlOOvpg_Xo,49990
+CasambiBt/_client.py,sha256=AASUN9OvmTIg9IeYMEvLI8kBEYbV9FapIuyDXGZMpME,57883
 CasambiBt/_constants.py,sha256=sbElg5W8eeQvvL1rHn_E0jhP1wOrrabc7dFLLnlDMsU,810
 CasambiBt/_discover.py,sha256=jLc6H69JddrCURgtANZEjws6_UbSzXJtvJkbKTaIUHY,1849
 CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
@@ -14,8 +14,8 @@ CasambiBt/_switch_events.py,sha256=S8OD0dBcw5T4J2C7qfmOQMnTJ7omIXRUYv4PqDOB87E,1
 CasambiBt/_unit.py,sha256=KIpvUT_Wm-O2Lmb1JVnNO625-j5j7GqufmZzfTR-jW0,18587
 CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
 CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.12.dev3.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.12.dev3.dist-info/METADATA,sha256=6oEPqnaAaaI5RZpDRNoquX7c9uHW742-J81FmPe1zNI,5877
-casambi_bt_revamped-0.3.12.dev3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-casambi_bt_revamped-0.3.12.dev3.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.12.dev3.dist-info/RECORD,,
+casambi_bt_revamped-0.3.12.dev5.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev5.dist-info/METADATA,sha256=mNRrJjPdZBbSvEJp9RBAYkv7wU0-znKwBhpR5XEXtLo,5877
+casambi_bt_revamped-0.3.12.dev5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev5.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev5.dist-info/RECORD,,