c++ - 我们如何从 boost::asio::tcp::ip::read_some 调用中顺序接收多个数据？

Question

让我们假设一个客户端持有两个不同的大对象(根据字节大小)并序列化它们，然后发送序列化的对象 使用 boost::asio 通过 TCP/IP 网络连接到服务器。

• 对于客户端实现，我使用 boost::asio::write 将二进制数据 (const char*) 发送到服务器。

• 对于服务器端实现，我使用 read_some 而不是 boost::asio::ip::tcp::iostream 来提高效率.我在服务器端构建了以下 recv 函数。第二个参数 std::stringstream &is 在函数末尾保存了一个大的接收数据(>65536 字节)。

当客户端顺序调用两个boost::asio::write以分别发送两个不同的二进制对象时，服务器端顺序调用两个相应的recv作为出色地。 但是，第一个 recv 函数吸收了所有两个传入的大数据，而第二个调用什么也没收到 ;-(。 我不确定为什么会发生这种情况以及如何解决。

由于两个不同的对象中的每一个都有自己的(反)序列化功能，我想分别发送每个数据。事实上，由于有超过 20 个对象(不仅仅是 2 个)必须通过网络发送。

void recv (
    boost::asio::ip::tcp::socket &socket,
    std::stringstream &is) {

    boost::array<char, 65536> buf;

    for (;;) {
        boost::system::error_code error;
        size_t len = socket.read_some(boost::asio::buffer(buf), error);
        std::cout << " read "<< len << " bytes" << std::endl;  // called multiple times for debugging!

        if (error == boost::asio::error::eof)
          break;
        else if (error)
          throw boost::system::system_error(error); // Some other error.

        std::stringstream buf_ss;
        buf_ss.write(buf.data(), len);
        is << buf_ss.str();
    }
}

客户端主文件:

int main () {
    ... // some 2 different big objects are constructed.
    std::stringstream ss1, ss2;
    ... // serializing bigObj1 -> ss1 and bigObj2-> ss2, where each object is serialized into a string. This is due to the dependency of our using some external library
    const char * big_obj_bin1 = reinterpret_cast<const char*>(ss1.str().c_str());
    const char * big_obj_bin2 = reinterpret_cast<const char*>(ss2.str().c_str());

    boost::system::error_code ignored_error;
    boost::asio::write(socket, boost::asio::buffer(big_obj_bin1, ss1.str().size()), ignored_error);
    boost::asio::write(socket, boost::asio::buffer(big_obj_bin2, ss2.str().size()), ignored_error);

    ... // do something
    return 0;
}

服务器主文件:

int main () {
    ... // socket is generated. (communication established)
    std::stringstream ss1, ss2;
    recv(socket,ss1); // this guy absorbs all of incoming data
    recv(socket,ss2); // this guy receives 0 bytes ;-(
    ... // deserialization to two bib objects
    return 0;
}

Answer 1

recv(socket,ss1); // this guy absorbs all of incoming data

当然它吸收了一切。您显式编码recv 以执行无限循环，直到eof。那是流的结尾，这意味着“每当套接字在远程端关闭时”。

所以协议(protocol)中缺少的基本内容是框架。最常见的解决方法是:

• 在数据之前发送数据长度，这样服务器就知道要读取多少

• 发送“特殊序列”来分隔帧。在文本中，一个常见的特殊分隔符是 '\0'。但是，对于二进制数据，(非常)很难找到一个不能自然出现在有效负载中的分隔符。

  当然，如果您知道有效载荷的额外特征，您可以使用它。例如。如果您的有效负载被压缩，您知道您不会经常找到 512 个相同字节的 block (它们会被压缩)。或者，您可以采用消除歧义的方式对二进制数据进行编码。 yEnc , Base122 等。想到(请参阅 Binary Data in JSON String. Something better than Base64 获取灵感)。

注意事项:

不管怎样

1. 手写阅读循环很笨拙。接下来，非常没有必要这样做并且无论如何也将 block 复制到字符串流中。如果您无论如何都要进行所有复制，只需将 boost::asio::[async_]read 与 boost::asio::streambuf 直接一起使用即可。

2. 这很清楚UB :

   const char * big_obj_bin1 = reinterpret_cast<const char*>(ss1.str().c_str());
   const char * big_obj_bin2 = reinterpret_cast<const char*>(ss2.str().c_str());
   

   str() returns a temporary copy of the buffer - 这不仅是一种浪费，而且意味着 const char* 在它们被初始化的那一刻就悬空。

   <