diff --git a/cmd/gost/register.go b/cmd/gost/register.go index 07cc7b8..c37487b 100644 --- a/cmd/gost/register.go +++ b/cmd/gost/register.go @@ -21,6 +21,8 @@ import ( _ "github.com/go-gost/gost/pkg/dialer/obfs/tls" _ "github.com/go-gost/gost/pkg/dialer/quic" _ "github.com/go-gost/gost/pkg/dialer/tcp" + _ "github.com/go-gost/gost/pkg/dialer/tls" + _ "github.com/go-gost/gost/pkg/dialer/tls/mux" _ "github.com/go-gost/gost/pkg/dialer/udp" // Register handlers diff --git a/go.mod b/go.mod index 561bcaa..37a6d53 100644 --- a/go.mod +++ b/go.mod @@ -44,7 +44,7 @@ require ( github.com/templexxx/xorsimd v0.4.1 // indirect github.com/tjfoc/gmsm v1.3.2 // indirect github.com/xtaci/kcp-go/v5 v5.6.1 - github.com/xtaci/smux v1.5.15 + github.com/xtaci/smux v1.5.16 github.com/xtaci/tcpraw v1.2.25 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 golang.org/x/mod v0.4.2 // indirect diff --git a/go.sum b/go.sum index 7f1a624..2945c44 100644 --- a/go.sum +++ b/go.sum @@ -399,6 +399,8 @@ github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae h1:J0GxkO96kL4WF+A github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae/go.mod h1:gXtu8J62kEgmN++bm9BVICuT/e8yiLI2KFobd/TRFsE= github.com/xtaci/smux v1.5.15 h1:6hMiXswcleXj5oNfcJc+DXS8Vj36XX2LaX98udog6Kc= github.com/xtaci/smux v1.5.15/go.mod h1:OMlQbT5vcgl2gb49mFkYo6SMf+zP3rcjcwQz7ZU7IGY= +github.com/xtaci/smux v1.5.16 h1:FBPYOkW8ZTjLKUM4LI4xnnuuDC8CQ/dB04HD519WoEk= +github.com/xtaci/smux v1.5.16/go.mod h1:OMlQbT5vcgl2gb49mFkYo6SMf+zP3rcjcwQz7ZU7IGY= github.com/xtaci/tcpraw v1.2.25 h1:VDlqo0op17JeXBM6e2G9ocCNLOJcw9mZbobMbJjo0vk= github.com/xtaci/tcpraw v1.2.25/go.mod h1:dKyZ2V75s0cZ7cbgJYdxPvms7af0joIeOyx1GgJQbLk= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= diff --git a/pkg/chain/chain.go b/pkg/chain/chain.go index 81aa69d..e50e1c1 100644 --- a/pkg/chain/chain.go +++ b/pkg/chain/chain.go @@ -31,7 +31,7 @@ func (c *Chain) GetRouteFor(network, address string) (r *Route) { break } - if node.transport.IsMultiplex() { + if node.transport.Multiplex() { tr := node.transport.Copy(). WithRoute(r) node = node.Copy(). diff --git a/pkg/chain/transport.go b/pkg/chain/transport.go index 496115e..f717022 100644 --- a/pkg/chain/transport.go +++ b/pkg/chain/transport.go @@ -75,9 +75,9 @@ func (tr *Transport) Bind(ctx context.Context, conn net.Conn, network, address s return nil, connector.ErrBindUnsupported } -func (tr *Transport) IsMultiplex() bool { +func (tr *Transport) Multiplex() bool { if mux, ok := tr.dialer.(dialer.Multiplexer); ok { - return mux.IsMultiplex() + return mux.Multiplex() } return false } diff --git a/pkg/dialer/dialer.go b/pkg/dialer/dialer.go index 89cc36b..26c7c4b 100644 --- a/pkg/dialer/dialer.go +++ b/pkg/dialer/dialer.go @@ -18,5 +18,5 @@ type Handshaker interface { } type Multiplexer interface { - IsMultiplex() bool + Multiplex() bool } diff --git a/pkg/dialer/http2/dialer.go b/pkg/dialer/http2/dialer.go index 52a2021..9ec9d60 100644 --- a/pkg/dialer/http2/dialer.go +++ b/pkg/dialer/http2/dialer.go @@ -45,8 +45,8 @@ func (d *http2Dialer) Init(md md.Metadata) (err error) { return nil } -// IsMultiplex implements dialer.Multiplexer interface. -func (d *http2Dialer) IsMultiplex() bool { +// Multiplex implements dialer.Multiplexer interface. +func (d *http2Dialer) Multiplex() bool { return true } diff --git a/pkg/dialer/http2/h2/dialer.go b/pkg/dialer/http2/h2/dialer.go index 1b6e766..2f4df9c 100644 --- a/pkg/dialer/http2/h2/dialer.go +++ b/pkg/dialer/http2/h2/dialer.go @@ -65,8 +65,8 @@ func (d *h2Dialer) Init(md md.Metadata) (err error) { return nil } -// IsMultiplex implements dialer.Multiplexer interface. -func (d *h2Dialer) IsMultiplex() bool { +// Multiplex implements dialer.Multiplexer interface. +func (d *h2Dialer) Multiplex() bool { return true } diff --git a/pkg/dialer/kcp/dialer.go b/pkg/dialer/kcp/dialer.go index 1fcd160..a671b49 100644 --- a/pkg/dialer/kcp/dialer.go +++ b/pkg/dialer/kcp/dialer.go @@ -50,8 +50,8 @@ func (d *kcpDialer) Init(md md.Metadata) (err error) { return nil } -// IsMultiplex implements dialer.Multiplexer interface. -func (d *kcpDialer) IsMultiplex() bool { +// Multiplex implements dialer.Multiplexer interface. +func (d *kcpDialer) Multiplex() bool { return true } @@ -103,7 +103,6 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia for _, option := range options { option(opts) } - config := d.md.config d.sessionMutex.Lock() defer d.sessionMutex.Unlock() @@ -120,7 +119,7 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia } if !ok || session.session == nil { - s, err := d.initSession(opts.Addr, conn, config) + s, err := d.initSession(ctx, opts.Addr, conn) if err != nil { d.logger.Error(err) conn.Close() @@ -140,12 +139,14 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia return cc, nil } -func (d *kcpDialer) initSession(addr string, conn net.Conn, config *kcp_util.Config) (*muxSession, error) { +func (d *kcpDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*muxSession, error) { pc, ok := conn.(net.PacketConn) if !ok { return nil, errors.New("kcp: wrong connection type") } + config := d.md.config + kcpconn, err := kcp.NewConn(addr, kcp_util.BlockCrypt(config.Key, config.Crypt, kcp_util.DefaultSalt), config.DataShard, config.ParityShard, pc) diff --git a/pkg/dialer/quic/dialer.go b/pkg/dialer/quic/dialer.go index 0d4d761..a1ef700 100644 --- a/pkg/dialer/quic/dialer.go +++ b/pkg/dialer/quic/dialer.go @@ -46,8 +46,8 @@ func (d *quicDialer) Init(md md.Metadata) (err error) { return nil } -// IsMultiplex implements dialer.Multiplexer interface. -func (d *quicDialer) IsMultiplex() bool { +// Multiplex implements dialer.Multiplexer interface. +func (d *quicDialer) Multiplex() bool { return true } diff --git a/pkg/dialer/tls/dialer.go b/pkg/dialer/tls/dialer.go new file mode 100644 index 0000000..9ed9483 --- /dev/null +++ b/pkg/dialer/tls/dialer.go @@ -0,0 +1,67 @@ +package tls + +import ( + "context" + "crypto/tls" + "net" + "time" + + "github.com/go-gost/gost/pkg/dialer" + "github.com/go-gost/gost/pkg/logger" + md "github.com/go-gost/gost/pkg/metadata" + "github.com/go-gost/gost/pkg/registry" +) + +func init() { + registry.RegisterDialer("tls", NewDialer) +} + +type tlsDialer struct { + md metadata + logger logger.Logger +} + +func NewDialer(opts ...dialer.Option) dialer.Dialer { + options := &dialer.Options{} + for _, opt := range opts { + opt(options) + } + + return &tlsDialer{ + logger: options.Logger, + } +} + +func (d *tlsDialer) Init(md md.Metadata) (err error) { + return d.parseMetadata(md) +} + +func (d *tlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (net.Conn, error) { + var options dialer.DialOptions + for _, opt := range opts { + opt(&options) + } + + var netd net.Dialer + conn, err := netd.DialContext(ctx, "tcp", addr) + if err != nil { + d.logger.Error(err) + } + return conn, err +} + +// Handshake implements dialer.Handshaker +func (d *tlsDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) { + if d.md.handshakeTimeout > 0 { + conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout)) + defer conn.SetDeadline(time.Time{}) + } + + tlsConn := tls.Client(conn, d.md.tlsConfig) + if err := tlsConn.HandshakeContext(ctx); err != nil { + conn.Close() + return nil, err + } + + return tlsConn, nil +} diff --git a/pkg/dialer/tls/metadata.go b/pkg/dialer/tls/metadata.go new file mode 100644 index 0000000..b03461a --- /dev/null +++ b/pkg/dialer/tls/metadata.go @@ -0,0 +1,43 @@ +package tls + +import ( + "crypto/tls" + "net" + "time" + + tls_util "github.com/go-gost/gost/pkg/common/util/tls" + md "github.com/go-gost/gost/pkg/metadata" +) + +type metadata struct { + tlsConfig *tls.Config + handshakeTimeout time.Duration +} + +func (d *tlsDialer) parseMetadata(md md.Metadata) (err error) { + const ( + certFile = "certFile" + keyFile = "keyFile" + caFile = "caFile" + secure = "secure" + serverName = "serverName" + + handshakeTimeout = "handshakeTimeout" + ) + + sn, _, _ := net.SplitHostPort(md.GetString(serverName)) + if sn == "" { + sn = "localhost" + } + d.md.tlsConfig, err = tls_util.LoadClientConfig( + md.GetString(certFile), + md.GetString(keyFile), + md.GetString(caFile), + md.GetBool(secure), + sn, + ) + + d.md.handshakeTimeout = md.GetDuration(handshakeTimeout) + + return +} diff --git a/pkg/dialer/tls/mux/conn.go b/pkg/dialer/tls/mux/conn.go new file mode 100644 index 0000000..3ec6db3 --- /dev/null +++ b/pkg/dialer/tls/mux/conn.go @@ -0,0 +1,38 @@ +package mux + +import ( + "net" + + "github.com/xtaci/smux" +) + +type muxSession struct { + conn net.Conn + session *smux.Session +} + +func (session *muxSession) GetConn() (net.Conn, error) { + return session.session.OpenStream() +} + +func (session *muxSession) Accept() (net.Conn, error) { + return session.session.AcceptStream() +} + +func (session *muxSession) Close() error { + if session.session == nil { + return nil + } + return session.session.Close() +} + +func (session *muxSession) IsClosed() bool { + if session.session == nil { + return true + } + return session.session.IsClosed() +} + +func (session *muxSession) NumStreams() int { + return session.session.NumStreams() +} diff --git a/pkg/dialer/tls/mux/dialer.go b/pkg/dialer/tls/mux/dialer.go new file mode 100644 index 0000000..499f577 --- /dev/null +++ b/pkg/dialer/tls/mux/dialer.go @@ -0,0 +1,182 @@ +package mux + +import ( + "context" + "crypto/tls" + "errors" + "net" + "sync" + "time" + + "github.com/go-gost/gost/pkg/dialer" + "github.com/go-gost/gost/pkg/logger" + md "github.com/go-gost/gost/pkg/metadata" + "github.com/go-gost/gost/pkg/registry" + "github.com/xtaci/smux" +) + +func init() { + registry.RegisterDialer("mtls", NewDialer) +} + +type mtlsDialer struct { + sessions map[string]*muxSession + sessionMutex sync.Mutex + logger logger.Logger + md metadata +} + +func NewDialer(opts ...dialer.Option) dialer.Dialer { + options := &dialer.Options{} + for _, opt := range opts { + opt(options) + } + + return &mtlsDialer{ + sessions: make(map[string]*muxSession), + logger: options.Logger, + } +} + +func (d *mtlsDialer) Init(md md.Metadata) (err error) { + if err = d.parseMetadata(md); err != nil { + return + } + + return nil +} + +// Multiplex implements dialer.Multiplexer interface. +func (d *mtlsDialer) Multiplex() bool { + return true +} + +func (d *mtlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) { + var options dialer.DialOptions + for _, opt := range opts { + opt(&options) + } + + d.sessionMutex.Lock() + defer d.sessionMutex.Unlock() + + session, ok := d.sessions[addr] + if session != nil && session.IsClosed() { + delete(d.sessions, addr) // session is dead + ok = false + } + if !ok { + conn, err = d.dial(ctx, "tcp", addr, &options) + if err != nil { + return + } + + session = &muxSession{conn: conn} + d.sessions[addr] = session + } + + return session.conn, err +} + +// Handshake implements dialer.Handshaker +func (d *mtlsDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) { + opts := &dialer.HandshakeOptions{} + for _, option := range options { + option(opts) + } + + d.sessionMutex.Lock() + defer d.sessionMutex.Unlock() + + if d.md.handshakeTimeout > 0 { + conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout)) + defer conn.SetDeadline(time.Time{}) + } + + session, ok := d.sessions[opts.Addr] + if session != nil && session.conn != conn { + conn.Close() + return nil, errors.New("mtls: unrecognized connection") + } + + if !ok || session.session == nil { + s, err := d.initSession(ctx, conn) + if err != nil { + d.logger.Error(err) + conn.Close() + delete(d.sessions, opts.Addr) + return nil, err + } + session = s + d.sessions[opts.Addr] = session + } + cc, err := session.GetConn() + if err != nil { + session.Close() + delete(d.sessions, opts.Addr) + return nil, err + } + + return cc, nil +} + +func (d *mtlsDialer) dial(ctx context.Context, network, addr string, opts *dialer.DialOptions) (net.Conn, error) { + dial := opts.DialFunc + if dial != nil { + conn, err := dial(ctx, addr) + if err != nil { + d.logger.Error(err) + } else { + d.logger.WithFields(map[string]interface{}{ + "src": conn.LocalAddr().String(), + "dst": addr, + }).Debug("dial with dial func") + } + return conn, err + } + + var netd net.Dialer + conn, err := netd.DialContext(ctx, network, addr) + if err != nil { + d.logger.Error(err) + } else { + d.logger.WithFields(map[string]interface{}{ + "src": conn.LocalAddr().String(), + "dst": addr, + }).Debugf("dial direct %s/%s", addr, network) + } + return conn, err +} + +func (d *mtlsDialer) initSession(ctx context.Context, conn net.Conn) (*muxSession, error) { + tlsConn := tls.Client(conn, d.md.tlsConfig) + if err := tlsConn.HandshakeContext(ctx); err != nil { + return nil, err + } + conn = tlsConn + + // stream multiplex + smuxConfig := smux.DefaultConfig() + smuxConfig.KeepAliveDisabled = d.md.muxKeepAliveDisabled + if d.md.muxKeepAliveInterval > 0 { + smuxConfig.KeepAliveInterval = d.md.muxKeepAliveInterval + } + if d.md.muxKeepAliveTimeout > 0 { + smuxConfig.KeepAliveTimeout = d.md.muxKeepAliveTimeout + } + if d.md.muxMaxFrameSize > 0 { + smuxConfig.MaxFrameSize = d.md.muxMaxFrameSize + } + if d.md.muxMaxReceiveBuffer > 0 { + smuxConfig.MaxReceiveBuffer = d.md.muxMaxReceiveBuffer + } + if d.md.muxMaxStreamBuffer > 0 { + smuxConfig.MaxStreamBuffer = d.md.muxMaxStreamBuffer + } + + session, err := smux.Client(conn, smuxConfig) + if err != nil { + return nil, err + } + return &muxSession{conn: conn, session: session}, nil +} diff --git a/pkg/dialer/tls/mux/metadata.go b/pkg/dialer/tls/mux/metadata.go new file mode 100644 index 0000000..d11cff1 --- /dev/null +++ b/pkg/dialer/tls/mux/metadata.go @@ -0,0 +1,63 @@ +package mux + +import ( + "crypto/tls" + "net" + "time" + + tls_util "github.com/go-gost/gost/pkg/common/util/tls" + md "github.com/go-gost/gost/pkg/metadata" +) + +type metadata struct { + tlsConfig *tls.Config + handshakeTimeout time.Duration + + muxKeepAliveDisabled bool + muxKeepAliveInterval time.Duration + muxKeepAliveTimeout time.Duration + muxMaxFrameSize int + muxMaxReceiveBuffer int + muxMaxStreamBuffer int +} + +func (d *mtlsDialer) parseMetadata(md md.Metadata) (err error) { + const ( + certFile = "certFile" + keyFile = "keyFile" + caFile = "caFile" + secure = "secure" + serverName = "serverName" + + handshakeTimeout = "handshakeTimeout" + + muxKeepAliveDisabled = "muxKeepAliveDisabled" + muxKeepAliveInterval = "muxKeepAliveInterval" + muxKeepAliveTimeout = "muxKeepAliveTimeout" + muxMaxFrameSize = "muxMaxFrameSize" + muxMaxReceiveBuffer = "muxMaxReceiveBuffer" + muxMaxStreamBuffer = "muxMaxStreamBuffer" + ) + + sn, _, _ := net.SplitHostPort(md.GetString(serverName)) + if sn == "" { + sn = "localhost" + } + d.md.tlsConfig, err = tls_util.LoadClientConfig( + md.GetString(certFile), + md.GetString(keyFile), + md.GetString(caFile), + md.GetBool(secure), + sn, + ) + d.md.handshakeTimeout = md.GetDuration(handshakeTimeout) + + d.md.muxKeepAliveDisabled = md.GetBool(muxKeepAliveDisabled) + d.md.muxKeepAliveInterval = md.GetDuration(muxKeepAliveInterval) + d.md.muxKeepAliveTimeout = md.GetDuration(muxKeepAliveTimeout) + d.md.muxMaxFrameSize = md.GetInt(muxMaxFrameSize) + d.md.muxMaxReceiveBuffer = md.GetInt(muxMaxReceiveBuffer) + d.md.muxMaxStreamBuffer = md.GetInt(muxMaxStreamBuffer) + + return +} diff --git a/pkg/dialer/udp/dialer.go b/pkg/dialer/udp/dialer.go index 2146f6e..67893b3 100644 --- a/pkg/dialer/udp/dialer.go +++ b/pkg/dialer/udp/dialer.go @@ -48,7 +48,3 @@ func (d *udpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp UDPConn: c, }, nil } - -func (d *udpDialer) parseMetadata(md md.Metadata) (err error) { - return -} diff --git a/pkg/dialer/udp/metadata.go b/pkg/dialer/udp/metadata.go index cc46071..1b146ec 100644 --- a/pkg/dialer/udp/metadata.go +++ b/pkg/dialer/udp/metadata.go @@ -1,6 +1,10 @@ package udp -import "time" +import ( + "time" + + md "github.com/go-gost/gost/pkg/metadata" +) const ( dialTimeout = "dialTimeout" @@ -13,3 +17,7 @@ const ( type metadata struct { dialTimeout time.Duration } + +func (d *udpDialer) parseMetadata(md md.Metadata) (err error) { + return +} diff --git a/pkg/listener/tls/listener.go b/pkg/listener/tls/listener.go index 614bed1..c56dd27 100644 --- a/pkg/listener/tls/listener.go +++ b/pkg/listener/tls/listener.go @@ -4,7 +4,6 @@ import ( "crypto/tls" "net" - "github.com/go-gost/gost/pkg/common/util" "github.com/go-gost/gost/pkg/listener" "github.com/go-gost/gost/pkg/logger" md "github.com/go-gost/gost/pkg/metadata" @@ -17,9 +16,9 @@ func init() { type tlsListener struct { addr string - md metadata net.Listener logger logger.Logger + md metadata } func NewListener(opts ...listener.Option) listener.Listener { @@ -43,14 +42,7 @@ func (l *tlsListener) Init(md md.Metadata) (err error) { return } - ln = tls.NewListener( - &util.TCPKeepAliveListener{ - TCPListener: ln.(*net.TCPListener), - KeepAlivePeriod: l.md.keepAlivePeriod, - }, - l.md.tlsConfig, - ) + l.Listener = tls.NewListener(ln, l.md.tlsConfig) - l.Listener = ln return } diff --git a/pkg/listener/tls/metadata.go b/pkg/listener/tls/metadata.go index bb47f52..f37733a 100644 --- a/pkg/listener/tls/metadata.go +++ b/pkg/listener/tls/metadata.go @@ -2,23 +2,20 @@ package tls import ( "crypto/tls" - "time" tls_util "github.com/go-gost/gost/pkg/common/util/tls" md "github.com/go-gost/gost/pkg/metadata" ) type metadata struct { - tlsConfig *tls.Config - keepAlivePeriod time.Duration + tlsConfig *tls.Config } func (l *tlsListener) parseMetadata(md md.Metadata) (err error) { const ( - certFile = "certFile" - keyFile = "keyFile" - caFile = "caFile" - keepAlivePeriod = "keepAlivePeriod" + certFile = "certFile" + keyFile = "keyFile" + caFile = "caFile" ) l.md.tlsConfig, err = tls_util.LoadServerConfig( @@ -30,6 +27,5 @@ func (l *tlsListener) parseMetadata(md md.Metadata) (err error) { return } - l.md.keepAlivePeriod = md.GetDuration(keepAlivePeriod) return } diff --git a/pkg/listener/tls/mux/listener.go b/pkg/listener/tls/mux/listener.go index 799006c..f4428bb 100644 --- a/pkg/listener/tls/mux/listener.go +++ b/pkg/listener/tls/mux/listener.go @@ -17,11 +17,11 @@ func init() { type mtlsListener struct { addr string - md metadata net.Listener - connChan chan net.Conn - errChan chan error - logger logger.Logger + cqueue chan net.Conn + errChan chan error + logger logger.Logger + md metadata } func NewListener(opts ...listener.Option) listener.Listener { @@ -46,11 +46,7 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) { } l.Listener = tls.NewListener(ln, l.md.tlsConfig) - queueSize := l.md.connQueueSize - if queueSize <= 0 { - queueSize = defaultQueueSize - } - l.connChan = make(chan net.Conn, queueSize) + l.cqueue = make(chan net.Conn, l.md.backlog) l.errChan = make(chan error, 1) go l.listenLoop() @@ -73,8 +69,8 @@ func (l *mtlsListener) listenLoop() { func (l *mtlsListener) mux(conn net.Conn) { smuxConfig := smux.DefaultConfig() smuxConfig.KeepAliveDisabled = l.md.muxKeepAliveDisabled - if l.md.muxKeepAlivePeriod > 0 { - smuxConfig.KeepAliveInterval = l.md.muxKeepAlivePeriod + if l.md.muxKeepAliveInterval > 0 { + smuxConfig.KeepAliveInterval = l.md.muxKeepAliveInterval } if l.md.muxKeepAliveTimeout > 0 { smuxConfig.KeepAliveTimeout = l.md.muxKeepAliveTimeout @@ -103,12 +99,12 @@ func (l *mtlsListener) mux(conn net.Conn) { } select { - case l.connChan <- stream: + case l.cqueue <- stream: case <-stream.GetDieCh(): stream.Close() default: stream.Close() - l.logger.Error("connection queue is full") + l.logger.Warnf("connection queue is full, client %s discarded", stream.RemoteAddr()) } } } @@ -116,7 +112,7 @@ func (l *mtlsListener) mux(conn net.Conn) { func (l *mtlsListener) Accept() (conn net.Conn, err error) { var ok bool select { - case conn = <-l.connChan: + case conn = <-l.cqueue: case err, ok = <-l.errChan: if !ok { err = listener.ErrClosed diff --git a/pkg/listener/tls/mux/metadata.go b/pkg/listener/tls/mux/metadata.go index fc9e922..c59d429 100644 --- a/pkg/listener/tls/mux/metadata.go +++ b/pkg/listener/tls/mux/metadata.go @@ -9,20 +9,20 @@ import ( ) const ( - defaultQueueSize = 128 + defaultBacklog = 128 ) type metadata struct { tlsConfig *tls.Config muxKeepAliveDisabled bool - muxKeepAlivePeriod time.Duration + muxKeepAliveInterval time.Duration muxKeepAliveTimeout time.Duration muxMaxFrameSize int muxMaxReceiveBuffer int muxMaxStreamBuffer int - connQueueSize int + backlog int } func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) { @@ -31,8 +31,10 @@ func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) { keyFile = "keyFile" caFile = "caFile" + backlog = "backlog" + muxKeepAliveDisabled = "muxKeepAliveDisabled" - muxKeepAlivePeriod = "muxKeepAlivePeriod" + muxKeepAliveInterval = "muxKeepAliveInterval" muxKeepAliveTimeout = "muxKeepAliveTimeout" muxMaxFrameSize = "muxMaxFrameSize" muxMaxReceiveBuffer = "muxMaxReceiveBuffer" @@ -48,5 +50,17 @@ func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) { return } + l.md.backlog = md.GetInt(backlog) + if l.md.backlog <= 0 { + l.md.backlog = defaultBacklog + } + + l.md.muxKeepAliveDisabled = md.GetBool(muxKeepAliveDisabled) + l.md.muxKeepAliveInterval = md.GetDuration(muxKeepAliveInterval) + l.md.muxKeepAliveTimeout = md.GetDuration(muxKeepAliveTimeout) + l.md.muxMaxFrameSize = md.GetInt(muxMaxFrameSize) + l.md.muxMaxReceiveBuffer = md.GetInt(muxMaxReceiveBuffer) + l.md.muxMaxStreamBuffer = md.GetInt(muxMaxStreamBuffer) + return }