zigpy-zboss 2.0.0__tar.gz → 2.0.3__tar.gz

{zigpy_zboss-2.0.0/zigpy_zboss.egg-info → zigpy_zboss-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.0
+Version: 2.0.3
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/tests/test_uart.py

@@ -280,6 +280,42 @@ async def test_connection_lost(dummy_serial_conn, mocker, event_loop):
     assert (await conn_lost_fut) == exception
 
 
+@pytest.mark.asyncio
+async def test_connect_url_port_skips_path_check(mocker, event_loop):
+    """A URL-style port (``socket://``/``tcp://``) has no filesystem path.
+
+    ``connect()`` must not gate on ``os.path.exists`` for such ports, otherwise
+    it spins in the retry loop until the timeout and never opens the connection
+    (regression for ser2net bridges and native-TCP NCPs).
+    """
+    target_url = "socket://127.0.0.1:6638"
+
+    def create_serial_conn(loop, protocol_factory, url, *args, **kwargs):
+        assert url == target_url
+        fut = event_loop.create_future()
+        protocol = protocol_factory()
+        event_loop.add_writer = lambda *a, **k: None
+        event_loop.add_reader = lambda *a, **k: None
+        event_loop.remove_writer = lambda *a, **k: None
+        event_loop.remove_reader = lambda *a, **k: None
+        transport = mocker.Mock()
+        transport.serial = mocker.Mock()
+        protocol.connection_made(transport)
+        fut.set_result((transport, protocol))
+        return fut
+
+    mocker.patch("serialx.create_serial_connection", new=create_serial_conn)
+    # A socket:// path never exists on disk; the check must be skipped for it.
+    exists = mocker.patch("zigpy_zboss.uart.os.path.exists", return_value=False)
+
+    protocol = await zboss_uart.connect(
+        conf.SCHEMA_DEVICE({conf.CONF_DEVICE_PATH: target_url}), api=mocker.Mock()
+    )
+
+    assert protocol is not None
+    exists.assert_not_called()
+
+
 # ToFix: this is not testing the uart test_connection_made method
 # @pytest.mark.asyncio
 # async def test_connection_made(dummy_serial_conn, mocker):

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/zigpy_zboss/__init__.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 2
 MINOR_VERSION = 0
-PATCH_VERSION = 0
+PATCH_VERSION = 3
 
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"

zigpy_zboss-2.0.3/zigpy_zboss/tools/get_nwk_keys.py

@@ -0,0 +1,87 @@
+"""Probe the NCP's network keys.
+
+Reads the active network key(s) from the live stack via GetNwkKeys and, for
+contrast, attempts to read the ZB_NVRAM_COMMON_DATA dataset directly. Use this
+to confirm GetNwkKeys returns a usable key on your hardware - the COMMON_DATA
+NVRAM read is the one that intermittently fails with GENERIC/ERROR and leaves
+zigpy with a blank network key.
+
+Usage:
+    python -m zigpy_zboss.tools.get_nwk_keys [/dev/ttyACM0]
+"""
+import asyncio
+import sys
+
+import serialx
+
+from zigpy_zboss import commands as c
+from zigpy_zboss import types as t
+from zigpy_zboss.api import ZBOSS
+from zigpy_zboss.tools.config import get_config
+
+
+def _is_blank(key) -> bool:
+    """Return True if the key is unset (all 0x00 or all 0xFF) or missing."""
+    return key is None or key.serialize() in (b"\xff" * 16, b"\x00" * 16)
+
+
+async def get_nwk_keys(config):
+    """Print the NCP network keys and contrast with the NVRAM read."""
+    zboss = ZBOSS(config)
+    await zboss.connect()
+    try:
+        rsp = await zboss.request(c.NcpConfig.GetNwkKeys.Req(TSN=1))
+        print(f"GetNwkKeys status: {rsp.StatusCat} {rsp.StatusCode}")
+        for idx, (key, num) in enumerate(
+            (
+                (rsp.NwkKey1, rsp.KeyNumber1),
+                (rsp.NwkKey2, rsp.KeyNumber2),
+                (rsp.NwkKey3, rsp.KeyNumber3),
+            ),
+            start=1,
+        ):
+            tag = "blank" if _is_blank(key) else "REAL"
+            print(f"  NwkKey{idx} (seq {num}): {key}  [{tag}]")
+
+        usable = not _is_blank(rsp.NwkKey1)
+        print(
+            "\nVerdict: GetNwkKeys "
+            + (
+                "returns a usable network key - the fix will work."
+                if usable
+                else "did NOT return a usable key on this firmware."
+            )
+        )
+
+        # Contrast: the COMMON_DATA NVRAM read that intermittently fails.
+        nv = await zboss.request(
+            c.NcpConfig.ReadNVRAM.Req(
+                TSN=2, DatasetId=t.DatasetId.ZB_NVRAM_COMMON_DATA
+            )
+        )
+        print(
+            f"\nZB_NVRAM_COMMON_DATA read status: {nv.StatusCat} "
+            f"{nv.StatusCode}"
+            + ("  (OK)" if nv.StatusCode == 0 else "  (this is the failure)")
+        )
+    finally:
+        zboss.close()
+
+
+async def main(argv):
+    """Get config and print the NCP network keys."""
+    config = get_config(argv)
+
+    try:
+        await get_nwk_keys(config)
+    except serialx.SerialException as exc:
+        print(f"Failed to read NCP network keys! {exc}")
+    except RuntimeError as exc2:
+        print(
+            f"Failed to read NCP network keys! {exc2}\n"
+            "Power cycle the module and try again."
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/zigpy_zboss/uart.py

@@ -288,8 +288,14 @@ async def connect(config: conf.ConfigType, api) -> ZbossNcpProtocol:
     last_exc: OSError | None = None
     protocol = None
 
+    # URL-style ports (``socket://``, ``tcp://``, ``rfc2217://``, …) are not
+    # filesystem paths, so the local-device existence check below must be
+    # skipped for them; otherwise the loop spins until the timeout and the
+    # connection is never opened (e.g. ser2net or a native TCP NCP).
+    is_local_device = "://" not in port
+
     while loop.time() < deadline:
-        if not os.path.exists(port):
+        if is_local_device and not os.path.exists(port):
             await asyncio.sleep(CONNECT_OPEN_RETRY_DELAY)
             continue
 

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/zigpy_zboss/zigbee/application.py

@@ -87,7 +87,10 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
     async def start_network(self):
         """Start the network."""
-        if self.state.node_info.nwk is None:
+        if (
+            self.state.node_info.nwk in (None, t.NWK(0xFFFE))
+            or self.state.node_info.ieee in (None, t.EUI64.UNKNOWN)
+        ):
             await self.load_network_info()
 
         await self.start_without_formation()
@@ -447,10 +450,6 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
         self.state.network_info.security_level = 0x05
 
-        common = await self._api.nvram.read(
-            t_zboss.DatasetId.ZB_NVRAM_COMMON_DATA,
-            t_zboss.DSCommonData
-        )
         counters = await self._api.nvram.read(
             t_zboss.DatasetId.ZB_IB_COUNTERS,
             t_zboss.DSIbCounters
@@ -461,37 +460,39 @@ class ControllerApplication(zigpy.application.ControllerApplication):
         if counters is not None:
             tx_counter = counters.nib_counter
 
-        if common is not None:
-            self.state.network_info.network_key = zigpy.state.Key(
-                key=common.nwk_key,
-                tx_counter=tx_counter,
-                rx_counter=0,
-                seq=common.nwk_key_seq,
-                partner_ieee=self.state.node_info.ieee,
+        nwk_keys = await self._api.request(
+            c.NcpConfig.GetNwkKeys.Req(TSN=self.get_sequence()))
+        nwk_key = nwk_keys.NwkKey1
+        if (
+            nwk_keys.StatusCode != 0
+            or nwk_key is None
+            or nwk_key.serialize() in (b"\xff" * 16, b"\x00" * 16)
+        ):
+            raise zigpy.exceptions.ControllerException(
+                "NCP reports joined but GetNwkKeys returned no usable network "
+                f"key (status={nwk_keys.StatusCode}, NwkKey1={nwk_key}); "
+                "refusing to load a blank key."
             )
+        self.state.network_info.network_key = zigpy.state.Key(
+            key=nwk_key,
+            tx_counter=tx_counter,
+            rx_counter=0,
+            seq=nwk_keys.KeyNumber1,
+            partner_ieee=self.state.node_info.ieee,
+        )
 
-            if self.state.node_info.logical_type == \
-                    zdo_t.LogicalType.Coordinator:
-                self.state.network_info.tc_link_key = zigpy.state.Key(
-                    key=common.tc_standard_key,
-                    tx_counter=0,
-                    rx_counter=0,
-                    seq=0,
-                    partner_ieee=self.state.node_info.ieee,
-                )
-            else:
-                res = await self._api.request(
-                    c.NcpConfig.GetTrustCenterAddr.Req(
-                        TSN=self.get_sequence()))
-                self.state.network_info.tc_link_key = (
-                    zigpy.state.Key(
-                        key=None,
-                        tx_counter=0,
-                        rx_counter=0,
-                        seq=0,
-                        partner_ieee=res.TCIEEE,
-                    ),
-                )
+        # The coordinator is the trust centre, and ZBOSS always uses the
+        # standard global TC link key (ZigBeeAlliance09) - we never push a
+        # custom one. Set it explicitly rather than reading the flaky
+        # ZB_NVRAM_COMMON_DATA dataset (its only extra contribution was
+        # partner_ieee, which nothing compares against).
+        self.state.network_info.tc_link_key = zigpy.state.Key(
+            key=t.KeyData(zigpy.config.CONF_NWK_TC_LINK_KEY_DEFAULT),
+            tx_counter=0,
+            rx_counter=0,
+            seq=0,
+            partner_ieee=self.state.node_info.ieee,
+        )
 
         res = await self._api.request(
             c.NcpConfig.GetRxOnWhenIdle.Req(TSN=self.get_sequence()))

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/zigpy_zboss/zigbee/device.py

@@ -73,7 +73,7 @@ class ZbossZDO(ZigpyZDO):
             )
         )
         if res.StatusCode != 0:
-            return (res.StatusCode % 0xFF, dst_address, cluster)
+            return (res.StatusCode, dst_address, cluster)
 
         return (zdo_t.Status.SUCCESS, dst_address, cluster)
 
@@ -81,7 +81,7 @@ class ZbossZDO(ZigpyZDO):
         """Unbinding request."""
         if dst_address.addrmode == t.AddrMode.IEEE:
             addr_mode = t_zboss.BindAddrMode.IEEE
-            dst_eui64 = t.Addressing.IEEE
+            dst_eui64 = dst_address.ieee
         # ZBOSS does not support the NWK mode for binding
         elif dst_address.addrmode == t.AddrMode.NWK:
             self.log(
@@ -114,7 +114,7 @@ class ZbossZDO(ZigpyZDO):
             )
         )
         if res.StatusCode != 0:
-            return (res.StatusCode % 0xFF, dst_address, cluster)
+            return (res.StatusCode, dst_address, cluster)
 
         return (zdo_t.Status.SUCCESS, dst_address, cluster)
 

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3/zigpy_zboss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.0
+Version: 2.0.3
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.3}/zigpy_zboss.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ zigpy_zboss/tools/__init__.py
 zigpy_zboss/tools/config.py
 zigpy_zboss/tools/factory_reset_ncp.py
 zigpy_zboss/tools/get_ncp_version.py
+zigpy_zboss/tools/get_nwk_keys.py
 zigpy_zboss/tools/log2pcap.py
 zigpy_zboss/types/__init__.py
 zigpy_zboss/types/basic.py