From ad5cf6fd61e737e593a8899a4c0b40c38ff4c339 Mon Sep 17 00:00:00 2001 From: ginuerzh Date: Sun, 3 Aug 2025 15:36:29 +0800 Subject: [PATCH] add proxyProtocol support for dialer --- dialer/dtls/dialer.go | 8 +++++ dialer/grpc/dialer.go | 15 +++++++++- dialer/http2/dialer.go | 15 +++++++++- dialer/http2/h2/dialer.go | 28 ++++++++++++++++-- dialer/mtcp/dialer.go | 8 +++++ dialer/mtls/dialer.go | 8 +++++ dialer/mws/dialer.go | 8 +++++ dialer/ssh/dialer.go | 8 +++++ dialer/sshd/dialer.go | 10 ++++++- dialer/tcp/dialer.go | 21 +++++++++---- dialer/tls/dialer.go | 15 ++++++++-- dialer/udp/dialer.go | 23 ++++++++++---- dialer/ws/dialer.go | 9 ++++++ internal/net/udp/listener.go | 4 --- internal/util/mux/mux.go | 23 ++++++++++++++ internal/util/tls/listener.go | 56 +++++++++++++++++++++++++++++++++++ internal/util/ws/ws.go | 3 ++ listener/mtls/listener.go | 4 +-- listener/mws/listener.go | 29 +++++++----------- listener/rtcp/listener.go | 1 + listener/tls/listener.go | 5 ++-- listener/unix/listener.go | 3 ++ listener/ws/listener.go | 4 +-- 23 files changed, 260 insertions(+), 48 deletions(-) create mode 100644 internal/util/tls/listener.go diff --git a/dialer/dtls/dialer.go b/dialer/dtls/dialer.go index 7ac9a04e..433e7b4b 100644 --- a/dialer/dtls/dialer.go +++ b/dialer/dtls/dialer.go @@ -8,6 +8,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" xdtls "github.com/go-gost/x/internal/util/dtls" "github.com/go-gost/x/registry" "github.com/pion/dtls/v2" @@ -50,6 +52,12 @@ func (d *dtlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO return nil, err } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + tlsCfg := d.options.TLSConfig if tlsCfg == nil { tlsCfg = &tls.Config{ diff --git a/dialer/grpc/dialer.go b/dialer/grpc/dialer.go index 7a608c4d..c2c284ce 100644 --- a/dialer/grpc/dialer.go +++ b/dialer/grpc/dialer.go @@ -7,6 +7,8 @@ import ( "github.com/go-gost/core/dialer" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" pb "github.com/go-gost/x/internal/util/grpc/proto" "github.com/go-gost/x/registry" "google.golang.org/grpc" @@ -71,7 +73,18 @@ func (d *grpcDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO grpcOpts := []grpc.DialOption{ // grpc.WithBlock(), grpc.WithContextDialer(func(c context.Context, s string) (net.Conn, error) { - return options.Dialer.Dial(c, "tcp", s) + conn, err := options.Dialer.Dial(c, "tcp", s) + if err != nil { + return nil, err + } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + + return conn, nil }), grpc.WithAuthority(host), grpc.WithConnectParams(grpc.ConnectParams{ diff --git a/dialer/http2/dialer.go b/dialer/http2/dialer.go index 0207345f..5b3f2abb 100644 --- a/dialer/http2/dialer.go +++ b/dialer/http2/dialer.go @@ -10,7 +10,9 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" net_dialer "github.com/go-gost/x/internal/net/dialer" + "github.com/go-gost/x/internal/net/proxyproto" mdx "github.com/go-gost/x/metadata" "github.com/go-gost/x/registry" ) @@ -91,7 +93,18 @@ func (d *http2Dialer) Dial(ctx context.Context, address string, opts ...dialer.D if netd == nil { netd = net_dialer.DefaultNetDialer } - return netd.Dial(ctx, network, addr) + conn, err := netd.Dial(ctx, network, addr) + if err != nil { + return nil, err + } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + + return conn, nil }, ForceAttemptHTTP2: true, MaxIdleConns: 16, diff --git a/dialer/http2/h2/dialer.go b/dialer/http2/h2/dialer.go index ebaa27f0..84fb9fa1 100644 --- a/dialer/http2/h2/dialer.go +++ b/dialer/http2/h2/dialer.go @@ -15,6 +15,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/registry" "golang.org/x/net/http2" ) @@ -94,14 +96,36 @@ func (d *h2Dialer) Dial(ctx context.Context, address string, opts ...dialer.Dial client.Transport = &http2.Transport{ AllowHTTP: true, DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { - return options.Dialer.Dial(ctx, network, addr) + conn, err := options.Dialer.Dial(ctx, network, addr) + if err != nil { + return nil, err + } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + + return conn, nil }, } } else { client.Transport = &http.Transport{ TLSClientConfig: d.options.TLSConfig, DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) { - return options.Dialer.Dial(ctx, network, addr) + conn, err := options.Dialer.Dial(ctx, network, addr) + if err != nil { + return nil, err + } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + + return conn, nil }, ForceAttemptHTTP2: true, MaxIdleConns: 100, diff --git a/dialer/mtcp/dialer.go b/dialer/mtcp/dialer.go index 7a1c5eb5..efcbdad5 100644 --- a/dialer/mtcp/dialer.go +++ b/dialer/mtcp/dialer.go @@ -10,6 +10,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/internal/util/mux" "github.com/go-gost/x/registry" ) @@ -72,6 +74,12 @@ func (d *mtcpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO return } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + session = &muxSession{conn: conn} d.sessions[addr] = session } diff --git a/dialer/mtls/dialer.go b/dialer/mtls/dialer.go index 2c7b9028..ec2f96d8 100644 --- a/dialer/mtls/dialer.go +++ b/dialer/mtls/dialer.go @@ -11,6 +11,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/internal/util/mux" "github.com/go-gost/x/registry" ) @@ -73,6 +75,12 @@ func (d *mtlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO return } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + session = &muxSession{conn: conn} d.sessions[addr] = session } diff --git a/dialer/mws/dialer.go b/dialer/mws/dialer.go index 9ffe7a78..a61310d6 100644 --- a/dialer/mws/dialer.go +++ b/dialer/mws/dialer.go @@ -11,6 +11,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/internal/util/mux" ws_util "github.com/go-gost/x/internal/util/ws" "github.com/go-gost/x/registry" @@ -87,6 +89,12 @@ func (d *mwsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp return } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + session = &muxSession{conn: conn} d.sessions[addr] = session } diff --git a/dialer/ssh/dialer.go b/dialer/ssh/dialer.go index d97f0003..8e03d570 100644 --- a/dialer/ssh/dialer.go +++ b/dialer/ssh/dialer.go @@ -8,6 +8,8 @@ import ( "github.com/go-gost/core/dialer" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" ssh_util "github.com/go-gost/x/internal/util/ssh" "github.com/go-gost/x/registry" "golang.org/x/crypto/ssh" @@ -73,6 +75,12 @@ func (d *sshDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp defer conn.SetDeadline(time.Time{}) } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + session, err = d.initSession(ctx, addr, conn) if err != nil { conn.Close() diff --git a/dialer/sshd/dialer.go b/dialer/sshd/dialer.go index df82e1ec..2c1410ff 100644 --- a/dialer/sshd/dialer.go +++ b/dialer/sshd/dialer.go @@ -3,12 +3,14 @@ package sshd import ( "context" "net" + "os" "sync" "time" - "os" "github.com/go-gost/core/dialer" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" ssh_util "github.com/go-gost/x/internal/util/ssh" "github.com/go-gost/x/registry" "golang.org/x/crypto/ssh" @@ -76,6 +78,12 @@ func (d *sshdDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO defer conn.SetDeadline(time.Time{}) } + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + session, err = d.initSession(ctx, addr, conn) if err != nil { conn.Close() diff --git a/dialer/tcp/dialer.go b/dialer/tcp/dialer.go index 91c9e60f..85ee6d6b 100644 --- a/dialer/tcp/dialer.go +++ b/dialer/tcp/dialer.go @@ -7,6 +7,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/registry" ) @@ -15,18 +17,20 @@ func init() { } type tcpDialer struct { - md metadata - logger logger.Logger + md metadata + logger logger.Logger + options dialer.Options } func NewDialer(opts ...dialer.Option) dialer.Dialer { - options := &dialer.Options{} + options := dialer.Options{} for _, opt := range opts { - opt(options) + opt(&options) } return &tcpDialer{ - logger: options.Logger, + logger: options.Logger, + options: options, } } @@ -44,5 +48,12 @@ func (d *tcpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp if err != nil { d.logger.Error(err) } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + return conn, err } diff --git a/dialer/tls/dialer.go b/dialer/tls/dialer.go index a5f68d36..49ccaa5f 100644 --- a/dialer/tls/dialer.go +++ b/dialer/tls/dialer.go @@ -9,6 +9,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/registry" ) @@ -18,7 +20,7 @@ func init() { type tlsDialer struct { md metadata - logger logger.Logger + log logger.Logger options dialer.Options } @@ -29,7 +31,7 @@ func NewDialer(opts ...dialer.Option) dialer.Dialer { } return &tlsDialer{ - logger: options.Logger, + log: options.Logger, options: options, } } @@ -46,8 +48,15 @@ func (d *tlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp conn, err := options.Dialer.Dial(ctx, "tcp", addr) if err != nil { - d.logger.Error(err) + d.log.Error(err) } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + return conn, err } diff --git a/dialer/udp/dialer.go b/dialer/udp/dialer.go index cc57d1e5..242410d4 100644 --- a/dialer/udp/dialer.go +++ b/dialer/udp/dialer.go @@ -7,6 +7,8 @@ import ( "github.com/go-gost/core/dialer" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/registry" ) @@ -15,8 +17,9 @@ func init() { } type udpDialer struct { - md metadata - logger logger.Logger + md metadata + logger logger.Logger + options dialer.Options } func NewDialer(opts ...dialer.Option) dialer.Dialer { @@ -26,7 +29,8 @@ func NewDialer(opts ...dialer.Option) dialer.Dialer { } return &udpDialer{ - logger: options.Logger, + logger: options.Logger, + options: *options, } } @@ -44,7 +48,16 @@ func (d *udpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp if err != nil { return nil, err } - return &conn{ + + c = &conn{ UDPConn: c.(*net.UDPConn), - }, nil + } + + c = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + c) + + return c, nil } diff --git a/dialer/ws/dialer.go b/dialer/ws/dialer.go index 1d6e90f8..44008bda 100644 --- a/dialer/ws/dialer.go +++ b/dialer/ws/dialer.go @@ -8,6 +8,8 @@ import ( "github.com/go-gost/core/dialer" md "github.com/go-gost/core/metadata" + ctxvalue "github.com/go-gost/x/ctx" + "github.com/go-gost/x/internal/net/proxyproto" ws_util "github.com/go-gost/x/internal/util/ws" "github.com/go-gost/x/registry" "github.com/gorilla/websocket" @@ -61,6 +63,13 @@ func (d *wsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOpt if err != nil { d.options.Logger.Error(err) } + + conn = proxyproto.WrapClientConn( + d.options.ProxyProtocol, + ctxvalue.SrcAddrFromContext(ctx), + ctxvalue.DstAddrFromContext(ctx), + conn) + return conn, err } diff --git a/internal/net/udp/listener.go b/internal/net/udp/listener.go index 0ad0b10e..f2e1cb60 100644 --- a/internal/net/udp/listener.go +++ b/internal/net/udp/listener.go @@ -214,10 +214,6 @@ func (c *conn) RemoteAddr() net.Addr { return c.remoteAddr } -func (c *conn) SetReadDeadline(t time.Time) error { - return nil -} - func (c *conn) IsIdle() bool { return atomic.LoadInt32(&c.idle) > 0 } diff --git a/internal/util/mux/mux.go b/internal/util/mux/mux.go index e31aec51..e17a42d0 100644 --- a/internal/util/mux/mux.go +++ b/internal/util/mux/mux.go @@ -4,6 +4,8 @@ import ( "net" "time" + "github.com/go-gost/core/metadata" + xnet "github.com/go-gost/x/internal/net" smux "github.com/xtaci/smux" ) @@ -143,6 +145,27 @@ func (c *streamConn) Write(b []byte) (n int, err error) { return c.stream.Write(b) } +func (c *streamConn) Metadata() metadata.Metadata { + if md, ok := c.Conn.(metadata.Metadatable); ok { + return md.Metadata() + } + return nil +} + +func (c *streamConn) SrcAddr() net.Addr { + if sc, ok := c.Conn.(xnet.SrcAddr); ok { + return sc.SrcAddr() + } + return nil +} + +func (c *streamConn) DstAddr() net.Addr { + if sc, ok := c.Conn.(xnet.DstAddr); ok { + return sc.DstAddr() + } + return nil +} + func (c *streamConn) Close() error { return c.stream.Close() } diff --git a/internal/util/tls/listener.go b/internal/util/tls/listener.go new file mode 100644 index 00000000..c227b496 --- /dev/null +++ b/internal/util/tls/listener.go @@ -0,0 +1,56 @@ +package tls + +import ( + "crypto/tls" + "net" + + "github.com/go-gost/core/metadata" + xnet "github.com/go-gost/x/internal/net" +) + +type listener struct { + net.Listener + config *tls.Config +} + +func NewListener(inner net.Listener, config *tls.Config) net.Listener { + l := new(listener) + l.Listener = inner + l.config = config + return l +} + +func (l *listener) Accept() (net.Conn, error) { + c, err := l.Listener.Accept() + if err != nil { + return nil, err + } + return &tlsConn{ + Conn: tls.Server(c, l.config), + }, nil +} + +type tlsConn struct { + *tls.Conn +} + +func (c *tlsConn) Metadata() metadata.Metadata { + if md, ok := c.NetConn().(metadata.Metadatable); ok { + return md.Metadata() + } + return nil +} + +func (c *tlsConn) SrcAddr() net.Addr { + if sc, ok := c.NetConn().(xnet.SrcAddr); ok { + return sc.SrcAddr() + } + return nil +} + +func (c *tlsConn) DstAddr() net.Addr { + if sc, ok := c.NetConn().(xnet.DstAddr); ok { + return sc.DstAddr() + } + return nil +} diff --git a/internal/util/ws/ws.go b/internal/util/ws/ws.go index ecfbfce2..02138a4b 100644 --- a/internal/util/ws/ws.go +++ b/internal/util/ws/ws.go @@ -81,6 +81,9 @@ func (c *websocketConn) SetWriteDeadline(t time.Time) error { } func (c *websocketConn) SrcAddr() net.Addr { + if sa, ok := c.Conn.NetConn().(xnet.SrcAddr); ok { + return sa.SrcAddr() + } return c.srcAddr } diff --git a/listener/mtls/listener.go b/listener/mtls/listener.go index 8aa78ead..5c47b39b 100644 --- a/listener/mtls/listener.go +++ b/listener/mtls/listener.go @@ -2,7 +2,6 @@ package mtls import ( "context" - "crypto/tls" "net" "time" @@ -14,6 +13,7 @@ import ( xnet "github.com/go-gost/x/internal/net" "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/internal/util/mux" + xtls "github.com/go-gost/x/internal/util/tls" climiter "github.com/go-gost/x/limiter/conn/wrapper" limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper" metrics "github.com/go-gost/x/metrics/wrapper" @@ -71,7 +71,7 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) { ln = admission.WrapListener(l.options.Admission, ln) ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter) ln = climiter.WrapListener(l.options.ConnLimiter, ln) - l.Listener = tls.NewListener(ln, l.options.TLSConfig) + l.Listener = xtls.NewListener(ln, l.options.TLSConfig) l.cqueue = make(chan net.Conn, l.md.backlog) l.errChan = make(chan error, 1) diff --git a/listener/mws/listener.go b/listener/mws/listener.go index ffc2814d..50091582 100644 --- a/listener/mws/listener.go +++ b/listener/mws/listener.go @@ -2,7 +2,6 @@ package mws import ( "context" - "crypto/tls" "net" "net/http" "net/http/httputil" @@ -17,6 +16,7 @@ import ( xhttp "github.com/go-gost/x/internal/net/http" "github.com/go-gost/x/internal/net/proxyproto" "github.com/go-gost/x/internal/util/mux" + xtls "github.com/go-gost/x/internal/util/tls" ws_util "github.com/go-gost/x/internal/util/ws" climiter "github.com/go-gost/x/limiter/conn/wrapper" limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper" @@ -38,7 +38,7 @@ type mwsListener struct { cqueue chan net.Conn errChan chan error tlsEnabled bool - logger logger.Logger + log logger.Logger md metadata options listener.Options } @@ -49,7 +49,7 @@ func NewListener(opts ...listener.Option) listener.Listener { opt(&options) } return &mwsListener{ - logger: options.Logger, + log: options.Logger, options: options, } } @@ -61,7 +61,7 @@ func NewTLSListener(opts ...listener.Option) listener.Listener { } return &mwsListener{ tlsEnabled: true, - logger: options.Logger, + log: options.Logger, options: options, } } @@ -102,7 +102,7 @@ func (l *mwsListener) Init(md md.Metadata) (err error) { lc := net.ListenConfig{} if l.md.mptcp { lc.SetMultipathTCP(true) - l.logger.Debugf("mptcp enabled: %v", lc.MultipathTCP()) + l.log.Debugf("mptcp enabled: %v", lc.MultipathTCP()) } ln, err := lc.Listen(context.Background(), network, l.options.Addr) if err != nil { @@ -116,7 +116,7 @@ func (l *mwsListener) Init(md md.Metadata) (err error) { ln = climiter.WrapListener(l.options.ConnLimiter, ln) if l.tlsEnabled { - ln = tls.NewListener(ln, l.options.TLSConfig) + ln = xtls.NewListener(ln, l.options.TLSConfig) } l.addr = ln.Addr() @@ -168,7 +168,7 @@ func (l *mwsListener) upgrade(w http.ResponseWriter, r *http.Request) { if clientIP != nil { cip = clientIP.String() } - log := l.logger.WithFields(map[string]any{ + log := l.log.WithFields(map[string]any{ "local": l.addr.String(), "remote": r.RemoteAddr, "client": cip, @@ -189,10 +189,10 @@ func (l *mwsListener) upgrade(w http.ResponseWriter, r *http.Request) { srcAddr = &net.TCPAddr{IP: clientIP} } - l.mux(ws_util.Conn(conn), srcAddr, log) + l.mux(ws_util.ConnWithSrcAddr(conn, srcAddr), log) } -func (l *mwsListener) mux(conn net.Conn, srcAddr net.Addr, log logger.Logger) { +func (l *mwsListener) mux(conn net.Conn, log logger.Logger) { defer conn.Close() session, err := mux.ServerSession(conn, l.md.muxCfg) @@ -210,19 +210,10 @@ func (l *mwsListener) mux(conn net.Conn, srcAddr net.Addr, log logger.Logger) { } select { - case l.cqueue <- &connWithSrcAddr{Conn: stream, srcAddr: srcAddr}: + case l.cqueue <- stream: default: stream.Close() log.Warnf("connection queue is full, client %s discarded", stream.RemoteAddr()) } } } - -type connWithSrcAddr struct { - net.Conn - srcAddr net.Addr -} - -func (c *connWithSrcAddr) SrcAddr() net.Addr { - return c.srcAddr -} diff --git a/listener/rtcp/listener.go b/listener/rtcp/listener.go index bef15a19..0e337606 100644 --- a/listener/rtcp/listener.go +++ b/listener/rtcp/listener.go @@ -80,6 +80,7 @@ func (l *rtcpListener) Accept() (conn net.Conn, err error) { if err != nil { return nil, listener.NewBindError(err) } + ln = metrics.WrapListener(l.options.Service, ln) ln = stats.WrapListener(ln, l.options.Stats) ln = admission.WrapListener(l.options.Admission, ln) diff --git a/listener/tls/listener.go b/listener/tls/listener.go index a15aaeb0..589ca454 100644 --- a/listener/tls/listener.go +++ b/listener/tls/listener.go @@ -2,7 +2,6 @@ package tls import ( "context" - "crypto/tls" "net" "time" @@ -13,6 +12,7 @@ import ( admission "github.com/go-gost/x/admission/wrapper" xnet "github.com/go-gost/x/internal/net" "github.com/go-gost/x/internal/net/proxyproto" + xtls "github.com/go-gost/x/internal/util/tls" climiter "github.com/go-gost/x/limiter/conn/wrapper" limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper" metrics "github.com/go-gost/x/metrics/wrapper" @@ -67,8 +67,7 @@ func (l *tlsListener) Init(md md.Metadata) (err error) { ln = admission.WrapListener(l.options.Admission, ln) ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter) ln = climiter.WrapListener(l.options.ConnLimiter, ln) - - l.ln = tls.NewListener(ln, l.options.TLSConfig) + l.ln = xtls.NewListener(ln, l.options.TLSConfig) return } diff --git a/listener/unix/listener.go b/listener/unix/listener.go index 57168640..57eb756c 100644 --- a/listener/unix/listener.go +++ b/listener/unix/listener.go @@ -2,12 +2,14 @@ package unix import ( "net" + "time" "github.com/go-gost/core/limiter" "github.com/go-gost/core/listener" "github.com/go-gost/core/logger" md "github.com/go-gost/core/metadata" admission "github.com/go-gost/x/admission/wrapper" + "github.com/go-gost/x/internal/net/proxyproto" climiter "github.com/go-gost/x/limiter/conn/wrapper" limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper" metrics "github.com/go-gost/x/metrics/wrapper" @@ -47,6 +49,7 @@ func (l *unixListener) Init(md md.Metadata) (err error) { return } + ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second) ln = metrics.WrapListener(l.options.Service, ln) ln = stats.WrapListener(ln, l.options.Stats) ln = admission.WrapListener(l.options.Admission, ln) diff --git a/listener/ws/listener.go b/listener/ws/listener.go index 639704b6..58b294a5 100644 --- a/listener/ws/listener.go +++ b/listener/ws/listener.go @@ -2,7 +2,6 @@ package ws import ( "context" - "crypto/tls" "net" "net/http" "net/http/httputil" @@ -16,6 +15,7 @@ import ( xnet "github.com/go-gost/x/internal/net" xhttp "github.com/go-gost/x/internal/net/http" "github.com/go-gost/x/internal/net/proxyproto" + xtls "github.com/go-gost/x/internal/util/tls" ws_util "github.com/go-gost/x/internal/util/ws" climiter "github.com/go-gost/x/limiter/conn/wrapper" limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper" @@ -111,7 +111,7 @@ func (l *wsListener) Init(md md.Metadata) (err error) { ln = climiter.WrapListener(l.options.ConnLimiter, ln) if l.tlsEnabled { - ln = tls.NewListener(ln, l.options.TLSConfig) + ln = xtls.NewListener(ln, l.options.TLSConfig) } l.addr = ln.Addr()