求助： tcp 连接转发

目前我做测试想做一个特殊的转发，A 代码运行在公网监听两个端口，一个是用户请求；另一个是 B 代码的请求连接。A 接受到请求后将用户的请求转发到 B ，目前表象一直卡在了 B 回传回去的问题上(没有对 B 请求成功是否验证)，请问各位大佬，这个如何操作

A 代码如下

package main

import (
	"fmt"
	"io"
	"net"
	"sync"
)

var (
	bConnMu sync.Mutex
	bConn   net.Conn
)

func handleUserRequest(userConn net.Conn) {
	defer func() {
		userConn.Close()
		fmt.Println("User connection closed")
	}()
	fmt.Println("Received user request")

	bConnMu.Lock()
	if bConn == nil {
		bConnMu.Unlock()
		fmt.Println("No connection to B machine")
		fmt.Fprintln(userConn, "No connection to B machine")
		return
	}
	bConnMu.Unlock()

	fmt.Println("Forwarding request to B machine")

	// 将用户请求转发给 B 机器
	err := forwardRequest(userConn, bConn)
	if err != nil {
		fmt.Println("Error forwarding request to B machine:", err)
		return
	}

	fmt.Println("User request completed")
}

func forwardRequest(userConn, bConn net.Conn) error {
	done := make(chan error, 1)

	// 将用户请求转发给 B 机器
	go func() {
		_, err := io.Copy(bConn, userConn)
		if err != nil {
			fmt.Println("Error forwarding request to B machine:", err)
		} else {
			fmt.Println("Finished forwarding request to B machine")
		}
		done <- err
	}()

	// 将 B 机器的响应转发给用户
	go func() {
		_, err := io.Copy(userConn, bConn)
		if err != nil {
			fmt.Println("Error forwarding response to user:", err)
		} else {
			fmt.Println("Finished forwarding response to user")
		}
		done <- err
	}()

	err := <-done
	if err != nil {
		return err
	}

	err = <-done
	return err
}

func handleBConnection(conn net.Conn) {
	fmt.Println("B machine connected")

	bConnMu.Lock()
	if bConn != nil {
		bConn.Close()
		fmt.Println("Closed previous connection to B machine")
	}
	bConn = conn
	bConnMu.Unlock()

	// 监听 B 机器的断开连接
	_, err := io.Copy(io.Discard, conn)
	if err != nil {
		fmt.Println("B machine disconnected with error:", err)
	} else {
		fmt.Println("B machine disconnected")
	}

	bConnMu.Lock()
	if bConn == conn {
		bConn = nil
		fmt.Println("Removed connection to B machine")
	}
	bConnMu.Unlock()
	conn.Close()
}

func main11() {
	// 启动监听用户代理请求的 goroutine
	fmt.Println("A machine listening for user requests on :12345")
	go func() {
		listener, err := net.Listen("tcp", ":12345")
		if err != nil {
			fmt.Println("Failed to listen for user requests:", err)
			return
		}
		defer listener.Close()

		for {
			conn, err := listener.Accept()
			if err != nil {
				fmt.Println("Failed to accept user request:", err)
				continue
			}

			go handleUserRequest(conn)
		}
	}()

	// 启动监听 B 机器连接的 goroutine
	fmt.Println("A machine listening for B machine connection on :12346")
	listener, err := net.Listen("tcp", ":12346")
	if err != nil {
		fmt.Println("Failed to listen for B machine connection:", err)
		return
	}
	defer listener.Close()

	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Failed to accept B machine connection:", err)
			continue
		}

		go handleBConnection(conn)
	}
}

B 代码如下

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"time"
)

func handleTunnel(conn net.Conn) {
	defer func() {
		conn.Close()
		fmt.Println("Tunnel connection closed")
	}()

	fmt.Println("Handling new tunnel connection")

	reader := bufio.NewReader(conn)
	for {
		conn.SetReadDeadline(time.Now().Add(30 * time.Second))

		request, err := http.ReadRequest(reader)
		if err != nil {
			if err == io.EOF {
				fmt.Println("A machine closed the connection")
				return
			}
			fmt.Println("Error reading request:", err)
			return
		}

		fmt.Printf("Received request from A machine: %s %s\n", request.Method, request.URL)

		if request.Method == http.MethodConnect {
			fmt.Printf("Processing CONNECT request: %s\n", request.URL.Host)

			targetConn, err := net.DialTimeout("tcp", request.URL.Host, 10*time.Second)
			if err != nil {
				log.Printf("Error connecting to target: %v\n", err)
				// 修改这里来手动发送 HTTP 响应
				conn.Write([]byte("HTTP/1.1 503 Service Unavailable\r\n\r\n"))
				return
			}

			conn.Write([]byte("HTTP/1.1 200 Connection Established\r\n\r\n"))

			// 设置通道同步 goroutines
			done := make(chan struct{})

			// 开启 goroutine 处理从 client 到目标主机的流量
			go func() {
				io.Copy(targetConn, conn) // 假设 conn 是从 net.Listen 获取的连接
				close(done)
			}()

			// 开启 goroutine 处理从目标主机到 client 的流量
			go func() {
				io.Copy(conn, targetConn)
				close(done)
			}()

			// 等待至少一个方向的流完成
			<-done

			targetConn.Close()
			conn.Close()
		} else {
			fmt.Printf("Processing normal request: %s\n", request.URL)

			// 处理普通请求
			targetConn, err := net.DialTimeout("tcp", request.Host, 10*time.Second)
			if err != nil {
				fmt.Println("Error connecting to target host:", err)
				conn.Write([]byte("HTTP/1.1 503 Service Unavailable\r\n\r\n"))
				continue
			}
			defer func() {
				targetConn.Close()
				fmt.Printf("Target connection to %s closed\n", request.Host)
			}()

			fmt.Println("Connected to target host:", request.Host)

			// 将请求转发给目标主机
			err = request.Write(targetConn)
			if err != nil {
				fmt.Println("Error forwarding request to target host:", err)
				conn.Write([]byte("HTTP/1.1 503 Service Unavailable\r\n\r\n"))
				continue
			}
			fmt.Println("Forwarded request to target host")

			// 将目标主机的响应转发给 A 机器
			response, err := http.ReadResponse(bufio.NewReader(targetConn), request)
			if err != nil {
				fmt.Println("Error reading response from target host:", err)
				conn.Write([]byte("HTTP/1.1 503 Service Unavailable\r\n\r\n"))
				continue
			}
			fmt.Println("Read response from target host")

			err = response.Write(conn)
			if err != nil {
				fmt.Println("Error forwarding response to A machine:", err)
				continue
			}
			fmt.Println("Forwarded response to A machine")
		}
	}
}

func connectToA() {
	for {
		fmt.Println("Attempting to connect to A machine")
		conn, err := net.Dial("tcp", "A 机器地址:12346")
		if err != nil {
			fmt.Println("Failed to connect to A machine:", err)
			time.Sleep(5 * time.Second)
			continue
		}
		fmt.Println("Connected to A machine")

		// 发送心跳包
		go func() {
			for {
				_, err := conn.Write([]byte("ping"))
				if err != nil {
					fmt.Println("Failed to send heartbeat:", err)
					conn.Close()
					return
				}
				time.Sleep(5 * time.Second)
			}
		}()

		handleTunnel(conn)
	}
}

func main() {
	go connectToA()

	select {} // 阻塞主线程
}