feat: support tuicV5

transport/tuic/common/congestion.go

@@ -0,0 +1,44 @@
+package common
+
+import (
+	"github.com/Dreamacro/clash/transport/tuic/congestion"
+
+	"github.com/metacubex/quic-go"
+)
+
+const (
+	DefaultStreamReceiveWindow     = 15728640 // 15 MB/s
+	DefaultConnectionReceiveWindow = 67108864 // 64 MB/s
+)
+
+func SetCongestionController(quicConn quic.Connection, cc string) {
+	switch cc {
+	case "cubic":
+		quicConn.SetCongestionControl(
+			congestion.NewCubicSender(
+				congestion.DefaultClock{},
+				congestion.GetInitialPacketSize(quicConn.RemoteAddr()),
+				false,
+				nil,
+			),
+		)
+	case "new_reno":
+		quicConn.SetCongestionControl(
+			congestion.NewCubicSender(
+				congestion.DefaultClock{},
+				congestion.GetInitialPacketSize(quicConn.RemoteAddr()),
+				true,
+				nil,
+			),
+		)
+	case "bbr":
+		quicConn.SetCongestionControl(
+			congestion.NewBBRSender(
+				congestion.DefaultClock{},
+				congestion.GetInitialPacketSize(quicConn.RemoteAddr()),
+				congestion.InitialCongestionWindow*congestion.InitialMaxDatagramSize,
+				congestion.DefaultBBRMaxCongestionWindow*congestion.InitialMaxDatagramSize,
+			),
+		)
+	}
+}

transport/tuic/common/stream.go

@@ -0,0 +1,67 @@
+package common
+
+import (
+	"net"
+	"sync"
+	"time"
+
+	"github.com/metacubex/quic-go"
+)
+
+type quicStreamConn struct {
+	quic.Stream
+	lock  sync.Mutex
+	lAddr net.Addr
+	rAddr net.Addr
+
+	closeDeferFn func()
+
+	closeOnce sync.Once
+	closeErr  error
+}
+
+func (q *quicStreamConn) Write(p []byte) (n int, err error) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+	return q.Stream.Write(p)
+}
+
+func (q *quicStreamConn) Close() error {
+	q.closeOnce.Do(func() {
+		q.closeErr = q.close()
+	})
+	return q.closeErr
+}
+
+func (q *quicStreamConn) close() error {
+	if q.closeDeferFn != nil {
+		defer q.closeDeferFn()
+	}
+
+	// https://github.com/cloudflare/cloudflared/commit/ed2bac026db46b239699ac5ce4fcf122d7cab2cd
+	// Make sure a possible writer does not block the lock forever. We need it, so we can close the writer
+	// side of the stream safely.
+	_ = q.Stream.SetWriteDeadline(time.Now())
+
+	// This lock is eventually acquired despite Write also acquiring it, because we set a deadline to writes.
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	// We have to clean up the receiving stream ourselves since the Close in the bottom does not handle that.
+	q.Stream.CancelRead(0)
+	return q.Stream.Close()
+}
+
+func (q *quicStreamConn) LocalAddr() net.Addr {
+	return q.lAddr
+}
+
+func (q *quicStreamConn) RemoteAddr() net.Addr {
+	return q.rAddr
+}
+
+var _ net.Conn = (*quicStreamConn)(nil)
+
+func NewQuicStreamConn(stream quic.Stream, lAddr, rAddr net.Addr, closeDeferFn func()) net.Conn {
+	return &quicStreamConn{Stream: stream, lAddr: lAddr, rAddr: rAddr, closeDeferFn: closeDeferFn}
+}

transport/tuic/common/type.go

@@ -0,0 +1,34 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"net"
+	"time"
+
+	C "github.com/Dreamacro/clash/constant"
+
+	"github.com/metacubex/quic-go"
+)
+
+var (
+	ClientClosed       = errors.New("tuic: client closed")
+	TooManyOpenStreams = errors.New("tuic: too many open streams")
+)
+
+type DialFunc func(ctx context.Context, dialer C.Dialer) (transport *quic.Transport, addr net.Addr, err error)
+
+type Client interface {
+	DialContextWithDialer(ctx context.Context, metadata *C.Metadata, dialer C.Dialer, dialFn DialFunc) (net.Conn, error)
+	ListenPacketWithDialer(ctx context.Context, metadata *C.Metadata, dialer C.Dialer, dialFn DialFunc) (net.PacketConn, error)
+	OpenStreams() int64
+	DialerRef() C.Dialer
+	LastVisited() time.Time
+	SetLastVisited(last time.Time)
+	Close()
+}
+
+type Server interface {
+	Serve() error
+	Close() error
+}