From 48d070d3456896885c5172c1d90c95ccea229539 Mon Sep 17 00:00:00 2001 From: ginuerzh Date: Mon, 8 Jul 2024 22:28:21 +0800 Subject: [PATCH] add router interface --- chain/node.go | 4 +- chain/resovle.go | 44 ------- chain/route.go | 78 ------------ chain/router.go | 195 +----------------------------- chain/transport.go | 103 ++-------------- common/net/addr.go | 84 ------------- common/net/dialer.go | 10 ++ common/net/dialer/dialer.go | 171 -------------------------- common/net/dialer/dialer_linux.go | 19 --- common/net/dialer/dialer_other.go | 11 -- common/net/udp/conn.go | 108 ----------------- common/net/udp/listener.go | 131 -------------------- common/net/udp/pool.go | 115 ------------------ common/net/udp/udp.go | 41 ------- connector/option.go | 8 +- dialer/option.go | 10 +- go.mod | 5 - go.sum | 4 - handler/option.go | 4 +- listener/option.go | 4 +- 20 files changed, 37 insertions(+), 1112 deletions(-) delete mode 100644 chain/resovle.go delete mode 100644 common/net/addr.go create mode 100644 common/net/dialer.go delete mode 100644 common/net/dialer/dialer.go delete mode 100644 common/net/dialer/dialer_linux.go delete mode 100644 common/net/dialer/dialer_other.go delete mode 100644 common/net/udp/conn.go delete mode 100644 common/net/udp/listener.go delete mode 100644 common/net/udp/pool.go delete mode 100644 common/net/udp/udp.go diff --git a/chain/node.go b/chain/node.go index 5449edb..ca97163 100644 --- a/chain/node.go +++ b/chain/node.go @@ -41,7 +41,7 @@ type TLSNodeSettings struct { type NodeOptions struct { Network string - Transport *Transport + Transport Transporter Bypass bypass.Bypass Resolver resolver.Resolver HostMapper hosts.HostMapper @@ -53,7 +53,7 @@ type NodeOptions struct { type NodeOption func(*NodeOptions) -func TransportNodeOption(tr *Transport) NodeOption { +func TransportNodeOption(tr Transporter) NodeOption { return func(o *NodeOptions) { o.Transport = tr } diff --git a/chain/resovle.go b/chain/resovle.go deleted file mode 100644 index 58f177c..0000000 --- a/chain/resovle.go +++ /dev/null @@ -1,44 +0,0 @@ -package chain - -import ( - "context" - "fmt" - "net" - - "github.com/go-gost/core/hosts" - "github.com/go-gost/core/logger" - "github.com/go-gost/core/resolver" -) - -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 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 -} diff --git a/chain/route.go b/chain/route.go index 8a4dbba..5ebc409 100644 --- a/chain/route.go +++ b/chain/route.go @@ -2,96 +2,18 @@ package chain import ( "context" - "errors" - "fmt" "net" "time" - "github.com/go-gost/core/common/net/dialer" - "github.com/go-gost/core/common/net/udp" "github.com/go-gost/core/logger" ) -var ( - ErrEmptyRoute = errors.New("empty route") -) - -var ( - DefaultRoute Route = &route{} -) - type Route interface { Dial(ctx context.Context, network, address string, opts ...DialOption) (net.Conn, error) Bind(ctx context.Context, network, address string, opts ...BindOption) (net.Listener, error) Nodes() []*Node } -// route is a Route without nodes. -type route struct{} - -func (*route) Dial(ctx context.Context, network, address string, opts ...DialOption) (net.Conn, error) { - var options DialOptions - for _, opt := range opts { - opt(&options) - } - - netd := dialer.NetDialer{ - Interface: options.Interface, - Netns: options.Netns, - Logger: options.Logger, - } - if options.SockOpts != nil { - netd.Mark = options.SockOpts.Mark - } - - return netd.Dial(ctx, network, address) -} - -func (*route) Bind(ctx context.Context, network, address string, opts ...BindOption) (net.Listener, error) { - var options BindOptions - for _, opt := range opts { - opt(&options) - } - - switch network { - case "tcp", "tcp4", "tcp6": - addr, err := net.ResolveTCPAddr(network, address) - if err != nil { - return nil, err - } - return net.ListenTCP(network, addr) - case "udp", "udp4", "udp6": - addr, err := net.ResolveUDPAddr(network, address) - if err != nil { - return nil, err - } - conn, err := net.ListenUDP(network, addr) - if err != nil { - return nil, err - } - logger := logger.Default().WithFields(map[string]any{ - "network": network, - "address": address, - }) - ln := udp.NewListener(conn, &udp.ListenConfig{ - Backlog: options.Backlog, - ReadQueueSize: options.UDPDataQueueSize, - ReadBufferSize: options.UDPDataBufferSize, - TTL: options.UDPConnTTL, - KeepAlive: true, - Logger: logger, - }) - return ln, err - default: - err := fmt.Errorf("network %s unsupported", network) - return nil, err - } -} - -func (r *route) Nodes() []*Node { - return nil -} - type DialOptions struct { Interface string Netns string diff --git a/chain/router.go b/chain/router.go index 9189ce5..b0c4d8d 100644 --- a/chain/router.go +++ b/chain/router.go @@ -1,9 +1,7 @@ package chain import ( - "bytes" "context" - "fmt" "net" "time" @@ -92,193 +90,8 @@ func LoggerRouterOption(logger logger.Logger) RouterOption { } } -type Router struct { - options RouterOptions -} - -func NewRouter(opts ...RouterOption) *Router { - r := &Router{} - for _, opt := range opts { - if opt != nil { - opt(&r.options) - } - } - if r.options.Timeout == 0 { - r.options.Timeout = 15 * time.Second - } - - if r.options.Logger == nil { - r.options.Logger = logger.Default().WithFields(map[string]any{"kind": "router"}) - } - return r -} - -func (r *Router) Options() *RouterOptions { - if r == nil { - return nil - } - return &r.options -} - -func (r *Router) Dial(ctx context.Context, network, address string) (conn net.Conn, err error) { - if r.options.Timeout > 0 { - var cancel context.CancelFunc - ctx, cancel = context.WithTimeout(ctx, r.options.Timeout) - defer cancel() - } - - host := address - if h, _, _ := net.SplitHostPort(address); h != "" { - host = h - } - r.record(ctx, recorder.RecorderServiceRouterDialAddress, []byte(host)) - - conn, err = r.dial(ctx, network, address) - if err != nil { - r.record(ctx, recorder.RecorderServiceRouterDialAddressError, []byte(host)) - return - } - - if network == "udp" || network == "udp4" || network == "udp6" { - if _, ok := conn.(net.PacketConn); !ok { - return &packetConn{conn}, nil - } - } - return -} - -func (r *Router) record(ctx context.Context, name string, data []byte) error { - if len(data) == 0 { - return nil - } - - for _, rec := range r.options.Recorders { - if rec.Record == name { - err := rec.Recorder.Record(ctx, data) - if err != nil { - r.options.Logger.Errorf("record %s: %v", name, err) - } - return err - } - } - return nil -} - -func (r *Router) dial(ctx context.Context, network, address string) (conn net.Conn, err error) { - count := r.options.Retries + 1 - if count <= 0 { - count = 1 - } - r.options.Logger.Debugf("dial %s/%s", address, network) - - for i := 0; i < count; i++ { - var ipAddr string - ipAddr, err = Resolve(ctx, "ip", address, r.options.Resolver, r.options.HostMapper, r.options.Logger) - if err != nil { - r.options.Logger.Error(err) - break - } - - var route Route - if r.options.Chain != nil { - route = r.options.Chain.Route(ctx, network, ipAddr, WithHostRouteOption(address)) - } - - if r.options.Logger.IsLevelEnabled(logger.DebugLevel) { - buf := bytes.Buffer{} - for _, node := range routePath(route) { - fmt.Fprintf(&buf, "%s@%s > ", node.Name, node.Addr) - } - fmt.Fprintf(&buf, "%s", ipAddr) - r.options.Logger.Debugf("route(retry=%d) %s", i, buf.String()) - } - - if route == nil { - route = DefaultRoute - } - conn, err = route.Dial(ctx, network, ipAddr, - InterfaceDialOption(r.options.IfceName), - NetnsDialOption(r.options.Netns), - SockOptsDialOption(r.options.SockOpts), - LoggerDialOption(r.options.Logger), - ) - if err == nil { - break - } - r.options.Logger.Errorf("route(retry=%d) %s", i, err) - } - - return -} - -func (r *Router) Bind(ctx context.Context, network, address string, opts ...BindOption) (ln net.Listener, err error) { - if r.options.Timeout > 0 { - var cancel context.CancelFunc - ctx, cancel = context.WithTimeout(ctx, r.options.Timeout) - defer cancel() - } - - count := r.options.Retries + 1 - if count <= 0 { - count = 1 - } - r.options.Logger.Debugf("bind on %s/%s", address, network) - - for i := 0; i < count; i++ { - var route Route - if r.options.Chain != nil { - route = r.options.Chain.Route(ctx, network, address) - if route == nil || len(route.Nodes()) == 0 { - err = ErrEmptyRoute - return - } - } - - if r.options.Logger.IsLevelEnabled(logger.DebugLevel) { - buf := bytes.Buffer{} - for _, node := range routePath(route) { - fmt.Fprintf(&buf, "%s@%s > ", node.Name, node.Addr) - } - fmt.Fprintf(&buf, "%s", address) - r.options.Logger.Debugf("route(retry=%d) %s", i, buf.String()) - } - - if route == nil { - route = DefaultRoute - } - ln, err = route.Bind(ctx, network, address, opts...) - if err == nil { - break - } - r.options.Logger.Errorf("route(retry=%d) %s", i, err) - } - - return -} - -func routePath(route Route) (path []*Node) { - if route == nil { - return - } - for _, node := range route.Nodes() { - if tr := node.Options().Transport; tr != nil { - path = append(path, routePath(tr.Options().Route)...) - } - path = append(path, node) - } - return -} - -type packetConn struct { - net.Conn -} - -func (c *packetConn) ReadFrom(b []byte) (n int, addr net.Addr, err error) { - n, err = c.Read(b) - addr = c.Conn.RemoteAddr() - return -} - -func (c *packetConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { - return c.Write(b) +type Router interface { + Options() *RouterOptions + Dial(ctx context.Context, network, address string) (net.Conn, error) + Bind(ctx context.Context, network, address string, opts ...BindOption) (net.Listener, error) } diff --git a/chain/transport.go b/chain/transport.go index f0a1562..fa372b7 100644 --- a/chain/transport.go +++ b/chain/transport.go @@ -4,9 +4,7 @@ import ( "context" "net" - net_dialer "github.com/go-gost/core/common/net/dialer" "github.com/go-gost/core/connector" - "github.com/go-gost/core/dialer" ) type TransportOptions struct { @@ -49,97 +47,12 @@ func RouteTransportOption(route Route) TransportOption { } } -type Transport struct { - dialer dialer.Dialer - connector connector.Connector - options TransportOptions -} - -func NewTransport(d dialer.Dialer, c connector.Connector, opts ...TransportOption) *Transport { - tr := &Transport{ - dialer: d, - connector: c, - } - for _, opt := range opts { - if opt != nil { - opt(&tr.options) - } - } - - return tr -} - -func (tr *Transport) Dial(ctx context.Context, addr string) (net.Conn, error) { - netd := &net_dialer.NetDialer{ - Interface: tr.options.IfceName, - Netns: tr.options.Netns, - } - if tr.options.SockOpts != nil { - netd.Mark = tr.options.SockOpts.Mark - } - if tr.options.Route != nil && len(tr.options.Route.Nodes()) > 0 { - netd.DialFunc = func(ctx context.Context, network, addr string) (net.Conn, error) { - return tr.options.Route.Dial(ctx, network, addr) - } - } - opts := []dialer.DialOption{ - dialer.HostDialOption(tr.options.Addr), - dialer.NetDialerDialOption(netd), - } - return tr.dialer.Dial(ctx, addr, opts...) -} - -func (tr *Transport) Handshake(ctx context.Context, conn net.Conn) (net.Conn, error) { - var err error - if hs, ok := tr.dialer.(dialer.Handshaker); ok { - conn, err = hs.Handshake(ctx, conn, - dialer.AddrHandshakeOption(tr.options.Addr)) - if err != nil { - return nil, err - } - } - if hs, ok := tr.connector.(connector.Handshaker); ok { - return hs.Handshake(ctx, conn) - } - return conn, nil -} - -func (tr *Transport) Connect(ctx context.Context, conn net.Conn, network, address string) (net.Conn, error) { - netd := &net_dialer.NetDialer{ - Interface: tr.options.IfceName, - Netns: tr.options.Netns, - } - if tr.options.SockOpts != nil { - netd.Mark = tr.options.SockOpts.Mark - } - return tr.connector.Connect(ctx, conn, network, address, - connector.NetDialerConnectOption(netd), - ) -} - -func (tr *Transport) Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) { - if binder, ok := tr.connector.(connector.Binder); ok { - return binder.Bind(ctx, conn, network, address, opts...) - } - return nil, connector.ErrBindUnsupported -} - -func (tr *Transport) Multiplex() bool { - if mux, ok := tr.dialer.(dialer.Multiplexer); ok { - return mux.Multiplex() - } - return false -} - -func (tr *Transport) Options() *TransportOptions { - if tr != nil { - return &tr.options - } - return nil -} - -func (tr *Transport) Copy() *Transport { - tr2 := &Transport{} - *tr2 = *tr - return tr +type Transporter interface { + Dial(ctx context.Context, addr string) (net.Conn, error) + Handshake(ctx context.Context, conn net.Conn) (net.Conn, error) + Connect(ctx context.Context, conn net.Conn, network, address string) (net.Conn, error) + Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) + Multiplex() bool + Options() *TransportOptions + Copy() Transporter } diff --git a/common/net/addr.go b/common/net/addr.go deleted file mode 100644 index bf379d1..0000000 --- a/common/net/addr.go +++ /dev/null @@ -1,84 +0,0 @@ -package net - -import ( - "fmt" - "net" -) - -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 -} diff --git a/common/net/dialer.go b/common/net/dialer.go new file mode 100644 index 0000000..51884ec --- /dev/null +++ b/common/net/dialer.go @@ -0,0 +1,10 @@ +package net + +import ( + "context" + "net" +) + +type Dialer interface { + Dial(ctx context.Context, network, addr string) (net.Conn, error) +} diff --git a/common/net/dialer/dialer.go b/common/net/dialer/dialer.go deleted file mode 100644 index e04dddd..0000000 --- a/common/net/dialer/dialer.go +++ /dev/null @@ -1,171 +0,0 @@ -package dialer - -import ( - "context" - "fmt" - "net" - "runtime" - "strings" - "syscall" - "time" - - xnet "github.com/go-gost/core/common/net" - "github.com/go-gost/core/logger" - "github.com/vishvananda/netns" -) - -const ( - DefaultTimeout = 10 * time.Second -) - -var ( - DefaultNetDialer = &NetDialer{} -) - -type NetDialer struct { - Interface string - Netns string - Mark int - DialFunc func(ctx context.Context, network, addr string) (net.Conn, error) - Logger logger.Logger -} - -func (d *NetDialer) 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() - } - - 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) - - ns, err := netns.GetFromName(d.Netns) - if err != nil { - return nil, fmt.Errorf("netns.GetFromName(%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 *NetDialer) 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) -} diff --git a/common/net/dialer/dialer_linux.go b/common/net/dialer/dialer_linux.go deleted file mode 100644 index 730af75..0000000 --- a/common/net/dialer/dialer_linux.go +++ /dev/null @@ -1,19 +0,0 @@ -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) -} diff --git a/common/net/dialer/dialer_other.go b/common/net/dialer/dialer_other.go deleted file mode 100644 index fff35b4..0000000 --- a/common/net/dialer/dialer_other.go +++ /dev/null @@ -1,11 +0,0 @@ -//go:build !linux - -package dialer - -func bindDevice(fd uintptr, ifceName string) error { - return nil -} - -func setMark(fd uintptr, mark int) error { - return nil -} diff --git a/common/net/udp/conn.go b/common/net/udp/conn.go deleted file mode 100644 index 0f62e30..0000000 --- a/common/net/udp/conn.go +++ /dev/null @@ -1,108 +0,0 @@ -package udp - -import ( - "errors" - "net" - "sync" - "sync/atomic" - - "github.com/go-gost/core/common/bufpool" -) - -// 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) Write(b []byte) (n int, err error) { - n, err = c.WriteTo(b, c.remoteAddr) - if !c.keepAlive { - c.Close() - } - return -} - -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) 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") - } -} diff --git a/common/net/udp/listener.go b/common/net/udp/listener.go deleted file mode 100644 index 00216fa..0000000 --- a/common/net/udp/listener.go +++ /dev/null @@ -1,131 +0,0 @@ -package udp - -import ( - "net" - "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 - // mux sync.Mutex - 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, - } - if cfg.KeepAlive { - 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 { - // ln.mux.Lock() - // defer ln.mux.Unlock() - - c, ok := ln.connPool.Get(raddr.String()) - if ok { - 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 - } -} diff --git a/common/net/udp/pool.go b/common/net/udp/pool.go deleted file mode 100644 index 232d03d..0000000 --- a/common/net/udp/pool.go +++ /dev/null @@ -1,115 +0,0 @@ -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 - } - } -} diff --git a/common/net/udp/udp.go b/common/net/udp/udp.go deleted file mode 100644 index 6428dee..0000000 --- a/common/net/udp/udp.go +++ /dev/null @@ -1,41 +0,0 @@ -package udp - -import ( - "io" - "net" - "syscall" -) - -type Conn interface { - net.PacketConn - io.Reader - io.Writer - readUDP - writeUDP - setBuffer - syscallConn - remoteAddr -} - -type setBuffer interface { - SetReadBuffer(bytes int) error - SetWriteBuffer(bytes int) error -} - -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) -} - -type syscallConn interface { - SyscallConn() (syscall.RawConn, error) -} - -type remoteAddr interface { - RemoteAddr() net.Addr -} diff --git a/connector/option.go b/connector/option.go index ef1b8e3..273c061 100644 --- a/connector/option.go +++ b/connector/option.go @@ -5,7 +5,7 @@ import ( "net/url" "time" - "github.com/go-gost/core/common/net/dialer" + xnet "github.com/go-gost/core/common/net" "github.com/go-gost/core/logger" ) @@ -36,14 +36,14 @@ func LoggerOption(logger logger.Logger) Option { } type ConnectOptions struct { - NetDialer *dialer.NetDialer + Dialer xnet.Dialer } type ConnectOption func(opts *ConnectOptions) -func NetDialerConnectOption(netd *dialer.NetDialer) ConnectOption { +func DialerConnectOption(dialer xnet.Dialer) ConnectOption { return func(opts *ConnectOptions) { - opts.NetDialer = netd + opts.Dialer = dialer } } diff --git a/dialer/option.go b/dialer/option.go index cd49177..af699f1 100644 --- a/dialer/option.go +++ b/dialer/option.go @@ -4,7 +4,7 @@ import ( "crypto/tls" "net/url" - "github.com/go-gost/core/common/net/dialer" + xnet "github.com/go-gost/core/common/net" "github.com/go-gost/core/logger" ) @@ -42,8 +42,8 @@ func ProxyProtocolOption(ppv int) Option { } type DialOptions struct { - Host string - NetDialer *dialer.NetDialer + Host string + Dialer xnet.Dialer } type DialOption func(opts *DialOptions) @@ -54,9 +54,9 @@ func HostDialOption(host string) DialOption { } } -func NetDialerDialOption(netd *dialer.NetDialer) DialOption { +func NetDialerDialOption(dialer xnet.Dialer) DialOption { return func(opts *DialOptions) { - opts.NetDialer = netd + opts.Dialer = dialer } } diff --git a/go.mod b/go.mod index b374330..846358a 100644 --- a/go.mod +++ b/go.mod @@ -3,8 +3,3 @@ module github.com/go-gost/core go 1.22 toolchain go1.22.2 - -require ( - github.com/vishvananda/netns v0.0.4 - golang.org/x/sys v0.21.0 -) diff --git a/go.sum b/go.sum index d991bfe..e69de29 100644 --- a/go.sum +++ b/go.sum @@ -1,4 +0,0 @@ -github.com/vishvananda/netns v0.0.4 h1:Oeaw1EM2JMxD51g9uhtC0D7erkIjgmj8+JZc26m1YX8= -github.com/vishvananda/netns v0.0.4/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM= -golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= -golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= diff --git a/handler/option.go b/handler/option.go index 6c9eee2..6081299 100644 --- a/handler/option.go +++ b/handler/option.go @@ -16,7 +16,7 @@ import ( type Options struct { Bypass bypass.Bypass - Router *chain.Router + Router chain.Router Auth *url.Userinfo Auther auth.Authenticator RateLimiter rate.RateLimiter @@ -36,7 +36,7 @@ func BypassOption(bypass bypass.Bypass) Option { } } -func RouterOption(router *chain.Router) Option { +func RouterOption(router chain.Router) Option { return func(opts *Options) { opts.Router = router } diff --git a/listener/option.go b/listener/option.go index 8419e1a..44130af 100644 --- a/listener/option.go +++ b/listener/option.go @@ -27,7 +27,7 @@ type Options struct { Service string ProxyProtocol int Netns string - Router *chain.Router + Router chain.Router } type Option func(opts *Options) @@ -104,7 +104,7 @@ func NetnsOption(netns string) Option { } } -func RouterOption(router *chain.Router) Option { +func RouterOption(router chain.Router) Option { return func(opts *Options) { opts.Router = router }