go - 端口转发在我为练习而编写的代理服务器中不起作用

Question

我正在使用 golang 开发端口转发代理以进行学习。
以下是端口转发代理的代码，尽管该代理显示输入到标准输出，但它没有将输入重定向到目标端口。

我尝试使用以下代码进行端口转发，它只能读取，写入不起作用。

func (self *RWInspector) RW() {
    for {
        b, err := self.r.ReadByte()
        if err != nil {
            fmt.Println("ReadByte", err)
        }
        fmt.Println("Single Byte output:", b)
        err = self.w.WriteByte(b)
        if err != nil {
            fmt.Println(err)
        }
    }
}
 

我一直在尝试读取一个字节，然后将其写入 Writer。但是当我检查了简单 netcat 应用程序的输出行为时，它没有从客户端获取输出。

完整代码：

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "log"
    "net"
    /*"os"
    "os/signal"*/)

type ProtocolParser struct {
    client     *net.Conn
    server     *net.Conn
    Negotiated bool
    CS         RWInspector
    SC         RWInspector
}

func (self *ProtocolParser) Run() {
    //self.CS.ReadUint32()
    go func() { self.CS.RW() }()
    self.SC.RW()

}

type RWInspector struct {
    r *bufio.Reader
    w *bufio.Writer
}

func (self *RWInspector) ReadUint32() { // this function does not use!
    b := make([]byte, 4)
    _, err := io.ReadAtLeast(self.r, b, 4)
    if err != nil {
        fmt.Println("ReadUint32", err)
    }
    var res uint32 = (uint32(b[3]) << 24) | (uint32(b[2]) << 16) | uint32(b[1])<<8 | uint32(b[0])
    fmt.Println("ReadUint32:", res)
    self.w.Write(b)
}

func (self *RWInspector) RW() {
    for {
        b, err := self.r.ReadByte()
        if err != nil {
            fmt.Println("ReadByte", err)
        }
        fmt.Println("Single Byte output:", b)
        err = self.w.WriteByte(b)
        if err != nil {
            fmt.Println(err)
        }
    }
}

func NewProtocolParser(client, server *net.Conn) ProtocolParser {
    np := ProtocolParser{client: client, server: server}
    np.client = client
    np.server = server
    cr := bufio.NewReader(*np.client)
    sr := bufio.NewReader(*np.server)
    sw := bufio.NewWriter(*np.server)
    cw := bufio.NewWriter(*np.client)
    np.CS = RWInspector{r: cr, w: sw}
    np.SC = RWInspector{r: sr, w: cw}
    np.Negotiated = false
    return np
}

var (
    target string
    port   int
)

func init() {
    flag.StringVar(&target, "target", "", "the target (<host>:<port>)")
    flag.IntVar(&port, "port", 7757, "the tunnelthing port")
}

func main() {
    flag.Parse()

    //signals := make(chan os.Signal, 1)
    stop := make(chan bool)
    incoming, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
    if err != nil {
        log.Fatalf("could not start server on %d: %v", port, err)
    }
    fmt.Printf("server running on %d\n", port)
    for {
        select {
        case <-stop:
            return
        default:
            client, err := incoming.Accept()
            if err != nil {
                log.Println("could not accept client connection", err)
                return
            }
            go func(client net.Conn) {
                defer client.Close()
                fmt.Printf("client '%v' connected!\n", client.RemoteAddr())
                target, err := net.Dial("tcp", target)
                if err != nil {
                    log.Println("could not connect to target", err)
                    return
                }
                defer target.Close()
                fmt.Printf("connection to server %v established!\n", target.RemoteAddr())

                //go func() { io.Copy(target, client) }()
                //go func() { io.Copy(client, target) }()
                /*target func*/
                pp := NewProtocolParser(&client, &target)
                pp.Run()

            }(client)
        }
    }
}

标签： goproxy