【问题标题】:Read until a string delimiter in boost::asio::streambuf读取到 boost::asio::streambuf 中的字符串分隔符
【发布时间】:2017-03-26 11:00:03
【问题描述】:

我想使用非常方便的 Boost async_read_until 来阅读消息,直到我得到 \r\n\r\n 分隔符。

我喜欢使用这个分隔符,因为它很容易使用 telnet 进行调试并制作多行命令。我只是用两条新线表示命令结束。

我这样称呼async_read_until:

void do_read()
{
    boost::asio::async_read_until(m_socket,
                                  m_input_buffer,
                                  "\r\n\r\n",
                                  std::bind(&player::handle_read, this, std::placeholders::_1, std::placeholders::_2));
}

我的处理程序现在看起来像这样:

void handle_read(boost::system::error_code ec, std::size_t nr)
{
    std::cout << "handle_read: ec=" << ec << ", nr=" << nr << std::endl;

    if (ec) {
        std::cout << "  -> emit on_disconnect\n";
    } else {
        std::istream iss(&m_input_buffer);
        std::string msg;
        std::getline(iss, msg);

        std::cout << "dump:\n";
        std::copy(msg.begin(), msg.end(), std::ostream_iterator<int>(std::cout, ", "));
        std::cout << std::endl;

        do_read();
    }
}

我想像示例一样使用std::getline,但在我的系统上,这保留了\r 字符。如您所见,如果我连接到服务器并写入hello 加上两个CRLF,我会得到这个转储服务器端:

handle_read: ec=system:0, nr=9
dump:
104, 101, 108, 108, 111, 13, 
                         ^^^ \r here

顺便说一句,这也会在缓冲区中保留下一个新行。所以我认为std::getline 不会为我完成这项工作。

我寻找一种方便有效的方法来读取boost::asio::streambuf,直到我得到这个\r\n\r\n 分隔符。由于我一次使用async_read_until,所以当调用处理程序时,缓冲区应该具有准确和完整的数据,不是吗?在我收到\r\n\r\n 之前,您建议阅读什么内容?

【问题讨论】:

    标签: c++ boost boost-asio


    【解决方案1】:

    首先回答您的问题:

    缓冲区应该包含准确且完整的数据,不是吗?

    是的,它将包含所有数据,包括“\r\n\r\n”

    在我得到 \r\n\r\n 之前,您建议阅读什么内容?

    你所做的已经足够好了。您只需要忽略每个命令末尾的附加 '\r'。您可以在读取stream 时执行此操作,或者让它由命令处理器(或为您执行命令处理的任何东西)处理。我的建议是将删除额外的 '\r' 推迟到命令处理器。

    您可能需要以下内容:

    #include <iostream>
    #include <string>
    #include <sstream>
    
    void handle_read()
    {
      std::stringstream oss;
      oss << "key : value\r\nkey2: value2\r\nkey3: value3\r\n\r\n";
      std::string parsed;
    
      while (std::getline(oss, parsed)) {
        // Check if it'a an empty line.
        if (parsed == "\r") break;
        // Remove the additional '\r' here or at command processor code.
        if (parsed[parsed.length() - 1] == '\r') parsed.pop_back();
        std::cout << parsed << std::endl;
        std::cout << parsed.length() << std::endl;
      }
    
    }
    
    int main() {
        handle_read();
        return 0;
    }
    

    如果您的协议允许您发送空命令,那么您将不得不更改逻辑并注意 2 个连续的空新行。

    【讨论】:

    • 谢谢,我已经用一个临时缓冲区实现了你的想法,并在迭代时清理了字符串。 ideone.com/KWj32L。我也会添加一些关于空字符串的测试。
    【解决方案2】:

    你真正想要解析什么?

    当然,你可以只使用你所在领域的知识并说

    std::getline(iss, msg, '\r');
    

    在更高的层次上,考虑解析你需要的东西:

    std::istringstream linestream(msg);
    std::string command;
    int arg;
    if (linestream >> command >> arg) {
        // ...
    }
    

    更好的是,考虑一个解析器生成器:

    std::string command;
    int arg;
    
    if (qi::phrase_parse(msg.begin(), msg.end(), command_ >> qi::int_, qi::space, command, arg))
    {
        // ...
    }
    

    command_ 可能在哪里

    qi::rule<std::string::const_iterator> command_ = qi::no_case [ 
         qi::lit("my_cmd1") | qi::lit("my_cmd2") 
      ];
    

    【讨论】:

      【解决方案3】:

      async_read_until() 操作将读取的所有数据提交到 streambuf 的输入序列中,bytes_transferred 值将包含最多包含第一个分隔符的字节数。虽然该操作可能会读取超出分隔符的更多数据,但可以使用bytes_transferred 和分隔符大小来仅提取所需的数据。例如,如果cmd1\r\n\r\ncmd2 可以从套接字读取,并且async_read_until() 操作以\r\n\r\n 的分隔符启动,那么streambuf 的输入序列可能包含cmd1\r\n\r\ncmd2:

          ,--------------- buffer_begin(streambuf.data())
         /   ,------------ buffer_begin(streambuf.data()) + bytes_transferred
        /   /                - delimiter.size()
       /   /       ,------ buffer_begin(streambuf.data()) + bytes_transferred
      /   /       /   ,--  buffer_end(streambud.data())
      cmd1\r\n\r\ncmd2
      

      因此,可以通过以下方式将cmd1 从streambuf 中提取为字符串:

      // Extract up to the first delimiter.
      std::string command{
        boost::asio::buffers_begin(streambuf.data(), 
        boost::asio::buffers_begin(streambuf.data()) + bytes_transferred
          - delimiter.size()};
      // Consume through the first delimiter.
      m_input_buffer.consume(bytes_transferred);
      

      这里是一个完整的例子demonstrating直接从streambuf的输入序列构造std::string:

      #include <functional> // std::bind
      #include <iostream>
      #include <boost/asio.hpp>
      
      const auto noop = std::bind([]{});
      
      int main()
      {
        using boost::asio::ip::tcp;
        boost::asio::io_service io_service;
      
        // Create all I/O objects.
        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 0));
        tcp::socket socket1(io_service);
        tcp::socket socket2(io_service);
      
        // Connect sockets.
        acceptor.async_accept(socket1, noop);
        socket2.async_connect(acceptor.local_endpoint(), noop);
        io_service.run();
        io_service.reset();
      
        const std::string delimiter = "\r\n\r\n";
      
        // Write two commands from socket1 to socket2.
        boost::asio::write(socket1, boost::asio::buffer("cmd1" + delimiter));
        boost::asio::write(socket1, boost::asio::buffer("cmd2" + delimiter));
      
        // Read a single command from socket2.
        boost::asio::streambuf streambuf;
        boost::asio::async_read_until(socket2, streambuf, delimiter,
          [delimiter, &streambuf](
            const boost::system::error_code& error_code,
            std::size_t bytes_transferred)
          {
            // Verify streambuf contains more data beyond the delimiter. (e.g.
            // async_read_until read beyond the delimiter)
            assert(streambuf.size() > bytes_transferred);
      
            // Extract up to the first delimiter.
            std::string command{
              buffers_begin(streambuf.data()),
              buffers_begin(streambuf.data()) + bytes_transferred
                - delimiter.size()};
      
            // Consume through the first delimiter so that subsequent async_read_until
            // will not reiterate over the same data.
            streambuf.consume(bytes_transferred);
      
            assert(command == "cmd1");
            std::cout << "received command: " << command << "\n"
                      << "streambuf contains " << streambuf.size() << " bytes."
                      << std::endl;
          }
        );
        io_service.run();
      }
      

      输出:

      received command: cmd1
      streambuf contains 8 bytes.
      

      【讨论】:

      • 如果实际缓冲区被读取到cmd1\r\n\r\ncmd2\r\n\r\n 会怎样?仅当发送第三个或更多命令时,才会解析第二个命令。所以我们需要在有一些可用数据时循环,不是吗?
      • @markand 没有。最优雅的解决方案是发出另一个async_read_until 操作。由于缓冲区已经包含分隔符,因此在尝试 I/O 之前将检测完成条件,并且完成处理程序将准备好运行。
      • 可能类似于this?
      • @markand 是的,以这种方式链接async_read_until 是处理它的惯用方式。
      猜你喜欢
      • 2015-05-09
      • 2018-04-09
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2017-09-02
      • 2011-08-06
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多