fix(udp): preserve wildcard reply sources and isolate destination sessions (#565)

* fix(udp): preserve local destinations and unicast reply sources on Linux

* fix(udp): select unicast sources for IPv6 multicast replies

* fix(udp): retain interface zones for link-local multicast sessions

* fix(udp): isolate interface-local multicast sessions

* fix(udp): include ingress interfaces in session identity

* fix(udp): restrict destination zones to IPv6

* ci(udp): follow rc5 patched Go toolchain requirement

---------

Co-authored-by: sagit <36596628+Sagit-chu@users.noreply.github.com>
This commit is contained in:
tsosunchia
2026-10-24 18:35:22 +08:00
committed by GitHub
parent dd3ed4e284
commit 3549fe5ad8
9 changed files with 977 additions and 5 deletions
+21 -3
View File
@@ -3,6 +3,7 @@ package udp
import (
"errors"
"net"
"strconv"
"sync"
"sync/atomic"
"time"
@@ -73,6 +74,7 @@ func (ln *listener) listenLoop() {
n, raddr, err := ln.conn.ReadFrom(b)
if err != nil {
bufpool.Put(b)
ln.errChan <- err
close(ln.errChan)
return
@@ -110,15 +112,27 @@ func (ln *listener) Close() error {
}
func (ln *listener) getConn(raddr net.Addr) *conn {
c, ok := ln.connPool.Get(raddr.String())
laddr := ln.Addr()
peer := raddr
var packet *packetAddr
if received, ok := raddr.(*packetAddr); ok {
packet = received
laddr, peer = received.local, received.Addr
}
key := laddr.String() + "|" + peer.String()
if packet != nil {
key += "|" + strconv.Itoa(packet.ifIndex)
}
c, ok := ln.connPool.Get(key)
if ok && !c.isClosed() {
return c
}
c = newConn(ln.conn, ln.Addr(), raddr, ln.config.ReadQueueSize, ln.config.Keepalive)
c = newConn(ln.conn, laddr, peer, ln.config.ReadQueueSize, ln.config.Keepalive)
c.packet = packet
select {
case ln.cqueue <- c:
ln.connPool.Set(raddr.String(), c)
ln.connPool.Set(key, c)
return c
default:
c.Close()
@@ -132,6 +146,7 @@ type conn struct {
net.PacketConn
localAddr net.Addr
remoteAddr net.Addr
packet *packetAddr
rc chan []byte // data receive queue
idle int32 // indicate the connection is idle
closed chan struct{}
@@ -176,6 +191,9 @@ func (c *conn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
if !c.keepalive {
defer c.Close()
}
if c.packet != nil {
addr = &packetAddr{Addr: addr, local: c.packet.local, control: c.packet.control, ifIndex: c.packet.ifIndex}
}
return c.PacketConn.WriteTo(b, addr)
}
+12
View File
@@ -0,0 +1,12 @@
package udp
import "net"
// packetAddr carries the received destination through the PacketConn wrappers.
// Its public address remains the real peer for admission, metrics and limits.
type packetAddr struct {
net.Addr
local *net.UDPAddr
control []byte
ifIndex int
}
+116
View File
@@ -0,0 +1,116 @@
package udp
import (
"encoding/binary"
"errors"
"net"
"golang.org/x/net/ipv6"
"golang.org/x/sys/unix"
)
// PreserveDestination pins wildcard UDP replies to the address they arrived on.
func PreserveDestination(c *net.UDPConn) (net.PacketConn, error) {
local := c.LocalAddr().(*net.UDPAddr)
if !local.IP.IsUnspecified() {
return c, nil
}
raw, err := c.SyscallConn()
if err != nil {
return nil, err
}
var sockErr error
if err = raw.Control(func(fd uintptr) {
if local.IP.To4() != nil {
sockErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_PKTINFO, 1)
return
}
if sockErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVPKTINFO, 1); sockErr != nil {
return
}
var onlyV6 int
onlyV6, sockErr = unix.GetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_V6ONLY)
if sockErr == nil && onlyV6 == 0 {
sockErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_PKTINFO, 1)
}
}); err != nil {
return nil, err
}
if sockErr != nil {
return nil, sockErr
}
return &destinationConn{UDPConn: c}, nil
}
type destinationConn struct {
*net.UDPConn
}
func (c *destinationConn) ReadFrom(b []byte) (int, net.Addr, error) {
var oob [128]byte
n, oobn, flags, remote, err := c.ReadMsgUDP(b, oob[:])
if err != nil {
return 0, remote, err
}
if flags&unix.MSG_CTRUNC != 0 {
return 0, nil, errors.New("UDP destination control message truncated")
}
var dst net.IP
var control []byte
var ifIndex int
if remote.IP.To4() != nil {
messages, err := unix.ParseSocketControlMessage(oob[:oobn])
if err != nil {
return 0, nil, err
}
for _, message := range messages {
if message.Header.Level != unix.IPPROTO_IP || message.Header.Type != unix.IP_PKTINFO {
continue
}
var info unix.Inet4Pktinfo
if _, err := binary.Decode(message.Data, binary.NativeEndian, &info); err != nil {
return 0, nil, err
}
dst, ifIndex = net.IP(info.Addr[:]), int(info.Ifindex)
// Spec_dst remains a local unicast address for broadcast destinations.
control = unix.PktInfo4(&unix.Inet4Pktinfo{Ifindex: info.Ifindex, Spec_dst: info.Spec_dst})
break
}
} else {
var cm ipv6.ControlMessage
if err = cm.Parse(oob[:oobn]); err != nil {
return 0, nil, err
}
dst, ifIndex = cm.Dst, cm.IfIndex
source := dst
if dst.IsMulticast() {
source = nil
}
control = (&ipv6.ControlMessage{Src: source, IfIndex: ifIndex}).Marshal()
}
if len(dst) == 0 || dst.IsUnspecified() {
return 0, nil, errors.New("UDP destination address missing")
}
local := &net.UDPAddr{IP: append(net.IP(nil), dst...), Port: c.LocalAddr().(*net.UDPAddr).Port}
if dst.To4() == nil && (dst.IsLinkLocalUnicast() || dst.IsLinkLocalMulticast() || dst.IsInterfaceLocalMulticast()) {
if iface, lookupErr := net.InterfaceByIndex(ifIndex); lookupErr == nil {
local.Zone = iface.Name
}
}
return n, &packetAddr{Addr: remote, local: local, control: control, ifIndex: ifIndex}, nil
}
func (c *destinationConn) WriteTo(b []byte, addr net.Addr) (int, error) {
if packet, ok := addr.(*packetAddr); ok {
remote, ok := packet.Addr.(*net.UDPAddr)
if !ok {
return 0, errors.New("invalid UDP peer address")
}
n, _, err := c.WriteMsgUDP(b, packet.control, remote)
if n < 0 {
n = 0
}
return n, err
}
return c.UDPConn.WriteTo(b, addr)
}
@@ -0,0 +1,304 @@
package udp
import (
"encoding/binary"
"fmt"
"io"
"net"
"os"
"testing"
"time"
"golang.org/x/net/ipv4"
"golang.org/x/net/ipv6"
"golang.org/x/sys/unix"
xlogger "github.com/go-gost/x/logger"
)
func TestMulticastDestinationRepliesFromUnicast(t *testing.T) {
rxName, txName := os.Getenv("FLUX_TEST_MULTICAST_RX"), os.Getenv("FLUX_TEST_MULTICAST_TX")
if rxName == "" || txName == "" {
t.Skip("requires isolated multicast veth interfaces")
}
rx, err := net.InterfaceByName(rxName)
if err != nil {
t.Fatal(err)
}
tx, err := net.InterfaceByName(txName)
if err != nil {
t.Fatal(err)
}
group := net.ParseIP("ff02::114")
socket, err := net.ListenMulticastUDP("udp6", rx, &net.UDPAddr{IP: group})
if err != nil {
t.Fatal(err)
}
defer socket.Close()
pc, err := PreserveDestination(socket)
if err != nil {
t.Fatal(err)
}
ln := NewListener(pc, &ListenConfig{
Backlog: 1, ReadQueueSize: 1, ReadBufferSize: 128, TTL: time.Second, Keepalive: true,
Logger: xlogger.NewLogger(xlogger.OutputOption(io.Discard)),
})
defer ln.Close()
client, err := net.ListenUDP("udp6", &net.UDPAddr{IP: net.ParseIP("fe80::1"), Zone: txName})
if err != nil {
t.Fatal(err)
}
defer client.Close()
if err := ipv6.NewPacketConn(client).SetMulticastInterface(tx); err != nil {
t.Fatal(err)
}
client.SetDeadline(time.Now().Add(3 * time.Second))
port := socket.LocalAddr().(*net.UDPAddr).Port
serverResult := make(chan error, 1)
go func() {
c, err := ln.Accept()
if err != nil {
serverResult <- err
return
}
defer c.Close()
local, peer := c.LocalAddr().(*net.UDPAddr), c.RemoteAddr().(*net.UDPAddr)
if !local.IP.Equal(group) || local.Port != port || local.Zone != rxName || !peer.IP.Equal(net.ParseIP("fe80::1")) ||
peer.Port != client.LocalAddr().(*net.UDPAddr).Port || peer.Zone != rxName {
serverResult <- fmt.Errorf("unexpected multicast session: local=%s peer=%s", local, peer)
return
}
var buf [128]byte
n, err := c.Read(buf[:])
if err == nil {
_, err = c.Write(buf[:n])
}
serverResult <- err
}()
if _, err := client.WriteToUDP([]byte("multicast"), &net.UDPAddr{IP: group, Port: port, Zone: txName}); err != nil {
t.Fatal(err)
}
select {
case err := <-serverResult:
if err != nil {
t.Fatal(err)
}
case <-time.After(3 * time.Second):
t.Fatal("multicast session timed out")
}
var buf [128]byte
n, from, err := client.ReadFromUDP(buf[:])
if err != nil {
t.Fatal(err)
}
if !from.IP.Equal(net.ParseIP("fe80::2")) || from.Port != port || from.Zone != txName || string(buf[:n]) != "multicast" {
t.Fatalf("unexpected multicast reply %q from %s", buf[:n], from)
}
}
func TestLinkLocalMulticastSessionsRetainZones(t *testing.T) {
testScopedMulticastSessions(t, "ff02::114", false)
}
func TestIPv4DestinationSessionsRetainInterfaces(t *testing.T) {
ifNames := []string{os.Getenv("FLUX_TEST_MULTICAST_TX"), os.Getenv("FLUX_TEST_MULTICAST_TX2")}
if ifNames[0] == "" || ifNames[1] == "" {
t.Skip("requires two isolated IPv4 multicast interfaces")
}
for _, network := range []string{"udp4", "udp"} {
for _, destination := range []string{"239.255.0.114", "224.0.0.114", "255.255.255.255"} {
t.Run(network+"/"+destination, func(t *testing.T) {
bind := net.IPv4zero
if network == "udp" {
bind = net.IPv6unspecified
}
server, err := net.ListenUDP(network, &net.UDPAddr{IP: bind})
if err != nil {
t.Fatal(err)
}
defer server.Close()
pc, err := PreserveDestination(server)
if err != nil {
t.Fatal(err)
}
client, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.ParseIP("198.18.0.1")})
if err != nil {
t.Fatal(err)
}
defer client.Close()
raw, err := client.SyscallConn()
if err != nil {
t.Fatal(err)
}
var sockErr error
if err := raw.Control(func(fd uintptr) {
sockErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_BROADCAST, 1)
}); err != nil {
t.Fatal(err)
}
if sockErr != nil {
t.Fatal(sockErr)
}
target := &net.UDPAddr{IP: net.ParseIP(destination), Port: server.LocalAddr().(*net.UDPAddr).Port}
for _, name := range ifNames {
iface, err := net.InterfaceByName(name)
if err != nil {
t.Fatal(err)
}
if target.IP.IsMulticast() {
if err := ipv4.NewPacketConn(server).JoinGroup(iface, target); err != nil {
t.Fatal(err)
}
}
if _, err := ipv4.NewPacketConn(client).WriteTo([]byte(name), &ipv4.ControlMessage{
Src: client.LocalAddr().(*net.UDPAddr).IP, IfIndex: iface.Index,
}, target); err != nil {
t.Fatal(err)
}
}
server.SetReadDeadline(time.Now().Add(3 * time.Second))
ln := NewListener(pc, &ListenConfig{
Backlog: 2, ReadQueueSize: 2, ReadBufferSize: 128, TTL: 10 * time.Second, Keepalive: true,
Logger: xlogger.NewLogger(xlogger.OutputOption(io.Discard)),
})
defer ln.Close()
seen := make(map[string]bool)
for range ifNames {
c, err := ln.Accept()
if err != nil {
t.Fatalf("interface did not get a separate session: %v", err)
}
defer c.Close()
var buf [128]byte
n, err := c.Read(buf[:])
if err != nil {
t.Fatal(err)
}
name := string(buf[:n])
if (name != ifNames[0] && name != ifNames[1]) || seen[name] ||
c.LocalAddr().String() != target.String() || c.RemoteAddr().String() != client.LocalAddr().String() {
t.Fatalf("unexpected interface session: data=%q local=%s peer=%s", buf[:n], c.LocalAddr(), c.RemoteAddr())
}
iface, err := net.InterfaceByName(name)
if err != nil {
t.Fatal(err)
}
messages, err := unix.ParseSocketControlMessage(c.(*conn).packet.control)
if err != nil || len(messages) != 1 {
t.Fatalf("invalid reply control: %v", err)
}
var info unix.Inet4Pktinfo
if _, err := binary.Decode(messages[0].Data, binary.NativeEndian, &info); err != nil {
t.Fatal(err)
}
if int(info.Ifindex) != iface.Index {
t.Fatalf("reply interface = %d, want %d", info.Ifindex, iface.Index)
}
seen[name] = true
}
})
}
}
}
func TestInterfaceLocalMulticastSessionsRetainZones(t *testing.T) {
testScopedMulticastSessions(t, "ff01::114", true)
}
func testScopedMulticastSessions(t *testing.T, destination string, interfaceLocal bool) {
t.Helper()
rxNames := []string{os.Getenv("FLUX_TEST_MULTICAST_RX"), os.Getenv("FLUX_TEST_MULTICAST_RX2")}
txNames := []string{os.Getenv("FLUX_TEST_MULTICAST_TX"), os.Getenv("FLUX_TEST_MULTICAST_TX2")}
for i := range rxNames {
if rxNames[i] == "" || txNames[i] == "" {
t.Skip("requires two isolated multicast veth pairs")
}
}
if interfaceLocal {
// Interface-local multicast is looped back on the sending interface.
rxNames = txNames
}
group := net.ParseIP(destination)
server, err := net.ListenUDP("udp6", &net.UDPAddr{IP: net.IPv6unspecified})
if err != nil {
t.Fatal(err)
}
defer server.Close()
clientIP := net.ParseIP("fd00:1::1")
client, err := net.ListenUDP("udp6", &net.UDPAddr{IP: clientIP})
if err != nil {
t.Fatal(err)
}
defer client.Close()
pc, err := PreserveDestination(server)
if err != nil {
t.Fatal(err)
}
for i, rxName := range rxNames {
rx, err := net.InterfaceByName(rxName)
if err != nil {
t.Fatal(err)
}
if err := ipv6.NewPacketConn(server).JoinGroup(rx, &net.UDPAddr{IP: group}); err != nil {
t.Fatal(err)
}
tx, err := net.InterfaceByName(txNames[i])
if err != nil {
t.Fatal(err)
}
if err := ipv6.NewPacketConn(client).SetMulticastInterface(tx); err != nil {
t.Fatal(err)
}
if _, err := client.WriteToUDP([]byte(rxName), &net.UDPAddr{
IP: group, Port: server.LocalAddr().(*net.UDPAddr).Port, Zone: txNames[i],
}); err != nil {
t.Fatal(err)
}
}
server.SetReadDeadline(time.Now().Add(3 * time.Second))
ln := NewListener(pc, &ListenConfig{
Backlog: 2, ReadQueueSize: 2, ReadBufferSize: 128, TTL: 10 * time.Second, Keepalive: true,
Logger: xlogger.NewLogger(xlogger.OutputOption(io.Discard)),
})
defer ln.Close()
first, err := ln.Accept()
if err != nil {
t.Fatal(err)
}
defer first.Close()
second, err := ln.Accept()
if err != nil {
t.Fatalf("second interface did not get a separate session: %v", err)
}
defer second.Close()
if first == second {
t.Fatal("interface-scoped multicast sessions were shared")
}
seen := make(map[string]bool)
for _, c := range []net.Conn{first, second} {
var buf [128]byte
n, err := c.Read(buf[:])
if err != nil {
t.Fatal(err)
}
zone := string(buf[:n])
local, peer := c.LocalAddr().(*net.UDPAddr), c.RemoteAddr().(*net.UDPAddr)
if (zone != rxNames[0] && zone != rxNames[1]) || seen[zone] || !local.IP.Equal(group) ||
local.Port != server.LocalAddr().(*net.UDPAddr).Port || local.Zone != zone ||
!peer.IP.Equal(clientIP) || peer.Port != client.LocalAddr().(*net.UDPAddr).Port || peer.Zone != "" {
t.Fatalf("unexpected scoped session: data=%q local=%s peer=%s", buf[:n], local, peer)
}
var reply ipv6.ControlMessage
if err := reply.Parse(c.(*conn).packet.control); err != nil {
t.Fatal(err)
}
iface, err := net.InterfaceByName(zone)
if err != nil {
t.Fatal(err)
}
if reply.IfIndex != iface.Index {
t.Fatalf("reply interface = %d, want %d", reply.IfIndex, iface.Index)
}
seen[zone] = true
}
}
@@ -0,0 +1,9 @@
//go:build !linux
package udp
import "net"
func PreserveDestination(c *net.UDPConn) (net.PacketConn, error) {
return c, nil
}
@@ -0,0 +1,289 @@
package udp
import (
"context"
"fmt"
"io"
"net"
"os"
"strings"
"sync/atomic"
"testing"
"time"
"golang.org/x/sys/unix"
corelimiter "github.com/go-gost/core/limiter"
coretraffic "github.com/go-gost/core/limiter/traffic"
corelistener "github.com/go-gost/core/listener"
corestats "github.com/go-gost/core/observer/stats"
xadmission "github.com/go-gost/x/admission"
xtraffic "github.com/go-gost/x/limiter/traffic"
xlogger "github.com/go-gost/x/logger"
xmetadata "github.com/go-gost/x/metadata"
"github.com/go-gost/x/metrics"
xstats "github.com/go-gost/x/observer/stats"
)
type countedTraffic struct {
coretraffic.TrafficLimiter
in, out atomic.Int64
}
func (l *countedTraffic) In(ctx context.Context, key string, opts ...corelimiter.Option) coretraffic.Limiter {
l.in.Add(1)
return l.TrafficLimiter.In(ctx, key, opts...)
}
func (l *countedTraffic) Out(ctx context.Context, key string, opts ...corelimiter.Option) coretraffic.Limiter {
l.out.Add(1)
return l.TrafficLimiter.Out(ctx, key, opts...)
}
func TestDestinationPreservedThroughWrappers(t *testing.T) {
v4 := []string{"127.0.0.1", "127.0.0.2"}
if address := os.Getenv("FLUX_TEST_IPV4_LINK_LOCAL"); address != "" {
v4 = append(v4, address)
}
v6 := strings.FieldsFunc(os.Getenv("FLUX_TEST_IPV6_ADDRS"), func(r rune) bool { return r == ',' })
if len(v6) == 0 {
v6 = []string{"::1"}
}
for _, tc := range []struct {
name, bind string
targets []string
clientBind string
}{
{"ipv4-wildcard", "0.0.0.0:0", v4, ""},
{"dual-stack-wildcard", "[::]:0", append(v4, v6...), ""},
{"fixed-ipv6-source", "[::]:0", v6, "::1"},
{"explicit-ipv4", "127.0.0.1:0", []string{"127.0.0.1"}, ""},
{"explicit-ipv6", "[::1]:0", []string{"::1"}, ""},
} {
t.Run(tc.name, func(t *testing.T) {
metrics.Enable(true)
defer metrics.Enable(false)
log := xlogger.NewLogger(xlogger.OutputOption(io.Discard))
stats := xstats.NewStats(false)
lim := &countedTraffic{TrafficLimiter: xtraffic.NewTrafficLimiter(
xtraffic.LimitsOption("$ 1MB 1MB", "$$ 1MB 1MB"), xtraffic.LoggerOption(log),
)}
ln := NewListener(corelistener.AddrOption(tc.bind), corelistener.LoggerOption(log),
corelistener.ServiceOption(t.Name()), corelistener.StatsOption(stats),
corelistener.TrafficLimiterOption(lim),
corelistener.AdmissionOption(xadmission.NewAdmission(
xadmission.WhitelistOption(true),
xadmission.MatchersOption([]string{"127.0.0.0/8", "169.254.0.0/16", "::1", "fd00::/8"}),
xadmission.LoggerOption(log),
)),
)
if err := ln.Init(xmetadata.NewMetadata(map[string]any{"keepAlive": true})); err != nil {
t.Fatal(err)
}
defer ln.Close()
clientIP := net.IPv6unspecified
if tc.clientBind != "" {
clientIP = net.ParseIP(tc.clientBind)
}
client, err := net.ListenUDP("udp", &net.UDPAddr{IP: clientIP})
if err != nil {
t.Fatal(err)
}
defer client.Close()
client.SetDeadline(time.Now().Add(5 * time.Second))
clientAddr := client.LocalAddr().(*net.UDPAddr)
var accepted atomic.Int64
errors := make(chan error, 128)
go func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
accepted.Add(1)
go func() {
defer c.Close()
buf := make([]byte, 128)
for {
n, err := c.Read(buf)
if err != nil {
return
}
var round, target int
if _, err := fmt.Sscanf(string(buf[:n]), "%d/%d", &round, &target); err != nil {
errors <- err
return
}
local := c.LocalAddr().(*net.UDPAddr)
if local.IP.To4() != nil && local.Zone != "" {
errors <- fmt.Errorf("IPv4 destination has a zone: %s", local)
return
}
if !local.IP.Equal(net.ParseIP(tc.targets[target])) {
errors <- fmt.Errorf("local destination = %s, want %s", local.IP, tc.targets[target])
return
}
peer, ok := c.RemoteAddr().(*net.UDPAddr)
if !ok {
errors <- fmt.Errorf("peer type changed: %T", c.RemoteAddr())
return
}
if tc.clientBind != "" && (!peer.IP.Equal(clientAddr.IP) || peer.Port != clientAddr.Port) {
errors <- fmt.Errorf("peer endpoint = %s, want %s", peer, clientAddr)
return
}
if _, err := c.Write(buf[:n]); err != nil {
errors <- err
return
}
}
}()
}
}()
port := ln.Addr().(*net.UDPAddr).Port
var bytes int
for round := 0; round < 3; round++ {
for target, ip := range tc.targets {
payload := []byte(fmt.Sprintf("%d/%d", round, target))
bytes += len(payload)
if _, err := client.WriteToUDP(payload, &net.UDPAddr{IP: net.ParseIP(ip), Port: port}); err != nil {
t.Fatal(err)
}
}
seen := make(map[int]bool)
for range tc.targets {
buf := make([]byte, 128)
n, from, err := client.ReadFromUDP(buf)
if err != nil {
select {
case serverErr := <-errors:
t.Fatal(serverErr)
default:
t.Fatal(err)
}
}
var gotRound, target int
if _, err := fmt.Sscanf(string(buf[:n]), "%d/%d", &gotRound, &target); err != nil {
t.Fatal(err)
}
if gotRound != round || seen[target] || from.Port != port || !from.IP.Equal(net.ParseIP(tc.targets[target])) {
t.Fatalf("unexpected reply %q from %s", buf[:n], from)
}
seen[target] = true
}
}
if accepted.Load() != int64(len(tc.targets)) {
t.Fatalf("accepted %d sessions, want %d", accepted.Load(), len(tc.targets))
}
deadline := time.Now().Add(time.Second)
for stats.Get(corestats.KindOutputBytes) < uint64(bytes) && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
if stats.Get(corestats.KindInputBytes) != uint64(bytes) || stats.Get(corestats.KindOutputBytes) != uint64(bytes) {
t.Fatalf("traffic stats lost: in=%d out=%d want=%d", stats.Get(corestats.KindInputBytes), stats.Get(corestats.KindOutputBytes), bytes)
}
if lim.in.Load() == 0 || lim.out.Load() == 0 {
t.Fatal("traffic limiter bypassed")
}
})
}
}
func TestBroadcastDestinationRepliesFromUnicast(t *testing.T) {
for _, bind := range []string{"0.0.0.0:0", "[::]:0"} {
t.Run(bind, func(t *testing.T) {
ln := NewListener(corelistener.AddrOption(bind),
corelistener.LoggerOption(xlogger.NewLogger(xlogger.OutputOption(io.Discard))))
if err := ln.Init(xmetadata.NewMetadata(map[string]any{"keepAlive": true})); err != nil {
t.Fatal(err)
}
defer ln.Close()
client, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)})
if err != nil {
t.Fatal(err)
}
defer client.Close()
raw, err := client.SyscallConn()
if err != nil {
t.Fatal(err)
}
var sockErr error
if err := raw.Control(func(fd uintptr) {
sockErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_BROADCAST, 1)
}); err != nil {
t.Fatal(err)
}
if sockErr != nil {
t.Fatal(sockErr)
}
client.SetDeadline(time.Now().Add(5 * time.Second))
target := &net.UDPAddr{IP: net.IPv4(127, 255, 255, 255), Port: ln.Addr().(*net.UDPAddr).Port}
if _, err := client.WriteToUDP([]byte("broadcast"), target); err != nil {
t.Fatal(err)
}
conn, err := acceptWithTimeout(t, ln, time.Second)
if err != nil {
t.Fatal(err)
}
defer conn.Close()
if conn.LocalAddr().String() != target.String() {
t.Fatalf("local destination = %s, want %s", conn.LocalAddr(), target)
}
if conn.RemoteAddr().String() != client.LocalAddr().String() {
t.Fatalf("peer endpoint = %s, want %s", conn.RemoteAddr(), client.LocalAddr())
}
var buf [128]byte
n, err := conn.Read(buf[:])
if err != nil {
t.Fatal(err)
}
if _, err := conn.Write(buf[:n]); err != nil {
t.Fatalf("reply to broadcast request: %v", err)
}
n, from, err := client.ReadFromUDP(buf[:])
if err != nil {
t.Fatal(err)
}
if !from.IP.Equal(net.IPv4(127, 0, 0, 1)) || from.Port != target.Port || string(buf[:n]) != "broadcast" {
t.Fatalf("unexpected broadcast reply %q from %s", buf[:n], from)
}
})
}
}
func TestDestinationSessionExpires(t *testing.T) {
ln := NewListener(corelistener.AddrOption("0.0.0.0:0"),
corelistener.LoggerOption(xlogger.NewLogger(xlogger.OutputOption(io.Discard))))
if err := ln.Init(xmetadata.NewMetadata(map[string]any{"keepAlive": true, "ttl": "20ms"})); err != nil {
t.Fatal(err)
}
defer ln.Close()
client, err := net.DialUDP("udp4", nil, &net.UDPAddr{IP: net.IPv4(127, 0, 0, 2), Port: ln.Addr().(*net.UDPAddr).Port})
if err != nil {
t.Fatal(err)
}
defer client.Close()
client.Write([]byte("first"))
first, err := acceptWithTimeout(t, ln, time.Second)
if err != nil {
t.Fatal(err)
}
var b [16]byte
first.Read(b[:])
time.Sleep(80 * time.Millisecond)
if _, err := first.Read(b[:]); err == nil {
t.Fatal("idle session did not expire")
}
client.Write([]byte("second"))
second, err := acceptWithTimeout(t, ln, time.Second)
if err != nil {
t.Fatal(err)
}
defer second.Close()
if first == second {
t.Fatal("expired session reused")
}
if second.LocalAddr().(*net.UDPAddr).IP.String() != "127.0.0.2" {
t.Fatalf("new session lost destination: %s", second.LocalAddr())
}
}
+6 -2
View File
@@ -56,11 +56,15 @@ func (l *udpListener) Init(md md.Metadata) (err error) {
return
}
var conn net.PacketConn
conn, err = net.ListenUDP(network, laddr)
socket, err := net.ListenUDP(network, laddr)
if err != nil {
return
}
conn, err := udp.PreserveDestination(socket)
if err != nil {
socket.Close()
return err
}
conn = metrics.WrapPacketConn(l.options.Service, conn)
conn = stats.WrapPacketConn(conn, l.options.Stats)
conn = admission.WrapPacketConn(l.options.Admission, conn)