forked from boostorg/beast
Fix soft-mutex assert in websocket stream:
Fix #1000 This resolves the assert 'ws_.wr_block_ == tok_'.
This commit is contained in:
1 parent
9f3c981d6a
commit
ab32400d00
12 files changed
+173
-162
No files matched your search
@@ -44,7 +44,6 @@ class stream<NextLayer, deflateSupported>::close_op
|
||||
stream<NextLayer, deflateSupported>& ws;
|
||||
detail::frame_buffer fb;
|
||||
error_code ev;
|
||||
token tok;
|
||||
bool cont = false;
|
||||
|
||||
state(
|
||||
@@ -52,7 +51,6 @@ class stream<NextLayer, deflateSupported>::close_op
|
||||
stream<NextLayer, deflateSupported>& ws_,
|
||||
close_reason const& cr)
|
||||
: ws(ws_)
|
||||
, tok(ws.tok_.unique())
|
||||
{
|
||||
// Serialize the close frame
|
||||
ws.template write_close<
|
||||
@@ -125,11 +123,8 @@ operator()(
|
||||
BOOST_ASIO_CORO_REENTER(*this)
|
||||
{
|
||||
// Maybe suspend
|
||||
if(! d.ws.wr_block_)
|
||||
if(d.ws.wr_block_.try_lock(this))
|
||||
{
|
||||
// Acquire the write block
|
||||
d.ws.wr_block_ = d.tok;
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! d.ws.check_open(ec))
|
||||
goto upcall;
|
||||
@@ -137,19 +132,17 @@ operator()(
|
||||
else
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(d.ws.wr_block_ != d.tok);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
d.ws.paused_close_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the write block
|
||||
BOOST_ASSERT(! d.ws.wr_block_);
|
||||
d.ws.wr_block_ = d.tok;
|
||||
d.ws.wr_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
d.ws.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! d.ws.check_open(ec))
|
||||
@@ -180,27 +173,20 @@ operator()(
|
||||
}
|
||||
|
||||
// Maybe suspend
|
||||
if(! d.ws.rd_block_)
|
||||
{
|
||||
// Acquire the read block
|
||||
d.ws.rd_block_ = d.tok;
|
||||
}
|
||||
else
|
||||
if(! d.ws.rd_block_.try_lock(this))
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(d.ws.rd_block_ != d.tok);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
d.ws.paused_r_close_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the read block
|
||||
BOOST_ASSERT(! d.ws.rd_block_);
|
||||
d.ws.rd_block_ = d.tok;
|
||||
d.ws.rd_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
d.ws.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(d.ws.rd_block_ == d.tok);
|
||||
BOOST_ASSERT(d.ws.rd_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
BOOST_ASSERT(d.ws.status_ != status::open);
|
||||
@@ -275,12 +261,12 @@ operator()(
|
||||
|
||||
teardown:
|
||||
// Teardown
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
|
||||
using beast::websocket::async_teardown;
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
async_teardown(d.ws.role_,
|
||||
d.ws.stream_, std::move(*this));
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
|
||||
if(ec == boost::asio::error::eof)
|
||||
{
|
||||
// Rationale:
|
||||
@@ -296,13 +282,10 @@ operator()(
|
||||
d.ws.close();
|
||||
|
||||
upcall:
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
d.ws.wr_block_.reset();
|
||||
if(d.ws.rd_block_ == d.tok)
|
||||
{
|
||||
d.ws.rd_block_.reset();
|
||||
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
|
||||
d.ws.wr_block_.unlock(this);
|
||||
if(d.ws.rd_block_.try_unlock(this))
|
||||
d.ws.paused_r_rd_.maybe_invoke();
|
||||
}
|
||||
d.ws.paused_rd_.maybe_invoke() ||
|
||||
d.ws.paused_ping_.maybe_invoke() ||
|
||||
d.ws.paused_wr_.maybe_invoke();
|
||||
|
||||
@@ -41,7 +41,6 @@ class stream<NextLayer, deflateSupported>::ping_op
|
||||
{
|
||||
stream<NextLayer, deflateSupported>& ws;
|
||||
detail::frame_buffer fb;
|
||||
token tok;
|
||||
|
||||
state(
|
||||
Handler const&,
|
||||
@@ -49,7 +48,6 @@ class stream<NextLayer, deflateSupported>::ping_op
|
||||
detail::opcode op,
|
||||
ping_data const& payload)
|
||||
: ws(ws_)
|
||||
, tok(ws.tok_.unique())
|
||||
{
|
||||
// Serialize the control frame
|
||||
ws.template write_ping<
|
||||
@@ -118,11 +116,8 @@ operator()(error_code ec, std::size_t)
|
||||
BOOST_ASIO_CORO_REENTER(*this)
|
||||
{
|
||||
// Maybe suspend
|
||||
if(! d.ws.wr_block_)
|
||||
if(d.ws.wr_block_.try_lock(this))
|
||||
{
|
||||
// Acquire the write block
|
||||
d.ws.wr_block_ = d.tok;
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! d.ws.check_open(ec))
|
||||
{
|
||||
@@ -136,19 +131,17 @@ operator()(error_code ec, std::size_t)
|
||||
else
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(d.ws.wr_block_ != d.tok);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
d.ws.paused_ping_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the write block
|
||||
BOOST_ASSERT(! d.ws.wr_block_);
|
||||
d.ws.wr_block_ = d.tok;
|
||||
d.ws.wr_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
d.ws.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
BOOST_ASSERT(d.ws.wr_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! d.ws.check_open(ec))
|
||||
@@ -163,8 +156,7 @@ operator()(error_code ec, std::size_t)
|
||||
goto upcall;
|
||||
|
||||
upcall:
|
||||
BOOST_ASSERT(d.ws.wr_block_ == d.tok);
|
||||
d.ws.wr_block_.reset();
|
||||
d.ws.wr_block_.unlock(this);
|
||||
d.ws.paused_close_.maybe_invoke() ||
|
||||
d.ws.paused_rd_.maybe_invoke() ||
|
||||
d.ws.paused_wr_.maybe_invoke();
|
||||
|
||||
@@ -85,7 +85,6 @@ class stream<NextLayer, deflateSupported>::read_some_op
|
||||
buffers_suffix<MutableBufferSequence> cb_;
|
||||
std::size_t bytes_written_ = 0;
|
||||
error_code result_;
|
||||
token tok_;
|
||||
close_code code_;
|
||||
bool did_read_ = false;
|
||||
bool cont_ = false;
|
||||
@@ -103,7 +102,6 @@ public:
|
||||
, ws_(ws)
|
||||
, bs_(bs)
|
||||
, cb_(bs)
|
||||
, tok_(ws_.tok_.unique())
|
||||
, code_(close_code::none)
|
||||
{
|
||||
}
|
||||
@@ -165,11 +163,8 @@ operator()(
|
||||
{
|
||||
// Maybe suspend
|
||||
do_maybe_suspend:
|
||||
if(! ws_.rd_block_)
|
||||
if(ws_.rd_block_.try_lock(this))
|
||||
{
|
||||
// Acquire the read block
|
||||
ws_.rd_block_ = tok_;
|
||||
|
||||
// Make sure the stream is not closed
|
||||
if( ws_.status_ == status::closed ||
|
||||
ws_.status_ == status::failed)
|
||||
@@ -182,19 +177,17 @@ operator()(
|
||||
{
|
||||
do_suspend:
|
||||
// Suspend
|
||||
BOOST_ASSERT(ws_.rd_block_ != tok_);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
ws_.paused_r_rd_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the read block
|
||||
BOOST_ASSERT(! ws_.rd_block_);
|
||||
ws_.rd_block_ = tok_;
|
||||
ws_.rd_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
ws_.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
|
||||
|
||||
// The only way to get read blocked is if
|
||||
// a `close_op` wrote a close frame
|
||||
@@ -209,7 +202,7 @@ operator()(
|
||||
// then finish the read with operation_aborted.
|
||||
|
||||
loop:
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
|
||||
// See if we need to read a frame header. This
|
||||
// condition is structured to give the decompressor
|
||||
// a chance to emit the final empty deflate block
|
||||
@@ -230,29 +223,28 @@ operator()(
|
||||
code_ = close_code::protocol_error;
|
||||
goto close;
|
||||
}
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
ws_.stream_.async_read_some(
|
||||
ws_.rd_buf_.prepare(read_size(
|
||||
ws_.rd_buf_, ws_.rd_buf_.max_size())),
|
||||
std::move(*this));
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.rd_block_.is_locked(this));
|
||||
if(! ws_.check_ok(ec))
|
||||
goto upcall;
|
||||
ws_.rd_buf_.commit(bytes_transferred);
|
||||
|
||||
// Allow a close operation
|
||||
// to acquire the read block
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
ws_.rd_block_.reset();
|
||||
ws_.rd_block_.unlock(this);
|
||||
if( ws_.paused_r_close_.maybe_invoke())
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(ws_.rd_block_);
|
||||
BOOST_ASSERT(ws_.rd_block_.is_locked());
|
||||
goto do_suspend;
|
||||
}
|
||||
// Acquire read block
|
||||
ws_.rd_block_ = tok_;
|
||||
ws_.rd_block_.lock(this);
|
||||
}
|
||||
// Immediately apply the mask to the portion
|
||||
// of the buffer holding payload data.
|
||||
@@ -302,36 +294,26 @@ operator()(
|
||||
detail::opcode::pong, payload);
|
||||
}
|
||||
|
||||
//BOOST_ASSERT(! ws_.paused_r_close_);
|
||||
|
||||
// Allow a close operation
|
||||
// to acquire the read block
|
||||
BOOST_ASSERT(ws_.rd_block_ == tok_);
|
||||
ws_.rd_block_.reset();
|
||||
ws_.rd_block_.unlock(this);
|
||||
ws_.paused_r_close_.maybe_invoke();
|
||||
|
||||
// Maybe suspend
|
||||
if(! ws_.wr_block_)
|
||||
{
|
||||
// Acquire the write block
|
||||
ws_.wr_block_ = tok_;
|
||||
}
|
||||
else
|
||||
if(! ws_.wr_block_.try_lock(this))
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(ws_.wr_block_ != tok_);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
ws_.paused_rd_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the write block
|
||||
BOOST_ASSERT(! ws_.wr_block_);
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
ws_.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! ws_.check_open(ec))
|
||||
@@ -339,14 +321,14 @@ operator()(
|
||||
}
|
||||
|
||||
// Send pong
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::async_write(ws_.stream_,
|
||||
ws_.rd_fb_.data(), std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
if(! ws_.check_ok(ec))
|
||||
goto upcall;
|
||||
ws_.wr_block_.reset();
|
||||
ws_.wr_block_.unlock(this);
|
||||
ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke() ||
|
||||
ws_.paused_wr_.maybe_invoke();
|
||||
@@ -629,30 +611,25 @@ operator()(
|
||||
goto upcall;
|
||||
|
||||
close:
|
||||
if(! ws_.wr_block_)
|
||||
if(ws_.wr_block_.try_lock(this))
|
||||
{
|
||||
// Acquire the write block
|
||||
ws_.wr_block_ = tok_;
|
||||
|
||||
// Make sure the stream is open
|
||||
BOOST_ASSERT(ws_.status_ == status::open);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Suspend
|
||||
BOOST_ASSERT(ws_.wr_block_ != tok_);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
ws_.paused_rd_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the write block
|
||||
BOOST_ASSERT(! ws_.wr_block_);
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
ws_.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! ws_.check_open(ec))
|
||||
@@ -673,23 +650,23 @@ operator()(
|
||||
ws_.rd_fb_, code_);
|
||||
|
||||
// Send close frame
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::async_write(
|
||||
ws_.stream_, ws_.rd_fb_.data(),
|
||||
std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
if(! ws_.check_ok(ec))
|
||||
goto upcall;
|
||||
}
|
||||
|
||||
// Teardown
|
||||
using beast::websocket::async_teardown;
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
async_teardown(ws_.role_,
|
||||
ws_.stream_, std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
if(ec == boost::asio::error::eof)
|
||||
{
|
||||
// Rationale:
|
||||
@@ -705,16 +682,12 @@ operator()(
|
||||
ws_.close();
|
||||
|
||||
upcall:
|
||||
if(ws_.rd_block_ == tok_)
|
||||
ws_.rd_block_.reset();
|
||||
ws_.rd_block_.try_unlock(this);
|
||||
ws_.paused_r_close_.maybe_invoke();
|
||||
if(ws_.wr_block_ == tok_)
|
||||
{
|
||||
ws_.wr_block_.reset();
|
||||
if(ws_.wr_block_.try_unlock(this))
|
||||
ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke() ||
|
||||
ws_.paused_wr_.maybe_invoke();
|
||||
}
|
||||
if(! cont_)
|
||||
return boost::asio::post(
|
||||
ws_.stream_.get_executor(),
|
||||
|
||||
@@ -45,7 +45,6 @@ template<class... Args>
|
||||
stream<NextLayer, deflateSupported>::
|
||||
stream(Args&&... args)
|
||||
: stream_(std::forward<Args>(args)...)
|
||||
, tok_(1)
|
||||
{
|
||||
BOOST_ASSERT(rd_buf_.max_size() >=
|
||||
max_control_frame_size);
|
||||
@@ -125,6 +124,9 @@ open(role_type role)
|
||||
rd_fh_.fin = false;
|
||||
rd_close_ = false;
|
||||
wr_close_ = false;
|
||||
// These should not be necessary, because all completion
|
||||
// handlers must be allowed to execute otherwise the
|
||||
// stream exhibits undefined behavior.
|
||||
wr_block_.reset();
|
||||
rd_block_.reset();
|
||||
cr_.code = close_code::none;
|
||||
@@ -196,6 +198,9 @@ reset()
|
||||
rd_close_ = false;
|
||||
wr_close_ = false;
|
||||
wr_cont_ = false;
|
||||
// These should not be necessary, because all completion
|
||||
// handlers must be allowed to execute otherwise the
|
||||
// stream exhibits undefined behavior.
|
||||
wr_block_.reset();
|
||||
rd_block_.reset();
|
||||
cr_.code = close_code::none;
|
||||
|
||||
@@ -146,7 +146,6 @@ class stream<NextLayer, deflateSupported>::write_some_op
|
||||
std::size_t bytes_transferred_ = 0;
|
||||
std::size_t remain_;
|
||||
std::size_t in_;
|
||||
token tok_;
|
||||
int how_;
|
||||
bool fin_;
|
||||
bool more_;
|
||||
@@ -165,7 +164,6 @@ public:
|
||||
: h_(std::forward<DeducedHandler>(h))
|
||||
, ws_(ws)
|
||||
, cb_(bs)
|
||||
, tok_(ws_.tok_.unique())
|
||||
, fin_(fin)
|
||||
{
|
||||
}
|
||||
@@ -293,11 +291,8 @@ operator()(
|
||||
}
|
||||
|
||||
// Maybe suspend
|
||||
if(! ws_.wr_block_)
|
||||
if(ws_.wr_block_.try_lock(this))
|
||||
{
|
||||
// Acquire the write block
|
||||
ws_.wr_block_ = tok_;
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! ws_.check_open(ec))
|
||||
goto upcall;
|
||||
@@ -306,19 +301,17 @@ operator()(
|
||||
{
|
||||
do_suspend:
|
||||
// Suspend
|
||||
BOOST_ASSERT(ws_.wr_block_ != tok_);
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
ws_.paused_wr_.emplace(std::move(*this));
|
||||
|
||||
// Acquire the write block
|
||||
BOOST_ASSERT(! ws_.wr_block_);
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
|
||||
// Resume
|
||||
BOOST_ASIO_CORO_YIELD
|
||||
boost::asio::post(
|
||||
ws_.get_executor(), std::move(*this));
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked(this));
|
||||
|
||||
// Make sure the stream is open
|
||||
if(! ws_.check_open(ec))
|
||||
@@ -377,15 +370,15 @@ operator()(
|
||||
fh_.op = detail::opcode::cont;
|
||||
// Allow outgoing control frames to
|
||||
// be sent in between message frames
|
||||
ws_.wr_block_.reset();
|
||||
ws_.wr_block_.unlock(this);
|
||||
if( ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_rd_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke())
|
||||
{
|
||||
BOOST_ASSERT(ws_.wr_block_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked());
|
||||
goto do_suspend;
|
||||
}
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
}
|
||||
goto upcall;
|
||||
}
|
||||
@@ -476,15 +469,15 @@ operator()(
|
||||
fh_.op = detail::opcode::cont;
|
||||
// Allow outgoing control frames to
|
||||
// be sent in between message frames:
|
||||
ws_.wr_block_.reset();
|
||||
ws_.wr_block_.unlock(this);
|
||||
if( ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_rd_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke())
|
||||
{
|
||||
BOOST_ASSERT(ws_.wr_block_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked());
|
||||
goto do_suspend;
|
||||
}
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
}
|
||||
goto upcall;
|
||||
}
|
||||
@@ -537,15 +530,15 @@ operator()(
|
||||
fh_.rsv1 = false;
|
||||
// Allow outgoing control frames to
|
||||
// be sent in between message frames:
|
||||
ws_.wr_block_.reset();
|
||||
ws_.wr_block_.unlock(this);
|
||||
if( ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_rd_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke())
|
||||
{
|
||||
BOOST_ASSERT(ws_.wr_block_);
|
||||
BOOST_ASSERT(ws_.wr_block_.is_locked());
|
||||
goto do_suspend;
|
||||
}
|
||||
ws_.wr_block_ = tok_;
|
||||
ws_.wr_block_.lock(this);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -559,8 +552,7 @@ operator()(
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
upcall:
|
||||
BOOST_ASSERT(ws_.wr_block_ == tok_);
|
||||
ws_.wr_block_.reset();
|
||||
ws_.wr_block_.unlock(this);
|
||||
ws_.paused_close_.maybe_invoke() ||
|
||||
ws_.paused_rd_.maybe_invoke() ||
|
||||
ws_.paused_ping_.maybe_invoke();
|
||||
|
||||
Reference in new issue
Block a user