Go语言Unix域Socket Echo服务器实现与常见问题解析

package main

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

// echo_srv 处理单个客户端连接，实现数据回显
func echo_srv(c net.Conn, wg *sync.WaitGroup) {
    defer c.Close() // 确保连接关闭
    defer wg.Done() // 确保WaitGroup计数减一

    // 循环读取客户端发送的数据并回显
    for {
        // 1. 正确分配缓冲区：创建一个1000字节的切片作为接收缓冲区
        msg := make([]byte, 1000)

        // 从连接中读取数据
        n, err := c.Read(msg)
        if err == io.EOF {
            // 2. 正确处理io.EOF：客户端关闭连接，优雅退出
            fmt.Printf("SERVER: 客户端已断开连接 (忽略 %d 字节)\n", n)
            return
        } else if err != nil {
            // 处理其他读取错误
            fmt.Printf("ERROR: 读取数据失败: %v\n", err)
            return
        }
        fmt.Printf("SERVER: 接收到 %v 字节数据\n", n)

        // 将接收到的数据回写给客户端
        // 3. 只写入实际读取到的字节：使用切片表达式 msg[:n]
        _, err = c.Write(msg[:n])
        if err != nil {
            fmt.Printf("ERROR: 写入数据失败: %v\n", err)
            return
        }
        fmt.Printf("SERVER: 发送了 %v 字节数据\n", n)
    }
}

// main 函数负责服务器的初始化和监听
func main() {
    var wg sync.WaitGroup // 声明 WaitGroup

    // 监听Unix域套接字
    ln, err := net.Listen("unix", "./sock_srv")
    if err != nil {
        fmt.Printf("ERROR: 监听失败: %v\n", err)
        return
    }
    defer ln.Close() // 确保监听器关闭

    fmt.Println("SERVER: 正在监听 Unix 域套接字 ./sock_srv")

    // 接受一个客户端连接
    conn, err := ln.Accept()
    if err != nil {
        fmt.Printf("ERROR: 接受连接失败: %v\n", err)
        return
    }
    fmt.Println("SERVER: 接受到客户端连接")

    wg.Add(1)            // 增加 WaitGroup 计数
    go echo_srv(conn, &wg) // 启动goroutine处理连接，并传入WaitGroup的指针

    wg.Wait() // 等待所有goroutine完成
    fmt.Println("SERVER: 所有客户端连接已处理完毕，服务器退出。")
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

func main() {
    stdin := bufio.NewReader(os.Stdin)

    // 连接到Unix域套接字
    conn, err := net.Dial("unix", "./sock_srv")
    if err != nil {
        fmt.Printf("ERROR: 连接服务器失败: %v\n", err)
        return
    }
    defer conn.Close() // 确保连接关闭

    fmt.Println("CLIENT: 已连接到服务器")

    for {
        fmt.Print("输入要发送的消息 (输入 'quit' 或 'exit' 退出): ")
        msg, err := stdin.ReadString('\n')
        if err != nil {
            fmt.Printf("ERROR: 读取标准输入失败: %v\n", err)
            return
        }

        msg = strings.TrimSpace(msg) // 移除换行符和空格

        if strings.ToLower(msg) == "quit" || strings.ToLower(msg) == "exit" {
            fmt.Println("CLIENT: 退出")
            return
        }

        // 发送消息给服务器
        n, err := conn.Write([]byte(msg))
        if err != nil {
            fmt.Printf("ERROR: 发送数据失败: %v\n", err)
            return
        }
        fmt.Printf("CLIENT: 发送了 %v 字节数据\n", n)

        // 创建一个缓冲区来接收回显数据
        // 注意：这里为了简化，直接使用原始消息字符串长度的缓冲区。
        // 生产环境中应使用固定大小或动态调整的缓冲区。
        recvBuf := make([]byte, len(msg))
        n, err = conn.Read(recvBuf)
        if err != nil {
            fmt.Printf("ERROR: 接收数据失败: %v\n", err)
            return
        }
        fmt.Printf("CLIENT: 接收到 %v 字节数据\n", n)

        fmt.Println("接收到的回显消息:", string(recvBuf[:n]))
    }
}