Refactor WebSocket errors (API Change):

fix #949

* New error codes are introduced for WebSocket failures

* More verbose messages for error codes

* Error codes are mapped to conditions for ease of testing

* error::failed and error::handshake_failed are deprecated (don't use)

Actions Required:

* Code which explicitly compares error_code values against the
  constant `websocket::error::handshake_failed` should compare
  against `websocket::condition::handshake_failed` instead.

* Code which explicitly compares error_code values against the
  constant `websocket::error::failed` should compare
  against `websocket::condition::protocol_violation` instead.
This commit is contained in:
Vinnie Falco committed 2018-01-12 07:35:26 -08:00
1 parent 08a9ed4c25
commit cc43b46c42
19 files changed
+705 -346

No files matched your search

@@ -42,6 +42,7 @@ class stream<NextLayer, deflateSupported>::response_op
struct data
{
stream<NextLayer, deflateSupported>& ws;
error_code result;
response_type res;
template<class Body, class Allocator, class Decorator>
@@ -52,7 +53,7 @@ class stream<NextLayer, deflateSupported>::response_op
http::basic_fields<Allocator>> const& req,
Decorator const& decorator)
: ws(ws_)
, res(ws_.build_response(req, decorator))
, res(ws_.build_response(req, decorator, result))
{
}
};
@@ -120,9 +121,8 @@ operator()(
BOOST_ASIO_CORO_YIELD
http::async_write(d.ws.next_layer(),
d.res, std::move(*this));
if(! ec && d.res.result() !=
http::status::switching_protocols)
ec = error::handshake_failed;
if(! ec)
ec = d.result;
if(! ec)
{
d.ws.do_pmd_config(d.res, is_deflate_supported{});
@@ -742,13 +742,14 @@ do_accept(
Decorator const& decorator,
error_code& ec)
{
auto const res = build_response(req, decorator);
error_code result;
auto const res = build_response(req, decorator, result);
http::write(stream_, res, ec);
if(ec)
return;
if(res.result() != http::status::switching_protocols)
ec = result;
if(ec)
{
ec = error::handshake_failed;
// VFALCO TODO Respect keep alive setting, perform
// teardown if Connection: close.
return;
+14 -22
View File
@@ -121,7 +121,6 @@ operator()(
{
using beast::detail::clamp;
auto& d = *d_;
close_code code{};
d.cont = cont;
BOOST_ASIO_CORO_REENTER(*this)
{
@@ -219,13 +218,10 @@ operator()(
{
// Read frame header
while(! d.ws.parse_fh(
d.ws.rd_fh_, d.ws.rd_buf_, code))
d.ws.rd_fh_, d.ws.rd_buf_, d.ev))
{
if(code != close_code::none)
{
d.ev = error::failed;
if(d.ev)
goto teardown;
}
BOOST_ASIO_CORO_YIELD
d.ws.stream_.async_read_some(
d.ws.rd_buf_.prepare(read_size(d.ws.rd_buf_,
@@ -247,13 +243,9 @@ operator()(
d.ws.rd_buf_.data());
if(d.ws.rd_fh_.len > 0 && d.ws.rd_fh_.mask)
detail::mask_inplace(mb, d.ws.rd_key_);
detail::read_close(d.ws.cr_, mb, code);
if(code != close_code::none)
{
// Protocol error
d.ev = error::failed;
detail::read_close(d.ws.cr_, mb, d.ev);
if(d.ev)
goto teardown;
}
d.ws.rd_buf_.consume(clamp(d.ws.rd_fh_.len));
goto teardown;
}
@@ -364,18 +356,18 @@ close(close_reason const& cr, error_code& ec)
if(! check_ok(ec))
return;
status_ = status::closing;
error_code result;
// Drain the connection
close_code code{};
if(rd_remain_ > 0)
goto read_payload;
for(;;)
{
// Read frame header
while(! parse_fh(rd_fh_, rd_buf_, code))
while(! parse_fh(rd_fh_, rd_buf_, result))
{
if(code != close_code::none)
return do_fail(close_code::none,
error::failed, ec);
if(result)
return do_fail(
close_code::none, result, ec);
auto const bytes_transferred =
stream_.read_some(
rd_buf_.prepare(read_size(rd_buf_,
@@ -396,12 +388,12 @@ close(close_reason const& cr, error_code& ec)
rd_buf_.data());
if(rd_fh_.len > 0 && rd_fh_.mask)
detail::mask_inplace(mb, rd_key_);
detail::read_close(cr_, mb, code);
if(code != close_code::none)
detail::read_close(cr_, mb, result);
if(result)
{
// Protocol error
return do_fail(close_code::none,
error::failed, ec);
// Protocol violation
return do_fail(
close_code::none, result, ec);
}
rd_buf_.consume(clamp(rd_fh_.len));
break;
+121 -34
View File
@@ -15,59 +15,146 @@ namespace beast {
namespace websocket {
namespace detail {
template<class>
string_view
inline
const char*
error_codes::
message(error e) const
name() const noexcept
{
switch(e)
return "boost.beast.websocket";
}
inline
std::string
error_codes::
message(int ev) const
{
switch(static_cast<error>(ev))
{
default:
case error::failed: return "WebSocket connection failed due to a protocol violation";
case error::closed: return "WebSocket connection closed normally";
case error::handshake_failed: return "WebSocket upgrade handshake failed";
case error::buffer_overflow: return "WebSocket dynamic buffer overflow";
case error::partial_deflate_block: return "WebSocket partial deflate block";
case error::closed: return "The WebSocket stream was gracefully closed at both endpoints";
case error::buffer_overflow: return "The WebSocket operation caused a dynamic buffer overflow";
case error::partial_deflate_block: return "The WebSocket stream produced an incomplete deflate block";
case error::message_too_big: return "The WebSocket message exceeded the locally configured limit";
case error::bad_http_version: return "The WebSocket handshake was not HTTP/1.1";
case error::bad_method: return "The WebSocket handshake method was not GET";
case error::no_host: return "The WebSocket handshake Host field is missing";
case error::no_connection: return "The WebSocket handshake Connection field is missing";
case error::no_connection_upgrade: return "The WebSocket handshake Connection field is missing the upgrade token";
case error::no_upgrade: return "The WebSocket handshake Upgrade field is missing";
case error::no_upgrade_websocket: return "The WebSocket handshake Upgrade field is missing the websocket token";
case error::no_sec_key: return "The WebSocket handshake Sec-WebSocket-Key field is missing";
case error::bad_sec_key: return "The WebSocket handshake Sec-WebSocket-Key field is invalid";
case error::no_sec_version: return "The WebSocket handshake Sec-WebSocket-Version field is missing";
case error::bad_sec_version: return "The WebSocket handshake Sec-WebSocket-Version field is invalid";
case error::no_sec_accept: return "The WebSocket handshake Sec-WebSocket-Accept field is missing";
case error::bad_sec_accept: return "The WebSocket handshake Sec-WebSocket-Accept field is invalid";
case error::upgrade_declined: return "The WebSocket handshake was declined by the remote peer";
case error::bad_opcode: return "The WebSocket frame contained an illegal opcode";
case error::bad_data_frame: return "The WebSocket data frame was unexpected";
case error::bad_continuation: return "The WebSocket continuation frame was unexpected";
case error::bad_reserved_bits: return "The WebSocket frame contained illegal reserved bits";
case error::bad_control_fragment: return "The WebSocket control frame was fragmented";
case error::bad_control_size: return "The WebSocket control frame size was invalid";
case error::bad_unmasked_frame: return "The WebSocket frame was unmasked";
case error::bad_masked_frame: return "The WebSocket frame was masked";
case error::bad_size: return "The WebSocket frame size was not canonical";
case error::bad_frame_payload: return "The WebSocket frame payload was not valid utf8";
case error::bad_close_code: return "The WebSocket close frame reason code was invalid";
case error::bad_close_size: return "The WebSocket close frame payload size was invalid";
case error::bad_close_payload: return "The WebSocket close frame payload was not valid utf8";
}
}
template<class>
string_view
error_conditions::
message(condition c) const
inline
error_condition
error_codes::
default_error_condition(int ev) const noexcept
{
switch(c)
switch(static_cast<error>(ev))
{
default:
case condition::handshake_failed: return "WebSocket upgrade handshake failed";
case error::closed:
case error::buffer_overflow:
case error::partial_deflate_block:
case error::message_too_big:
return {ev, *this};
case error::bad_http_version:
case error::bad_method:
case error::no_host:
case error::no_connection:
case error::no_connection_upgrade:
case error::no_upgrade:
case error::no_upgrade_websocket:
case error::no_sec_key:
case error::bad_sec_key:
case error::no_sec_version:
case error::bad_sec_version:
case error::no_sec_accept:
case error::bad_sec_accept:
case error::upgrade_declined:
return condition::handshake_failed;
case error::bad_opcode:
case error::bad_data_frame:
case error::bad_continuation:
case error::bad_reserved_bits:
case error::bad_control_fragment:
case error::bad_control_size:
case error::bad_unmasked_frame:
case error::bad_masked_frame:
case error::bad_size:
case error::bad_frame_payload:
case error::bad_close_code:
case error::bad_close_size:
case error::bad_close_payload:
return condition::protocol_violation;
}
}
template<class>
bool
inline
const char*
error_conditions::
equivalent(
error_code const& ec,
condition c) const noexcept
name() const noexcept
{
if(ec.category() == error_code{error{}}.category())
{
switch(c)
{
case condition::handshake_failed:
switch(static_cast<error>(ec.value()))
{
case error::handshake_failed:
return true;
}
return false;
}
}
return false;
return "boost.beast.websocket";
}
inline
std::string
error_conditions::
message(int cv) const
{
switch(static_cast<condition>(cv))
{
default:
case condition::handshake_failed: return "The WebSocket handshake failed";
case condition::protocol_violation: return "A WebSocket protocol violation occurred";
}
}
} // detail
inline
error_code
make_error_code(error e)
{
static detail::error_codes const cat{};
return error_code{static_cast<
std::underlying_type<error>::type>(e), cat};
}
inline
error_condition
make_error_condition(condition c)
{
static detail::error_conditions const cat{};
return error_condition{static_cast<
std::underlying_type<condition>::type>(c), cat};
}
} // websocket
} // beast
} // boost
+34 -31
View File
@@ -84,7 +84,7 @@ class stream<NextLayer, deflateSupported>::read_some_op
MutableBufferSequence bs_;
buffers_suffix<MutableBufferSequence> cb_;
std::size_t bytes_written_ = 0;
error_code ev_;
error_code result_;
token tok_;
close_code code_;
bool did_read_ = false;
@@ -160,7 +160,6 @@ operator()(
using beast::detail::clamp;
using boost::asio::buffer;
using boost::asio::buffer_size;
close_code code{};
cont_ = cont;
BOOST_ASIO_CORO_REENTER(*this)
{
@@ -220,13 +219,15 @@ operator()(
{
// Read frame header
while(! ws_.parse_fh(
ws_.rd_fh_, ws_.rd_buf_, code))
ws_.rd_fh_, ws_.rd_buf_, result_))
{
if(code != close_code::none)
if(result_)
{
// _Fail the WebSocket Connection_
code_ = code;
ev_ = error::failed;
if(result_ == error::message_too_big)
code_ = close_code::too_big;
else
code_ = close_code::protocol_error;
goto close;
}
BOOST_ASSERT(ws_.rd_block_ == tok_);
@@ -370,7 +371,6 @@ operator()(
ws_.rd_fh_.len), ws_.rd_buf_.data());
auto const len = buffer_size(cb);
BOOST_ASSERT(len == ws_.rd_fh_.len);
code = close_code::none;
ping_data payload;
detail::read_ping(payload, cb);
ws_.rd_buf_.consume(len);
@@ -400,12 +400,11 @@ operator()(
BOOST_ASSERT(! ws_.rd_close_);
ws_.rd_close_ = true;
close_reason cr;
detail::read_close(cr, cb, code);
if(code != close_code::none)
detail::read_close(cr, cb, result_);
if(result_)
{
// _Fail the WebSocket Connection_
code_ = code;
ev_ = error::failed;
code_ = close_code::protocol_error;
goto close;
}
ws_.cr_ = cr;
@@ -419,14 +418,14 @@ operator()(
// _Close the WebSocket Connection_
BOOST_ASSERT(ws_.wr_close_);
code_ = close_code::none;
ev_ = error::closed;
result_ = error::closed;
goto close;
}
// _Start the WebSocket Closing Handshake_
code_ = cr.code == close_code::none ?
close_code::normal :
static_cast<close_code>(cr.code);
ev_ = error::closed;
result_ = error::closed;
goto close;
}
}
@@ -477,7 +476,7 @@ operator()(
{
// _Fail the WebSocket Connection_
code_ = close_code::bad_payload;
ev_ = error::failed;
result_ = error::bad_frame_payload;
goto close;
}
}
@@ -511,7 +510,7 @@ operator()(
{
// _Fail the WebSocket Connection_
code_ = close_code::bad_payload;
ev_ = error::failed;
result_ = error::bad_frame_payload;
goto close;
}
}
@@ -604,7 +603,7 @@ operator()(
{
// _Fail the WebSocket Connection_
code_ = close_code::too_big;
ev_ = error::failed;
result_ = error::message_too_big;
goto close;
}
cb_.consume(zs.total_out);
@@ -622,7 +621,7 @@ operator()(
{
// _Fail the WebSocket Connection_
code_ = close_code::bad_payload;
ev_ = error::failed;
result_ = error::bad_frame_payload;
goto close;
}
}
@@ -698,7 +697,7 @@ operator()(
ec.assign(0, ec.category());
}
if(! ec)
ec = ev_;
ec = result_;
if(ec && ec != error::closed)
ws_.status_ = status::failed;
else
@@ -1049,12 +1048,17 @@ loop:
if(rd_remain_ == 0 && (! rd_fh_.fin || rd_done_))
{
// Read frame header
while(! parse_fh(rd_fh_, rd_buf_, code))
error_code result;
while(! parse_fh(rd_fh_, rd_buf_, result))
{
if(code != close_code::none)
if(result)
{
// _Fail the WebSocket Connection_
do_fail(code, error::failed, ec);
if(result == error::message_too_big)
code = close_code::too_big;
else
code = close_code::protocol_error;
do_fail(code, result, ec);
return bytes_written;
}
auto const bytes_transferred =
@@ -1121,11 +1125,12 @@ loop:
BOOST_ASSERT(! rd_close_);
rd_close_ = true;
close_reason cr;
detail::read_close(cr, b, code);
if(code != close_code::none)
detail::read_close(cr, b, result);
if(result)
{
// _Fail the WebSocket Connection_
do_fail(code, error::failed, ec);
do_fail(close_code::protocol_error,
result, ec);
return bytes_written;
}
cr_ = cr;
@@ -1190,10 +1195,8 @@ loop:
! rd_utf8_.finish()))
{
// _Fail the WebSocket Connection_
do_fail(
close_code::bad_payload,
error::failed,
ec);
do_fail(close_code::bad_payload,
error::bad_frame_payload, ec);
return bytes_written;
}
}
@@ -1227,7 +1230,7 @@ loop:
{
// _Fail the WebSocket Connection_
do_fail(close_code::bad_payload,
error::failed, ec);
error::bad_frame_payload, ec);
return bytes_written;
}
}
@@ -1325,7 +1328,7 @@ loop:
rd_size_, zs.total_out, rd_msg_max_))
{
do_fail(close_code::too_big,
error::failed, ec);
error::message_too_big, ec);
return bytes_written;
}
cb.consume(zs.total_out);
@@ -1343,7 +1346,7 @@ loop:
{
// _Fail the WebSocket Connection_
do_fail(close_code::bad_payload,
error::failed, ec);
error::bad_frame_payload, ec);
return bytes_written;
}
}
@@ -26,9 +26,9 @@ is_upgrade(http::header<true,
return false;
if(req.method() != http::verb::get)
return false;
if(! http::token_list{req["Connection"]}.exists("upgrade"))
if(! http::token_list{req[http::field::connection]}.exists("upgrade"))
return false;
if(! http::token_list{req["Upgrade"]}.exists("websocket"))
if(! http::token_list{req[http::field::upgrade]}.exists("websocket"))
return false;
return true;
}
+121 -68
View File
@@ -332,20 +332,15 @@ stream<NextLayer, deflateSupported>::
parse_fh(
detail::frame_header& fh,
DynamicBuffer& b,
close_code& code)
error_code& ec)
{
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;
// need more bytes
ec.assign(0, ec.category());
return false;
}
buffers_suffix<typename
@@ -368,7 +363,8 @@ parse_fh(
need += 4;
if(buffer_size(cb) < need)
{
code = close_code::none;
// need more bytes
ec.assign(0, ec.category());
return false;
}
fh.op = static_cast<
@@ -385,13 +381,15 @@ parse_fh(
if(rd_cont_)
{
// new data frame when continuation expected
return err(close_code::protocol_error);
ec = error::bad_data_frame;
return false;
}
if(fh.rsv2 || fh.rsv3 ||
! this->rd_deflated(fh.rsv1))
{
// reserved bits not cleared
return err(close_code::protocol_error);
ec = error::bad_reserved_bits;
return false;
}
break;
@@ -399,12 +397,14 @@ parse_fh(
if(! rd_cont_)
{
// continuation without an active message
return err(close_code::protocol_error);
ec = error::bad_continuation;
return false;
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
ec = error::bad_reserved_bits;
return false;
}
break;
@@ -412,31 +412,41 @@ parse_fh(
if(detail::is_reserved(fh.op))
{
// reserved opcode
return err(close_code::protocol_error);
ec = error::bad_opcode;
return false;
}
if(! fh.fin)
{
// fragmented control message
return err(close_code::protocol_error);
ec = error::bad_control_fragment;
return false;
}
if(fh.len > 125)
{
// invalid length for control message
return err(close_code::protocol_error);
ec = error::bad_control_size;
return false;
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
ec = error::bad_reserved_bits;
return false;
}
break;
}
// unmasked frame from client
if(role_ == role_type::server && ! fh.mask)
return err(close_code::protocol_error);
// masked frame from server
{
// unmasked frame from client
ec = error::bad_unmasked_frame;
return false;
}
if(role_ == role_type::client && fh.mask)
return err(close_code::protocol_error);
{
// masked frame from server
ec = error::bad_masked_frame;
return false;
}
if(detail::is_control(fh.op) &&
buffer_size(cb) < need + fh.len)
{
@@ -452,9 +462,12 @@ parse_fh(
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);
{
// length not canonical
ec = error::bad_size;
return false;
}
break;
}
case 127:
@@ -463,9 +476,12 @@ parse_fh(
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);
{
// length not canonical
ec = error::bad_size;
return false;
}
break;
}
}
@@ -493,19 +509,27 @@ parse_fh(
{
if(rd_size_ > (std::numeric_limits<
std::uint64_t>::max)() - fh.len)
return err(close_code::too_big);
{
// message size exceeds configured limit
ec = error::message_too_big;
return false;
}
}
if(! this->rd_deflated())
{
if(rd_msg_max_ && beast::detail::sum_exceeds(
rd_size_, fh.len, rd_msg_max_))
return err(close_code::too_big);
{
// message size exceeds configured limit
ec = error::message_too_big;
return false;
}
}
rd_cont_ = ! fh.fin;
rd_remain_ = fh.len;
}
b.consume(b.size() - buffer_size(cb));
code = close_code::none;
ec.assign(0, ec.category());
return true;
}
@@ -652,7 +676,8 @@ stream<NextLayer, deflateSupported>::
build_response(
http::request<Body,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator)
Decorator const& decorator,
error_code& result)
{
auto const decorate =
[&decorator](response_type& res)
@@ -666,40 +691,58 @@ build_response(
}
};
auto err =
[&](std::string const& text)
[&](error e)
{
result = e;
response_type res;
res.version(req.version());
res.result(http::status::bad_request);
res.body() = text;
res.body() = result.message();
res.prepare_payload();
decorate(res);
return res;
};
if(req.version() < 11)
return err("HTTP version 1.1 required");
if(req.version() != 11)
return err(error::bad_http_version);
if(req.method() != http::verb::get)
return err("Wrong method");
if(! is_upgrade(req))
return err("Expected Upgrade request");
return err(error::bad_method);
if(! req.count(http::field::host))
return err("Missing Host");
if(! req.count(http::field::sec_websocket_key))
return err("Missing Sec-WebSocket-Key");
auto const key = req[http::field::sec_websocket_key];
if(key.size() > detail::sec_ws_key_type::max_size_n)
return err("Invalid Sec-WebSocket-Key");
return err(error::no_host);
{
auto const version =
req[http::field::sec_websocket_version];
if(version.empty())
return err("Missing Sec-WebSocket-Version");
if(version != "13")
auto const it = req.find(http::field::connection);
if(it == req.end())
return err(error::no_connection);
if(! http::token_list{it->value()}.exists("upgrade"))
return err(error::no_connection_upgrade);
}
{
auto const it = req.find(http::field::upgrade);
if(it == req.end())
return err(error::no_upgrade);
if(! http::token_list{it->value()}.exists("websocket"))
return err(error::no_upgrade_websocket);
}
string_view key;
{
auto const it = req.find(http::field::sec_websocket_key);
if(it == req.end())
return err(error::no_sec_key);
key = it->value();
if(key.size() > detail::sec_ws_key_type::max_size_n)
return err(error::bad_sec_key);
}
{
auto const it = req.find(http::field::sec_websocket_version);
if(it == req.end())
return err(error::no_sec_version);
if(it->value() != "13")
{
response_type res;
res.result(http::status::upgrade_required);
res.version(req.version());
res.set(http::field::sec_websocket_version, "13");
result = error::bad_sec_version;
res.body() = result.message();
res.prepare_payload();
decorate(res);
return res;
@@ -707,7 +750,6 @@ build_response(
}
response_type res;
build_response_pmd(res, req, is_deflate_supported{});
res.result(http::status::switching_protocols);
res.version(req.version());
res.set(http::field::upgrade, "websocket");
@@ -717,7 +759,9 @@ build_response(
detail::make_sec_ws_accept(acc, key);
res.set(http::field::sec_websocket_accept, acc);
}
build_response_pmd(res, req, is_deflate_supported{});
decorate(res);
result = {};
return res;
}
@@ -747,30 +791,39 @@ on_response(
detail::sec_ws_key_type const& key,
error_code& ec)
{
bool const success = [&]()
auto const err =
[&](error e)
{
ec = e;
};
if(res.result() != http::status::switching_protocols)
return err(error::upgrade_declined);
if(res.version() != 11)
return err(error::bad_http_version);
{
if(res.version() < 11)
return false;
if(res.result() != http::status::switching_protocols)
return false;
if(! http::token_list{res[http::field::connection]}.exists("upgrade"))
return false;
if(! http::token_list{res[http::field::upgrade]}.exists("websocket"))
return false;
if(res.count(http::field::sec_websocket_accept) != 1)
return false;
auto const it = res.find(http::field::connection);
if(it == res.end())
return err(error::no_connection);
if(! http::token_list{it->value()}.exists("upgrade"))
return err(error::no_connection_upgrade);
}
{
auto const it = res.find(http::field::upgrade);
if(it == res.end())
return err(error::no_upgrade);
if(! http::token_list{it->value()}.exists("websocket"))
return err(error::no_upgrade_websocket);
}
{
auto const it = res.find(http::field::sec_websocket_accept);
if(it == res.end())
return err(error::no_sec_accept);
detail::sec_ws_accept_type acc;
detail::make_sec_ws_accept(acc, key);
if(acc.compare(
res[http::field::sec_websocket_accept]) != 0)
return false;
return true;
}();
if(! success)
{
ec = error::handshake_failed;
return;
if(acc.compare(it->value()) != 0)
return err(error::bad_sec_accept);
}
ec.assign(0, ec.category());
on_response_pmd(res, is_deflate_supported{});
open(role_type::client);