v1.0.0

testing/servers/http/http.go

@@ -0,0 +1,40 @@
+package tcp
+
+import (
+	"net/http"
+
+	"github.com/xtls/xray-core/v1/common/net"
+)
+
+type Server struct {
+	Port        net.Port
+	PathHandler map[string]http.HandlerFunc
+	server      *http.Server
+}
+
+func (s *Server) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
+	if req.URL.Path == "/" {
+		resp.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		resp.WriteHeader(http.StatusOK)
+		resp.Write([]byte("Home"))
+		return
+	}
+
+	handler, found := s.PathHandler[req.URL.Path]
+	if found {
+		handler(resp, req)
+	}
+}
+
+func (s *Server) Start() (net.Destination, error) {
+	s.server = &http.Server{
+		Addr:    "127.0.0.1:" + s.Port.String(),
+		Handler: s,
+	}
+	go s.server.ListenAndServe()
+	return net.TCPDestination(net.LocalHostIP, s.Port), nil
+}
+
+func (s *Server) Close() error {
+	return s.server.Close()
+}

testing/servers/tcp/port.go

@@ -0,0 +1,16 @@
+package tcp
+
+import (
+	"github.com/xtls/xray-core/v1/common"
+	"github.com/xtls/xray-core/v1/common/net"
+)
+
+// PickPort returns an unused TCP port in the system. The port returned is highly likely to be unused, but not guaranteed.
+func PickPort() net.Port {
+	listener, err := net.Listen("tcp4", "127.0.0.1:0")
+	common.Must(err)
+	defer listener.Close()
+
+	addr := listener.Addr().(*net.TCPAddr)
+	return net.Port(addr.Port)
+}

testing/servers/tcp/tcp.go

@@ -0,0 +1,110 @@
+package tcp
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/xtls/xray-core/v1/common/buf"
+	"github.com/xtls/xray-core/v1/common/net"
+	"github.com/xtls/xray-core/v1/common/task"
+	"github.com/xtls/xray-core/v1/transport/internet"
+	"github.com/xtls/xray-core/v1/transport/pipe"
+)
+
+type Server struct {
+	Port         net.Port
+	MsgProcessor func(msg []byte) []byte
+	ShouldClose  bool
+	SendFirst    []byte
+	Listen       net.Address
+	listener     net.Listener
+}
+
+func (server *Server) Start() (net.Destination, error) {
+	return server.StartContext(context.Background(), nil)
+}
+
+func (server *Server) StartContext(ctx context.Context, sockopt *internet.SocketConfig) (net.Destination, error) {
+	listenerAddr := server.Listen
+	if listenerAddr == nil {
+		listenerAddr = net.LocalHostIP
+	}
+	listener, err := internet.ListenSystem(ctx, &net.TCPAddr{
+		IP:   listenerAddr.IP(),
+		Port: int(server.Port),
+	}, sockopt)
+	if err != nil {
+		return net.Destination{}, err
+	}
+
+	localAddr := listener.Addr().(*net.TCPAddr)
+	server.Port = net.Port(localAddr.Port)
+	server.listener = listener
+	go server.acceptConnections(listener.(*net.TCPListener))
+
+	return net.TCPDestination(net.IPAddress(localAddr.IP), net.Port(localAddr.Port)), nil
+}
+
+func (server *Server) acceptConnections(listener *net.TCPListener) {
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			fmt.Printf("Failed accept TCP connection: %v\n", err)
+			return
+		}
+
+		go server.handleConnection(conn)
+	}
+}
+
+func (server *Server) handleConnection(conn net.Conn) {
+	if len(server.SendFirst) > 0 {
+		conn.Write(server.SendFirst)
+	}
+
+	pReader, pWriter := pipe.New(pipe.WithoutSizeLimit())
+	err := task.Run(context.Background(), func() error {
+		defer pWriter.Close()
+
+		for {
+			b := buf.New()
+			if _, err := b.ReadFrom(conn); err != nil {
+				if err == io.EOF {
+					return nil
+				}
+				return err
+			}
+			copy(b.Bytes(), server.MsgProcessor(b.Bytes()))
+			if err := pWriter.WriteMultiBuffer(buf.MultiBuffer{b}); err != nil {
+				return err
+			}
+		}
+	}, func() error {
+		defer pReader.Interrupt()
+
+		w := buf.NewWriter(conn)
+		for {
+			mb, err := pReader.ReadMultiBuffer()
+			if err != nil {
+				if err == io.EOF {
+					return nil
+				}
+				return err
+			}
+			if err := w.WriteMultiBuffer(mb); err != nil {
+				return err
+			}
+		}
+	})
+
+	if err != nil {
+		fmt.Println("failed to transfer data: ", err.Error())
+	}
+
+	conn.Close()
+}
+
+func (server *Server) Close() error {
+	return server.listener.Close()
+}

testing/servers/udp/port.go

@@ -0,0 +1,19 @@
+package udp
+
+import (
+	"github.com/xtls/xray-core/v1/common"
+	"github.com/xtls/xray-core/v1/common/net"
+)
+
+// PickPort returns an unused UDP port in the system. The port returned is highly likely to be unused, but not guaranteed.
+func PickPort() net.Port {
+	conn, err := net.ListenUDP("udp4", &net.UDPAddr{
+		IP:   net.LocalHostIP.IP(),
+		Port: 0,
+	})
+	common.Must(err)
+	defer conn.Close()
+
+	addr := conn.LocalAddr().(*net.UDPAddr)
+	return net.Port(addr.Port)
+}

testing/servers/udp/udp.go

@@ -0,0 +1,54 @@
+package udp
+
+import (
+	"fmt"
+
+	"github.com/xtls/xray-core/v1/common/net"
+)
+
+type Server struct {
+	Port         net.Port
+	MsgProcessor func(msg []byte) []byte
+	accepting    bool
+	conn         *net.UDPConn
+}
+
+func (server *Server) Start() (net.Destination, error) {
+	conn, err := net.ListenUDP("udp", &net.UDPAddr{
+		IP:   []byte{127, 0, 0, 1},
+		Port: int(server.Port),
+		Zone: "",
+	})
+	if err != nil {
+		return net.Destination{}, err
+	}
+	server.Port = net.Port(conn.LocalAddr().(*net.UDPAddr).Port)
+	fmt.Println("UDP server started on port ", server.Port)
+
+	server.conn = conn
+	go server.handleConnection(conn)
+	localAddr := conn.LocalAddr().(*net.UDPAddr)
+	return net.UDPDestination(net.IPAddress(localAddr.IP), net.Port(localAddr.Port)), nil
+}
+
+func (server *Server) handleConnection(conn *net.UDPConn) {
+	server.accepting = true
+	for server.accepting {
+		buffer := make([]byte, 2*1024)
+		nBytes, addr, err := conn.ReadFromUDP(buffer)
+		if err != nil {
+			fmt.Printf("Failed to read from UDP: %v\n", err)
+			continue
+		}
+
+		response := server.MsgProcessor(buffer[:nBytes])
+		if _, err := conn.WriteToUDP(response, addr); err != nil {
+			fmt.Println("Failed to write to UDP: ", err.Error())
+		}
+	}
+}
+
+func (server *Server) Close() error {
+	server.accepting = false
+	return server.conn.Close()
+}