我正试图接收一个未知大小的缓冲区,我的部分代码如下:
void Connection::asyncRead()
{
auto self(shared_from_this());
socket_.async_read_some(boost::asio::buffer(buffer_out),
[this, self](boost::system::error_code ec, std::size_t length)
{
OnRead(ec, length);
});
}
我不知道缓冲区的大小,所以我尝试在固定大小的缓冲区中接收缓冲区,如何知道缓冲区是否结束?
如果您想发送/接收没有固定大小的消息,可以使用定义消息头的方法,例如使用4字节字段来存储消息内容的大小:
[header(4 bytes) to store the size of message][content of message]
那么你总是知道第一步是读取4个字节,为数据准备缓冲区并读取更多的数据,直到缓冲区被填满。
另一种方法是关闭套接字(下面是伪代码(
The receiving side | the sending side
--------------------------------------------------------------------------------
error_code ec; |
asio::read(sock,buf,ec) [2] |
| prepare some buffer with unknown size
| string buf;
| buf += ...; // add data
| asio::write(sock,buf)
| sock.shutdown(socket_base::shutdown_send); [1]
通过呼叫发送方的sock.shutdown()
[1],您可以通知整个消息已发送给接收方。然后,在读取消息[2]后,在接收方,您应该检查ec
错误代码变量的状态是否为boost::asio::eof
。如果您收到end-of-file
,您就知道该消息已完成。如果ec
与eof
不同,则意味着发生了错误。
从1.66 boost版本开始,您可以使用dynamic_buffer
来存储数据,它将字符串或向量作为缓冲区。或者您可以考虑streambuf
来读取非固定缓冲区。
编辑
增加了dynamic_buffer
的使用。根据参考文献,dynamic_buffer
可以在像async_read
、async_until
这样的自由函数中使用,但不能在async_read_some
中用作套接字的成员函数。以下是客户端和服务器的代码:
服务器:
using namespace boost;
struct Data {
std::shared_ptr<asio::ip::tcp::socket> sock;
std::string buf; // buf is empty [1]
};
void readHandler (
const boost::system::error_code& ec,
size_t length,
std::shared_ptr<Data> d) {
std::cout << "readHandler" << std::endl;
if (ec == boost::asio::error::eof)
{
// here we got the whole message
std::cout << d->buf << std::endl;
}
else
{
std::cout << "Error" << std::endl;
}
}
int main() {
try {
asio::ip::tcp::endpoint ep(asio::ip::address_v4::any(),9999);
asio::io_service ios;
asio::ip::tcp::acceptor acceptor(ios, ep);
std::shared_ptr<asio::ip::tcp::socket> sock{new asio::ip::tcp::socket(ios)};
acceptor.accept(*sock);
std::shared_ptr<Data> data(new Data);
data->sock = move(sock);
boost::asio::async_read (*(data->sock), asio::dynamic_buffer(data->buf),
std::bind(readHandler,std::placeholders::_1, std::placeholders::_2,data)); // [2]
ios.run(); // wait until async_write is complete
}
catch (system::system_error &e) {
std::cout << "error " << e.what() << std::endl;
}
return 0;
}
在[1]中,我们创建空缓冲区作为字符串对象,在[2]中,我们调用async_read
来使用dynamic_buffer
获取数据。当发送端关闭其一侧的套接字时,会调用传递到async_read
的处理程序。
客户:
using namespace boost;
int main() {
try {
asio::ip::tcp::endpoint ep(asio::ip::address::from_string("127.0.0.1"),9999);
asio::io_service ios;
asio::ip::tcp::socket sock(ios, ep.protocol());
sock.connect(ep);
std::string buf = "some message";
for (int i = 0; i < buf.size(); ++i) {
// synchronous function was used to make simpler code
asio::write(sock,asio::buffer(buf.c_str()+i,1)); // send 1 char
std::this_thread::sleep_for(std::chrono::seconds(1)); // delay 1 second
}
sock.shutdown(asio::socket_base::shutdown_send);
}
catch (system::system_error &e) {
std::cout << "Error " << e.what() << std::endl;
}
return 0;
}
正如您所看到的,我们从字符串中逐字符发送,延迟1秒。所以,当您启动服务器然后启动客户端时,服务器应该在大约12秒后收到整个消息。async_read
在服务器中等待,直到eof
到来——它是由客户端在套接字上调用shutdown
发送的。