init

go-gost/x/internal/net/addr.go

@@ -0,0 +1,199 @@
+package net
+
+import (
+	"fmt"
+	"net"
+	"net/netip"
+	"strconv"
+	"strings"
+)
+
+func ParseInterfaceAddr(ifceName, network string) (ifce string, addr []net.Addr, err error) {
+	if ifceName == "" {
+		addr = append(addr, nil)
+		return
+	}
+
+	ip := net.ParseIP(ifceName)
+	if ip == nil {
+		var ife *net.Interface
+		ife, err = net.InterfaceByName(ifceName)
+		if err != nil {
+			return
+		}
+		var addrs []net.Addr
+		addrs, err = ife.Addrs()
+		if err != nil {
+			return
+		}
+		if len(addrs) == 0 {
+			err = fmt.Errorf("addr not found for interface %s", ifceName)
+			return
+		}
+		ifce = ifceName
+		for _, addr_ := range addrs {
+			if ipNet, ok := addr_.(*net.IPNet); ok {
+				addr = append(addr, ipToAddr(ipNet.IP, network))
+			}
+		}
+	} else {
+		ifce, err = findInterfaceByIP(ip)
+		if err != nil {
+			return
+		}
+		addr = []net.Addr{ipToAddr(ip, network)}
+	}
+
+	return
+}
+
+func ipToAddr(ip net.IP, network string) (addr net.Addr) {
+	port := 0
+	switch network {
+	case "tcp", "tcp4", "tcp6":
+		addr = &net.TCPAddr{IP: ip, Port: port}
+		return
+	case "udp", "udp4", "udp6":
+		addr = &net.UDPAddr{IP: ip, Port: port}
+		return
+	default:
+		addr = &net.IPAddr{IP: ip}
+		return
+	}
+}
+
+func findInterfaceByIP(ip net.IP) (string, error) {
+	ifces, err := net.Interfaces()
+	if err != nil {
+		return "", err
+	}
+	for _, ifce := range ifces {
+		addrs, _ := ifce.Addrs()
+		if len(addrs) == 0 {
+			continue
+		}
+		for _, addr := range addrs {
+			ipAddr, _ := addr.(*net.IPNet)
+			if ipAddr == nil {
+				continue
+			}
+			// logger.Default().Infof("%s-%s", ipAddr, ip)
+			if ipAddr.IP.Equal(ip) {
+				return ifce.Name, nil
+			}
+		}
+	}
+	return "", nil
+}
+
+// AddrPortRange is the network address with port range supported.
+// e.g. 192.168.1.1:0-65535
+type AddrPortRange string
+
+func (p AddrPortRange) Addrs() (addrs []string) {
+	// ignore url scheme, e.g. http://, tls://, tcp://.
+	if strings.Contains(string(p), "://") {
+		return nil
+	}
+
+	h, sp, err := net.SplitHostPort(string(p))
+	if err != nil {
+		return nil
+	}
+
+	pr := PortRange{}
+	pr.Parse(sp)
+
+	for i := pr.Min; i <= pr.Max; i++ {
+		addrs = append(addrs, net.JoinHostPort(h, strconv.Itoa(i)))
+	}
+	return addrs
+}
+
+// Port range is a range of port list.
+type PortRange struct {
+	Min int
+	Max int
+}
+
+// Parse parses the s to PortRange.
+// The s can be a single port number and will be converted to port range port-port.
+func (pr *PortRange) Parse(s string) error {
+	minmax := strings.Split(s, "-")
+	switch len(minmax) {
+	case 1:
+		port, err := strconv.Atoi(s)
+		if err != nil {
+			return err
+		}
+		if port < 0 || port > 65535 {
+			return fmt.Errorf("invalid port: %s", s)
+		}
+
+		pr.Min, pr.Max = port, port
+		return nil
+
+	case 2:
+		min, err := strconv.Atoi(minmax[0])
+		if err != nil {
+			return err
+		}
+		max, err := strconv.Atoi(minmax[1])
+		if err != nil {
+			return err
+		}
+
+		pr.Min, pr.Max = min, max
+		return nil
+
+	default:
+		return fmt.Errorf("invalid port range: %s", s)
+	}
+}
+
+func (pr *PortRange) Contains(port int) bool {
+	return port >= pr.Min && port <= pr.Max
+}
+
+type IPRange struct {
+	Min netip.Addr
+	Max netip.Addr
+}
+
+func (r *IPRange) Parse(s string) error {
+	minmax := strings.Split(s, "-")
+	switch len(minmax) {
+	case 1:
+		addr, err := netip.ParseAddr(strings.TrimSpace(s))
+		if err != nil {
+			return err
+		}
+
+		r.Min, r.Max = addr, addr
+		return nil
+
+	case 2:
+		min, err := netip.ParseAddr(strings.TrimSpace(minmax[0]))
+		if err != nil {
+			return err
+		}
+		max, err := netip.ParseAddr(strings.TrimSpace(minmax[1]))
+		if err != nil {
+			return err
+		}
+
+		r.Min, r.Max = min, max
+		return nil
+
+	default:
+		return fmt.Errorf("invalid ip range: %s", s)
+	}
+}
+
+func (r *IPRange) Contains(addr netip.Addr) bool {
+	return !(addr.Less(r.Min) || r.Max.Less(addr))
+}
+
+type ClientAddr interface {
+	ClientAddr() net.Addr
+}

go-gost/x/internal/net/dialer/dialer.go

@@ -0,0 +1,180 @@
+package dialer
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/go-gost/core/logger"
+	ctxvalue "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
+	"github.com/vishvananda/netns"
+)
+
+const (
+	DefaultTimeout = 10 * time.Second
+)
+
+var (
+	DefaultNetDialer = &Dialer{}
+)
+
+type Dialer struct {
+	Interface string
+	Netns     string
+	Mark      int
+	DialFunc  func(ctx context.Context, network, addr string) (net.Conn, error)
+	Logger    logger.Logger
+}
+
+func (d *Dialer) Dial(ctx context.Context, network, addr string) (conn net.Conn, err error) {
+	if d == nil {
+		d = DefaultNetDialer
+	}
+
+	log := d.Logger
+	if log == nil {
+		log = logger.Default()
+	}
+	log = log.WithFields(map[string]any{
+		"sid": ctxvalue.SidFromContext(ctx),
+	})
+
+	if d.Netns != "" {
+		runtime.LockOSThread()
+		defer runtime.UnlockOSThread()
+
+		originNs, err := netns.Get()
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(): %v", err)
+		}
+		defer netns.Set(originNs)
+
+		var ns netns.NsHandle
+		if strings.HasPrefix(d.Netns, "/") {
+			ns, err = netns.GetFromPath(d.Netns)
+		} else {
+			ns, err = netns.GetFromName(d.Netns)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(%s): %v", d.Netns, err)
+		}
+		defer ns.Close()
+
+		if err := netns.Set(ns); err != nil {
+			return nil, fmt.Errorf("netns.Set(%s): %v", d.Netns, err)
+		}
+	}
+
+	if d.DialFunc != nil {
+		return d.DialFunc(ctx, network, addr)
+	}
+
+	switch network {
+	case "unix":
+		netd := net.Dialer{}
+		return netd.DialContext(ctx, network, addr)
+	default:
+	}
+
+	ifces := strings.Split(d.Interface, ",")
+	for _, ifce := range ifces {
+		strict := strings.HasSuffix(ifce, "!")
+		ifce = strings.TrimSuffix(ifce, "!")
+		var ifceName string
+		var ifAddrs []net.Addr
+		ifceName, ifAddrs, err = xnet.ParseInterfaceAddr(ifce, network)
+		if err != nil && strict {
+			return
+		}
+
+		for _, ifAddr := range ifAddrs {
+			conn, err = d.dialOnce(ctx, network, addr, ifceName, ifAddr, log)
+			if err == nil {
+				return
+			}
+
+			log.Debugf("dial %s %v@%s failed: %s", network, ifAddr, ifceName, err)
+
+			if strict &&
+				!strings.Contains(err.Error(), "no suitable address found") &&
+				!strings.Contains(err.Error(), "mismatched local address type") {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (d *Dialer) dialOnce(ctx context.Context, network, addr, ifceName string, ifAddr net.Addr, log logger.Logger) (net.Conn, error) {
+	if ifceName != "" {
+		log.Debugf("interface: %s %v/%s", ifceName, ifAddr, network)
+	}
+
+	switch network {
+	case "udp", "udp4", "udp6":
+		if addr == "" {
+			var laddr *net.UDPAddr
+			if ifAddr != nil {
+				laddr, _ = ifAddr.(*net.UDPAddr)
+			}
+
+			c, err := net.ListenUDP(network, laddr)
+			if err != nil {
+				return nil, err
+			}
+			sc, err := c.SyscallConn()
+			if err != nil {
+				log.Error(err)
+				return nil, err
+			}
+			err = sc.Control(func(fd uintptr) {
+				if ifceName != "" {
+					if err := bindDevice(fd, ifceName); err != nil {
+						log.Warnf("bind device: %v", err)
+					}
+				}
+				if d.Mark != 0 {
+					if err := setMark(fd, d.Mark); err != nil {
+						log.Warnf("set mark: %v", err)
+					}
+				}
+			})
+			if err != nil {
+				log.Error(err)
+			}
+			return c, nil
+		}
+	case "tcp", "tcp4", "tcp6":
+	default:
+		return nil, fmt.Errorf("dial: unsupported network %s", network)
+	}
+	netd := net.Dialer{
+		LocalAddr: ifAddr,
+		Control: func(network, address string, c syscall.RawConn) error {
+			return c.Control(func(fd uintptr) {
+				if ifceName != "" {
+					if err := bindDevice(fd, ifceName); err != nil {
+						log.Warnf("bind device: %v", err)
+					}
+				}
+				if d.Mark != 0 {
+					if err := setMark(fd, d.Mark); err != nil {
+						log.Warnf("set mark: %v", err)
+					}
+				}
+			})
+		},
+	}
+	if d.Netns != "" {
+		// https://github.com/golang/go/issues/44922#issuecomment-796645858
+		netd.FallbackDelay = -1
+	}
+
+	return netd.DialContext(ctx, network, addr)
+}

go-gost/x/internal/net/dialer/dialer_linux.go

@@ -0,0 +1,19 @@
+package dialer
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+func bindDevice(fd uintptr, ifceName string) error {
+	if ifceName == "" {
+		return nil
+	}
+	return unix.BindToDevice(int(fd), ifceName)
+}
+
+func setMark(fd uintptr, mark int) error {
+	if mark == 0 {
+		return nil
+	}
+	return unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_MARK, mark)
+}

go-gost/x/internal/net/dialer/dialer_other.go

@@ -0,0 +1,11 @@
+//go:build !linux
+
+package dialer
+
+func bindDevice(fd uintptr, ifceName string) error {
+	return nil
+}
+
+func setMark(fd uintptr, mark int) error {
+	return nil
+}

go-gost/x/internal/net/http/http.go

@@ -0,0 +1,72 @@
+package http
+
+import (
+	"bytes"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+)
+
+func GetClientIP(req *http.Request) net.IP {
+	if req == nil {
+		return nil
+	}
+	// cloudflare CDN
+	sip := req.Header.Get("CF-Connecting-IP")
+	if sip == "" {
+		ss := strings.Split(req.Header.Get("X-Forwarded-For"), ",")
+		if len(ss) > 0 && ss[0] != "" {
+			sip = ss[0]
+		}
+	}
+	if sip == "" {
+		sip = req.Header.Get("X-Real-Ip")
+	}
+
+	return net.ParseIP(sip)
+}
+
+type Body struct {
+	r          io.ReadCloser
+	buf        bytes.Buffer
+	length     int64
+	recordSize int
+}
+
+func NewBody(r io.ReadCloser, maxRecordSize int) *Body {
+	p := &Body{
+		r:          r,
+		recordSize: maxRecordSize,
+	}
+
+	return p
+}
+
+func (p *Body) Read(b []byte) (n int, err error) {
+	n, err = p.r.Read(b)
+	p.length += int64(n)
+
+	if p.recordSize > 0 {
+		b = b[:n]
+		if n > p.recordSize {
+			b = b[:p.recordSize]
+		}
+		p.buf.Write(b)
+		p.recordSize -= n
+	}
+
+	return
+}
+
+func (p *Body) Close() error {
+	return p.r.Close()
+}
+
+func (p *Body) Content() []byte {
+	return p.buf.Bytes()
+}
+
+func (p *Body) Length() int64 {
+	return p.length
+}

go-gost/x/internal/net/ip/ip.go

@@ -0,0 +1,26 @@
+package ip
+
+import (
+	"fmt"
+
+	"github.com/songgao/water/waterutil"
+)
+
+var prots = map[waterutil.IPProtocol]string{
+	waterutil.HOPOPT:     "HOPOPT",
+	waterutil.ICMP:       "ICMP",
+	waterutil.IGMP:       "IGMP",
+	waterutil.GGP:        "GGP",
+	waterutil.TCP:        "TCP",
+	waterutil.UDP:        "UDP",
+	waterutil.IPv6_Route: "IPv6-Route",
+	waterutil.IPv6_Frag:  "IPv6-Frag",
+	waterutil.IPv6_ICMP:  "IPv6-ICMP",
+}
+
+func Protocol(p waterutil.IPProtocol) string {
+	if v, ok := prots[p]; ok {
+		return v
+	}
+	return fmt.Sprintf("unknown(%d)", p)
+}

go-gost/x/internal/net/net.go

@@ -0,0 +1,121 @@
+package net
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"runtime"
+	"strings"
+	"syscall"
+
+	"github.com/vishvananda/netns"
+)
+
+type SetBuffer interface {
+	SetReadBuffer(bytes int) error
+	SetWriteBuffer(bytes int) error
+}
+
+type SyscallConn interface {
+	SyscallConn() (syscall.RawConn, error)
+}
+
+type RemoteAddr interface {
+	RemoteAddr() net.Addr
+}
+
+// tcpraw.TCPConn
+type SetDSCP interface {
+	SetDSCP(int) error
+}
+
+func IsIPv4(address string) bool {
+	return address != "" && address[0] != ':' && address[0] != '['
+}
+
+type ListenConfig struct {
+	Netns string
+	net.ListenConfig
+}
+
+func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (net.Listener, error) {
+	if lc.Netns != "" {
+		runtime.LockOSThread()
+		defer runtime.UnlockOSThread()
+
+		originNs, err := netns.Get()
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(): %v", err)
+		}
+		defer netns.Set(originNs)
+
+		var ns netns.NsHandle
+		if strings.HasPrefix(lc.Netns, "/") {
+			ns, err = netns.GetFromPath(lc.Netns)
+		} else {
+			ns, err = netns.GetFromName(lc.Netns)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(%s): %v", lc.Netns, err)
+		}
+		defer ns.Close()
+
+		if err := netns.Set(ns); err != nil {
+			return nil, fmt.Errorf("netns.Set(%s): %v", lc.Netns, err)
+		}
+	}
+
+	return lc.ListenConfig.Listen(ctx, network, address)
+}
+
+func (lc *ListenConfig) ListenPacket(ctx context.Context, network, address string) (net.PacketConn, error) {
+	if lc.Netns != "" {
+		runtime.LockOSThread()
+		defer runtime.UnlockOSThread()
+
+		originNs, err := netns.Get()
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(): %v", err)
+		}
+		defer netns.Set(originNs)
+
+		var ns netns.NsHandle
+		if strings.HasPrefix(lc.Netns, "/") {
+			ns, err = netns.GetFromPath(lc.Netns)
+		} else {
+			ns, err = netns.GetFromName(lc.Netns)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("netns.Get(%s): %v", lc.Netns, err)
+		}
+		defer ns.Close()
+
+		if err := netns.Set(ns); err != nil {
+			return nil, fmt.Errorf("netns.Set(%s): %v", lc.Netns, err)
+		}
+	}
+	return lc.ListenConfig.ListenPacket(ctx, network, address)
+}
+
+type readWriteConn struct {
+	net.Conn
+	r io.Reader
+	w io.Writer
+}
+
+func NewReadWriteConn(r io.Reader, w io.Writer, c net.Conn) net.Conn {
+	return &readWriteConn{
+		Conn: c,
+		r:    r,
+		w:    w,
+	}
+}
+
+func (c *readWriteConn) Read(p []byte) (int, error) {
+	return c.r.Read(p)
+}
+
+func (c *readWriteConn) Write(p []byte) (int, error) {
+	return c.w.Write(p)
+}

go-gost/x/internal/net/proxyproto/conn.go

@@ -0,0 +1,17 @@
+package proxyproto
+
+import (
+	"net"
+
+	proxyproto "github.com/pires/go-proxyproto"
+)
+
+func WrapClientConn(ppv int, src, dst net.Addr, c net.Conn) net.Conn {
+	if ppv <= 0 {
+		return c
+	}
+
+	header := proxyproto.HeaderProxyFromAddrs(byte(ppv), src, dst)
+	header.WriteTo(c)
+	return c
+}

go-gost/x/internal/net/proxyproto/listener.go

@@ -0,0 +1,19 @@
+package proxyproto
+
+import (
+	"net"
+	"time"
+
+	proxyproto "github.com/pires/go-proxyproto"
+)
+
+func WrapListener(ppv int, ln net.Listener, readHeaderTimeout time.Duration) net.Listener {
+	if ppv <= 0 {
+		return ln
+	}
+
+	return &proxyproto.Listener{
+		Listener:          ln,
+		ReadHeaderTimeout: readHeaderTimeout,
+	}
+}

go-gost/x/internal/net/resovle.go

@@ -0,0 +1,52 @@
+package net
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	"github.com/go-gost/core/hosts"
+	"github.com/go-gost/core/logger"
+	"github.com/go-gost/core/resolver"
+	ctxvalue "github.com/go-gost/x/ctx"
+)
+
+func Resolve(ctx context.Context, network, addr string, r resolver.Resolver, hosts hosts.HostMapper, log logger.Logger) (string, error) {
+	if addr == "" {
+		return addr, nil
+	}
+
+	host, port, _ := net.SplitHostPort(addr)
+	if host == "" {
+		return addr, nil
+	}
+
+	if log == nil {
+		log = logger.Default()
+	}
+	log = log.WithFields(map[string]any{
+		"sid": ctxvalue.SidFromContext(ctx),
+	})
+
+	if hosts != nil {
+		if ips, _ := hosts.Lookup(ctx, network, host); len(ips) > 0 {
+			log.Debugf("hit host mapper: %s -> %s", host, ips)
+			return net.JoinHostPort(ips[0].String(), port), nil
+		}
+	}
+
+	if r != nil {
+		ips, err := r.Resolve(ctx, network, host)
+		if err != nil {
+			if err == resolver.ErrInvalid {
+				return addr, nil
+			}
+			log.Error(err)
+		}
+		if len(ips) == 0 {
+			return "", fmt.Errorf("resolver: domain %s does not exist", host)
+		}
+		return net.JoinHostPort(ips[0].String(), port), nil
+	}
+	return addr, nil
+}

go-gost/x/internal/net/transport.go

@@ -0,0 +1,36 @@
+package net
+
+import (
+	"io"
+
+	"github.com/go-gost/core/common/bufpool"
+)
+
+const (
+	bufferSize = 64 * 1024
+)
+
+func Transport(rw1, rw2 io.ReadWriter) error {
+	errc := make(chan error, 1)
+	go func() {
+		errc <- CopyBuffer(rw1, rw2, bufferSize)
+	}()
+
+	go func() {
+		errc <- CopyBuffer(rw2, rw1, bufferSize)
+	}()
+
+	if err := <-errc; err != nil && err != io.EOF {
+		return err
+	}
+
+	return nil
+}
+
+func CopyBuffer(dst io.Writer, src io.Reader, bufSize int) error {
+	buf := bufpool.Get(bufSize)
+	defer bufpool.Put(buf)
+
+	_, err := io.CopyBuffer(dst, src, buf)
+	return err
+}

go-gost/x/internal/net/udp/conn.go

@@ -0,0 +1,29 @@
+package udp
+
+import (
+	"io"
+	"net"
+
+	xnet "github.com/go-gost/x/internal/net"
+)
+
+type Conn interface {
+	net.PacketConn
+	io.Reader
+	io.Writer
+	ReadUDP
+	WriteUDP
+	xnet.SetBuffer
+	xnet.SyscallConn
+	xnet.RemoteAddr
+}
+
+type ReadUDP interface {
+	ReadFromUDP(b []byte) (n int, addr *net.UDPAddr, err error)
+	ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *net.UDPAddr, err error)
+}
+
+type WriteUDP interface {
+	WriteToUDP(b []byte, addr *net.UDPAddr) (int, error)
+	WriteMsgUDP(b, oob []byte, addr *net.UDPAddr) (n, oobn int, err error)
+}

go-gost/x/internal/net/udp/listener.go

@@ -0,0 +1,238 @@
+package udp
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-gost/core/common/bufpool"
+	"github.com/go-gost/core/logger"
+)
+
+type ListenConfig struct {
+	Addr           net.Addr
+	Backlog        int
+	ReadQueueSize  int
+	ReadBufferSize int
+	TTL            time.Duration
+	Keepalive      bool
+	Logger         logger.Logger
+}
+type listener struct {
+	conn     net.PacketConn
+	cqueue   chan net.Conn
+	connPool *connPool
+	closed   chan struct{}
+	errChan  chan error
+	config   *ListenConfig
+}
+
+func NewListener(conn net.PacketConn, cfg *ListenConfig) net.Listener {
+	if cfg == nil {
+		cfg = &ListenConfig{}
+	}
+
+	ln := &listener{
+		conn:    conn,
+		cqueue:  make(chan net.Conn, cfg.Backlog),
+		closed:  make(chan struct{}),
+		errChan: make(chan error, 1),
+		config:  cfg,
+	}
+	ln.connPool = newConnPool(cfg.TTL).WithLogger(cfg.Logger)
+	go ln.listenLoop()
+
+	return ln
+}
+
+func (ln *listener) Accept() (conn net.Conn, err error) {
+	select {
+	case conn = <-ln.cqueue:
+		return
+	case <-ln.closed:
+		return nil, net.ErrClosed
+	case err = <-ln.errChan:
+		if err == nil {
+			err = net.ErrClosed
+		}
+		return
+	}
+}
+
+func (ln *listener) listenLoop() {
+	for {
+		select {
+		case <-ln.closed:
+			return
+		default:
+		}
+
+		b := bufpool.Get(ln.config.ReadBufferSize)
+
+		n, raddr, err := ln.conn.ReadFrom(b)
+		if err != nil {
+			ln.errChan <- err
+			close(ln.errChan)
+			return
+		}
+
+		c := ln.getConn(raddr)
+		if c == nil {
+			bufpool.Put(b)
+			continue
+		}
+
+		if err := c.WriteQueue(b[:n]); err != nil {
+			ln.config.Logger.Warn("data discarded: ", err)
+		}
+	}
+}
+
+func (ln *listener) Addr() net.Addr {
+	if ln.config.Addr != nil {
+		return ln.config.Addr
+	}
+	return ln.conn.LocalAddr()
+}
+
+func (ln *listener) Close() error {
+	select {
+	case <-ln.closed:
+	default:
+		close(ln.closed)
+		ln.conn.Close()
+		ln.connPool.Close()
+	}
+
+	return nil
+}
+
+func (ln *listener) getConn(raddr net.Addr) *conn {
+	c, ok := ln.connPool.Get(raddr.String())
+	if ok && !c.isClosed() {
+		return c
+	}
+
+	c = newConn(ln.conn, ln.Addr(), raddr, ln.config.ReadQueueSize, ln.config.Keepalive)
+	select {
+	case ln.cqueue <- c:
+		ln.connPool.Set(raddr.String(), c)
+		return c
+	default:
+		c.Close()
+		ln.config.Logger.Warnf("connection queue is full, client %s discarded", raddr)
+		return nil
+	}
+}
+
+// conn is a server side connection for UDP client peer, it implements net.Conn and net.PacketConn.
+type conn struct {
+	net.PacketConn
+	localAddr  net.Addr
+	remoteAddr net.Addr
+	rc         chan []byte // data receive queue
+	idle       int32       // indicate the connection is idle
+	closed     chan struct{}
+	closeMutex sync.Mutex
+	keepalive  bool
+}
+
+func newConn(c net.PacketConn, laddr, remoteAddr net.Addr, queueSize int, keepalive bool) *conn {
+	return &conn{
+		PacketConn: c,
+		localAddr:  laddr,
+		remoteAddr: remoteAddr,
+		rc:         make(chan []byte, queueSize),
+		closed:     make(chan struct{}),
+		keepalive:  keepalive,
+	}
+}
+
+func (c *conn) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
+	select {
+	case bb := <-c.rc:
+		n = copy(b, bb)
+		c.SetIdle(false)
+		bufpool.Put(bb)
+
+	case <-c.closed:
+		err = net.ErrClosed
+		return
+	}
+
+	addr = c.remoteAddr
+
+	return
+}
+
+func (c *conn) Read(b []byte) (n int, err error) {
+	n, _, err = c.ReadFrom(b)
+	return
+}
+
+func (c *conn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
+	if !c.keepalive {
+		defer c.Close()
+	}
+	return c.PacketConn.WriteTo(b, addr)
+}
+
+func (c *conn) Write(b []byte) (n int, err error) {
+	return c.WriteTo(b, c.remoteAddr)
+}
+
+func (c *conn) Close() error {
+	c.closeMutex.Lock()
+	defer c.closeMutex.Unlock()
+
+	select {
+	case <-c.closed:
+	default:
+		close(c.closed)
+	}
+	return nil
+}
+
+func (c *conn) isClosed() bool {
+	select {
+	case <-c.closed:
+		return true
+	default:
+		return false
+	}
+}
+
+func (c *conn) LocalAddr() net.Addr {
+	return c.localAddr
+}
+
+func (c *conn) RemoteAddr() net.Addr {
+	return c.remoteAddr
+}
+
+func (c *conn) IsIdle() bool {
+	return atomic.LoadInt32(&c.idle) > 0
+}
+
+func (c *conn) SetIdle(idle bool) {
+	v := int32(0)
+	if idle {
+		v = 1
+	}
+	atomic.StoreInt32(&c.idle, v)
+}
+
+func (c *conn) WriteQueue(b []byte) error {
+	select {
+	case c.rc <- b:
+		return nil
+
+	case <-c.closed:
+		return net.ErrClosed
+
+	default:
+		return errors.New("recv queue is full")
+	}
+}

go-gost/x/internal/net/udp/pool.go

@@ -0,0 +1,115 @@
+package udp
+
+import (
+	"sync"
+	"time"
+
+	"github.com/go-gost/core/logger"
+)
+
+type connPool struct {
+	m      sync.Map
+	ttl    time.Duration
+	closed chan struct{}
+	logger logger.Logger
+}
+
+func newConnPool(ttl time.Duration) *connPool {
+	p := &connPool{
+		ttl:    ttl,
+		closed: make(chan struct{}),
+	}
+	go p.idleCheck()
+	return p
+}
+
+func (p *connPool) WithLogger(logger logger.Logger) *connPool {
+	p.logger = logger
+	return p
+}
+
+func (p *connPool) Get(key any) (c *conn, ok bool) {
+	if p == nil {
+		return
+	}
+
+	v, ok := p.m.Load(key)
+	if ok {
+		c, ok = v.(*conn)
+	}
+	return
+}
+
+func (p *connPool) Set(key any, c *conn) {
+	if p == nil {
+		return
+	}
+
+	p.m.Store(key, c)
+}
+
+func (p *connPool) Delete(key any) {
+	if p == nil {
+		return
+	}
+	p.m.Delete(key)
+}
+
+func (p *connPool) Close() {
+	if p == nil {
+		return
+	}
+
+	select {
+	case <-p.closed:
+		return
+	default:
+	}
+
+	close(p.closed)
+
+	p.m.Range(func(k, v any) bool {
+		if c, ok := v.(*conn); ok && c != nil {
+			c.Close()
+		}
+		return true
+	})
+}
+
+func (p *connPool) idleCheck() {
+	ticker := time.NewTicker(p.ttl)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			size := 0
+			idles := 0
+			p.m.Range(func(key, value any) bool {
+				c, ok := value.(*conn)
+				if !ok || c == nil {
+					p.Delete(key)
+					return true
+				}
+				size++
+
+				if c.IsIdle() {
+					idles++
+					p.Delete(key)
+					c.Close()
+					return true
+				}
+
+				c.SetIdle(true)
+
+				return true
+			})
+
+			if idles > 0 {
+				p.logger.Debugf("connection pool: size=%d, idle=%d", size, idles)
+			}
+		case <-p.closed:
+			return
+		}
+	}
+}

go-gost/x/internal/net/udp/relay.go

@@ -0,0 +1,117 @@
+package udp
+
+import (
+	"context"
+	"math"
+	"net"
+
+	"github.com/go-gost/core/bypass"
+	"github.com/go-gost/core/logger"
+)
+
+const (
+	MaxMessageSize = math.MaxUint16
+)
+
+type Relay struct {
+	pc1 net.PacketConn
+	pc2 net.PacketConn
+
+	bypass bypass.Bypass
+	logger logger.Logger
+}
+
+func NewRelay(pc1, pc2 net.PacketConn) *Relay {
+	return &Relay{
+		pc1: pc1,
+		pc2: pc2,
+	}
+}
+
+func (r *Relay) WithBypass(bp bypass.Bypass) *Relay {
+	r.bypass = bp
+	return r
+}
+
+func (r *Relay) WithLogger(logger logger.Logger) *Relay {
+	r.logger = logger
+	return r
+}
+
+func (r *Relay) Run(ctx context.Context) (err error) {
+	errc := make(chan error, 2)
+
+	go func() {
+		var b [MaxMessageSize]byte
+		for {
+			err := func() error {
+				n, raddr, err := r.pc1.ReadFrom(b[:])
+				if err != nil {
+					return err
+				}
+
+				if r.bypass != nil && r.bypass.Contains(ctx, "udp", raddr.String()) {
+					if r.logger != nil {
+						r.logger.Warn("bypass: ", raddr)
+					}
+					return nil
+				}
+
+				if _, err := r.pc2.WriteTo(b[:n], raddr); err != nil {
+					return err
+				}
+
+				if r.logger != nil {
+					r.logger.Tracef("%s >>> %s data: %d",
+						r.pc2.LocalAddr(), raddr, n)
+
+				}
+
+				return nil
+			}()
+
+			if err != nil {
+				errc <- err
+				return
+			}
+		}
+	}()
+
+	go func() {
+		var b [MaxMessageSize]byte
+		for {
+			err := func() error {
+				n, raddr, err := r.pc2.ReadFrom(b[:])
+				if err != nil {
+					return err
+				}
+
+				if r.bypass != nil && r.bypass.Contains(ctx, "udp", raddr.String()) {
+					if r.logger != nil {
+						r.logger.Warn("bypass: ", raddr)
+					}
+					return nil
+				}
+
+				if _, err := r.pc1.WriteTo(b[:n], raddr); err != nil {
+					return err
+				}
+
+				if r.logger != nil {
+					r.logger.Tracef("%s <<< %s data: %d",
+						r.pc2.LocalAddr(), raddr, n)
+
+				}
+
+				return nil
+			}()
+
+			if err != nil {
+				errc <- err
+				return
+			}
+		}
+	}()
+
+	return <-errc
+}