Add MTProxy, MASQUE, VPN, Link parser. Update AmneziaWG. Remove Tunneling

protocol/bond/conn.go

@@ -1,6 +1,7 @@
 package bond
 
 import (
+	"bytes"
 	"encoding/binary"
 	"errors"
 	"io"
@@ -13,9 +14,7 @@ type bondedConn struct {
 	downloadRatios []uint8
 	uploadRatios   []uint8
 
-	readBuffer []byte
-	readOffset int
-	readSize   int
+	readBuffer *bytes.Buffer
 }
 
 func NewBondedConn(conns []net.Conn, downloadRatios, uploadRatios []uint8) *bondedConn {
@@ -23,12 +22,13 @@ func NewBondedConn(conns []net.Conn, downloadRatios, uploadRatios []uint8) *bond
 		conns:          conns,
 		downloadRatios: downloadRatios,
 		uploadRatios:   uploadRatios,
-		readBuffer:     make([]byte, 65535),
+		readBuffer:     bytes.NewBuffer(make([]byte, 0, 65536)),
 	}
 }
 
 func (c *bondedConn) Read(b []byte) (n int, err error) {
-	if c.readOffset == c.readSize {
+	if c.readBuffer.Len() == 0 {
+		c.readBuffer.Reset()
 		var header [2]byte
 		_, err := io.ReadFull(c.conns[0], header[:])
 		if err != nil {
@@ -41,19 +41,14 @@ func (c *bondedConn) Read(b []byte) (n int, err error) {
 			if chunkLen == 0 {
 				continue
 			}
-			chunk := c.readBuffer[total : total+chunkLen]
-			n, err := io.ReadFull(c.conns[i], chunk)
-			total += n
+			n, err := io.CopyN(c.readBuffer, c.conns[i], int64(chunkLen))
+			total += int(n)
 			if err != nil {
 				return total, err
 			}
 		}
-		c.readOffset = 0
-		c.readSize = size
 	}
-	n = copy(b, c.readBuffer[c.readOffset:c.readSize])
-	c.readOffset += n
-	return n, nil
+	return c.readBuffer.Read(b)
 }
 
 func (c *bondedConn) Write(b []byte) (n int, err error) {

protocol/bond/inbound.go

@@ -6,7 +6,8 @@ import (
 	"net"
 	"time"
 
-	"github.com/patrickmn/go-cache"
+	"github.com/gofrs/uuid/v5"
+	"github.com/patrickmn/go-cache/v2"
 	"github.com/sagernet/sing-box/adapter"
 	"github.com/sagernet/sing-box/adapter/inbound"
 	"github.com/sagernet/sing-box/common/kmutex"
@@ -29,9 +30,9 @@ type Inbound struct {
 	logger   logger.ContextLogger
 	router   adapter.ConnectionRouterEx
 	inbounds []adapter.Inbound
-	conns    *cache.Cache
+	conns    *cache.Cache[uuid.UUID, map[uint8]*ratioConn]
 
-	mtx *kmutex.Kmutex[string]
+	mtx *kmutex.Kmutex[uuid.UUID]
 }
 
 func NewInbound(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.BondInboundOptions) (adapter.Inbound, error) {
@@ -42,23 +43,23 @@ func NewInbound(ctx context.Context, router adapter.Router, logger log.ContextLo
 		Adapter: inbound.NewAdapter(C.TypeBond, tag),
 		logger:  logger,
 		router:  uot.NewRouter(router, logger),
-		conns:   cache.New(C.TCPConnectTimeout, time.Second),
-		mtx:     kmutex.New[string](),
+		conns:   cache.New[uuid.UUID, map[uint8]*ratioConn](C.TCPConnectTimeout, time.Second),
+		mtx:     kmutex.New[uuid.UUID](),
 	}
+	router = NewRouter(router, logger, inbound.connHandler)
 	inboundRegistry := service.FromContext[adapter.InboundRegistry](ctx)
 	inbounds := make([]adapter.Inbound, len(options.Inbounds))
 	for i, inboundOptions := range options.Inbounds {
-		inbound, err := inboundRegistry.UnsafeCreate(ctx, NewRouter(router, logger, inbound.connHandler), logger, inboundOptions.Tag, inboundOptions.Type, inboundOptions.Options)
+		inbound, err := inboundRegistry.UnsafeCreate(ctx, router, logger, inboundOptions.Tag, inboundOptions.Type, inboundOptions.Options)
 		if err != nil {
 			return nil, err
 		}
 		inbounds[i] = inbound
 	}
 	inbound.inbounds = inbounds
-	inbound.conns.OnEvicted(func(s string, i interface{}) {
+	inbound.conns.OnEvicted(func(s uuid.UUID, ratioConns map[uint8]*ratioConn) {
 		inbound.mtx.Lock(s)
 		defer inbound.mtx.Unlock(s)
-		ratioConns := i.(map[uint8]*ratioConn)
 		for _, ratioConn := range ratioConns {
 			if ratioConn != nil {
 				ratioConn.conn.Close()
@@ -93,21 +94,15 @@ func (h *Inbound) Close() error {
 }
 
 func (h *Inbound) connHandler(ctx context.Context, conn net.Conn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) error {
-	if metadata.Destination != Destination {
-		h.router.RouteConnectionEx(ctx, conn, metadata, onClose)
-		return nil
-	}
 	request, err := ReadRequest(conn)
 	if err != nil {
 		return err
 	}
-	requestUUID := request.UUID.String()
+	requestUUID := request.UUID
 	h.mtx.Lock(requestUUID)
 	var ratioConns map[uint8]*ratioConn
-	rawRatioConns, ok := h.conns.Get(requestUUID)
-	if ok {
-		ratioConns = rawRatioConns.(map[uint8]*ratioConn)
-	} else {
+	ratioConns, ok := h.conns.Get(requestUUID)
+	if !ok {
 		ratioConns = make(map[uint8]*ratioConn, request.Count)
 		h.conns.SetDefault(requestUUID, ratioConns)
 	}

protocol/bond/router.go

@@ -21,14 +21,24 @@ func NewRouter(router adapter.Router, logger logger.ContextLogger, handler func(
 }
 
 func (r *Router) RouteConnection(ctx context.Context, conn net.Conn, metadata adapter.InboundContext) error {
+	if metadata.Destination != Destination {
+		return r.Router.RouteConnection(ctx, conn, metadata)
+	}
 	return r.handler(ctx, conn, metadata, func(error) {})
 }
 
 func (r *Router) RoutePacketConnection(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext) error {
+	if metadata.Destination != Destination {
+		return r.Router.RoutePacketConnection(ctx, conn, metadata)
+	}
 	return os.ErrInvalid
 }
 
 func (r *Router) RouteConnectionEx(ctx context.Context, conn net.Conn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) {
+	if metadata.Destination != Destination {
+		r.Router.RouteConnectionEx(ctx, conn, metadata, onClose)
+		return
+	}
 	if err := r.handler(ctx, conn, metadata, onClose); err != nil {
 		r.logger.ErrorContext(ctx, err)
 		N.CloseOnHandshakeFailure(conn, onClose, err)
@@ -36,6 +46,10 @@ func (r *Router) RouteConnectionEx(ctx context.Context, conn net.Conn, metadata
 }
 
 func (r *Router) RoutePacketConnectionEx(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) {
+	if metadata.Destination != Destination {
+		r.Router.RoutePacketConnectionEx(ctx, conn, metadata, onClose)
+		return
+	}
 	r.logger.ErrorContext(ctx, os.ErrInvalid)
 	N.CloseOnHandshakeFailure(conn, onClose, os.ErrInvalid)
 }