Broadcast to all IPv4 subnets for UDP discovery

Replace single IPAddress.Broadcast send with per-interface IPv4 subnet broadcasts to avoid route-selection issues on multi-interface hosts. Added GetBroadcastEndpoints and ComputeBroadcastAddress to compute per-unicast broadcast addresses (skips loopback/tunnel interfaces and non-IPv4 addresses) and fall back to IPAddress.Broadcast if none found. Also handle socket errors for unreachable routes and added NetworkInterface usage.

Author: mrdevrobot

src/EntglDb.Network/UdpDiscoveryService.cs

@@ -1,40 +1,41 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Net.Sockets;
-using System.Text;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
-using EntglDb.Core.Network;
-
-namespace EntglDb.Network;
-
-/// <summary>
-/// Provides UDP-based peer discovery for the EntglDb network.
-/// Broadcasts presence beacons and listens for other nodes on the local network.
-/// </summary>
-internal class UdpDiscoveryService : IDiscoveryService
-{
-    private const int DiscoveryPort = 25000;
-    private readonly ILogger<UdpDiscoveryService> _logger;
-    private readonly IPeerNodeConfigurationProvider _configProvider;
-    private readonly ILocalInterestsProvider? _localInterests;
-    private CancellationTokenSource? _cts;
-    private readonly ConcurrentDictionary<string, PeerNode> _activePeers = new();
-    private readonly object _startStopLock = new object();
-
-    public UdpDiscoveryService(
-        IPeerNodeConfigurationProvider peerNodeConfigurationProvider,
-        ILogger<UdpDiscoveryService> logger,
-        ILocalInterestsProvider? localInterests = null)
-    {
-        _configProvider = peerNodeConfigurationProvider ?? throw new ArgumentNullException(nameof(peerNodeConfigurationProvider));
-        _localInterests = localInterests;
-        _logger = logger;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using EntglDb.Core.Network;
+
+namespace EntglDb.Network;
+
+/// <summary>
+/// Provides UDP-based peer discovery for the EntglDb network.
+/// Broadcasts presence beacons and listens for other nodes on the local network.
+/// </summary>
+internal class UdpDiscoveryService : IDiscoveryService
+{
+    private const int DiscoveryPort = 25000;
+    private readonly ILogger<UdpDiscoveryService> _logger;
+    private readonly IPeerNodeConfigurationProvider _configProvider;
+    private readonly ILocalInterestsProvider? _localInterests;
+    private CancellationTokenSource? _cts;
+    private readonly ConcurrentDictionary<string, PeerNode> _activePeers = new();
+    private readonly object _startStopLock = new object();
+
+    public UdpDiscoveryService(
+        IPeerNodeConfigurationProvider peerNodeConfigurationProvider,
+        ILogger<UdpDiscoveryService> logger,
+        ILocalInterestsProvider? localInterests = null)
+    {
+        _configProvider = peerNodeConfigurationProvider ?? throw new ArgumentNullException(nameof(peerNodeConfigurationProvider));
+        _localInterests = localInterests;
+        _logger = logger;
     }
 
     /// <summary>
@@ -229,27 +230,37 @@ private async Task BroadcastAsync(CancellationToken token)
         using var udp = new UdpClient();
         udp.EnableBroadcast = true;
 
-        var endpoint = new IPEndPoint(IPAddress.Broadcast, DiscoveryPort);
-
         while (!token.IsCancellationRequested)
         {
             try
             {
                 // Re-fetch config each time in case it changes (though usually static)
                 var conf = await _configProvider.GetConfiguration();
 
-                var beacon = new DiscoveryBeacon 
-                { 
-                    NodeId = conf.NodeId, 
-                    TcpPort = conf.TcpPort,
-                    ClusterHash = ComputeClusterHash(conf.AuthToken),
-                    InterestingCollections = _localInterests?.InterestedCollection.ToList() ?? new List<string>()
+                var beacon = new DiscoveryBeacon 
+                { 
+                    NodeId = conf.NodeId, 
+                    TcpPort = conf.TcpPort,
+                    ClusterHash = ComputeClusterHash(conf.AuthToken),
+                    InterestingCollections = _localInterests?.InterestedCollection.ToList() ?? new List<string>()
                 };
 
                 var json = JsonSerializer.Serialize(beacon);
                 var bytes = Encoding.UTF8.GetBytes(json);
 
-                await udp.SendAsync(bytes, bytes.Length, endpoint);
+                // Broadcast on each active IPv4 subnet to avoid route selection issues on multi-interface hosts.
+                var endpoints = GetBroadcastEndpoints(DiscoveryPort);
+                foreach (var endpoint in endpoints)
+                {
+                    try
+                    {
+                        await udp.SendAsync(bytes, bytes.Length, endpoint);
+                    }
+                    catch (SocketException sex) when (sex.SocketErrorCode is SocketError.HostUnreachable or SocketError.NetworkUnreachable)
+                    {
+                        _logger.LogWarning(sex, "UDP Broadcast route unavailable for {Endpoint}", endpoint);
+                    }
+                }
             }
             catch (Exception ex)
             {
@@ -260,6 +271,73 @@ private async Task BroadcastAsync(CancellationToken token)
         }
     }
 
+    private static IEnumerable<IPEndPoint> GetBroadcastEndpoints(int port)
+    {
+        var endpoints = new HashSet<IPAddress>();
+
+        foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
+        {
+            if (nic.OperationalStatus != OperationalStatus.Up)
+            {
+                continue;
+            }
+
+            if (nic.NetworkInterfaceType is NetworkInterfaceType.Loopback or NetworkInterfaceType.Tunnel)
+            {
+                continue;
+            }
+
+            IPInterfaceProperties? properties;
+            try
+            {
+                properties = nic.GetIPProperties();
+            }
+            catch
+            {
+                continue;
+            }
+
+            foreach (var unicast in properties.UnicastAddresses)
+            {
+                var ip = unicast.Address;
+                var mask = unicast.IPv4Mask;
+
+                if (ip.AddressFamily != AddressFamily.InterNetwork || mask == null)
+                {
+                    continue;
+                }
+
+                if (IPAddress.IsLoopback(ip) || ip.Equals(IPAddress.Any))
+                {
+                    continue;
+                }
+
+                endpoints.Add(ComputeBroadcastAddress(ip, mask));
+            }
+        }
+
+        if (endpoints.Count == 0)
+        {
+            endpoints.Add(IPAddress.Broadcast);
+        }
+
+        return endpoints.Select(address => new IPEndPoint(address, port));
+    }
+
+    private static IPAddress ComputeBroadcastAddress(IPAddress address, IPAddress mask)
+    {
+        var ipBytes = address.GetAddressBytes();
+        var maskBytes = mask.GetAddressBytes();
+        var broadcastBytes = new byte[ipBytes.Length];
+
+        for (var i = 0; i < ipBytes.Length; i++)
+        {
+            broadcastBytes[i] = (byte)(ipBytes[i] | (~maskBytes[i] & 0xFF));
+        }
+
+        return new IPAddress(broadcastBytes);
+    }
+
     private string ComputeClusterHash(string authToken)
     {
         if (string.IsNullOrEmpty(authToken)) return "";