c - O_NONBLOCK SOCK_STREAM 限制为 8192

Question

我正在从 C 程序写入 SOCK_STREAM正在从 go 程序监听的 Unix 域套接字，使用 net.Listen("unix", sockname) .当我将套接字设置为 O_NONBLOCK使用 fcntl() ，我看到C程序在第一次写入时只写入了8192字节。失败后，我监控并回写剩余数据，但我服务器上读取的数据在这种情况下是无效的。

当我不使用 O_NONBLOCK 时, 然后整个 8762 字节被写在一个单一的写入中，一切都按预期工作。

C 客户端套接字连接

    if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        return;
    }
   int flags = fcntl(fd, F_GETFL, 0);
   flags = flags|O_NONBLOCK;
   fcntl(fd, F_SETFL, flags);
   ...
    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        return;
    }

C 客户端编写

        while (written < to_write) {
            int result;
            if ((result = write(fd, &buffer[written], to_write - written)) < 0) {
                if (errno == EINTR) {
                    continue;
                }
                if (errno == EAGAIN) {
                    struct pollfd pfd = { .fd = fd, .events = POLLOUT };
                    poll_count++;
                    if (poll_count > 3) {
                        goto end;
                    }
                    if ((poll(&pfd, 1, -1) <= 0) && (errno != EAGAIN)) {
                        goto end;
                    }
                    continue;
                }
end:
                return written ? written : result;
            }
            written += result;
            buffer += result;
        }

Go服务器阅读

buf := make([]byte, 0, count)
var tmpsize int32
for {
    if count <= 0 {
        break
    }

    if count > 100 {
        tmpsize = 100
    } else {
        tmpsize = count
    }

    tmp := make([]byte, tmpsize)
    nr, err = conn.Read(tmp)
    if err != nil {
        return
    }

    buf = append(buf, tmp[:nr]...)
    count = count - int32(nr)
}

我在这里错过了什么。我在 OSX 上运行它。我还尝试设置 SO_SNDBUF在 Go Server 中设置为 10000，但这没有帮助

err = syscall.SetsockoptInt(int(fd.Fd()), syscall.SOL_SOCKET, syscall.SO_SNDBUF, 10000)
if err != nil {
    return
}

Answer 1

我要做的是将数据直接读入 bytes.Buffer，类似于此处列出的答案:

https://stackoverflow.com/a/24343240/8092543

https://golang.org/pkg/io/#Copy

io.Copy 的美妙之处在于它使用了一个 Writer + Reader 接口(interface)，这很好地满足了但是你的 bytes.Buffer (io.Writer) 和你的conn.Read (io.Reader)。将整个 block 替换为...

var buf bytes.Buffer
count, err := io.Copy(buf, conn)
if err != nil { 
    return nil, fmt.Errorf("error during conn read: %v", err)
}

return buf.Bytes(), nil