Stun Nat Type Testing

app/log/command/config_grpc.pb.go

@@ -81,10 +81,10 @@ type LoggerServiceServer interface {
 type UnimplementedLoggerServiceServer struct{}
 
 func (UnimplementedLoggerServiceServer) RestartLogger(context.Context, *RestartLoggerRequest) (*RestartLoggerResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RestartLogger not implemented")
+	return nil, status.Error(codes.Unimplemented, "method RestartLogger not implemented")
 }
 func (UnimplementedLoggerServiceServer) FollowLog(*FollowLogRequest, grpc.ServerStreamingServer[FollowLogResponse]) error {
-	return status.Errorf(codes.Unimplemented, "method FollowLog not implemented")
+	return status.Error(codes.Unimplemented, "method FollowLog not implemented")
 }
 func (UnimplementedLoggerServiceServer) mustEmbedUnimplementedLoggerServiceServer() {}
 func (UnimplementedLoggerServiceServer) testEmbeddedByValue()                       {}
@@ -97,7 +97,7 @@ type UnsafeLoggerServiceServer interface {
 }
 
 func RegisterLoggerServiceServer(s grpc.ServiceRegistrar, srv LoggerServiceServer) {
-	// If the following call pancis, it indicates UnimplementedLoggerServiceServer was
+	// If the following call panics, it indicates UnimplementedLoggerServiceServer was
 	// embedded by pointer and is nil.  This will cause panics if an
 	// unimplemented method is ever invoked, so we test this at initialization
 	// time to prevent it from happening at runtime later due to I/O.

common/dualStack/fusedPacketConn/fusedPacketSocket.go

@@ -0,0 +1,130 @@
+package fusedPacketConn
+
+import (
+	"errors"
+	"time"
+
+	"github.com/v2fly/v2ray-core/v5/common/net"
+)
+
+var errClosed = errors.New("fused packet conn is closed")
+
+// FusedPacketConn combines two PacketConn socket to create a dual stack PacketConn
+// When sending packet, the correct PacketConn for that destination address will be chosen
+// When receiving packet, will receive packet from either socket
+// Other operations will be done on both conn
+type FusedPacketConn struct {
+	ipv6 net.PacketConn
+	ipv4 net.PacketConn
+
+	readCh chan readResult
+	done   chan struct{}
+
+	localAddrPreferIPv6 bool
+}
+
+type readResult struct {
+	data []byte
+	addr net.Addr
+	err  error
+}
+
+func NewFusedPacketConn(ipv4, ipv6 net.PacketConn, readBufSize int, localAddrPreferIPv6 bool) *FusedPacketConn {
+	f := &FusedPacketConn{
+		ipv4:                ipv4,
+		ipv6:                ipv6,
+		readCh:              make(chan readResult, 2),
+		done:                make(chan struct{}),
+		localAddrPreferIPv6: localAddrPreferIPv6,
+	}
+	go f.readLoop(ipv4, readBufSize)
+	go f.readLoop(ipv6, readBufSize)
+	return f
+}
+
+func (f *FusedPacketConn) readLoop(conn net.PacketConn, bufSize int) {
+	for {
+		buf := make([]byte, bufSize)
+		n, addr, err := conn.ReadFrom(buf)
+		select {
+		case <-f.done:
+			return
+		case f.readCh <- readResult{data: buf[:n], addr: addr, err: err}:
+		}
+		if err != nil {
+			return
+		}
+	}
+}
+
+func (f *FusedPacketConn) ReadFrom(p []byte) (int, net.Addr, error) {
+	select {
+	case <-f.done:
+		return 0, nil, errClosed
+	case r := <-f.readCh:
+		if r.err != nil {
+			return 0, r.addr, r.err
+		}
+		n := copy(p, r.data)
+		return n, r.addr, nil
+	}
+}
+
+func isIPv4Addr(addr net.Addr) bool {
+	udpAddr, ok := addr.(*net.UDPAddr)
+	if !ok {
+		return false
+	}
+	return udpAddr.IP.To4() != nil
+}
+
+func (f *FusedPacketConn) WriteTo(p []byte, addr net.Addr) (int, error) {
+	if isIPv4Addr(addr) {
+		return f.ipv4.WriteTo(p, addr)
+	}
+	return f.ipv6.WriteTo(p, addr)
+}
+
+func (f *FusedPacketConn) Close() error {
+	close(f.done)
+	err4 := f.ipv4.Close()
+	err6 := f.ipv6.Close()
+	if err4 != nil {
+		return err4
+	}
+	return err6
+}
+
+func (f *FusedPacketConn) LocalAddr() net.Addr {
+	if f.localAddrPreferIPv6 {
+		return f.ipv6.LocalAddr()
+	}
+	return f.ipv4.LocalAddr()
+}
+
+func (f *FusedPacketConn) SetDeadline(t time.Time) error {
+	err4 := f.ipv4.SetDeadline(t)
+	err6 := f.ipv6.SetDeadline(t)
+	if err4 != nil {
+		return err4
+	}
+	return err6
+}
+
+func (f *FusedPacketConn) SetReadDeadline(t time.Time) error {
+	err4 := f.ipv4.SetReadDeadline(t)
+	err6 := f.ipv6.SetReadDeadline(t)
+	if err4 != nil {
+		return err4
+	}
+	return err6
+}
+
+func (f *FusedPacketConn) SetWriteDeadline(t time.Time) error {
+	err4 := f.ipv4.SetWriteDeadline(t)
+	err6 := f.ipv6.SetWriteDeadline(t)
+	if err4 != nil {
+		return err4
+	}
+	return err6
+}

common/natTraversal/stun/filteredStunConnection.go

@@ -0,0 +1,29 @@
+package stun
+
+import (
+	"github.com/pion/stun/v3"
+
+	"github.com/v2fly/v2ray-core/v5/common/net"
+)
+
+type STUNMessageCallback func(b []byte, addr net.Addr)
+
+func NewFilteredConnection(inner net.PacketConn, callback STUNMessageCallback) (*FilteredConnection, error) {
+	return &FilteredConnection{
+		PacketConn:      inner,
+		stunMsgCallback: callback,
+	}, nil
+}
+
+type FilteredConnection struct {
+	net.PacketConn
+	stunMsgCallback STUNMessageCallback
+}
+
+func (f *FilteredConnection) ReadFrom(b []byte) (int, net.Addr, error) {
+	n, addr, err := f.PacketConn.ReadFrom(b)
+	if stun.IsMessage(b[:n]) {
+		f.stunMsgCallback(b[:n], addr)
+	}
+	return n, addr, err
+}