feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
9f468ec1c15cb67405ddcce8e38d61c0cc961c4b
boost_beast/include/boost/beast/websocket/impl/accept.hpp

860 lines
25 KiB
C++
Raw Normal View History

Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
//
Check BOOST_NO_CXX11_THREAD_LOCAL
2019-02-21 07:00:31 -08:00
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
//
// 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)
//
Boost prep
2017-07-20 13:40:34 -07:00
// Official repository: https://github.com/boostorg/beast
//
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_WEBSOCKET_IMPL_ACCEPT_IPP
#define BOOST_BEAST_WEBSOCKET_IMPL_ACCEPT_IPP
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
#include <boost/beast/websocket/impl/stream_impl.hpp>
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/websocket/detail/type_traits.hpp>
#include <boost/beast/http/empty_body.hpp>
#include <boost/beast/http/parser.hpp>
#include <boost/beast/http/read.hpp>
#include <boost/beast/http/string_body.hpp>
#include <boost/beast/http/write.hpp>
Rename to async_base, stable_async_base
2019-02-25 09:31:51 -08:00
#include <boost/beast/core/async_base.hpp>
buffer_size is in buffer_traits.hpp
2019-03-05 08:25:54 -08:00
#include <boost/beast/core/buffer_traits.hpp>
Add executor_type trait
2019-02-04 21:52:54 -08:00
#include <boost/beast/core/stream_traits.hpp>
Partial support for BOOST_NO_EXCEPTIONS: Some stream operations are modified to use a helper function which supports BOOST_NO_EXCEPTIONS.
2018-10-30 17:30:48 -07:00
#include <boost/beast/core/detail/buffer.hpp>
websocket test coverage
2019-02-17 05:23:40 -08:00
#include <boost/beast/version.hpp>
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
#include <boost/asio/coroutine.hpp>
Update for Net-TS Asio (API Change): fix #769 The following classes are removed: * handler_type * async_result * async_completion * is_dynamic_buffer * is_const_buffer_sequence * is_mutable_buffer_sequence * handler_alloc Actions Required: * Use BOOST_ASIO_HANDLER_TYPE instead of handler_type * Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result * Use boost::asio::async_completion * Use boost::asio::is_dynamic_buffer * Use boost::asio::is_const_buffer_sequence * Use boost::asio::is_mutable_buffer_sequence * boost::asio::associated_allocator_t replaces handler_alloc
2017-09-07 07:39:52 -07:00
#include <boost/asio/post.hpp>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
#include <boost/assert.hpp>
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
#include <boost/throw_exception.hpp>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
#include <memory>
#include <type_traits>
Boost prep
2017-07-20 13:40:34 -07:00
namespace boost {
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
namespace beast {
namespace websocket {
websocket test coverage
2019-02-17 05:23:40 -08:00
//------------------------------------------------------------------------------
namespace detail {
template<class Body, class Allocator>
void
impl_base<true>::
build_response_pmd(
http::response<http::string_body>& res,
http::request<Body,
http::basic_fields<Allocator>> const& req)
{
pmd_offer offer;
pmd_offer unused;
pmd_read(offer, req);
pmd_negotiate(res, unused, offer, pmd_opts_);
}
template<class Body, class Allocator>
void
impl_base<false>::
build_response_pmd(
http::response<http::string_body>&,
http::request<Body,
http::basic_fields<Allocator>> const&)
{
}
} // detail
template<class NextLayer, bool deflateSupported>
template<class Body, class Allocator, class Decorator>
response_type
stream<NextLayer, deflateSupported>::impl_type::
build_response(
http::request<Body,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator,
error_code& result)
{
auto const decorate =
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
[this, &decorator](response_type& res)
websocket test coverage
2019-02-17 05:23:40 -08:00
{
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
decorator_opt(res);
websocket test coverage
2019-02-17 05:23:40 -08:00
decorator(res);
if(! res.count(http::field::server))
Remove redundant use of `static_string` This avoids an instantiation and copy of the data when adding the Server header field. Close #1613 Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-05-19 17:37:08 +02:00
res.set(http::field::server,
string_view(BOOST_BEAST_VERSION_STRING));
websocket test coverage
2019-02-17 05:23:40 -08:00
};
auto err =
[&](error e)
{
result = e;
response_type res;
res.version(req.version());
res.result(http::status::bad_request);
res.body() = result.message();
res.prepare_payload();
decorate(res);
return res;
};
if(req.version() != 11)
return err(error::bad_http_version);
if(req.method() != http::verb::get)
return err(error::bad_method);
if(! req.count(http::field::host))
return err(error::no_host);
{
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;
}
}
response_type res;
res.result(http::status::switching_protocols);
res.version(req.version());
res.set(http::field::upgrade, "websocket");
res.set(http::field::connection, "upgrade");
{
detail::sec_ws_accept_type acc;
detail::make_sec_ws_accept(acc, key);
res.set(http::field::sec_websocket_accept, acc);
}
this->build_response_pmd(res, req);
decorate(res);
result = {};
return res;
}
//------------------------------------------------------------------------------
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
/** Respond to an HTTP request
*/
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
template<class Handler>
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
class stream<NextLayer, deflateSupported>::response_op
Rename to async_base, stable_async_base
2019-02-25 09:31:51 -08:00
: public beast::stable_async_base<
Add executor_type trait
2019-02-04 21:52:54 -08:00
Handler, beast::executor_type<stream>>
Replace uses of `net::coroutine` with `asio::coroutine` `asio::coroutine` is an extension, which is not part of the Networking TS, so the `net` alias is not appropriate in this case. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-06-16 23:47:44 +02:00
, public asio::coroutine
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
boost::weak_ptr<impl_type> wp_;
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
error_code result_; // must come before res_
response_type& res_;
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
public:
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
template<
class Handler_,
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
class Body, class Allocator,
class Decorator>
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
response_op(
Handler_&& h,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
boost::shared_ptr<impl_type> const& sp,
http::request<Body,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator,
bool cont = false)
Rename to async_base, stable_async_base
2019-02-25 09:31:51 -08:00
: stable_async_base<Handler,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
beast::executor_type<stream>>(
std::forward<Handler_>(h),
Next layer is a base class
2019-02-27 14:48:31 -08:00
sp->stream().get_executor())
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
, wp_(sp)
Fix completion handler invocation signatures Completion handlers should be called with the exact same signature as provided to `async_result`. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-07 10:40:48 +01:00
, res_(beast::allocate_stable<response_type>(*this,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
sp->build_response(req, decorator, result_)))
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
(*this)({}, 0, cont);
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
Update for Net-TS Asio (API Change): fix #769 The following classes are removed: * handler_type * async_result * async_completion * is_dynamic_buffer * is_const_buffer_sequence * is_mutable_buffer_sequence * handler_alloc Actions Required: * Use BOOST_ASIO_HANDLER_TYPE instead of handler_type * Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result * Use boost::asio::async_completion * Use boost::asio::is_dynamic_buffer * Use boost::asio::is_const_buffer_sequence * Use boost::asio::is_mutable_buffer_sequence * boost::asio::associated_allocator_t replaces handler_alloc
2017-09-07 07:39:52 -07:00
void operator()(
error_code ec = {},
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
std::size_t bytes_transferred = 0,
bool cont = true)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
boost::ignore_unused(bytes_transferred);
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto sp = wp_.lock();
if(! sp)
Fix completion handler invocation signatures Completion handlers should be called with the exact same signature as provided to `async_result`. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-07 10:40:48 +01:00
{
ec = net::error::operation_aborted;
return this->complete(cont, ec);
}
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto& impl = *sp;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
BOOST_ASIO_CORO_REENTER(*this)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
impl.change_status(status::handshake);
impl.update_timer(this->get_executor());
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
// Send response
BOOST_ASIO_CORO_YIELD
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
http::async_write(
Next layer is a base class
2019-02-27 14:48:31 -08:00
impl.stream(), res_, std::move(*this));
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
if(impl.check_stop_now(ec))
goto upcall;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
if(! ec)
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
ec = result_;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
if(! ec)
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
impl.do_pmd_config(res_);
impl.open(role_type::server);
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
}
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
upcall:
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
this->complete(cont, ec);
Use executor_work_guard in composed operations: fix #1076 As per Asio and Networking TS requirements, composed operations must maintain an object of type executor_work_guard for the executor associated with the I/O object, for the lifetime of the asynchronous operation. This is in addition to the requirement for maintaining an object of type executor_work_guard for the executor associated with the handler.
2018-04-09 16:22:15 -07:00
}
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
};
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
//------------------------------------------------------------------------------
// read and respond to an upgrade request
//
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Use async_initiate
2019-02-20 20:25:01 -08:00
template<class Handler, class Decorator>
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
class stream<NextLayer, deflateSupported>::accept_op
Rename to async_base, stable_async_base
2019-02-25 09:31:51 -08:00
: public beast::stable_async_base<
Add executor_type trait
2019-02-04 21:52:54 -08:00
Handler, beast::executor_type<stream>>
Replace uses of `net::coroutine` with `asio::coroutine` `asio::coroutine` is an extension, which is not part of the Networking TS, so the `net` alias is not appropriate in this case. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-06-16 23:47:44 +02:00
, public asio::coroutine
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
boost::weak_ptr<impl_type> wp_;
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
http::request_parser<http::empty_body>& p_;
Decorator d_;
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
public:
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
template<class Handler_, class Buffers>
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
accept_op(
Handler_&& h,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
boost::shared_ptr<impl_type> const& sp,
Use async_initiate
2019-02-20 20:25:01 -08:00
Decorator const& decorator,
Buffers const& buffers)
Rename to async_base, stable_async_base
2019-02-25 09:31:51 -08:00
: stable_async_base<Handler,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
beast::executor_type<stream>>(
std::forward<Handler_>(h),
Next layer is a base class
2019-02-27 14:48:31 -08:00
sp->stream().get_executor())
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
, wp_(sp)
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
, p_(beast::allocate_stable<
http::request_parser<http::empty_body>>(*this))
, d_(decorator)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto& impl = *sp;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
error_code ec;
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto const mb =
beast::detail::dynamic_buffer_prepare(
Rename to buffer_bytes
2019-03-05 08:47:02 -08:00
impl.rd_buf, buffer_bytes(buffers),
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
ec, error::buffer_overflow);
if(! ec)
impl.rd_buf.commit(
net::buffer_copy(*mb, buffers));
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
(*this)(ec);
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
Update for Net-TS Asio (API Change): fix #769 The following classes are removed: * handler_type * async_result * async_completion * is_dynamic_buffer * is_const_buffer_sequence * is_mutable_buffer_sequence * handler_alloc Actions Required: * Use BOOST_ASIO_HANDLER_TYPE instead of handler_type * Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result * Use boost::asio::async_completion * Use boost::asio::is_dynamic_buffer * Use boost::asio::is_const_buffer_sequence * Use boost::asio::is_mutable_buffer_sequence * boost::asio::associated_allocator_t replaces handler_alloc
2017-09-07 07:39:52 -07:00
void operator()(
error_code ec = {},
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
std::size_t bytes_transferred = 0,
bool cont = true)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
boost::ignore_unused(bytes_transferred);
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto sp = wp_.lock();
if(! sp)
Fix completion handler invocation signatures Completion handlers should be called with the exact same signature as provided to `async_result`. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-07 10:40:48 +01:00
{
ec = net::error::operation_aborted;
return this->complete(cont, ec);
}
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
auto& impl = *sp;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
BOOST_ASIO_CORO_REENTER(*this)
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
impl.change_status(status::handshake);
impl.update_timer(this->get_executor());
// The constructor could have set ec
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
if(ec)
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
goto upcall;
BOOST_ASIO_CORO_YIELD
Next layer is a base class
2019-02-27 14:48:31 -08:00
http::async_read(impl.stream(),
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
impl.rd_buf, p_, std::move(*this));
if(ec == http::error::end_of_stream)
ec = error::closed;
if(impl.check_stop_now(ec))
goto upcall;
Fix completion handler invocation signatures Completion handlers should be called with the exact same signature as provided to `async_result`. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-07 10:40:48 +01:00
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
{
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
// Arguments from our state must be
// moved to the stack before releasing
// the handler.
auto const req = p_.release();
auto const decorator = d_;
response_op<Handler>(
this->release_handler(),
sp, req, decorator, true);
return;
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
}
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
upcall:
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
this->complete(cont, ec);
Use executor_work_guard in composed operations: fix #1076 As per Asio and Networking TS requirements, composed operations must maintain an object of type executor_work_guard for the executor associated with the I/O object, for the lifetime of the asynchronous operation. This is in addition to the requirement for maintaining an object of type executor_work_guard for the executor associated with the handler.
2018-04-09 16:22:15 -07:00
}
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
}
Use async_op_base: Composed operation implementations use async_op_base and stable_async_op_base, to eliminate redundant boilerplate.
2019-01-05 19:40:46 -08:00
};
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
Use async_initiate
2019-02-20 20:25:01 -08:00
template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_response_op
{
template<
class AcceptHandler,
class Body, class Allocator,
class Decorator>
void
operator()(
AcceptHandler&& h,
boost::shared_ptr<impl_type> const& sp,
http::request<Body,
Pass references as pointers to async_initiate
2019-02-26 07:17:24 -08:00
http::basic_fields<Allocator>> const* m,
Use async_initiate
2019-02-20 20:25:01 -08:00
Decorator const& d)
{
// If you get an error on the following line it means
// that your handler does not meet the documented type
// requirements for the handler.
static_assert(
beast::detail::is_invocable<AcceptHandler,
void(error_code)>::value,
"AcceptHandler type requirements not met");
response_op<
typename std::decay<AcceptHandler>::type>(
Pass references as pointers to async_initiate
2019-02-26 07:17:24 -08:00
std::forward<AcceptHandler>(h), sp, *m, d);
Use async_initiate
2019-02-20 20:25:01 -08:00
}
};
template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_accept_op
{
template<
class AcceptHandler,
class Decorator,
class Buffers>
void
operator()(
AcceptHandler&& h,
boost::shared_ptr<impl_type> const& sp,
Decorator const& d,
Buffers const& b)
{
// If you get an error on the following line it means
// that your handler does not meet the documented type
// requirements for the handler.
static_assert(
beast::detail::is_invocable<AcceptHandler,
void(error_code)>::value,
"AcceptHandler type requirements not met");
accept_op<
typename std::decay<AcceptHandler>::type,
Decorator>(
std::forward<AcceptHandler>(h),
sp,
d,
b);
}
};
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
//------------------------------------------------------------------------------
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
template<class NextLayer, bool deflateSupported>
template<class Body, class Allocator,
class Decorator>
void
stream<NextLayer, deflateSupported>::
do_accept(
http::request<Body,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator,
error_code& ec)
{
impl_->change_status(status::handshake);
error_code result;
auto const res = impl_->build_response(req, decorator, result);
Next layer is a base class
2019-02-27 14:48:31 -08:00
http::write(impl_->stream(), res, ec);
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
if(ec)
return;
ec = result;
if(ec)
{
// VFALCO TODO Respect keep alive setting, perform
// teardown if Connection: close.
return;
}
impl_->do_pmd_config(res);
impl_->open(role_type::server);
}
template<class NextLayer, bool deflateSupported>
template<class Buffers, class Decorator>
void
stream<NextLayer, deflateSupported>::
do_accept(
Buffers const& buffers,
Decorator const& decorator,
error_code& ec)
{
impl_->reset();
auto const mb =
beast::detail::dynamic_buffer_prepare(
Rename to buffer_bytes
2019-03-05 08:47:02 -08:00
impl_->rd_buf, buffer_bytes(buffers), ec,
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
error::buffer_overflow);
if(ec)
return;
impl_->rd_buf.commit(net::buffer_copy(*mb, buffers));
http::request_parser<http::empty_body> p;
http::read(next_layer(), impl_->rd_buf, p, ec);
if(ec == http::error::end_of_stream)
ec = error::closed;
if(ec)
return;
do_accept(p.get(), decorator, ec);
}
//------------------------------------------------------------------------------
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
void
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
accept()
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
error_code ec;
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
accept(ec);
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
void
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
accept(error_code& ec)
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
do_accept(
net::const_buffer{},
&default_decorate_res, ec);
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
template<class ConstBufferSequence>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
accept(ConstBufferSequence const& buffers)
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
static_assert(net::is_const_buffer_sequence<
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
error_code ec;
accept(buffers, ec);
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
template<class ConstBufferSequence>
Refactor HTTP serialization (API Change): A new class `serializer` is introduced to permit incremental serialization of HTTP messages. Existing free functions are re-implemented in terms of this new class. * The BodyReader concept is refined to support a greater variety of strategies for providing buffers representing the body to the serialization algorithms. * Added buffer_body, a new model of Body which allows the caller to provide a series of owned buffers using their own serialization loop. * Added empty_body, a model of Body which is for serialization only, to represent HTTP messages with no content body. * Removed overloads of write and async_write which send only the HTTP header. * Removed public interfaces for performing low-level chunk encoding.
2017-05-08 12:41:45 -07:00
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
accept(
ConstBufferSequence const& buffers, error_code& ec)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
static_assert(net::is_const_buffer_sequence<
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
Add websocket::stream timeouts
2019-02-13 08:00:07 -08:00
do_accept(buffers, &default_decorate_res, ec);
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
}
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
accept requires a message
2017-07-14 13:00:09 -07:00
template<class Body, class Allocator>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
void
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
accept(
http::request<Body,
http::basic_fields<Allocator>> const& req)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
error_code ec;
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
accept(req, ec);
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
accept requires a message
2017-07-14 13:00:09 -07:00
template<class Body, class Allocator>
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
void
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
websocket accept refactoring (API Change): * stream overloads of accept which take both a message and a buffer sequence are removed. Actions Required: * Do not call websocket accept overloads which take both a message and a buffer sequence, as it is illegal per rfc6455.
2017-08-16 19:25:02 -07:00
accept(
http::request<Body,
http::basic_fields<Allocator>> const& req,
error_code& ec)
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
do_accept(req, &default_decorate_res, ec);
}
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
//------------------------------------------------------------------------------
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class AcceptHandler>
Doc tidy
2019-03-04 23:13:42 -08:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept(
AcceptHandler&& handler)
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
handler,
impl_,
&default_decorate_res,
net::const_buffer{});
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class ResponseDecorator,
class AcceptHandler>
Doc tidy
2019-03-04 23:13:42 -08:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept_ex(
ResponseDecorator const& decorator,
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
AcceptHandler&& handler)
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
static_assert(detail::is_response_decorator<
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
handler,
impl_,
decorator,
net::const_buffer{});
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class ConstBufferSequence,
class AcceptHandler>
Use automatically deduced return types for all async operations: C++14 or later is required to support completion tokens that use per-operation return type deduction. For C++11, a completion token's async_result specialisation must still provide the nested typedef `return_type`.
2019-10-31 05:10:22 -07:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept(
ConstBufferSequence const& buffers,
Use automatically deduced return types for all async operations: C++14 or later is required to support completion tokens that use per-operation return type deduction. For C++11, a completion token's async_result specialisation must still provide the nested typedef `return_type`.
2019-10-31 05:10:22 -07:00
AcceptHandler&& handler,
typename std::enable_if<
! http::detail::is_header<
ConstBufferSequence>::value>::type*
)
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
static_assert(net::is_const_buffer_sequence<
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
handler,
impl_,
&default_decorate_res,
buffers);
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class ConstBufferSequence,
class ResponseDecorator,
class AcceptHandler>
Use automatically deduced return types for all async operations: C++14 or later is required to support completion tokens that use per-operation return type deduction. For C++11, a completion token's async_result specialisation must still provide the nested typedef `return_type`.
2019-10-31 05:10:22 -07:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept_ex(
ConstBufferSequence const& buffers,
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
ResponseDecorator const& decorator,
Use automatically deduced return types for all async operations: C++14 or later is required to support completion tokens that use per-operation return type deduction. For C++11, a completion token's async_result specialisation must still provide the nested typedef `return_type`.
2019-10-31 05:10:22 -07:00
AcceptHandler&& handler,
typename std::enable_if<
! http::detail::is_header<
ConstBufferSequence>::value>::type*)
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
static_assert(net::is_const_buffer_sequence<
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
static_assert(detail::is_response_decorator<
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
handler,
impl_,
decorator,
buffers);
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class Body, class Allocator,
accept requires a message
2017-07-14 13:00:09 -07:00
class AcceptHandler>
Doc tidy
2019-03-04 23:13:42 -08:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept(
http::request<Body, http::basic_fields<Allocator>> const& req,
AcceptHandler&& handler)
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_response_op{},
handler,
impl_,
Pass references as pointers to async_initiate
2019-02-26 07:17:24 -08:00
&req,
Use async_initiate
2019-02-20 20:25:01 -08:00
&default_decorate_res);
Provide websocket::stream accept() overloads (API Change): This adds enough functions to the accept and async_accept overload set to cover all combinations of request, buffers, and error_code parameters. This also fixes a defect where providing a complete Upgrade request when there are additional unprocessed octets remaining in the callers stream buffer could not be furnished to the WebSocket implementation.
2017-04-25 10:12:43 -07:00
}
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
template<class NextLayer, bool deflateSupported>
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
template<
class Body, class Allocator,
class ResponseDecorator,
class AcceptHandler>
Doc tidy
2019-03-04 23:13:42 -08:00
BOOST_BEAST_ASYNC_RESULT1(AcceptHandler)
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
stream<NextLayer, deflateSupported>::
Refactor accept, handshake ops
2017-07-27 14:14:47 -07:00
async_accept_ex(
http::request<Body, http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator,
AcceptHandler&& handler)
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
{
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
static_assert(is_async_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"AsyncStream type requirements not met");
permessage-deflate is a compile-time feature (API Change): fix #849 This adds an additional `bool` template parameter to `websocket::stream`: * When deflateSupported is `true`, the stream will be capable of negotiating the permessage-deflate websocket extension per the configured run-time settings. * When deflateSupported is `false`, the stream will never negotiate the permessage-deflate websocket extension. Furthermore, all of the code necessary for implementing the permessage-deflate extension will be excluded from function instantiations. The resulting emitted object code should be smaller.
2017-11-18 16:52:18 -08:00
static_assert(detail::is_response_decorator<
Refactor websocket decorators (API Change): fix #80, #212, fix #303, fix #314, fix #317 websocket::stream now provides the following families of functions for performing handshakes: When operating in the server role: * stream::accept * stream::accept_ex * stream::async_accept * stream::async_accept_ex When operating in the client role: * stream::handshake * stream::handshake_ex * stream::async_handshake * stream::async_handshake_ex Member functions ending with "_ex" allow an additional RequestDecorator parameter (for the accept family of functions) or ResponseDecorator parameter (for the handshake family of functions). The decorator is called to optionally modify the contents of the HTTP request or HTTP response object generated by the implementation, before the message is sent. This permits callers to set the User-Agent or Server fields, add or modify HTTP fields related to subprotocols, or perform any required transformation of the HTTP message for application-specific needs. The handshake() family of functions now have an additional set of overloads accepting a parameter of type response_type&, allowing the caller to receive the HTTP Response to the Upgrade handshake. This permits inspection of the response to handle things like subprotocols, authentication, or other application-specific needs. The new implementation does not require any state to be stored in the stream object. Therefore, websocket::stream objects are now smaller in size. The overload of set_option for setting a decorator on the stream is removed. The only way to set decorators now is with a suitable overload of accept or handshake.
2017-04-25 09:35:22 -07:00
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
websocket stream uses shared_ptr<impl_type>
2019-01-19 07:24:00 -08:00
impl_->reset();
Use async_initiate
2019-02-20 20:25:01 -08:00
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_response_op{},
handler,
impl_,
Pass references as pointers to async_initiate
2019-02-26 07:17:24 -08:00
&req,
Use async_initiate
2019-02-20 20:25:01 -08:00
decorator);
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
}
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
//------------------------------------------------------------------------------
template<class NextLayer, bool deflateSupported>
template<class ResponseDecorator>
void
stream<NextLayer, deflateSupported>::
accept_ex(ResponseDecorator const& decorator)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(detail::is_response_decorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer, bool deflateSupported>
template<class ResponseDecorator>
void
stream<NextLayer, deflateSupported>::
accept_ex(ResponseDecorator const& decorator, error_code& ec)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(detail::is_response_decorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
do_accept(
net::const_buffer{},
decorator, ec);
}
template<class NextLayer, bool deflateSupported>
template<
class ConstBufferSequence,
class ResponseDecorator>
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer, deflateSupported>::
accept_ex(
ConstBufferSequence const& buffers,
ResponseDecorator const &decorator)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(detail::is_response_decorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(buffers, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer, bool deflateSupported>
template<
class ConstBufferSequence,
class ResponseDecorator>
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer, deflateSupported>::
accept_ex(
ConstBufferSequence const& buffers,
ResponseDecorator const& decorator,
error_code& ec)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"ConstBufferSequence type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
do_accept(buffers, decorator, ec);
}
template<class NextLayer, bool deflateSupported>
template<
class Body, class Allocator,
class ResponseDecorator>
void
stream<NextLayer, deflateSupported>::
accept_ex(
http::request<Body,
http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(detail::is_response_decorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(req, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer, bool deflateSupported>
template<
class Body, class Allocator,
class ResponseDecorator>
void
stream<NextLayer, deflateSupported>::
accept_ex(
http::request<Body,
http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator,
error_code& ec)
{
handler_ptr is deprecated (API Change): * `handler_ptr` is deprecated and should not be used. Actions Required: * Replace use of `handler_ptr` with `stable_async_base` and `allocate_stable`.
2019-03-06 08:09:35 -08:00
#ifndef BOOST_BEAST_ALLOW_DEPRECATED
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(sizeof(ResponseDecorator) == 0,
BOOST_BEAST_DEPRECATION_STRING);
#endif
static_assert(is_sync_stream<next_layer_type>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"SyncStream type requirements not met");
WebSocket Decorator is a socket option (API Change): This changes the interface used to apply a decorator to the HTTP request or response messages used to perform the WebSocket handshake as follows: * Add the `stream_base::decorator` option object * Add `stream::set_option` overload to set the decorator from the option * The decorator applies to all client and server handshakes performed on the stream after the option is set. * Overloads of the following functions which accept a Decorator are deprecated: - accept, accept_ex - handshake, handshake_ex - async_accept, async_accept_ex - async_handshake, async_handshake_ex Actions Required: * Code which passes decorator to any `websocket::stream` member function should call `stream::set_option` instead with a newly constructed `stream_base::decorator` object containing the decorator. Alternatively, the macro `BOOST_BEAST_ALLOW_DEPRECATED` may be defined to 1.
2019-02-17 16:03:09 -08:00
static_assert(detail::is_response_decorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
impl_->reset();
do_accept(req, decorator, ec);
}
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
} // websocket
} // beast
Boost prep
2017-07-20 13:40:34 -07:00
} // boost
Reorganize source files and definitions
2016-10-24 08:12:09 -04:00
#endif
Copy Permalink