feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity

WebSocket optimizations (API Change):

Browse Source 
The websocket stream is optimized to contain a small
circular static buffer, reducing the number of I/O calls when
reading data. The size of the buffer is tuned for maximum
performance with TCP/IP and no long needs configuration:

* read_some replaces read_frame
* write_some replaces write_Frame
* async_read_some replaces async_read_frame
* async_write_some replaces async_write_frame

* websocket::stream::read_buffer_size is removed

Actions Required:

* Remove calls websocket::stream::read_buffer_size

* Use read_some and write_some instead of read_frame and write_frame
This commit is contained in:
Vinnie Falco
2017-07-20 08:15:32 -07:00
parent 28b5275c73
commit cb501a07c8
21 changed files with 2350 additions and 1241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/beast/websocket/impl/accept.ipp
-2
View File
@@ -28,8 +28,6 @@
namespace beast {
namespace websocket {
//------------------------------------------------------------------------------
// Respond to an upgrade HTTP request
template<class NextLayer>
template<class Handler>
include/beast/websocket/impl/close.ipp
+32 -25
View File
@@ -35,11 +35,13 @@ class stream<NextLayer>::close_op
close_reason cr;
detail::frame_streambuf fb;
int state = 0;
token tok;
data(Handler&, stream<NextLayer>& ws_,
close_reason const& cr_)
: ws(ws_)
, cr(cr_)
, tok(ws.t_.unique())
{
ws.template write_close<
flat_static_buffer_base>(fb, cr);
@@ -114,7 +116,7 @@ operator()(error_code ec, std::size_t)
auto& d = *d_;
if(ec)
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.failed_ = true;
goto upcall;
}
@@ -128,7 +130,7 @@ operator()(error_code ec, std::size_t)
d.ws.close_op_.emplace(std::move(*this));
return;
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -140,7 +142,7 @@ operator()(error_code ec, std::size_t)
do_write:
// send close frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.state = 3;
d.ws.wr_close_ = true;
boost::asio::async_write(d.ws.stream_,
@@ -149,7 +151,7 @@ operator()(error_code ec, std::size_t)
case 1:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
d.state = 2;
// The current context is safe but might not be
// the same as the one for this operation (since
@@ -161,7 +163,7 @@ operator()(error_code ec, std::size_t)
return;
case 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -174,30 +176,15 @@ operator()(error_code ec, std::size_t)
break;
}
upcall:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
d.ws.rd_op_.maybe_invoke() ||
d.ws.ping_op_.maybe_invoke() ||
d.ws.wr_op_.maybe_invoke();
d_.invoke(ec);
}
template<class NextLayer>
template<class CloseHandler>
async_return_type<
CloseHandler, void(error_code)>
stream<NextLayer>::
async_close(close_reason const& cr, CloseHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
async_completion<CloseHandler,
void(error_code)> init{handler};
close_op<handler_type<
CloseHandler, void(error_code)>>{
init.completion_handler, *this, cr}({});
return init.result.get();
}
//------------------------------------------------------------------------------
template<class NextLayer>
void
@@ -219,9 +206,12 @@ close(close_reason const& cr, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
BOOST_ASSERT(! wr_close_);
// If rd_close_ is set then we already sent a close
BOOST_ASSERT(! rd_close_);
if(wr_close_)
{
// Can't call close twice, abort operation
BOOST_ASSERT(! wr_close_);
ec = boost::asio::error::operation_aborted;
return;
}
@@ -230,9 +220,26 @@ close(close_reason const& cr, error_code& ec)
write_close<flat_static_buffer_base>(fb, cr);
boost::asio::write(stream_, fb.data(), ec);
failed_ = !!ec;
if(failed_)
return;
}
//------------------------------------------------------------------------------
template<class NextLayer>
template<class CloseHandler>
async_return_type<
CloseHandler, void(error_code)>
stream<NextLayer>::
async_close(close_reason const& cr, CloseHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
async_completion<CloseHandler,
void(error_code)> init{handler};
close_op<handler_type<
CloseHandler, void(error_code)>>{
init.completion_handler, *this, cr}({});
return init.result.get();
}
} // websocket
} // beast
include/beast/websocket/impl/error.ipp
+1
View File
@@ -39,6 +39,7 @@ public:
case error::closed: return "WebSocket connection closed normally";
case error::failed: return "WebSocket connection failed due to a protocol violation";
case error::handshake_failed: return "WebSocket Upgrade handshake failed";
case error::buffer_overflow: return "buffer overflow";
default:
return "beast.websocket error";
include/beast/websocket/impl/fail.ipp
+233
View File
@@ -0,0 +1,233 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BEAST_WEBSOCKET_IMPL_FAIL_IPP
#define BEAST_WEBSOCKET_IMPL_FAIL_IPP
#include <beast/websocket/teardown.hpp>
#include <beast/core/bind_handler.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/flat_static_buffer.hpp>
#include <beast/core/detail/config.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/optional.hpp>
#include <memory>
#include <type_traits>
#include <utility>
namespace beast {
namespace websocket {
// _Fail the WebSocket Connection_
//
template<class NextLayer>
template<class Handler>
class stream<NextLayer>::fail_op
{
Handler h_;
stream<NextLayer>& ws_;
int step_ = 0;
bool dispatched_ = false;
fail_how how_;
token tok_;
public:
fail_op(fail_op&&) = default;
fail_op(fail_op const&) = default;
// send close code, then teardown
template<class DeducedHandler>
fail_op(
DeducedHandler&& h,
stream<NextLayer>& ws,
close_code code)
: h_(std::forward<DeducedHandler>(h))
, ws_(ws)
, how_(fail_how::code)
, tok_(ws_.t_.unique())
{
ws_.rd_.fb.consume(ws_.rd_.fb.size());
ws_.template write_close<
flat_static_buffer_base>(
ws_.rd_.fb, code);
}
// maybe send frame in fb, then teardown
template<class DeducedHandler>
fail_op(
DeducedHandler&& h,
stream<NextLayer>& ws,
fail_how how)
: h_(std::forward<DeducedHandler>(h))
, ws_(ws)
, how_(how)
, tok_(ws_.t_.unique())
{
}
Handler&
handler()
{
return h_;
}
void operator()(error_code ec = {},
std::size_t bytes_transferred = 0);
friend
void* asio_handler_allocate(
std::size_t size, fail_op* op)
{
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->h_));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, fail_op* op)
{
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->h_));
}
friend
bool asio_handler_is_continuation(fail_op* op)
{
using boost::asio::asio_handler_is_continuation;
return op->dispatched_ ||
asio_handler_is_continuation(
std::addressof(op->h_));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, fail_op* op)
{
using boost::asio::asio_handler_invoke;
asio_handler_invoke(f,
std::addressof(op->h_));
}
};
template<class NextLayer>
template<class Handler>
void
stream<NextLayer>::
fail_op<Handler>::
operator()(error_code ec, std::size_t)
{
enum
{
do_start = 0,
do_resume = 20,
do_teardown = 40
};
switch(step_)
{
case do_start:
// Acquire write block
if(ws_.wr_block_)
{
// suspend
BOOST_ASSERT(ws_.wr_block_ != tok_);
step_ = do_resume;
ws_.rd_op_.save(std::move(*this));
return;
}
ws_.wr_block_ = tok_;
goto go_write;
case do_resume:
BOOST_ASSERT(! ws_.wr_block_);
ws_.wr_block_ = tok_;
step_ = do_resume + 1;
// We were invoked from a foreign context, so post
return ws_.get_io_service().post(std::move(*this));
case do_resume + 1:
BOOST_ASSERT(ws_.wr_block_ == tok_);
dispatched_ = true;
go_write:
BOOST_ASSERT(ws_.wr_block_ == tok_);
if(ws_.failed_)
{
ws_.wr_block_.reset();
ec = boost::asio::error::operation_aborted;
break;
}
if(how_ == fail_how::teardown)
goto go_teardown;
if(ws_.wr_close_)
goto go_teardown;
// send close frame
step_ = do_teardown;
ws_.wr_close_ = true;
return boost::asio::async_write(
ws_.stream_, ws_.rd_.fb.data(),
std::move(*this));
case do_teardown:
BOOST_ASSERT(ws_.wr_block_ == tok_);
dispatched_ = true;
ws_.failed_ = !!ec;
if(ws_.failed_)
{
ws_.wr_block_.reset();
break;
}
go_teardown:
BOOST_ASSERT(ws_.wr_block_ == tok_);
step_ = do_teardown + 1;
websocket_helpers::call_async_teardown(
ws_.next_layer(), std::move(*this));
return;
case do_teardown + 1:
BOOST_ASSERT(ws_.wr_block_ == tok_);
dispatched_ = true;
ws_.failed_ = true;
ws_.wr_block_.reset();
if(ec == boost::asio::error::eof)
{
// Rationale:
// http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error
ec.assign(0, ec.category());
}
if(! ec)
{
switch(how_)
{
default:
case fail_how::code:
case fail_how::teardown: ec = error::failed; break;
case fail_how::close: ec = error::closed; break;
}
}
break;
}
// upcall
BOOST_ASSERT(ws_.wr_block_ != tok_);
ws_.close_op_.maybe_invoke() ||
ws_.ping_op_.maybe_invoke() ||
ws_.wr_op_.maybe_invoke();
if(! dispatched_)
ws_.stream_.get_io_service().post(
bind_handler(std::move(h_), ec));
else
h_(ec);
}
} // websocket
} // beast
#endif
include/beast/websocket/impl/ping.ipp
+9 -7
View File
@@ -35,10 +35,12 @@ class stream<NextLayer>::ping_op
stream<NextLayer>& ws;
detail::frame_streambuf fb;
int state = 0;
token tok;
data(Handler&, stream<NextLayer>& ws_,
detail::opcode op_, ping_data const& payload)
: ws(ws_)
, tok(ws.t_.unique())
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
@@ -115,7 +117,7 @@ operator()(error_code ec, std::size_t)
auto& d = *d_;
if(ec)
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.failed_ = true;
goto upcall;
}
@@ -129,7 +131,7 @@ operator()(error_code ec, std::size_t)
d.ws.ping_op_.emplace(std::move(*this));
return;
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -140,7 +142,7 @@ operator()(error_code ec, std::size_t)
do_write:
// send ping frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.state = 3;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
@@ -148,7 +150,7 @@ operator()(error_code ec, std::size_t)
case 1:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
d.state = 2;
// The current context is safe but might not be
// the same as the one for this operation (since
@@ -160,7 +162,7 @@ operator()(error_code ec, std::size_t)
return;
case 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -173,8 +175,8 @@ operator()(error_code ec, std::size_t)
break;
}
upcall:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
d.ws.close_op_.maybe_invoke() ||
d.ws.rd_op_.maybe_invoke() ||
d.ws.wr_op_.maybe_invoke();
include/beast/websocket/impl/read.ipp
+1148 -950
View File
File diff suppressed because it is too large Load Diff
include/beast/websocket/impl/stream.ipp
+253 -22
View File
@@ -21,6 +21,7 @@
#include <beast/core/consuming_buffers.hpp>
#include <beast/core/flat_static_buffer.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/clamp.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/assert.hpp>
#include <boost/endian/buffers.hpp>
@@ -42,6 +43,61 @@ stream<NextLayer>::
stream(Args&&... args)
: stream_(std::forward<Args>(args)...)
{
BOOST_ASSERT(rd_.buf.max_size() >=
max_control_frame_size);
}
template<class NextLayer>
std::size_t
stream<NextLayer>::
read_size_hint(
std::size_t initial_size) const
{
using beast::detail::clamp;
// no permessage-deflate
if(! pmd_ || (! rd_.done && ! pmd_->rd_set))
{
// fresh message
if(rd_.done)
return initial_size;
if(rd_.fh.fin)
return clamp(rd_.remain);
}
return (std::max)(
initial_size, clamp(rd_.remain));
}
template<class NextLayer>
template<class DynamicBuffer, class>
std::size_t
stream<NextLayer>::
read_size_hint(
DynamicBuffer& buffer) const
{
static_assert(is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
using beast::detail::clamp;
// no permessage-deflate
if(! pmd_ || (! rd_.done && ! pmd_->rd_set))
{
// fresh message
if(rd_.done)
return (std::min)(
buffer.max_size(),
(std::max)(+tcp_frame_size,
buffer.capacity() - buffer.size()));
if(rd_.fh.fin)
{
BOOST_ASSERT(rd_.remain != 0);
return (std::min)(
buffer.max_size(), clamp(rd_.remain));
}
}
return (std::min)(buffer.max_size(), (std::max)(
(std::max)(+tcp_frame_size, clamp(rd_.remain)),
buffer.capacity() - buffer.size()));
}
template<class NextLayer>
@@ -78,10 +134,13 @@ open(role_type role)
// VFALCO TODO analyze and remove dupe code in reset()
role_ = role;
failed_ = false;
rd_.remain = 0;
rd_.cont = false;
rd_.done = true;
rd_.buf.consume(rd_.buf.size());
rd_close_ = false;
wr_close_ = false;
wr_block_ = nullptr; // should be nullptr on close anyway
wr_block_.reset();
ping_data_ = nullptr; // should be nullptr on close anyway
wr_.cont = false;
@@ -121,7 +180,6 @@ void
stream<NextLayer>::
close()
{
rd_.buf.reset();
wr_.buf.reset();
pmd_.reset();
}
@@ -132,35 +190,20 @@ stream<NextLayer>::
reset()
{
failed_ = false;
rd_.remain = 0;
rd_.cont = false;
rd_.done = true;
rd_.buf.consume(rd_.buf.size());
rd_close_ = false;
wr_close_ = false;
wr_.cont = false;
wr_block_ = nullptr; // should be nullptr on close anyway
wr_block_.reset();
ping_data_ = nullptr; // should be nullptr on close anyway
stream_.buffer().consume(
stream_.buffer().size());
}
// Called before each read frame
template<class NextLayer>
void
stream<NextLayer>::
rd_begin()
{
// Maintain the read buffer
if(pmd_)
{
if(! rd_.buf || rd_.buf_size != rd_buf_size_)
{
rd_.buf_size = rd_buf_size_;
rd_.buf = boost::make_unique_noinit<
std::uint8_t[]>(rd_.buf_size);
}
}
}
// Called before each write frame
template<class NextLayer>
void
@@ -190,6 +233,194 @@ wr_begin()
//------------------------------------------------------------------------------
// Attempt to read a complete frame header.
// Returns `false` if more bytes are needed
template<class NextLayer>
template<class DynamicBuffer>
bool
stream<NextLayer>::
parse_fh(
detail::frame_header& fh,
DynamicBuffer& b,
close_code& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
auto const err =
[&](close_code cv)
{
code = cv;
return false;
};
if(buffer_size(b.data()) < 2)
{
code = close_code::none;
return false;
}
consuming_buffers<typename
DynamicBuffer::const_buffers_type> cb{
b.data()};
{
std::uint8_t tmp[2];
cb.consume(buffer_copy(buffer(tmp), cb));
std::size_t need;
fh.len = tmp[1] & 0x7f;
switch(fh.len)
{
case 126: need = 2; break;
case 127: need = 8; break;
default:
need = 0;
}
fh.mask = (tmp[1] & 0x80) != 0;
if(fh.mask)
need += 4;
if(buffer_size(cb) < need)
{
code = close_code::none;
return false;
}
fh.op = static_cast<
detail::opcode>(tmp[0] & 0x0f);
fh.fin = (tmp[0] & 0x80) != 0;
fh.rsv1 = (tmp[0] & 0x40) != 0;
fh.rsv2 = (tmp[0] & 0x20) != 0;
fh.rsv3 = (tmp[0] & 0x10) != 0;
}
switch(fh.op)
{
case detail::opcode::binary:
case detail::opcode::text:
if(rd_.cont)
{
// new data frame when continuation expected
return err(close_code::protocol_error);
}
if((fh.rsv1 && ! pmd_) ||
fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
if(pmd_)
pmd_->rd_set = fh.rsv1;
break;
case detail::opcode::cont:
if(! rd_.cont)
{
// continuation without an active message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
default:
if(detail::is_reserved(fh.op))
{
// reserved opcode
return err(close_code::protocol_error);
}
if(! fh.fin)
{
// fragmented control message
return err(close_code::protocol_error);
}
if(fh.len > 125)
{
// invalid length for control message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
}
// unmasked frame from client
if(role_ == role_type::server && ! fh.mask)
return err(close_code::protocol_error);
// masked frame from server
if(role_ == role_type::client && fh.mask)
return err(close_code::protocol_error);
if(detail::is_control(fh.op) &&
buffer_size(cb) < fh.len)
{
// Make the entire control frame payload
// get read in before we return `true`
return false;
}
switch(fh.len)
{
case 126:
{
std::uint8_t tmp[2];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb));
fh.len = detail::big_uint16_to_native(&tmp[0]);
// length not canonical
if(fh.len < 126)
return err(close_code::protocol_error);
break;
}
case 127:
{
std::uint8_t tmp[8];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb));
fh.len = detail::big_uint64_to_native(&tmp[0]);
// length not canonical
if(fh.len < 65536)
return err(close_code::protocol_error);
break;
}
}
if(fh.mask)
{
std::uint8_t tmp[4];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb));
fh.key = detail::little_uint32_to_native(&tmp[0]);
detail::prepare_key(rd_.key, fh.key);
}
else
{
// initialize this otherwise operator== breaks
fh.key = 0;
}
if(! detail::is_control(fh.op))
{
if(fh.op != detail::opcode::cont)
{
rd_.size = 0;
rd_.op = fh.op;
}
else
{
if(rd_.size > (std::numeric_limits<
std::uint64_t>::max)() - fh.len)
return err(close_code::too_big);
}
if(! pmd_ || ! pmd_->rd_set)
{
if(rd_msg_max_ && beast::detail::sum_exceeds(
rd_.size, fh.len, rd_msg_max_))
return err(close_code::too_big);
}
rd_.cont = ! fh.fin;
rd_.remain = fh.len;
}
b.consume(b.size() - buffer_size(cb));
code = close_code::none;
return true;
}
// Read fixed frame header from buffer
// Requires at least 2 bytes
//
@@ -357,7 +588,7 @@ read_fh2(detail::frame_header& fh,
// initialize this otherwise operator== breaks
fh.key = 0;
}
if(! is_control(fh.op))
if(! detail::is_control(fh.op))
{
if(fh.op != detail::opcode::cont)
{
include/beast/websocket/impl/write.ipp
+42 -38
View File
@@ -32,7 +32,7 @@ namespace websocket {
template<class NextLayer>
template<class Buffers, class Handler>
class stream<NextLayer>::write_frame_op
class stream<NextLayer>::write_some_op
{
struct data : op
{
@@ -46,12 +46,14 @@ class stream<NextLayer>::write_frame_op
std::uint64_t remain;
int step = 0;
int entry_state;
token tok;
data(Handler& handler, stream<NextLayer>& ws_,
bool fin_, Buffers const& bs)
: ws(ws_)
, cb(bs)
, fin(fin_)
, tok(ws.t_.unique())
{
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
@@ -61,11 +63,11 @@ class stream<NextLayer>::write_frame_op
handler_ptr<data, Handler> d_;
public:
write_frame_op(write_frame_op&&) = default;
write_frame_op(write_frame_op const&) = default;
write_some_op(write_some_op&&) = default;
write_some_op(write_some_op const&) = default;
template<class DeducedHandler, class... Args>
write_frame_op(DeducedHandler&& h,
write_some_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
@@ -83,7 +85,7 @@ public:
friend
void* asio_handler_allocate(
std::size_t size, write_frame_op* op)
std::size_t size, write_some_op* op)
{
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
@@ -92,7 +94,7 @@ public:
friend
void asio_handler_deallocate(
void* p, std::size_t size, write_frame_op* op)
void* p, std::size_t size, write_some_op* op)
{
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
@@ -100,14 +102,14 @@ public:
}
friend
bool asio_handler_is_continuation(write_frame_op* op)
bool asio_handler_is_continuation(write_some_op* op)
{
return op->d_->cont;
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, write_frame_op* op)
void asio_handler_invoke(Function&& f, write_some_op* op)
{
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
@@ -119,7 +121,7 @@ template<class NextLayer>
template<class Buffers, class Handler>
void
stream<NextLayer>::
write_frame_op<Buffers, Handler>::
write_some_op<Buffers, Handler>::
operator()(error_code ec,
std::size_t bytes_transferred, bool again)
{
@@ -142,7 +144,7 @@ operator()(error_code ec,
d.cont = d.cont || again;
if(ec)
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.failed_ = true;
goto upcall;
}
@@ -212,7 +214,7 @@ loop:
//----------------------------------------------------------------------
case do_nomask_nofrag:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.fh.fin = d.fin;
d.fh.len = buffer_size(d.cb);
detail::write<flat_static_buffer_base>(
@@ -229,7 +231,7 @@ loop:
go_nomask_frag:
case do_nomask_frag:
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
auto const n = clamp(
d.remain, d.ws.wr_.buf_size);
d.remain -= n;
@@ -248,8 +250,8 @@ loop:
}
case do_nomask_frag + 1:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
d.cb.consume(
bytes_transferred - d.fh_buf.size());
d.fh_buf.consume(d.fh_buf.size());
@@ -264,14 +266,14 @@ loop:
return d.ws.get_io_service().post(
std::move(*this));
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
goto go_nomask_frag;
//----------------------------------------------------------------------
case do_mask_nofrag:
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.remain = buffer_size(d.cb);
d.fh.fin = d.fin;
d.fh.len = d.remain;
@@ -317,7 +319,7 @@ loop:
go_mask_frag:
case do_mask_frag:
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
auto const n = clamp(
d.remain, d.ws.wr_.buf_size);
d.remain -= n;
@@ -342,8 +344,8 @@ loop:
}
case do_mask_frag + 1:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.ws.wr_block_.reset();
d.cb.consume(
bytes_transferred - d.fh_buf.size());
d.fh_buf.consume(d.fh_buf.size());
@@ -359,7 +361,7 @@ loop:
std::move(*this));
return;
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
goto go_mask_frag;
//----------------------------------------------------------------------
@@ -367,7 +369,7 @@ loop:
go_deflate:
case do_deflate:
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
auto b = buffer(d.ws.wr_.buf.get(),
d.ws.wr_.buf_size);
auto const more = detail::deflate(
@@ -414,9 +416,9 @@ loop:
}
case do_deflate + 1:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
d.fh_buf.consume(d.fh_buf.size());
d.ws.wr_block_ = nullptr;
d.ws.wr_block_.reset();
d.fh.op = detail::opcode::cont;
d.fh.rsv1 = false;
// Allow outgoing control frames to
@@ -430,11 +432,11 @@ loop:
std::move(*this));
return;
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
goto go_deflate;
case do_deflate + 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
if(d.fh.fin && (
(d.ws.role_ == role_type::client &&
d.ws.pmd_config_.client_no_context_takeover) ||
@@ -449,12 +451,12 @@ loop:
if(d.ws.wr_block_)
{
// suspend
BOOST_ASSERT(d.ws.wr_block_ != &d);
BOOST_ASSERT(d.ws.wr_block_ != d.tok);
d.step = do_maybe_suspend + 1;
d.ws.wr_op_.emplace(std::move(*this));
return;
}
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -467,7 +469,7 @@ loop:
case do_maybe_suspend + 1:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.ws.wr_block_ = d.tok;
d.step = do_maybe_suspend + 2;
// The current context is safe but might not be
// the same as the one for this operation (since
@@ -479,7 +481,7 @@ loop:
return;
case do_maybe_suspend + 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
@@ -495,8 +497,8 @@ loop:
goto upcall;
}
upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
if(d.ws.wr_block_ == d.tok)
d.ws.wr_block_.reset();
d.ws.close_op_.maybe_invoke() ||
d.ws.rd_op_.maybe_invoke() ||
d.ws.ping_op_.maybe_invoke();
@@ -515,12 +517,14 @@ class stream<NextLayer>::write_op
stream<NextLayer>& ws;
consuming_buffers<Buffers> cb;
std::size_t remain;
token tok;
data(Handler&, stream<NextLayer>& ws_,
Buffers const& bs)
: ws(ws_)
, cb(bs)
, remain(boost::asio::buffer_size(cb))
, tok(ws.t_.unique())
{
}
};
@@ -604,7 +608,7 @@ operator()(error_code ec)
d.step = d.step ? 3 : 2;
auto const pb = buffer_prefix(n, d.cb);
d.cb.consume(n);
return d.ws.async_write_frame(
return d.ws.async_write_some(
fin, pb, std::move(*this));
}
@@ -621,7 +625,7 @@ template<class NextLayer>
template<class ConstBufferSequence>
void
stream<NextLayer>::
write_frame(bool fin, ConstBufferSequence const& buffers)
write_some(bool fin, ConstBufferSequence const& buffers)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
@@ -629,7 +633,7 @@ write_frame(bool fin, ConstBufferSequence const& buffers)
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
error_code ec;
write_frame(fin, buffers, ec);
write_some(fin, buffers, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
@@ -638,7 +642,7 @@ template<class NextLayer>
template<class ConstBufferSequence>
void
stream<NextLayer>::
write_frame(bool fin,
write_some(bool fin,
ConstBufferSequence const& buffers, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
@@ -845,7 +849,7 @@ template<class ConstBufferSequence, class WriteHandler>
async_return_type<
WriteHandler, void(error_code)>
stream<NextLayer>::
async_write_frame(bool fin,
async_write_some(bool fin,
ConstBufferSequence const& bs, WriteHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
@@ -855,7 +859,7 @@ async_write_frame(bool fin,
"ConstBufferSequence requirements not met");
async_completion<WriteHandler,
void(error_code)> init{handler};
write_frame_op<ConstBufferSequence, handler_type<
write_some_op<ConstBufferSequence, handler_type<
WriteHandler, void(error_code)>>{init.completion_handler,
*this, fin, bs}({}, 0, false);
return init.result.get();
@@ -891,7 +895,7 @@ write(ConstBufferSequence const& buffers, error_code& ec)
static_assert(beast::is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
write_frame(true, buffers, ec);
write_some(true, buffers, ec);
}
template<class NextLayer>