![](/img/trans.png)
[英]Using boost::asio::async_wait_until with boost::asio::streambuf
[英]Read until a string delimiter in boost::asio::streambuf
我想使用非常方便的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
值将包含直到并包括第一个分隔符的字节数。 虽然操作可以读取分隔符之外的更多数据,但可以使用bytes_transferred
和分隔符大小来仅提取所需数据。 例如,如果可以从套接字读取cmd1\\r\\n\\r\\ncmd2
,并且使用\\r\\n\\r\\n
的分隔符启动async_read_until()
操作,则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
因此,可以从streambuf通过以下方式将cmd1
提取到字符串中:
// 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);
这是一个完整的例子, 演示了直接从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.
首先回答你的问题:
缓冲区应该具有完全和完整的数据不是吗?
是的,它将包含所有数据,包括“\\ 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个空的新行。
你真的希望解析什么?
当然,您可以使用您所在领域的知识并说出来
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")
];
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.