DNS SERVER: Fixing IPV6 query answers which could fail in some cases by UDP interface issues

RELEASE-NOTES.md

@@ -1,6 +1,7 @@
-## 5.5.0
+## 5.5.1
 * Releasing JRE Docker Image Version
 * Enabling DPS to run on any JRE 21+
+* Fixing IPV6 query answers which could fail in some cases by UDP interface issues
 
 ## 5.3.0
 * Docker Solver: Specify Preferred Networks to use when solving container IP #662

gradle.properties

@@ -1 +1 @@
-version=5.5.0-snapshot
+version=5.5.1-snapshot

src/main/java/com/mageddo/dnsproxyserver/solver/stub/SolverStub.java

@@ -51,7 +51,7 @@ public Response handle(Message query) {
       log.debug("status=notSolved, hostname={}", hostname);
       return null;
     }
-    if (!foundIp.isVersionEqualsTo(questionType.toVersion())) {
+    if (!foundIp.versionIs(questionType.toVersion())) {
       log.debug("status=incompatibleIpAndQueryType, hostname={}, questionType={}", hostname,
           questionType
       );

src/main/java/com/mageddo/dnsproxyserver/utils/InetAddresses.java

@@ -2,10 +2,15 @@
 
 import java.net.InetSocketAddress;
 
+import com.mageddo.net.IP;
 import com.mageddo.net.IpAddr;
 
 public class InetAddresses {
 
+  public static InetSocketAddress toSocketAddress(IP ip, int port) {
+    return new InetSocketAddress(Ips.toAddress(ip), port);
+  }
+
   public static InetSocketAddress toSocketAddress(String ip, int port) {
     return new InetSocketAddress(Ips.toAddress(ip), port);
   }

src/main/java/com/mageddo/dnsproxyserver/utils/Ips.java

@@ -75,6 +75,18 @@ public static InetSocketAddress getAnyLocalAddress(int port) {
     return new InetSocketAddress(getAnyLocalAddress(), port);
   }
 
+  public static InetSocketAddress getAnyLocalIpv6Address(int port) {
+    return new InetSocketAddress(getAnyLocalIpv6Address(), port);
+  }
+
+  public static InetAddress getAnyLocalIpv6Address() {
+    try {
+      return InetAddress.getByAddress(new byte[16]);
+    } catch (UnknownHostException e) {
+      return null;
+    }
+  }
+
   public static boolean isIpv6(String v) {
     return StringUtils.trimToEmpty(v)
         .contains(":");

src/main/java/com/mageddo/dnsserver/Addresses.java

@@ -0,0 +1,38 @@
+package com.mageddo.dnsserver;
+
+import java.util.List;
+
+import com.mageddo.commons.Collections;
+import com.mageddo.net.IP;
+import com.mageddo.net.Networks;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class Addresses {
+
+  public static List<IP> findBindAddresses(IP address) {
+    try {
+      return mustFindBindAddresses(address);
+    } catch (Exception e) {
+      log.warn(
+          "status=couldNotFindBestBindAddresses, action=pleaseReportThat, using={}, msg={}",
+          address, e.getMessage(), e
+      );
+      return Collections.singletonList(address);
+    }
+  }
+
+  private static List<IP> mustFindBindAddresses(IP address) {
+    if (!address.isAnyLocal()) {
+      return Collections.singletonList(address);
+    }
+    if (address.versionIs(IP.Version.IPV6)) {
+      return Networks.findMachineIps();
+    }
+    return Collections.filter(
+        Networks.findMachineIps(),
+        ip -> ip.versionIs(address.version())
+    );
+  }
+}

src/main/java/com/mageddo/dnsserver/UDPServer.java

@@ -1,5 +1,6 @@
 package com.mageddo.dnsserver;
 
+import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.SocketAddress;
@@ -36,21 +37,25 @@ public void start() {
 
   private void start0() {
     try {
-      this.server = new DatagramSocket(this.address);
-      while (!server.isClosed()) {
+      this.server = this.createSocket();
+      while (!this.server.isClosed()) {
 
         final var datagram = new DatagramPacket(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
-        server.receive(datagram);
+        this.server.receive(datagram);
 
-        this.pool.submit(() -> this.handle(server, datagram));
+        this.pool.submit(() -> this.handle(this.server, datagram));
 
       }
     } catch (Exception e) {
-      log.error("status=dnsServerStartFailed, address={}, msg={}", address, e.getMessage(), e);
+      log.error("status=dnsServerStartFailed, address={}, msg={}", this.address, e.getMessage(), e);
       throw new RuntimeException(e);
     }
   }
 
+  private DatagramSocket createSocket() throws IOException {
+    return new DatagramSocket(this.address);
+  }
+
   void handle(DatagramSocket server, DatagramPacket datagram) {
     try {
       final var query = new Message(datagram.getData());

src/main/java/com/mageddo/dnsserver/UDPServerPool.java

@@ -1,15 +1,18 @@
 package com.mageddo.dnsserver;
 
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
+import com.mageddo.commons.Collections;
+import com.mageddo.dnsproxyserver.utils.InetAddresses;
 import com.mageddo.dnsproxyserver.utils.Ips;
+import com.mageddo.net.IP;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -23,15 +26,31 @@ public class UDPServerPool {
   private List<UDPServer> servers = new ArrayList<>();
 
   public void start(int port) {
-    this.servers = Collections.singletonList(
-        new UDPServer(Ips.getAnyLocalAddress(port), this.requestHandler));
+    final var addresses = this.buildAddressesToBind(port);
+    this.servers = Collections.map(
+        addresses,
+        address -> new UDPServer(address, this.requestHandler)
+    );
     this.servers.forEach(UDPServer::start);
-    final var addresses = this.servers
-        .stream()
-        .map(UDPServer::getAddress)
+    log.info("Starting UDP server, addresses={}", this.toString(addresses));
+  }
+
+  private List<InetSocketAddress> buildAddressesToBind(int port) {
+    final var bindIp = Ips.from(Ips.getAnyLocalIpv6Address());
+    return this.buildAddressesToBind(bindIp, port);
+  }
+
+  private List<InetSocketAddress> buildAddressesToBind(IP ip, int port) {
+    return Collections.map(
+        Addresses.findBindAddresses(ip),
+        it -> InetAddresses.toSocketAddress(it, port)
+    );
+  }
+
+  private String toString(List<InetSocketAddress> addresses) {
+    return addresses.stream()
         .map(SocketAddress::toString)
         .collect(Collectors.joining(", "));
-    log.info("Starting UDP server, addresses={}", addresses);
   }
 
   public void stop() {

src/main/java/com/mageddo/net/IP.java

@@ -35,9 +35,11 @@ static List<IP> listOf(String... ips) {
 
   boolean isLoopback();
 
+  boolean isAnyLocal();
+
   boolean notEqualTo(String ip);
 
-  default boolean isVersionEqualsTo(Version version) {
+  default boolean versionIs(Version version) {
     return this.version()
         .equals(version);
   }

src/main/java/com/mageddo/net/IpImpl.java

@@ -84,6 +84,11 @@ public boolean isLoopback() {
     return this.ip.isLoopbackAddress();
   }
 
+  @Override
+  public boolean isAnyLocal() {
+    return this.ip.isAnyLocalAddress();
+  }
+
   @Override
   public boolean notEqualTo(String ip) {
     return !Objects.equals(this, IP.of(ip));

src/main/java/com/mageddo/net/Networks.java

@@ -41,11 +41,11 @@ public static IP findCurrentMachineIP(IP.Version version) {
   /**
    * The "relevance" is understood as the IP which have most chances of represent the real
    * hardware network interface,
-   * we say "most chances" beucase java api haven't deterministic information on that.
+   * we say "most chances" because java api haven't deterministic information on that.
    *
    * @return Machine ips ordered by relevance.
    */
-  static List<IP> findMachineIps() {
+  public static List<IP> findMachineIps() {
     return findInterfaces()
         .stream()
         .sorted(Comparator.comparingInt(NetworkInterface::getIndex))