diff --git a/cmd/derper/depaware.txt b/cmd/derper/depaware.txt index b7e74ed54..bea9ad7e9 100644 --- a/cmd/derper/depaware.txt +++ b/cmd/derper/depaware.txt @@ -107,6 +107,7 @@ tailscale.com/cmd/derper dependencies: (generated by github.com/tailscale/depawa 💣 tailscale.com/net/netns from tailscale.com/derp/derphttp tailscale.com/net/netutil from tailscale.com/client/local+ tailscale.com/net/netx from tailscale.com/net/dnscache+ + tailscale.com/net/pktinfo from tailscale.com/net/stunserver tailscale.com/net/routecheck from tailscale.com/client/local tailscale.com/net/routecheck/peernode from tailscale.com/net/routecheck tailscale.com/net/sockstats from tailscale.com/derp/derphttp diff --git a/cmd/stund/depaware.txt b/cmd/stund/depaware.txt index af23011af..1c280c825 100644 --- a/cmd/stund/depaware.txt +++ b/cmd/stund/depaware.txt @@ -53,6 +53,7 @@ tailscale.com/cmd/stund dependencies: (generated by github.com/tailscale/depawar tailscale.com/kube/kubetypes from tailscale.com/envknob tailscale.com/metrics from tailscale.com/net/stunserver+ tailscale.com/net/netaddr from tailscale.com/net/tsaddr + tailscale.com/net/pktinfo from tailscale.com/net/stunserver tailscale.com/net/stun from tailscale.com/net/stunserver tailscale.com/net/stunserver from tailscale.com/cmd/stund tailscale.com/net/tsaddr from tailscale.com/tsweb diff --git a/net/pktinfo/pktinfo.go b/net/pktinfo/pktinfo.go new file mode 100644 index 000000000..947a2fb5d --- /dev/null +++ b/net/pktinfo/pktinfo.go @@ -0,0 +1,54 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +// Package pktinfo lets a UDP server learn the local address each datagram +// was sent to and reply from that same address. +// +// A server on a wildcard socket otherwise replies from whatever source +// address the kernel picks by routing to the client. On a multi-homed host +// that is the default route's address, not necessarily the one the request +// arrived on, which breaks clients and middleboxes (conntrack, policy +// routing) that expect the reply to come from the address they sent to. +// +// The functions operate on raw socket control message bytes, as used by +// [net.UDPConn.ReadMsgUDPAddrPort], [net.UDPConn.WriteMsgUDPAddrPort], and +// the OOB fields of golang.org/x/net/ipv4 and ipv6 batch messages. +// +// It is only implemented on Linux. Elsewhere, [Enable] returns +// [errors.ErrUnsupported]. +package pktinfo + +import ( + "net" + "net/netip" +) + +// Enable asks the kernel to include, in the control messages of each +// datagram received on pc, the local address the datagram was sent to. +// See [Dst]. A wildcard "udp" socket is dual-stack and receives IPv4 +// datagrams too; both families are handled. +func Enable(pc *net.UDPConn) error { + return enable(pc) +} + +// Dst returns the local destination address recorded in the control +// messages oob of a received datagram, or the zero [netip.Addr] if there +// is none. IPv4 addresses received on a dual-stack socket are returned +// unmapped. +func Dst(oob []byte) netip.Addr { + return dst(oob) +} + +// AppendSrc appends to b the control message that makes a datagram sent +// with it be sent from the local address src. It returns b unchanged if +// src isn't a usable source address (invalid, unspecified, or multicast). +// +// Only the source address is pinned. The interface index is left zero so +// that routing (including policy routing) still decides the egress +// interface. +func AppendSrc(b []byte, src netip.Addr) []byte { + if !src.IsValid() || src.IsUnspecified() || src.IsMulticast() { + return b + } + return appendSrc(b, src) +} diff --git a/net/pktinfo/pktinfo_linux.go b/net/pktinfo/pktinfo_linux.go new file mode 100644 index 000000000..50c817da9 --- /dev/null +++ b/net/pktinfo/pktinfo_linux.go @@ -0,0 +1,120 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +package pktinfo + +import ( + "encoding/binary" + "math/bits" + "net" + "net/netip" + "slices" + + "golang.org/x/sys/unix" +) + +// cmsgLenSize is the size of struct cmsghdr's cmsg_len field, a size_t, +// which is the word size on every Linux ABI Go supports. +const cmsgLenSize = bits.UintSize / 8 + +// appendSrc assumes cmsg_len is followed by exactly the two int32 fields +// cmsg_level and cmsg_type. Fail to compile otherwise. +var _ [0]struct{} = [unix.SizeofCmsghdr - cmsgLenSize - 8]struct{}{} + +func enable(pc *net.UDPConn) error { + // A wildcard "udp" socket is AF_INET6 (dual-stack) and its + // LocalAddr is "[::]"; a "udp4" or IPv4-bound socket is AF_INET. + v6 := true + if la, ok := pc.LocalAddr().(*net.UDPAddr); ok && la.IP.To4() != nil { + v6 = false + } + rc, err := pc.SyscallConn() + if err != nil { + return err + } + var sockErr error + err = rc.Control(func(fd uintptr) { + if v6 { + sockErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVPKTINFO, 1) + if sockErr != nil { + return + } + } + // On a dual-stack socket, IPV6_RECVPKTINFO alone reports + // IPv4 datagrams' header destination as a v4-mapped address, + // which for a broadcast datagram is the broadcast address: + // useless as a reply source. IP_PKTINFO applies to the IPv4 + // datagrams on the same socket and carries ipi_spec_dst, the + // unicast address the kernel considers ours for replying. + sockErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_PKTINFO, 1) + }) + if err != nil { + return err + } + return sockErr +} + +func dst(oob []byte) netip.Addr { + msgs, err := unix.ParseSocketControlMessage(oob) + if err != nil { + return netip.Addr{} + } + var v6 netip.Addr + for _, m := range msgs { + switch { + case m.Header.Level == unix.IPPROTO_IP && m.Header.Type == unix.IP_PKTINFO: + // struct in_pktinfo is ipi_ifindex, ipi_spec_dst, ipi_addr. + // This is the preferred answer; see enable. + if len(m.Data) >= unix.SizeofInet4Pktinfo { + return netip.AddrFrom4([4]byte(m.Data[4:8])) + } + case m.Header.Level == unix.IPPROTO_IPV6 && m.Header.Type == unix.IPV6_PKTINFO: + // struct in6_pktinfo is ipi6_addr followed by ipi6_ifindex. + if len(m.Data) >= unix.SizeofInet6Pktinfo { + v6 = netip.AddrFrom16([16]byte(m.Data[:16])).Unmap() + } + } + } + return v6 +} + +// appendSrc builds the control message by hand rather than with +// golang.org/x/net/ipv6, whose ControlMessage silently drops a v4-mapped +// Src, or with [unix.PktInfo4] and [unix.PktInfo6], which allocate per call. +// +// The cmsg level follows the address family of src, not the socket's. +// Linux accepts an IP_PKTINFO cmsg on a dual-stack AF_INET6 socket when +// the destination is IPv4, since such sends go through the IPv4 path. +func appendSrc(b []byte, src netip.Addr) []byte { + var level, typ, dataLen int + if src.Is4() { + level, typ, dataLen = unix.SOL_IP, unix.IP_PKTINFO, unix.SizeofInet4Pktinfo + } else { + level, typ, dataLen = unix.SOL_IPV6, unix.IPV6_PKTINFO, unix.SizeofInet6Pktinfo + } + start := len(b) + b = slices.Grow(b, unix.CmsgSpace(dataLen))[:start+unix.CmsgSpace(dataLen)] + clear(b[start:]) + + hdr := b[start:] + switch cmsgLenSize { + case 8: + binary.NativeEndian.PutUint64(hdr, uint64(unix.CmsgLen(dataLen))) + case 4: + binary.NativeEndian.PutUint32(hdr, uint32(unix.CmsgLen(dataLen))) + } + binary.NativeEndian.PutUint32(hdr[cmsgLenSize:], uint32(level)) + binary.NativeEndian.PutUint32(hdr[cmsgLenSize+4:], uint32(typ)) + + data := hdr[unix.CmsgLen(0):] + if src.Is4() { + // struct in_pktinfo is ipi_ifindex, ipi_spec_dst, ipi_addr. + a := src.As4() + copy(data[4:], a[:]) + } else { + // struct in6_pktinfo is ipi6_addr followed by ipi6_ifindex. + a := src.As16() + copy(data, a[:]) + } + return b +} diff --git a/net/pktinfo/pktinfo_linux_test.go b/net/pktinfo/pktinfo_linux_test.go new file mode 100644 index 000000000..823a613db --- /dev/null +++ b/net/pktinfo/pktinfo_linux_test.go @@ -0,0 +1,199 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +package pktinfo + +import ( + "net" + "net/netip" + "testing" + "time" + + "golang.org/x/sys/unix" + "tailscale.com/util/cibuild" + "tailscale.com/util/must" +) + +// TestReplySourceAddr verifies that an echo server using this package +// replies from the address the request was sent to, not from whichever +// address the kernel would otherwise pick for the reply's destination. +// It sends from 127.0.0.1 to the server at 127.0.0.2 (all of 127/8 is +// local on Linux); without pktinfo the kernel replies from 127.0.0.1. +func TestReplySourceAddr(t *testing.T) { + tests := []struct { + name string + network string // "udp" for a dual-stack socket, "udp4" for AF_INET + pktInfo bool // whether to use pktinfo; false is the negative control + }{ + {"dualstack", "udp", true}, + {"dualstack-nopktinfo", "udp", false}, + {"v4", "udp4", true}, + {"v4-nopktinfo", "udp4", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.network == "udp" { + // The dual-stack cases need an AF_INET6 socket, + // which net.ListenUDP("udp") quietly won't + // create on a host with IPv6 disabled. + if c, err := net.ListenPacket("udp6", "[::1]:0"); err != nil { + if !cibuild.On() { + t.Skipf("IPv6 not supported: %v", err) + } + t.Fatalf("IPv6 not supported: %v", err) + } else { + c.Close() + } + } + srv := must.Get(net.ListenUDP(tt.network, nil)) + defer srv.Close() + if tt.pktInfo { + if err := Enable(srv); err != nil { + t.Fatalf("Enable: %v", err) + } + } + go func() { + var buf, oob [1500]byte + n, oobn, _, from, err := srv.ReadMsgUDPAddrPort(buf[:], oob[:]) + if err != nil { + return + } + srv.WriteMsgUDPAddrPort(buf[:n], AppendSrc(nil, Dst(oob[:oobn])), from) + }() + port := uint16(srv.LocalAddr().(*net.UDPAddr).Port) + serverAddr := netip.AddrPortFrom(netip.MustParseAddr("127.0.0.2"), port) + + c := must.Get(net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)})) + defer c.Close() + c.SetDeadline(time.Now().Add(5 * time.Second)) + must.Get(c.WriteToUDPAddrPort([]byte("hello"), serverAddr)) + + var buf [1500]byte + n, from, err := c.ReadFromUDPAddrPort(buf[:]) + if err != nil { + t.Fatalf("reading reply: %v", err) + } + if string(buf[:n]) != "hello" { + t.Errorf("reply = %q; want %q", buf[:n], "hello") + } + wantFrom := serverAddr + if !tt.pktInfo { + wantFrom = netip.AddrPortFrom(netip.MustParseAddr("127.0.0.1"), port) + } + if from != wantFrom { + t.Errorf("reply came from %v; want %v", from, wantFrom) + } + }) + } +} + +// TestAppendSrcMatchesUnix checks the hand-built control messages against +// the ones x/sys/unix builds. +func TestAppendSrcMatchesUnix(t *testing.T) { + v4 := netip.MustParseAddr("192.0.2.1") + v6 := netip.MustParseAddr("2001:db8::1") + + want4 := unix.PktInfo4(&unix.Inet4Pktinfo{Spec_dst: v4.As4()}) + if got := AppendSrc(nil, v4); string(got) != string(want4) { + t.Errorf("v4: got % x, want % x", got, want4) + } + want6 := unix.PktInfo6(&unix.Inet6Pktinfo{Addr: v6.As16()}) + if got := AppendSrc(nil, v6); string(got) != string(want6) { + t.Errorf("v6: got % x, want % x", got, want6) + } + if got := AppendSrc([]byte("prefix"), v4); string(got) != "prefix"+string(want4) { + t.Errorf("append: got % x", got) + } + for _, a := range []netip.Addr{{}, netip.IPv4Unspecified(), netip.IPv6Unspecified(), netip.MustParseAddr("224.0.0.1"), netip.MustParseAddr("ff02::1")} { + if got := AppendSrc(nil, a); got != nil { + t.Errorf("AppendSrc(%v) = % x; want nil", a, got) + } + } + if got := Dst(want4); got != v4 { + t.Errorf("Dst(v4 pktinfo) = %v; want %v", got, v4) + } + if got := Dst(want6); got != v6 { + t.Errorf("Dst(v6 pktinfo) = %v; want %v", got, v6) + } + mapped := unix.PktInfo6(&unix.Inet6Pktinfo{Addr: v4.As16()}) + if got := Dst(mapped); got != v4 { + t.Errorf("Dst(mapped v4 pktinfo) = %v; want %v", got, v4) + } +} + +// TestBroadcastDst verifies that an IPv4 broadcast datagram received on a +// dual-stack socket reports a unicast reply address, not the broadcast +// address, and that the reply then actually gets out. It needs a +// broadcast-capable interface and skips without one. +func TestBroadcastDst(t *testing.T) { + var local, bcast netip.Addr + ifs := must.Get(net.Interfaces()) + for _, ifi := range ifs { + const want = net.FlagUp | net.FlagBroadcast + if ifi.Flags&net.FlagLoopback != 0 || ifi.Flags&want != want { + continue + } + addrs, _ := ifi.Addrs() + for _, a := range addrs { + ipn, ok := a.(*net.IPNet) + if !ok || ipn.IP.To4() == nil { + continue + } + pfx := must.Get(netip.ParsePrefix(ipn.String())).Masked() + if pfx.Bits() > 30 { + continue // no directed broadcast address + } + local, _ = netip.AddrFromSlice(ipn.IP.To4()) + b := pfx.Addr().As4() + for i := range b { + b[i] |= ^ipn.Mask[i] + } + bcast = netip.AddrFrom4(b) + break + } + if bcast.IsValid() { + break + } + } + if !bcast.IsValid() { + t.Skip("no broadcast-capable IPv4 interface") + } + t.Logf("using local %v, broadcast %v", local, bcast) + + srv := must.Get(net.ListenUDP("udp", nil)) + defer srv.Close() + must.Do(Enable(srv)) + port := uint16(srv.LocalAddr().(*net.UDPAddr).Port) + gotDst := make(chan netip.Addr, 1) + go func() { + var buf, oob [1500]byte + n, oobn, _, from, err := srv.ReadMsgUDPAddrPort(buf[:], oob[:]) + if err != nil { + return + } + dst := Dst(oob[:oobn]) + gotDst <- dst + srv.WriteMsgUDPAddrPort(buf[:n], AppendSrc(nil, dst), from) + }() + + c := must.Get(net.ListenUDP("udp4", &net.UDPAddr{IP: local.AsSlice()})) + defer c.Close() + rc := must.Get(c.SyscallConn()) + rc.Control(func(fd uintptr) { + must.Do(unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_BROADCAST, 1)) + }) + c.SetDeadline(time.Now().Add(5 * time.Second)) + must.Get(c.WriteToUDPAddrPort([]byte("hello"), netip.AddrPortFrom(bcast, port))) + + var buf [1500]byte + _, from, err := c.ReadFromUDPAddrPort(buf[:]) + if err != nil { + t.Fatalf("reading reply: %v", err) + } + if dst := <-gotDst; dst != local { + t.Errorf("Dst = %v; want %v", dst, local) + } + if from.Addr() != local { + t.Errorf("reply came from %v; want %v", from.Addr(), local) + } +} diff --git a/net/pktinfo/pktinfo_other.go b/net/pktinfo/pktinfo_other.go new file mode 100644 index 000000000..cbfd2a314 --- /dev/null +++ b/net/pktinfo/pktinfo_other.go @@ -0,0 +1,18 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +//go:build !linux + +package pktinfo + +import ( + "errors" + "net" + "net/netip" +) + +func enable(pc *net.UDPConn) error { return errors.ErrUnsupported } + +func dst(oob []byte) netip.Addr { return netip.Addr{} } + +func appendSrc(b []byte, src netip.Addr) []byte { return b } diff --git a/net/stunserver/pktinfo_linux_test.go b/net/stunserver/pktinfo_linux_test.go new file mode 100644 index 000000000..24884097a --- /dev/null +++ b/net/stunserver/pktinfo_linux_test.go @@ -0,0 +1,70 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +package stunserver + +import ( + "context" + "net" + "net/netip" + "testing" + "time" + + "tailscale.com/net/stun" + "tailscale.com/util/cibuild" + "tailscale.com/util/must" +) + +// TestReplySourceAddr verifies that a response is sent from the address +// the request was sent to. It sends from 127.0.0.1 to the server at +// 127.0.0.2 (all of 127/8 is local on Linux); without pktinfo the kernel +// would reply from 127.0.0.1 instead. See the tests in net/pktinfo for the +// negative control and the v4-only socket case. +func TestReplySourceAddr(t *testing.T) { + // Listen always creates a dual-stack socket, which needs IPv6. + if c, err := net.ListenPacket("udp6", "[::1]:0"); err != nil { + if !cibuild.On() { + t.Skipf("IPv6 not supported: %v", err) + } + t.Fatalf("IPv6 not supported: %v", err) + } else { + c.Close() + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + s := New(ctx) + must.Do(s.Listen(":0")) + if !s.pktInfo { + t.Fatal("pktinfo not enabled") + } + go s.Serve() + port := uint16(s.LocalAddr().(*net.UDPAddr).Port) + serverAddr := netip.AddrPortFrom(netip.MustParseAddr("127.0.0.2"), port) + + c := must.Get(net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)})) + defer c.Close() + c.SetDeadline(time.Now().Add(5 * time.Second)) + txid := stun.NewTxID() + must.Get(c.WriteToUDPAddrPort(stun.Request(txid), serverAddr)) + + var buf [1500]byte + n, from, err := c.ReadFromUDPAddrPort(buf[:]) + if err != nil { + t.Fatalf("reading STUN response: %v", err) + } + if from != serverAddr { + t.Errorf("response came from %v; want %v", from, serverAddr) + } + tid, mapped, err := stun.ParseResponse(buf[:n]) + if err != nil { + t.Fatalf("parsing STUN response: %v", err) + } + if tid != txid { + t.Errorf("wrong transaction ID") + } + clientAddr := c.LocalAddr().(*net.UDPAddr).AddrPort() + if mapped != clientAddr { + t.Errorf("mapped address = %v; want %v", mapped, clientAddr) + } +} diff --git a/net/stunserver/stunserver.go b/net/stunserver/stunserver.go index 97df8cb4d..840c5dc20 100644 --- a/net/stunserver/stunserver.go +++ b/net/stunserver/stunserver.go @@ -8,6 +8,7 @@ package stunserver import ( "context" "errors" + "expvar" "io" "log" "net" @@ -15,6 +16,7 @@ import ( "time" "tailscale.com/metrics" + "tailscale.com/net/pktinfo" "tailscale.com/net/stun" ) @@ -29,11 +31,31 @@ var ( stunIPv4 = stunAddrFamily.Get("ipv4") stunIPv6 = stunAddrFamily.Get("ipv6") + + // stunNoLocalAddr counts requests for which the kernel didn't report + // the local address the request was sent to, despite pktinfo being + // enabled, so the response was sent from a kernel-chosen source + // address instead. + stunNoLocalAddr = newCounter("counter_no_local_addr") ) +func newCounter(name string) *expvar.Int { + v := new(expvar.Int) + stats.Set(name, v) + return v +} + type STUNServer struct { ctx context.Context // ctx signals service shutdown pc *net.UDPConn // pc is the UDP listener + + // pktInfo is whether the kernel reports the destination address of + // each request (see [pktinfo.Enable]). When it does, the response is + // sent from that same address rather than from whatever source + // address a route lookup on the reply's destination would pick. + // On a multi-homed server those differ, and replies from the wrong + // address break conntrack-based policy routing (tailscale/tailscale#21404). + pktInfo bool } // New creates a new STUN server. The server is shutdown when ctx is done. @@ -51,6 +73,11 @@ func (s *STUNServer) Listen(listenAddr string) error { if err != nil { return err } + if err := pktinfo.Enable(s.pc); err == nil { + s.pktInfo = true + } else if !errors.Is(err, errors.ErrUnsupported) { + log.Printf("STUN server: pktinfo unavailable; responses will use the kernel-chosen source address: %v", err) + } log.Printf("STUN server listening on %v", s.LocalAddr()) // close the listener on shutdown in order to break out of the read loop go func() { @@ -63,13 +90,9 @@ func (s *STUNServer) Listen(listenAddr string) error { // Serve starts serving responses to STUN requests. Listen must be called before Serve. func (s *STUNServer) Serve() error { var buf [64 << 10]byte - var ( - n int - ua *net.UDPAddr - err error - ) + var oob, oobOut [256]byte for { - n, ua, err = s.pc.ReadFromUDP(buf[:]) + n, remote, local, err := s.readFrom(buf[:], oob[:]) if err != nil { if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) { return nil @@ -89,15 +112,17 @@ func (s *STUNServer) Serve() error { stunNotSTUN.Add(1) continue } - if ua.IP.To4() != nil { + remote = netip.AddrPortFrom(remote.Addr().Unmap(), remote.Port()) + if remote.Addr().Is4() { stunIPv4.Add(1) } else { stunIPv6.Add(1) } - addr, _ := netip.AddrFromSlice(ua.IP) - res := stun.Response(txid, netip.AddrPortFrom(addr, uint16(ua.Port))) - _, err = s.pc.WriteTo(res, ua) - if err != nil { + if s.pktInfo && !local.IsValid() { + stunNoLocalAddr.Add(1) + } + res := stun.Response(txid, remote) + if err := s.writeTo(res, remote, local, oobOut[:0]); err != nil { stunWriteError.Add(1) } else { stunSuccess.Add(1) @@ -105,6 +130,34 @@ func (s *STUNServer) Serve() error { } } +// readFrom reads one datagram into buf, returning its length, its sender, +// and the local address it was sent to (the zero [netip.Addr] if unknown). +// oob is scratch space for control messages. +func (s *STUNServer) readFrom(buf, oob []byte) (n int, remote netip.AddrPort, local netip.Addr, err error) { + if !s.pktInfo { + n, remote, err = s.pc.ReadFromUDPAddrPort(buf) + return n, remote, netip.Addr{}, err + } + n, oobn, _, remote, err := s.pc.ReadMsgUDPAddrPort(buf, oob) + if err != nil { + return 0, remote, netip.Addr{}, err + } + return n, remote, pktinfo.Dst(oob[:oobn]), nil +} + +// writeTo sends b to remote from the local address local, if known. +// Otherwise the kernel picks the source address. oob is scratch space for +// control messages. +func (s *STUNServer) writeTo(b []byte, remote netip.AddrPort, local netip.Addr, oob []byte) error { + oob = pktinfo.AppendSrc(oob, local) + if len(oob) == 0 { + _, err := s.pc.WriteToUDPAddrPort(b, remote) + return err + } + _, _, err := s.pc.WriteMsgUDPAddrPort(b, oob, remote) + return err +} + // ListenAndServe starts the STUN server on listenAddr. func (s *STUNServer) ListenAndServe(listenAddr string) error { if err := s.Listen(listenAddr); err != nil { diff --git a/net/udprelay/server.go b/net/udprelay/server.go index 55c8c8d24..40cbbfca7 100644 --- a/net/udprelay/server.go +++ b/net/udprelay/server.go @@ -879,7 +879,8 @@ func (s *Server) packetReadLoop(readFromSocket, otherSocket batching.Conn, readF writeBuffsByDest := make(map[netip.AddrPort][][]byte, batching.MaximumWriteBatchSize) for { - // TODO: extract laddr from IP_PKTINFO for use in reply + // TODO: extract laddr from IP_PKTINFO for use in reply, using + // tailscale.com/net/pktinfo. // ReadBatch will split coalesced datagrams before returning, which // WriteBatchTo will re-coalesce further down. We _could_ be more // efficient and not split datagrams that belong to the same VNI if they