eburet-oss/sing-tun-lx
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add UDPEgressPool

Browse source
This commit is contained in:
世界 2026-07-17 10:40:08 +08:00
parent 95bc107a1c
commit 1ba7d79118
No known key found for this signature in database
GPG key ID: CD109927C34A63C4
4 changed files with 414 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

2
go.mod
View file

@ -11,7 +11,7 @@ require (
github.com/sagernet/gvisor v0.0.0-20250811.0-sing-box-mod.1
github.com/sagernet/netlink v0.0.0-20240612041022-b9a21c07ac6a
github.com/sagernet/nftables v0.3.0-mod.2
github.com/sagernet/sing v0.8.12-0.20260716111929-074fc9988b34
github.com/sagernet/sing v0.8.12-0.20260717023913-84ab32b56cb8
github.com/stretchr/testify v1.11.1
go4.org/netipx v0.0.0-20231129151722-fdeea329fbba
golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8

4
go.sum
View file

@ -24,8 +24,8 @@ github.com/sagernet/netlink v0.0.0-20240612041022-b9a21c07ac6a h1:ObwtHN2VpqE0ZN
github.com/sagernet/netlink v0.0.0-20240612041022-b9a21c07ac6a/go.mod h1:xLnfdiJbSp8rNqYEdIW/6eDO4mVoogml14Bh2hSiFpM=
github.com/sagernet/nftables v0.3.0-mod.2 h1:ck2KMU02OxL1eDFgGaWYglMDpoOZ7OHzxje+vW5Q0OQ=
github.com/sagernet/nftables v0.3.0-mod.2/go.mod h1:8kslHG4VvYNihcco+i6uxIX7qbT8A56T0y5q7U44ZaQ=
github.com/sagernet/sing v0.8.12-0.20260716111929-074fc9988b34 h1:rgSs2ttiz8EaubsOt0SkzsqciY0m0PRp3w/fOisPoNo=
github.com/sagernet/sing v0.8.12-0.20260716111929-074fc9988b34/go.mod h1:olXxWQNqRW/l2Q6JI3b2Qmz8iQnIFlOeeH8bx6JhgUA=
github.com/sagernet/sing v0.8.12-0.20260717023913-84ab32b56cb8 h1:dyRIj+MZ2rc9JVzJoG04jxu+MpvHrLIZLJr0QjNAMGg=
github.com/sagernet/sing v0.8.12-0.20260717023913-84ab32b56cb8/go.mod h1:olXxWQNqRW/l2Q6JI3b2Qmz8iQnIFlOeeH8bx6JhgUA=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/vishvananda/netns v0.0.4 h1:Oeaw1EM2JMxD51g9uhtC0D7erkIjgmj8+JZc26m1YX8=

287
udp_egress.go Normal file
View file

@ -0,0 +1,287 @@
package tun
import (
"context"
"net"
"net/netip"
"runtime"
"slices"
"sync"
"sync/atomic"
"github.com/sagernet/sing/common/buf"
"github.com/sagernet/sing/common/control"
E "github.com/sagernet/sing/common/exceptions"
"github.com/sagernet/sing/common/logger"
"github.com/sagernet/sing/common/x/list"
)
const udpEgressBufferSize = 65535
type UDPEgressPoolOptions struct {
Logger logger.Logger
Network string
Control control.Func
InterfaceFinder control.InterfaceFinder
InterfaceMonitor DefaultInterfaceMonitor
ExcludeInterface string
IsExempt func() bool
}
type UDPEgressPool struct {
logger logger.Logger
network string
control control.Func
interfaceFinder control.InterfaceFinder
interfaceMonitor DefaultInterfaceMonitor
excludeInterface string
isExempt func() bool
access sync.Mutex
port uint16
anchorInterfaceIndex int
receiveDone chan struct{}
members map[udpEgressSpec]*udpEgressMember
state atomic.Pointer[[]*udpEgressMember]
packetChan chan udpEgressPacket
memberReaders sync.WaitGroup
finderElement *list.Element[control.InterfaceUpdateCallback]
}
type udpEgressSpec struct {
interfaceIndex int
interfaceName string
prefix netip.Prefix
}
type udpEgressMember struct {
prefix netip.Prefix
conn *net.UDPConn
}
type udpEgressPacket struct {
buffer *buf.Buffer
source netip.AddrPort
}
func NewUDPEgressPool(options UDPEgressPoolOptions) *UDPEgressPool {
return &UDPEgressPool{
logger: options.Logger,
network: options.Network,
control: options.Control,
interfaceFinder: options.InterfaceFinder,
interfaceMonitor: options.InterfaceMonitor,
excludeInterface: options.ExcludeInterface,
isExempt: options.IsExempt,
anchorInterfaceIndex: -1,
members: make(map[udpEgressSpec]*udpEgressMember),
packetChan: make(chan udpEgressPacket, 128),
}
}
func (p *UDPEgressPool) Close() {
p.SetEgressPort(0)
p.access.Lock()
defer p.access.Unlock()
if p.finderElement != nil {
p.interfaceFinder.UnregisterInterfaceUpdateCallback(p.finderElement)
p.finderElement = nil
}
}
func (p *UDPEgressPool) SetEgressPort(port uint16) bool {
p.access.Lock()
defer p.access.Unlock()
if p.port == port {
return p.state.Load() != nil
}
if p.receiveDone != nil {
close(p.receiveDone)
p.receiveDone = nil
}
p.port = 0
p.state.Store(nil)
for spec, member := range p.members {
delete(p.members, spec)
member.conn.Close()
}
p.memberReaders.Wait()
for {
select {
case packet := <-p.packetChan:
packet.buffer.Release()
default:
goto drained
}
}
drained:
p.anchorInterfaceIndex = -1
if port == 0 {
return false
}
p.port = port
defaultInterface := p.interfaceMonitor.DefaultInterface()
if defaultInterface != nil {
p.anchorInterfaceIndex = defaultInterface.Index
}
p.receiveDone = make(chan struct{})
if p.finderElement == nil {
p.finderElement = p.interfaceFinder.RegisterInterfaceUpdateCallback(func(interfaces []control.Interface) {
p.access.Lock()
defer p.access.Unlock()
p.rebuildLocked()
})
}
p.rebuildLocked()
return p.state.Load() != nil
}
func (p *UDPEgressPool) LookupEgress(destination netip.AddrPort) *net.UDPConn {
members := p.state.Load()
if members == nil {
return nil
}
address := destination.Addr().Unmap()
for _, member := range *members {
if member.prefix.Contains(address) {
return member.conn
}
}
return nil
}
func (p *UDPEgressPool) ReceiveEgress(buffer []byte) (int, netip.AddrPort, error) {
p.access.Lock()
receiveDone := p.receiveDone
p.access.Unlock()
if receiveDone == nil {
return 0, netip.AddrPort{}, net.ErrClosed
}
select {
case <-receiveDone:
return 0, netip.AddrPort{}, net.ErrClosed
default:
}
select {
case packet := <-p.packetChan:
copied := copy(buffer, packet.buffer.Bytes())
packet.buffer.Release()
return copied, packet.source, nil
case <-receiveDone:
return 0, netip.AddrPort{}, net.ErrClosed
}
}
func (p *UDPEgressPool) rebuildLocked() {
if p.port == 0 {
return
}
specs := make(map[udpEgressSpec]struct{})
if !p.isExempt() {
for _, networkInterface := range p.interfaceFinder.Interfaces() {
if networkInterface.Flags&net.FlagUp == 0 ||
networkInterface.Flags&net.FlagLoopback != 0 ||
networkInterface.Flags&net.FlagPointToPoint != 0 ||
networkInterface.Flags&net.FlagBroadcast == 0 ||
networkInterface.Index == p.anchorInterfaceIndex ||
networkInterface.Name == p.excludeInterface {
continue
}
for _, prefix := range networkInterface.Addresses {
if !prefix.Addr().IsGlobalUnicast() {
continue
}
if p.network == "udp4" && !prefix.Addr().Is4() {
continue
}
if p.network == "udp6" && prefix.Addr().Is4() {
continue
}
specs[udpEgressSpec{
interfaceIndex: networkInterface.Index,
interfaceName: networkInterface.Name,
prefix: prefix,
}] = struct{}{}
}
}
}
for spec, member := range p.members {
_, loaded := specs[spec]
if loaded {
continue
}
delete(p.members, spec)
member.conn.Close()
}
for spec := range specs {
_, loaded := p.members[spec]
if loaded {
continue
}
memberConn, err := p.listenMember(spec)
if err != nil {
p.logger.Warn(E.Cause(err, "listen egress member on ", spec.interfaceName, " (", spec.prefix.Addr(), ")"))
continue
}
member := &udpEgressMember{
prefix: spec.prefix.Masked(),
conn: memberConn,
}
p.members[spec] = member
p.memberReaders.Add(1)
go p.readMember(member, p.receiveDone)
}
members := make([]*udpEgressMember, 0, len(p.members))
for _, member := range p.members {
members = append(members, member)
}
slices.SortFunc(members, func(firstMember, secondMember *udpEgressMember) int {
return secondMember.prefix.Bits() - firstMember.prefix.Bits()
})
if len(members) == 0 {
p.state.Store(nil)
} else {
p.state.Store(&members)
}
}
func (p *UDPEgressPool) listenMember(spec udpEgressSpec) (*net.UDPConn, error) {
var listenConfig net.ListenConfig
if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
listenConfig.Control = control.ReuseAddrOnly()
}
listenConfig.Control = control.Append(listenConfig.Control, control.DisableUDPNetReset())
listenConfig.Control = control.Append(listenConfig.Control, control.BindToInterface(p.interfaceFinder, spec.interfaceName, spec.interfaceIndex))
listenConfig.Control = control.Append(listenConfig.Control, p.control)
var network string
if spec.prefix.Addr().Is4() {
network = "udp4"
} else {
network = "udp6"
}
packetConn, err := listenConfig.ListenPacket(context.Background(), network, netip.AddrPortFrom(spec.prefix.Addr(), p.port).String())
if err != nil {
return nil, err
}
return packetConn.(*net.UDPConn), nil
}
func (p *UDPEgressPool) readMember(member *udpEgressMember, doneChan <-chan struct{}) {
defer p.memberReaders.Done()
for {
buffer := buf.NewSize(udpEgressBufferSize)
dataLength, source, err := member.conn.ReadFromUDPAddrPort(buffer.FreeBytes())
if err != nil {
buffer.Release()
return
}
buffer.Extend(dataLength)
select {
case p.packetChan <- udpEgressPacket{buffer: buffer, source: source}:
case <-doneChan:
buffer.Release()
return
default:
buffer.Release()
}
}
}

124
udp_egress_conn.go Normal file
View file

@ -0,0 +1,124 @@
package tun
import (
"net"
"net/netip"
"sync"
"time"
"github.com/sagernet/sing/common/buf"
E "github.com/sagernet/sing/common/exceptions"
)
type UDPEgressConn struct {
anchor *net.UDPConn
pool *UDPEgressPool
packetChan chan udpEgressConnPacket
doneChan chan struct{}
closeOnce sync.Once
readWait sync.WaitGroup
}
type udpEgressConnPacket struct {
buffer *buf.Buffer
source netip.AddrPort
err error
}
func NewUDPEgressConn(anchor *net.UDPConn, pool *UDPEgressPool) *UDPEgressConn {
conn := &UDPEgressConn{
anchor: anchor,
pool: pool,
packetChan: make(chan udpEgressConnPacket, 64),
doneChan: make(chan struct{}),
}
conn.readWait.Add(2)
go conn.read(anchor.ReadFromUDPAddrPort)
go conn.read(pool.ReceiveEgress)
return conn
}
func (c *UDPEgressConn) read(readPacket func([]byte) (int, netip.AddrPort, error)) {
defer c.readWait.Done()
for {
buffer := buf.NewSize(udpEgressBufferSize)
dataLength, source, err := readPacket(buffer.FreeBytes())
if err != nil {
buffer.Release()
if E.IsClosed(err) {
return
}
select {
case c.packetChan <- udpEgressConnPacket{err: err}:
case <-c.doneChan:
return
}
continue
}
buffer.Extend(dataLength)
select {
case c.packetChan <- udpEgressConnPacket{buffer: buffer, source: source}:
case <-c.doneChan:
buffer.Release()
return
}
}
}
func (c *UDPEgressConn) ReadFromUDPAddrPort(buffer []byte) (int, netip.AddrPort, error) {
select {
case packet := <-c.packetChan:
if packet.err != nil {
return 0, netip.AddrPort{}, packet.err
}
copied := copy(buffer, packet.buffer.Bytes())
packet.buffer.Release()
return copied, packet.source, nil
case <-c.doneChan:
return 0, netip.AddrPort{}, net.ErrClosed
}
}
func (c *UDPEgressConn) WriteToUDPAddrPort(buffer []byte, destination netip.AddrPort) (int, error) {
memberConn := c.pool.LookupEgress(destination)
if memberConn != nil {
return memberConn.WriteToUDPAddrPort(buffer, destination)
}
return c.anchor.WriteToUDPAddrPort(buffer, destination)
}
func (c *UDPEgressConn) LocalAddr() net.Addr {
return c.anchor.LocalAddr()
}
func (c *UDPEgressConn) SetDeadline(t time.Time) error {
return c.anchor.SetDeadline(t)
}
func (c *UDPEgressConn) SetReadDeadline(t time.Time) error {
return c.anchor.SetReadDeadline(t)
}
func (c *UDPEgressConn) SetWriteDeadline(t time.Time) error {
return c.anchor.SetWriteDeadline(t)
}
func (c *UDPEgressConn) Close() error {
c.closeOnce.Do(func() {
close(c.doneChan)
c.anchor.Close()
c.pool.Close()
c.readWait.Wait()
for {
select {
case packet := <-c.packetChan:
if packet.buffer != nil {
packet.buffer.Release()
}
default:
return
}
}
})
return nil
}