Add individual address to gateway descriptor and set the source address of outgoing telegrams correctly (#788)

Author: marvin-w

test/io_tests/gateway_scanner_test.py

@@ -47,6 +47,7 @@ class TestGatewayScanner:
         local_ip="192.168.42.50",
         supports_tunnelling=True,
         supports_routing=True,
+        individual_address=IndividualAddress("1.1.0"),
     )
     gateway_desc_neither = GatewayDescriptor(
         name="AC/S 1.1.1 Application Control",
@@ -152,10 +153,31 @@ def test_search_response_reception(self):
 
         assert gateway_scanner.found_gateways == []
         gateway_scanner._response_rec_callback(
-            test_search_response, udp_client_mock, interface="en1"
+            test_search_response,
+            udp_client_mock,
+            interface="en1",
+            netmask="255.255.255.0",
         )
         assert str(gateway_scanner.found_gateways[0]) == str(self.gateway_desc_both)
 
+    def test_search_response_wrong_network(self):
+        """Test function of gateway scanner when network iface doesnt match search response."""
+        xknx = XKNX()
+        gateway_scanner = GatewayScanner(xknx)
+        test_search_response = fake_router_search_response(xknx)
+        udp_client_mock = create_autospec(UDPClient)
+        udp_client_mock.local_addr = ("192.168.100.50", 0)
+        udp_client_mock.getsockname.return_value = ("192.168.100.50", 0)
+
+        assert gateway_scanner.found_gateways == []
+        gateway_scanner._response_rec_callback(
+            test_search_response,
+            udp_client_mock,
+            interface="en1",
+            netmask="255.255.255.0",
+        )
+        assert gateway_scanner.found_gateways == []
+
     @patch("xknx.io.gateway_scanner.netifaces", autospec=True)
     async def test_scan_timeout(self, netifaces_mock):
         """Test gateway scanner timeout."""
@@ -192,8 +214,8 @@ async def async_none():
 
         assert _search_interface_mock.call_count == 2
         expected_calls = [
-            ((gateway_scanner, "lo0", "127.0.0.1"),),
-            ((gateway_scanner, "en1", "10.1.1.2"),),
+            ((gateway_scanner, "lo0", "127.0.0.1", "255.0.0.0"),),
+            ((gateway_scanner, "en1", "10.1.1.2", "255.255.255.0"),),
         ]
         assert _search_interface_mock.call_args_list == expected_calls
         assert test_scan == []

test/str_test.py

@@ -664,11 +664,9 @@ def test_gateway_descriptor(self):
             local_ip="192.168.2.50",
             supports_tunnelling=True,
             supports_routing=False,
+            individual_address=IndividualAddress("1.1.1"),
         )
-        assert (
-            str(gateway_descriptor)
-            == '<GatewayDescriptor name="KNX-Interface" addr="192.168.2.3:1234" local="192.168.2.50@en1" routing="False" tunnelling="True" />'
-        )
+        assert str(gateway_descriptor) == "1.1.1 - KNX-Interface @ 192.168.2.3:1234"
 
     #
     # Routing Indication

xknx/core/payload_reader.py

@@ -81,7 +81,11 @@ async def send(
     async def send_telegram(self, payload: APCI) -> None:
         """Send the telegram."""
         await self.xknx.telegrams.put(
-            Telegram(destination_address=self.address, payload=payload)
+            Telegram(
+                destination_address=self.address,
+                payload=payload,
+                source_address=self.xknx.current_address,
+            )
         )
 
     async def telegram_received(

xknx/core/value_reader.py

@@ -70,7 +70,9 @@ async def read(self) -> Telegram | None:
     async def send_group_read(self) -> None:
         """Send group read."""
         telegram = Telegram(
-            destination_address=self.group_address, payload=GroupValueRead()
+            destination_address=self.group_address,
+            payload=GroupValueRead(),
+            source_address=self.xknx.current_address,
         )
         await self.xknx.telegrams.put(telegram)
 

xknx/io/__init__.py

@@ -9,7 +9,7 @@
 # flake8: noqa
 from .connection import ConnectionConfig, ConnectionType
 from .const import DEFAULT_MCAST_GRP, DEFAULT_MCAST_PORT
-from .gateway_scanner import GatewayScanFilter, GatewayScanner
+from .gateway_scanner import GatewayDescriptor, GatewayScanFilter, GatewayScanner
 from .knxip_interface import KNXIPInterface
 from .routing import Routing
 from .tunnel import Tunnel

xknx/io/gateway_scanner.py

@@ -9,19 +9,22 @@
 
 import asyncio
 from functools import partial
+from ipaddress import IPv4Address, IPv4Network
 import logging
 from typing import TYPE_CHECKING
 
 import netifaces
 from xknx.knxip import (
     HPAI,
+    DIBDeviceInformation,
     DIBServiceFamily,
     DIBSuppSVCFamilies,
     KNXIPFrame,
     KNXIPServiceType,
     SearchRequest,
     SearchResponse,
 )
+from xknx.telegram import IndividualAddress
 
 from .udp_client import UDPClient
 
@@ -43,6 +46,7 @@ def __init__(
         local_ip: str,
         supports_tunnelling: bool = False,
         supports_routing: bool = False,
+        individual_address: IndividualAddress | None = None,
     ):
         """Initialize GatewayDescriptor class."""
         self.name = name
@@ -52,16 +56,11 @@ def __init__(
         self.local_ip = local_ip
         self.supports_routing = supports_routing
         self.supports_tunnelling = supports_tunnelling
+        self.individual_address = individual_address
 
     def __str__(self) -> str:
         """Return object as readable string."""
-        return (
-            f'<GatewayDescriptor name="{self.name}" '
-            f'addr="{self.ip_addr}:{self.port}" '
-            f'local="{self.local_ip}@{self.local_interface}" '
-            f'routing="{self.supports_routing}" '
-            f'tunnelling="{self.supports_tunnelling}" />'
-        )
+        return f"{self.individual_address} - {self.name} @ {self.ip_addr}:{self.port}"
 
 
 class GatewayScanFilter:
@@ -146,12 +145,15 @@ async def _send_search_requests(self) -> None:
             try:
                 af_inet = netifaces.ifaddresses(interface)[netifaces.AF_INET]
                 ip_addr = af_inet[0]["addr"]
-                await self._search_interface(interface, ip_addr)
+                netmask = af_inet[0]["netmask"]
+                await self._search_interface(interface, ip_addr, netmask)
             except KeyError:
                 logger.info("Could not connect to an KNX/IP device on %s", interface)
                 continue
 
-    async def _search_interface(self, interface: str, ip_addr: str) -> None:
+    async def _search_interface(
+        self, interface: str, ip_addr: str, netmask: str
+    ) -> None:
         """Send a search request on a specific interface."""
         logger.debug("Searching on %s / %s", interface, ip_addr)
 
@@ -163,7 +165,7 @@ async def _search_interface(self, interface: str, ip_addr: str) -> None:
         )
 
         udp_client.register_callback(
-            partial(self._response_rec_callback, interface=interface),
+            partial(self._response_rec_callback, interface=interface, netmask=netmask),
             [KNXIPServiceType.SEARCH_RESPONSE],
         )
         await udp_client.connect()
@@ -177,13 +179,25 @@ async def _search_interface(self, interface: str, ip_addr: str) -> None:
         udp_client.send(KNXIPFrame.init_from_body(search_request))
 
     def _response_rec_callback(
-        self, knx_ip_frame: KNXIPFrame, udp_client: UDPClient, interface: str = ""
+        self,
+        knx_ip_frame: KNXIPFrame,
+        udp_client: UDPClient,
+        interface: str = "",
+        netmask: str = "",
     ) -> None:
         """Verify and handle knxipframe. Callback from internal udpclient."""
         if not isinstance(knx_ip_frame.body, SearchResponse):
             logger.warning("Could not understand knxipframe")
             return
 
+        address: IPv4Address = IPv4Address(knx_ip_frame.body.control_endpoint.ip_addr)
+        network: IPv4Network = IPv4Network(
+            f"{udp_client.local_addr[0]}/{netmask}", False
+        )
+
+        if address not in network:
+            return
+
         gateway = GatewayDescriptor(
             name=knx_ip_frame.body.device_name,
             ip_addr=knx_ip_frame.body.control_endpoint.ip_addr,
@@ -202,6 +216,16 @@ def _response_rec_callback(
         except StopIteration:
             pass
 
+        try:
+            device_infos = next(
+                device_infos
+                for device_infos in knx_ip_frame.body.dibs
+                if isinstance(device_infos, DIBDeviceInformation)
+            )
+            gateway.individual_address = device_infos.individual_address
+        except StopIteration:
+            pass
+
         self._add_found_gateway(gateway)
 
     def _add_found_gateway(self, gateway: GatewayDescriptor) -> None:

xknx/io/tunnel.py

@@ -184,6 +184,7 @@ async def _connect_request(self) -> bool:
             self.communication_channel = connect.communication_channel
             # Use the individual address provided by the tunnelling server
             self._src_address = IndividualAddress(connect.identifier)
+            self.xknx.current_address = self._src_address
             logger.debug(
                 "Tunnel established communication_channel=%s, id=%s",
                 connect.communication_channel,

xknx/remote_value/remote_value.py

@@ -213,6 +213,7 @@ async def _send(
                     if response
                     else GroupValueWrite(payload)
                 ),
+                source_address=self.xknx.current_address,
             )
             await self.xknx.telegrams.put(telegram)
 

xknx/xknx.py

@@ -72,6 +72,7 @@ def __init__(
         self.connection_config = connection_config
         self.daemon_mode = daemon_mode
         self.version = VERSION
+        self.current_address = IndividualAddress(0)
 
         if log_directory is not None:
             self.setup_logging(log_directory)