add binder for connector

This commit is contained in:
ginuerzh
2021-11-20 23:41:11 +08:00
parent c5df25e84d
commit 3fd3b5e801
29 changed files with 1396 additions and 284 deletions

View File

@ -1,17 +0,0 @@
package rtcp
import "net"
type peerConn struct {
net.Conn
localAddr net.Addr
remoteAddr net.Addr
}
func (c *peerConn) LocalAddr() net.Addr {
return c.localAddr
}
func (c *peerConn) RemoteAddr() net.Addr {
return c.remoteAddr
}

View File

@ -2,14 +2,10 @@ package rtcp
import (
"context"
"fmt"
"net"
"sync"
"time"
"github.com/go-gost/gosocks5"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/common/util/mux"
"github.com/go-gost/gost/pkg/connector"
"github.com/go-gost/gost/pkg/listener"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
@ -21,16 +17,13 @@ func init() {
}
type rtcpListener struct {
addr string
laddr net.Addr
chain *chain.Chain
md metadata
ln net.Listener
cqueue chan net.Conn
session *mux.Session
sessionMux sync.Mutex
logger logger.Logger
closed chan struct{}
addr string
laddr net.Addr
chain *chain.Chain
accepter connector.Accepter
md metadata
logger logger.Logger
closed chan struct{}
}
func NewListener(opts ...listener.Option) listener.Listener {
@ -61,14 +54,6 @@ func (l *rtcpListener) Init(md md.Metadata) (err error) {
}
l.laddr = laddr
l.cqueue = make(chan net.Conn, l.md.backlog)
if l.chain.IsEmpty() {
l.ln, err = net.ListenTCP("tcp", laddr)
return err
}
go l.listenLoop()
return
}
@ -78,10 +63,6 @@ func (l *rtcpListener) Addr() net.Addr {
}
func (l *rtcpListener) Close() error {
if l.ln != nil {
return l.ln.Close()
}
select {
case <-l.closed:
default:
@ -92,120 +73,21 @@ func (l *rtcpListener) Close() error {
}
func (l *rtcpListener) Accept() (conn net.Conn, err error) {
if l.ln != nil {
return l.ln.Accept()
if l.accepter == nil {
r := (&chain.Router{}).
WithChain(l.chain).
WithRetry(l.md.retryCount).
WithLogger(l.logger)
l.accepter, err = r.Bind(context.Background(), "tcp", l.laddr.String())
if err != nil {
return nil, connector.NewAcceptError(err)
}
}
select {
case conn = <-l.cqueue:
case <-l.closed:
err = net.ErrClosed
conn, err = l.accepter.Accept()
if err != nil {
l.accepter.Close()
l.accepter = nil
return nil, connector.NewAcceptError(err)
}
return
}
func (l *rtcpListener) listenLoop() {
var tempDelay time.Duration
for {
select {
case <-l.closed:
return
default:
}
conn, err := l.accept()
if err != nil {
if tempDelay == 0 {
tempDelay = 1000 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 6 * time.Second; tempDelay > max {
tempDelay = max
}
l.logger.Warnf("accept: %v, retrying in %v", err, tempDelay)
time.Sleep(tempDelay)
continue
}
tempDelay = 0
select {
case l.cqueue <- conn:
default:
conn.Close()
l.logger.Warnf("connection queue is full, client %s discarded", conn.RemoteAddr().String())
}
}
}
func (l *rtcpListener) accept() (net.Conn, error) {
if l.md.enableMux {
return l.muxAccept()
}
r := (&chain.Router{}).
WithChain(l.chain).
WithRetry(l.md.retryCount).
WithLogger(l.logger)
cc, err := r.Connect(context.Background())
if err != nil {
return nil, err
}
conn, err := l.waitPeer(cc)
if err != nil {
l.logger.Error(err)
cc.Close()
return nil, err
}
l.logger.Debugf("peer %s accepted", conn.RemoteAddr())
return conn, nil
}
func (l *rtcpListener) waitPeer(conn net.Conn) (net.Conn, error) {
addr := gosocks5.Addr{}
addr.ParseFrom(l.addr)
req := gosocks5.NewRequest(gosocks5.CmdBind, &addr)
if err := req.Write(conn); err != nil {
return nil, err
}
// first reply, bind status
rep, err := gosocks5.ReadReply(conn)
if err != nil {
return nil, err
}
l.logger.Debug(rep)
if rep.Rep != gosocks5.Succeeded {
return nil, fmt.Errorf("bind on %s failed", l.addr)
}
l.logger.Debugf("bind on %s OK", rep.Addr)
// second reply, peer connected
rep, err = gosocks5.ReadReply(conn)
if err != nil {
return nil, err
}
if rep.Rep != gosocks5.Succeeded {
return nil, fmt.Errorf("peer connect failed")
}
raddr, err := net.ResolveTCPAddr("tcp", rep.Addr.String())
if err != nil {
return nil, err
}
return &peerConn{
Conn: conn,
localAddr: l.laddr,
remoteAddr: raddr,
}, nil
}

View File

@ -1,109 +0,0 @@
package rtcp
import (
"context"
"fmt"
"net"
"github.com/go-gost/gosocks5"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/common/util/mux"
"github.com/go-gost/gost/pkg/common/util/socks"
)
func (l *rtcpListener) muxAccept() (net.Conn, error) {
session, err := l.getSession()
if err != nil {
l.logger.Error(err)
return nil, err
}
cc, err := session.Accept()
if err != nil {
session.Close()
return nil, err
}
conn, err := l.getPeerConn(cc)
if err != nil {
l.logger.Error(err)
cc.Close()
return nil, err
}
l.logger.Debugf("peer %s accepted", conn.RemoteAddr())
return conn, nil
}
func (l *rtcpListener) getPeerConn(conn net.Conn) (net.Conn, error) {
// second reply, peer connected
rep, err := gosocks5.ReadReply(conn)
if err != nil {
return nil, err
}
if rep.Rep != gosocks5.Succeeded {
err = fmt.Errorf("peer connect failed")
return nil, err
}
raddr, err := net.ResolveTCPAddr("tcp", rep.Addr.String())
if err != nil {
return nil, err
}
return &peerConn{
Conn: conn,
localAddr: l.laddr,
remoteAddr: raddr,
}, nil
}
func (l *rtcpListener) getSession() (s *mux.Session, err error) {
l.sessionMux.Lock()
defer l.sessionMux.Unlock()
if l.session != nil && !l.session.IsClosed() {
return l.session, nil
}
r := (&chain.Router{}).
WithChain(l.chain).
WithRetry(l.md.retryCount).
WithLogger(l.logger)
conn, err := r.Connect(context.Background())
if err != nil {
return nil, err
}
l.session, err = l.initSession(conn)
if err != nil {
conn.Close()
return
}
return l.session, nil
}
func (l *rtcpListener) initSession(conn net.Conn) (*mux.Session, error) {
addr := gosocks5.Addr{}
addr.ParseFrom(l.addr)
req := gosocks5.NewRequest(socks.CmdMuxBind, &addr)
if err := req.Write(conn); err != nil {
return nil, err
}
// first reply, bind status
rep, err := gosocks5.ReadReply(conn)
if err != nil {
return nil, err
}
if rep.Rep != gosocks5.Succeeded {
err = fmt.Errorf("bind on %s failed", l.addr)
return nil, err
}
l.logger.Debugf("bind on %s OK", rep.Addr)
return mux.ServerSession(conn)
}

View File

@ -14,8 +14,7 @@ const (
)
type metadata struct {
ttl time.Duration
ttl time.Duration
readBufferSize int
readQueueSize int
backlog int