Combine VMess response with first packet for performance

net/address.go

@@ -18,10 +18,12 @@ type Address struct {
 }
 
 func IPAddress(ip []byte, port uint16) Address {
+	ipCopy := make([]byte, len(ip))
+	copy(ipCopy, ip)
 	// TODO: check IP length
 	return Address{
 		Type:   AddrTypeIP,
-		IP:     net.IP(ip),
+		IP:     net.IP(ipCopy),
 		Domain: "",
 		Port:   port,
 	}

net/freedom/freedom.go

@@ -23,6 +23,7 @@ func (vconn *FreedomConnection) Start(ray core.OutboundRay) error {
 	output := ray.OutboundOutput()
 	conn, err := net.Dial("tcp", vconn.dest.String())
 	if err != nil {
+		close(output)
 		return log.Error("Failed to open tcp: %s : %v", vconn.dest.String(), err)
 	}
 	log.Debug("Sending outbound tcp: %s", vconn.dest.String())

net/vmess/vmessin.go

@@ -60,36 +60,34 @@ func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error
 	}
 	log.Debug("Received request for %s", request.Address.String())
 
-	response := vmessio.NewVMessResponse(request)
+	ray := handler.vPoint.NewInboundConnectionAccepted(request.Address)
-	nBytes, err := connection.Write(response[:])
+	input := ray.InboundInput()
-	if err != nil {
+	output := ray.InboundOutput()
-		return log.Error("Failed to write VMess response (%d bytes): %v", nBytes, err)
-	}
 
-	requestKey := request.RequestKey[:]
+	readFinish := make(chan bool)
-	requestIV := request.RequestIV[:]
+	writeFinish := make(chan bool)
-	responseKey := md5.Sum(requestKey)
-	responseIV := md5.Sum(requestIV)
 
-	requestReader, err := v2io.NewAesDecryptReader(requestKey, requestIV, connection)
+	go handleInput(request, connection, input, readFinish)
-	if err != nil {
+
-		return log.Error("Failed to create decrypt reader: %v", err)
+	responseKey := md5.Sum(request.RequestKey[:])
-	}
+	responseIV := md5.Sum(request.RequestIV[:])
 
+	response := vmessio.NewVMessResponse(request)
 	responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
 	if err != nil {
 		return log.Error("Failed to create encrypt writer: %v", err)
 	}
 
-	ray := handler.vPoint.NewInboundConnectionAccepted(request.Address)
+	// Optimize for small response packet
-	input := ray.InboundInput()
+	buffer := make([]byte, 0, 1024)
-	output := ray.InboundOutput()
+	buffer = append(buffer, response[:]...)
-
+	data, open := <-output
-	readFinish := make(chan bool)
+	if open {
-	writeFinish := make(chan bool)
+		buffer = append(buffer, data...)
+	}
+	responseWriter.Write(buffer)
 
-	go handler.dumpInput(requestReader, input, readFinish)
+	go handleOutput(request, responseWriter, output, writeFinish)
-	go handler.dumpOutput(responseWriter, output, writeFinish)
 
 	<-writeFinish
 	if tcpConn, ok := connection.(*net.TCPConn); ok {
@@ -101,17 +99,22 @@ func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error
 	return nil
 }
 
-func (handler *VMessInboundHandler) dumpInput(reader io.Reader, input chan<- []byte, finish chan<- bool) {
+func handleInput(request *vmessio.VMessRequest, reader io.Reader, input chan<- []byte, finish chan<- bool) {
-	v2net.ReaderToChan(input, reader)
+	defer close(input)
-	close(input)
+	defer close(finish)
-	log.Debug("VMessIn closing input")
+
-	finish <- true
+	requestReader, err := v2io.NewAesDecryptReader(request.RequestKey[:], request.RequestIV[:], reader)
+	if err != nil {
+		log.Error("Failed to create decrypt reader: %v", err)
+		return
+	}
+
+	v2net.ReaderToChan(input, requestReader)
 }
 
-func (handler *VMessInboundHandler) dumpOutput(writer io.Writer, output <-chan []byte, finish chan<- bool) {
+func handleOutput(request *vmessio.VMessRequest, writer io.Writer, output <-chan []byte, finish chan<- bool) {
 	v2net.ChanToWriter(writer, output)
-	log.Debug("VMessOut closing output")
+	close(finish)
-	finish <- true
 }
 
 type VMessInboundHandlerFactory struct {

net/vmess/vmessout.go

@@ -79,8 +79,10 @@ func startCommunicate(request *vmessio.VMessRequest, dest v2net.Address, ray cor
 		close(output)
 		return err
 	}
+
+	log.Debug("VMessOut: Tunneling request for %s", request.Address.String())
+
 	defer conn.Close()
-	defer close(output)
 
 	requestFinish := make(chan bool)
 	responseFinish := make(chan bool)
@@ -115,23 +117,24 @@ func handleRequest(conn *net.TCPConn, request *vmessio.VMessRequest, input <-cha
 
 func handleResponse(conn *net.TCPConn, request *vmessio.VMessRequest, output chan<- []byte, finish chan<- bool) error {
 	defer close(finish)
+	defer close(output)
 	responseKey := md5.Sum(request.RequestKey[:])
 	responseIV := md5.Sum(request.RequestIV[:])
 
-	response := vmessio.VMessResponse{}
+	decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
-	nBytes, err := conn.Read(response[:])
 	if err != nil {
-		log.Error("Failed to read VMess response (%d bytes): %v", nBytes, err)
+		log.Error("Failed to create decrypt reader: %v", err)
 		return err
 	}
-	log.Debug("Got response %v", response)
-	// TODO: check response
 
-	decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
+	response := vmessio.VMessResponse{}
+	nBytes, err := decryptResponseReader.Read(response[:])
 	if err != nil {
-		log.Error("Failed to create decrypt reader: %v", err)
+		log.Error("Failed to read VMess response (%d bytes): %v", nBytes, err)
 		return err
 	}
+	log.Debug("Got response %v", response)
+	// TODO: check response
 
 	v2net.ReaderToChan(output, decryptResponseReader)
 	return nil