Reply from the address the query was sent to on wildcard UDP listeners

Fixes discussion #3397
This commit is contained in:
Frank Denis 2026-11-04 23:09:17 +01:00
parent 277917a4b8
commit 8d5b1b5beb
2 changed files with 147 additions and 3 deletions

View file

@ -1,6 +1,7 @@
package main
import (
"bytes"
"context"
"encoding/binary"
"net"
@ -14,6 +15,8 @@
"github.com/jedisct1/dlog"
clocksmith "github.com/jedisct1/go-clocksmith"
stamps "github.com/jedisct1/go-dnsstamps"
"golang.org/x/net/ipv4"
"golang.org/x/net/ipv6"
netproxy "golang.org/x/net/proxy"
)
@ -116,6 +119,10 @@ type Proxy struct {
}
func (proxy *Proxy) registerUDPListener(conn *net.UDPConn) {
if conn.LocalAddr().(*net.UDPAddr).IP.IsUnspecified() {
ipv6.NewPacketConn(conn).SetControlMessage(ipv6.FlagDst, true)
ipv4.NewPacketConn(conn).SetControlMessage(ipv4.FlagDst, true)
}
proxy.listenersMu.Lock()
proxy.udpListeners = append(proxy.udpListeners, conn)
proxy.listenersMu.Unlock()
@ -462,15 +469,44 @@ func (proxy *Proxy) updateRegisteredServers() error {
return nil
}
// Sends replies from the address the client sent its query to
type udpReplyConn struct {
*net.UDPConn
oob []byte
}
func (conn *udpReplyConn) WriteTo(packet []byte, addr net.Addr) (int, error) {
var dst net.IP
if cm := new(ipv6.ControlMessage); cm.Parse(conn.oob) == nil && cm.Dst != nil {
dst = cm.Dst
} else if cm := new(ipv4.ControlMessage); cm.Parse(conn.oob) == nil {
dst = cm.Dst
}
var source []byte
if dst.To4() != nil {
source = (&ipv4.ControlMessage{Src: dst}).Marshal()
} else if dst != nil {
source = (&ipv6.ControlMessage{Src: dst}).Marshal()
}
n, _, err := conn.WriteMsgUDP(packet, source, addr.(*net.UDPAddr))
return n, err
}
func (proxy *Proxy) udpListener(clientPc *net.UDPConn) {
defer clientPc.Close()
oob := make([]byte, len(ipv4.NewControlMessage(ipv4.FlagDst))+len(ipv6.NewControlMessage(ipv6.FlagDst)))
for {
buffer := make([]byte, MaxDNSPacketSize-1)
length, clientAddr, err := clientPc.ReadFrom(buffer)
length, oobLength, _, udpAddr, err := clientPc.ReadMsgUDP(buffer, oob)
if err != nil {
return
}
packet := buffer[:length]
var clientAddr net.Addr = udpAddr
var responsePc net.Conn = clientPc
if oobLength > 0 {
responsePc = &udpReplyConn{UDPConn: clientPc, oob: bytes.Clone(oob[:oobLength])}
}
if !proxy.clientsCountInc() {
dlog.Warnf("Too many incoming connections (max=%d)", proxy.maxClients)
dlog.Debugf("Number of goroutines: %d", runtime.NumGoroutine())
@ -479,7 +515,7 @@ func (proxy *Proxy) udpListener(clientPc *net.UDPConn) {
proxy.xTransport.mainProto,
packet,
&clientAddr,
clientPc,
responsePc,
time.Now(),
true,
) // respond synchronously, but only to cached/synthesized queries
@ -487,7 +523,7 @@ func (proxy *Proxy) udpListener(clientPc *net.UDPConn) {
}
go func() {
defer proxy.clientsCountDec()
proxy.processIncomingQuery("udp", proxy.xTransport.mainProto, packet, &clientAddr, clientPc, time.Now(), false)
proxy.processIncomingQuery("udp", proxy.xTransport.mainProto, packet, &clientAddr, responsePc, time.Now(), false)
}()
}
}

View file

@ -3,9 +3,12 @@
import (
"fmt"
"net"
"runtime"
"sync"
"testing"
"time"
"codeberg.org/miekg/dns"
)
func TestUDPConnPool_Basic(t *testing.T) {
@ -232,3 +235,108 @@ func BenchmarkUDPConnPool_MultiAddrContention(b *testing.B) {
}
})
}
func TestUDPListenerReplySource(t *testing.T) {
// Queries sent to a second local address catch replies coming from the wrong one
ipv4Targets := []string{"127.0.0.1"}
switch runtime.GOOS {
case "linux":
ipv4Targets = append(ipv4Targets, "127.0.0.2")
case "darwin":
addrs, _ := net.InterfaceAddrs()
for _, addr := range addrs {
if ipNet, ok := addr.(*net.IPNet); ok && ipNet.IP.To4() != nil && ipNet.IP.IsGlobalUnicast() {
ipv4Targets = append(ipv4Targets, ipNet.IP.String())
break
}
}
default:
t.Skip("only Linux and macOS reply from the queried address for both IPv4 and IPv6")
}
for _, tt := range []struct {
network, listen string
targets []string
}{
{"udp4", "0.0.0.0", ipv4Targets},
{"udp", "::", append([]string{"::1"}, ipv4Targets...)},
{"udp4", "127.0.0.1", []string{"127.0.0.1"}},
} {
for _, maxClients := range []uint32{0, 16} {
t.Run(fmt.Sprintf("%s %s maxClients=%d", tt.network, tt.listen, maxClients), func(t *testing.T) {
proxy := NewProxy()
proxy.maxClients = maxClients
proxy.questionSizeEstimator = NewQuestionSizeEstimator()
proxy.xTransport = &XTransport{mainProto: "udp"}
proxy.pluginBlockIPv6 = true
if err := proxy.InitPluginsGlobals(); err != nil {
t.Fatal(err)
}
listener, err := net.ListenUDP(tt.network, &net.UDPAddr{IP: net.ParseIP(tt.listen)})
if err != nil {
if tt.network == "udp" {
t.Skipf("IPv6 unavailable: %v", err)
}
t.Fatal(err)
}
proxy.registerUDPListener(listener)
done := make(chan struct{})
go func() {
proxy.udpListener(listener)
close(done)
}()
t.Cleanup(func() {
listener.Close()
<-done
})
port := listener.LocalAddr().(*net.UDPAddr).Port
type query struct {
client *net.UDPConn
server *net.UDPAddr
}
var queries []query
for range 4 {
for _, target := range tt.targets {
server := &net.UDPAddr{IP: net.ParseIP(target), Port: port}
clientIP := net.IPv6loopback
if server.IP.To4() != nil {
clientIP = net.IPv4(127, 0, 0, 1)
}
client, err := net.ListenUDP("udp", &net.UDPAddr{IP: clientIP})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { client.Close() })
client.SetDeadline(time.Now().Add(3 * time.Second))
msg := dns.NewMsg("example.com.", dns.TypeAAAA)
msg.ID = uint16(len(queries))
if err := msg.Pack(); err != nil {
t.Fatal(err)
}
if _, err := client.WriteToUDP(msg.Data, server); err != nil {
t.Fatal(err)
}
queries = append(queries, query{client, server})
}
}
for i, q := range queries {
buffer := make([]byte, MaxDNSPacketSize)
n, source, err := q.client.ReadFromUDP(buffer)
if err != nil {
t.Fatal(err)
}
if !source.IP.Equal(q.server.IP) || source.Port != q.server.Port {
t.Errorf("reply from %s, want %s", source, q.server)
}
msg := &dns.Msg{Data: buffer[:n]}
if err := msg.Unpack(); err != nil {
t.Fatal(err)
}
if !msg.Response || msg.ID != uint16(i) || len(msg.Answer) == 0 {
t.Errorf("unexpected response: %v", msg)
}
}
})
}
}
}