我想使用非常方便的 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
之前,您建议我阅读什么?
最佳答案
async_read_until()
操作将读取的所有数据提交到 streambuf 的输入序列中,并且 bytes_transferred
value 将包含字节数,直到并包括第一个定界符。虽然该操作可能会读取超出分隔符的更多数据,但可以使用 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施工 std::string
直接来自 streambuf 的输入序列:
#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.
关于c++ - 一直读到 boost::asio::streambuf 中的字符串定界符,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/40561097/