go-gost/gost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add rtcp

Browse Source
This commit is contained in:
ginuerzh
2021-11-15 12:55:05 +08:00
parent 3fe5084629
commit ce3d62759a
38 changed files with 788 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
pkg/listener/kcp/listener.go
View File

@ -48,6 +48,7 @@ func (l *kcpListener) Init(md md.Metadata) (err error) {
config = DefaultConfig
}
config.Init()
l.md.config = config
var ln *kcp.Listener
@ -168,7 +169,3 @@ func (l *kcpListener) mux(conn net.Conn) {
}
}
}
func (l *kcpListener) parseMetadata(md md.Metadata) (err error) {
return
}

14
pkg/listener/kcp/metadata.go
View File

@ -1,8 +1,6 @@
package kcp
const (
connQueueSize = "connQueueSize"
)
import md "github.com/go-gost/gost/pkg/metadata"
const (
defaultQueueSize = 128
@ -13,3 +11,13 @@ type metadata struct {
connQueueSize int
}
func (l *kcpListener) parseMetadata(md md.Metadata) (err error) {
const (
connQueueSize = "connQueueSize"
)
l.md.connQueueSize = md.GetInt(connQueueSize)
return
}

8
pkg/listener/option.go
View File

@ -1,11 +1,13 @@
package listener
import (
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/logger"
)
type Options struct {
Addr string
Chain *chain.Chain
Logger logger.Logger
}
@ -17,6 +19,12 @@ func AddrOption(addr string) Option {
}
}
func ChainOption(chain *chain.Chain) Option {
return func(opts *Options) {
opts.Chain = chain
}
}
func LoggerOption(logger logger.Logger) Option {
return func(opts *Options) {
opts.Logger = logger

17
pkg/listener/rtcp/conn.go Normal file
View File

@ -0,0 +1,17 @@
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
}

214
pkg/listener/rtcp/listener.go Normal file
View File

@ -0,0 +1,214 @@
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/internal/utils/mux"
"github.com/go-gost/gost/pkg/listener"
"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.RegisterListener("rtcp", NewListener)
}
type rtcpListener struct {
addr string
laddr net.Addr
chain *chain.Chain
md metadata
ln net.Listener
connChan chan net.Conn
session *mux.Session
sessionMux sync.Mutex
logger logger.Logger
closed chan struct{}
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
for _, opt := range opts {
opt(options)
}
return &rtcpListener{
addr: options.Addr,
chain: options.Chain,
closed: make(chan struct{}),
logger: options.Logger,
}
}
func (l *rtcpListener) Init(md md.Metadata) (err error) {
if err = l.parseMetadata(md); err != nil {
return
}
laddr, err := net.ResolveTCPAddr("tcp", l.addr)
if err != nil {
return
}
l.laddr = laddr
l.connChan = make(chan net.Conn, l.md.connQueueSize)
if l.chain.IsEmpty() {
l.ln, err = net.ListenTCP("tcp", laddr)
return err
}
go l.listenLoop()
return
}
func (l *rtcpListener) Addr() net.Addr {
return l.laddr
}
func (l *rtcpListener) Close() error {
if l.ln != nil {
return l.ln.Close()
}
select {
case <-l.closed:
default:
close(l.closed)
}
return nil
}
func (l *rtcpListener) Accept() (conn net.Conn, err error) {
if l.ln != nil {
return l.ln.Accept()
}
select {
case conn = <-l.connChan:
case <-l.closed:
err = net.ErrClosed
}
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.connChan <- 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 {
l.logger.Error(err)
return nil, err
}
// first reply, bind status
rep, err := gosocks5.ReadReply(conn)
if err != nil {
l.logger.Error(err)
return nil, err
}
l.logger.Debug(rep)
if rep.Rep != gosocks5.Succeeded {
err = fmt.Errorf("bind on %s failed", l.addr)
l.logger.Error(err)
return nil, err
}
l.logger.Debugf("bind on %s OK", rep.Addr)
// second reply, peer connected
rep, err = gosocks5.ReadReply(conn)
if err != nil {
l.logger.Error(err)
return nil, err
}
if rep.Rep != gosocks5.Succeeded {
err = fmt.Errorf("peer connect failed")
l.logger.Error(err)
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
}

35
pkg/listener/rtcp/metadata.go Normal file
View File

@ -0,0 +1,35 @@
package rtcp
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
)
const (
defaultKeepAlivePeriod = 180 * time.Second
defaultConnQueueSize = 128
)
type metadata struct {
enableMux bool
connQueueSize int
retryCount int
}
func (l *rtcpListener) parseMetadata(md md.Metadata) (err error) {
const (
enableMux = "mux"
connQueueSize = "connQueueSize"
retryCount = "retry"
)
l.md.enableMux = md.GetBool(enableMux)
l.md.retryCount = md.GetInt(retryCount)
l.md.connQueueSize = md.GetInt(connQueueSize)
if l.md.connQueueSize <= 0 {
l.md.connQueueSize = defaultConnQueueSize
}
return
}

109
pkg/listener/rtcp/mux.go Normal file
View File

@ -0,0 +1,109 @@
package rtcp
import (
"context"
"fmt"
"net"
"github.com/go-gost/gosocks5"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/internal/utils/mux"
"github.com/go-gost/gost/pkg/internal/utils/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)
}

7
pkg/listener/tcp/listener.go
View File

@ -57,10 +57,3 @@ func (l *tcpListener) Init(md md.Metadata) (err error) {
l.Listener = ln
return
}
func (l *tcpListener) parseMetadata(md md.Metadata) (err error) {
l.md.keepAlive = md.GetBool(keepAlive)
l.md.keepAlivePeriod = md.GetDuration(keepAlivePeriod)
return
}

19
pkg/listener/tcp/metadata.go
View File

@ -1,10 +1,9 @@
package tcp
import "time"
import (
"time"
const (
keepAlive = "keepAlive"
keepAlivePeriod = "keepAlivePeriod"
md "github.com/go-gost/gost/pkg/metadata"
)
const (
@ -15,3 +14,15 @@ type metadata struct {
keepAlive bool
keepAlivePeriod time.Duration
}
func (l *tcpListener) parseMetadata(md md.Metadata) (err error) {
const (
keepAlive = "keepAlive"
keepAlivePeriod = "keepAlivePeriod"
)
l.md.keepAlive = md.GetBool(keepAlive)
l.md.keepAlivePeriod = md.GetDuration(keepAlivePeriod)
return
}

54
pkg/listener/udp/listener.go
View File

@ -15,14 +15,14 @@ func init() {
}
type udpListener struct {
addr string
md metadata
conn net.PacketConn
connChan chan net.Conn
errChan chan error
closeChan chan struct{}
connPool *connPool
logger logger.Logger
addr string
md metadata
conn net.PacketConn
connChan chan net.Conn
errChan chan error
closed chan struct{}
connPool *connPool
logger logger.Logger
}
func NewListener(opts ...listener.Option) listener.Listener {
@ -31,10 +31,10 @@ func NewListener(opts ...listener.Option) listener.Listener {
opt(options)
}
return &udpListener{
addr: options.Addr,
errChan: make(chan error, 1),
closeChan: make(chan struct{}),
logger: options.Logger,
addr: options.Addr,
errChan: make(chan error, 1),
closed: make(chan struct{}),
logger: options.Logger,
}
}
@ -75,13 +75,14 @@ func (l *udpListener) Accept() (conn net.Conn, err error) {
func (l *udpListener) Close() error {
select {
case <-l.closeChan:
return nil
case <-l.closed:
default:
close(l.closeChan)
close(l.closed)
l.connPool.Close()
return l.conn.Close()
}
return nil
}
func (l *udpListener) Addr() net.Addr {
@ -126,26 +127,3 @@ func (l *udpListener) getConn(addr net.Addr) *conn {
}
return c
}
func (l *udpListener) parseMetadata(md md.Metadata) (err error) {
l.md.ttl = md.GetDuration(ttl)
if l.md.ttl <= 0 {
l.md.ttl = defaultTTL
}
l.md.readBufferSize = md.GetInt(readBufferSize)
if l.md.readBufferSize <= 0 {
l.md.readBufferSize = defaultReadBufferSize
}
l.md.readQueueSize = md.GetInt(readQueueSize)
if l.md.readQueueSize <= 0 {
l.md.readQueueSize = defaultReadQueueSize
}
l.md.connQueueSize = md.GetInt(connQueueSize)
if l.md.connQueueSize <= 0 {
l.md.connQueueSize = defaultConnQueueSize
}
return
}

43
pkg/listener/udp/metadata.go
View File

@ -1,6 +1,10 @@
package udp
import "time"
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
)
const (
defaultTTL = 60 * time.Second
@ -9,13 +13,6 @@ const (
defaultConnQueueSize = 128
)
const (
ttl = "ttl"
readBufferSize = "readBufferSize"
readQueueSize = "readQueueSize"
connQueueSize = "connQueueSize"
)
type metadata struct {
ttl time.Duration
@ -23,3 +20,33 @@ type metadata struct {
readQueueSize int
connQueueSize int
}
func (l *udpListener) parseMetadata(md md.Metadata) (err error) {
const (
ttl = "ttl"
readBufferSize = "readBufferSize"
readQueueSize = "readQueueSize"
connQueueSize = "connQueueSize"
)
l.md.ttl = md.GetDuration(ttl)
if l.md.ttl <= 0 {
l.md.ttl = defaultTTL
}
l.md.readBufferSize = md.GetInt(readBufferSize)
if l.md.readBufferSize <= 0 {
l.md.readBufferSize = defaultReadBufferSize
}
l.md.readQueueSize = md.GetInt(readQueueSize)
if l.md.readQueueSize <= 0 {
l.md.readQueueSize = defaultReadQueueSize
}
l.md.connQueueSize = md.GetInt(connQueueSize)
if l.md.connQueueSize <= 0 {
l.md.connQueueSize = defaultConnQueueSize
}
return
}