Reply from the address the query was sent to on wildcard UDP listeners
Fixes discussion #3397
This commit is contained in:
parent
277917a4b8
commit
8d5b1b5beb
2 changed files with 147 additions and 3 deletions
|
|
@ -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)
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue