虎绿林ChatGPT应该添加一个重置会话功能，不然他会称呼你为蠢驴
@罐子，下面是一个用Go语言实现的TCP端口转发的简单代码示例：
package main
import (
"bufio"
"fmt"
"net"
"os"
)
func main() {
arguments := os.Args
if len(arguments) == 1 {
fmt.Println("Please provide a host:port string.")
return
}
target := arguments[1]
listener, err := net.Listen("tcp", "0.0.0.0:0")
if err != nil {
fmt.Println(err)
return
}
defer listener.Close()
fmt.Println("Listening on", listener.Addr().String())
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Accept error:", err)
continue
}
go forward(conn, target)
}
}
func forward(conn net.Conn, target string) {
targetConn, err := net.Dial("tcp", target)
if err != nil {
fmt.Println("Dial error:", err)
conn.Close()
return
}
defer targetConn.Close()
go func() {
buf := make([]byte, 65536)
for {
n, err := conn.Read(buf)
if n == 0 || err != nil {
break
}
targetConn.Write(buf[:n])
}
}()
buf := make([]byte, 65536)
for {
n, err := targetConn.Read(buf)
if n == 0 || err != nil {
break
}
conn.Write(buf[:n])
}
}
此代码将监听一个任意的本地端口，并将所有的连接请求转发到指定的目标地址。这是一个高性能的实现，因为它使用了Go语言的并发编程技术，在一个单独的Go协程中处理每个连接请求。
对于一加8Pro，这是一款高性能的智能手机，具有高速处理器、大容量内存和存储以及先进的图形
@罐子，以下是一个更加高性能的 TCP 端口转发程序，它使用了并发处理和多路复用，可以同时处理多个连接：
package main
import (
"io"
"log"
"net"
)
const (
LocalAddr = ":8000" // 本地监听地址
RemoteAddr = "example.com:80" // 远程服务器地址
)
func main() {
local, err := net.Listen("tcp", LocalAddr)
if err != nil {
log.Fatalf("Failed to listen on %s: %s", LocalAddr, err)
}
log.Printf("Listening on %s", LocalAddr)
for {
conn, err := local.Accept()
if err != nil {
log.Printf("Failed to accept connection: %s", err)
continue
}
go forward(conn)
}
}
func forward(local net.Conn) {
defer local.Close()
remote, err := net.Dial("tcp", RemoteAddr)
if err != nil {
log.Printf("Failed to connect to %s: %s", RemoteAddr, err)
return
}
defer remote.Close()
log.Printf("Forwarding from %s to %s", local.RemoteAddr(), remote.RemoteAddr())
// 同时进行读写
go io.Copy(local, remote)
io.Copy(remote, local)
}
这个程序使用了两个 io.Copy 函数，分别在不同的 goroutine 中进行。这样可以同时进行读写操作，从而最大化性能。在使用此程序时，请确保将 LocalAddr 和 RemoteAddr 设置为正确的地址和端口号。
@罐子，以下是一个使用 Golang 编写的高性能 TCP 端口转发程序，可以将本地某个端口的 TCP 流量转发到另一个远程 TCP 地址和端口：
package main
import (
"io"
"log"
"net"
)
func main() {
listenAddr := "127.0.0.1:8080" // 本地监听地址和端口
forwardAddr := "example.com:80" // 转发目标地址和端口
ln, err := net.Listen("tcp", listenAddr)
if err != nil {
log.Fatalf("Failed to listen on %s: %v", listenAddr, err)
}
log.Printf("Listening on %s, forwarding to %s", listenAddr, forwardAddr)
for {
conn, err := ln.Accept()
if err != nil {
log.Printf("Failed to accept connection: %v", err)
continue
}
go handleConnection(conn, forwardAddr)
}
}
func handleConnection(conn net.Conn, forwardAddr string) {
defer conn.Close()
fwdConn, err := net.Dial("tcp", forwardAddr)
if err != nil {
log.Printf("Failed to connect to %s: %v", forwardAddr, err)
return
}
defer fwdConn.Close()
// 使用 io.Copy 完成数据转发
_, err = io.Copy(conn, fwdConn)
if err != nil {
log.Printf("Connection closed: %v", err)
}
}
该程序使用 net.Listen 监听本地端口，并通过 Accept 方法接受客户端连接。每当有新连接到来时，程序启动一个新的 goroutine，通过 net.Dial 方法连接到转发目标地址和端口，并使用 io.Copy 完成数据的转发。
如果需要转发多个端口，可以在监听之前使用 goroutine 启动多个 Listen 任务。此外，为了提高性能，可以使用 goroutine 池等技术来限制每个 goroutine 的并发数量。
@罐子，读取回复出错