套接字-在数据传输后保持套接字打开

Question

我编写了简单的服务器/客户端程序，其中客户端将一些硬编码数据以小块形式发送给服务器程序，服务器程序正在等待数据，以便将其打印到终端。在客户端，我在循环中调用send（），同时有更多的数据要发送，而在服务器上，我使用read（）执行同样的操作，即返回的字节数为

如果我在完成发送后专门在客户端的套接字上调用close（），那么这个示例非常有效，但如果我不这样做，服务器将不会实际退出read（）循环，直到我关闭客户端并断开连接。在服务器端，我使用：

while((bytesRead = read(socket, buffer, BUFFER_SIZE)) > 0)

当所有的数据都被接收到时，字节读不应该是0吗？如果是这样，为什么它不会退出这个循环，直到我关闭套接字？在我的最终应用程序中，在请求之间保持套接字打开将是有益的，但是所有的示例代码和信息我可以在发送数据后立即找到调用关闭（），这不是我想要的。

我错过了什么？

Answer 1

您可以在recv调用上设置标志以防止阻塞。

一种轻松检测这种情况的方法是包装recv调用：

enum class read_result
{
    // note: numerically in increasing order of severity
    ok,
    would_block,
    end_of_file,
    error,
};

template<std::size_t BufferLength>
read_result read(int socket_fd, char (&buffer)[BufferLength], int& bytes_read)
{
    auto result = recv(socket_fd, buffer, BufferLength, MSG_DONTWAIT);
    if (result > 0)
    {
        return read_result::ok;
    }
    else if (result == 0)
    {
        return read_result::end_of_file;
    }
    else {

        auto err = errno;

        if (err == EAGAIN or err == EWOULDBLOCK) {
            return read_result::would_block;
        }
        else {
            return read_result ::error;
        }
    }
}

一个用例可能是：

#include <unistd.h>
#include <sys/socket.h>
#include <cstdlib>
#include <cerrno>
#include <iostream>

enum class read_result
{
    // note: numerically in increasing order of severity
    ok,
    would_block,
    end_of_file,
    error,
};

template<std::size_t BufferLength>
read_result read(int socket_fd, char (&buffer)[BufferLength], int& bytes_read)
{
    auto result = recv(socket_fd, buffer, BufferLength, MSG_DONTWAIT);
    if (result > 0)
    {
        return read_result::ok;
    }
    else if (result == 0)
    {
        return read_result::end_of_file;
    }
    else {

        auto err = errno;

        if (err == EAGAIN or err == EWOULDBLOCK) {
            return read_result::would_block;
        }
        else {
            return read_result ::error;
        }
    }
}

struct keep_reading
{
    keep_reading& operator=(read_result result)
    {
        result_ = result;
    }

    const operator bool() const {
        return result_ < read_result::end_of_file;
    }

    auto get_result() const -> read_result { return result_; }

private:
    read_result result_ = read_result::ok;
};

int main()
{
    int socket; // = open my socket and wait for it to be connected etc

    char buffer [1024];
    int bytes_read = 0;
    keep_reading should_keep_reading;
    while(keep_reading = read(socket, buffer, bytes_read))
    {
        if (should_keep_reading.get_result() != read_result::would_block) {
            // read things here
        }
        else {
            // idle processing here
        }
    }

    std::cout << "reason for stopping: " << should_keep_reading.get_result() << std::endl;
}

Answer 2

当套接字的另一端连接到地球另一端的其他网络系统时，接收套接字知道“何时接收到所有数据”的唯一方式正是套接字的另一边关闭的时候。这就是告诉套接字的另一边“所有数据都已收到”。

套接字所知道的只是它连接到其他某个套接字终结点。就是这样。故事结束。套接字对具有套接字连接另一端的程序的内部工作原理没有特殊知识。也不应该知道。这恰好是打开套接字的程序的责任，而不是套接字本身。

如果你的程序，在接收端，知道它应该接收什么数据，它现在已经收到了它需要接收的一切，那么它可以关闭它的套接字末端，然后继续手头的下一个任务。

您必须在程序的逻辑中加入一种方法，以某种形式或方式确定所有数据都已传输。它的确切性质将由你来定义。也许，在发送套接字上的所有数据之前，您的发送程序会在同一个套接字中预先发送后续数据中的字节数。然后，您的接收程序首先读取字节数，然后读取数据本身，然后知道它已经接收了所有内容，并且可以继续。

这是一种简单的方法。确切的细节取决于您。或者，您也可以实现超时：设置一个计时器，如果在规定的时间段内未收到任何数据，则假设没有更多数据。