forked from boostorg/beast
Add multi_port to server-framework
This commit is contained in:
1 parent
f6e0e5ef47
commit
a4a4121444
22 files changed
+937
-301
No files matched your search
@@ -0,0 +1,398 @@
|
||||
//
|
||||
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef BEAST_EXAMPLE_SERVER_MULTI_PORT_HPP
|
||||
#define BEAST_EXAMPLE_SERVER_MULTI_PORT_HPP
|
||||
|
||||
#include "detect_ssl.hpp"
|
||||
#include "ws_async_port.hpp"
|
||||
#include "http_async_port.hpp"
|
||||
#include "https_ports.hpp"
|
||||
#include "wss_ports.hpp"
|
||||
|
||||
#include <beast/core.hpp>
|
||||
|
||||
#include <boost/function.hpp>
|
||||
|
||||
namespace framework {
|
||||
|
||||
// A connection that detects an opening SSL handshake
|
||||
//
|
||||
// If the SSL handshake is detected, then an HTTPS connection object
|
||||
// is move constructed from this object. Otherwise, this object continues
|
||||
// as a normal unencrypted HTTP connection. If the underlying port has
|
||||
// the ws_upgrade_service configured, the connection may be optionally
|
||||
// be upgraded to WebSocket by the client.
|
||||
//
|
||||
template<class... Services>
|
||||
class multi_con
|
||||
|
||||
// Give this object the enable_shared_from_this, and have
|
||||
// the base class call impl().shared_from_this(). The reason
|
||||
// is so that the shared_ptr has the correct type. This lets
|
||||
// the derived class (this class) use its members in calls to
|
||||
// `std::bind`, without an ugly call to `dynamic_downcast` or
|
||||
// other nonsense.
|
||||
//
|
||||
: public std::enable_shared_from_this<multi_con<Services...>>
|
||||
|
||||
// The stream should be created before the base class so
|
||||
// use the "base from member" idiom.
|
||||
//
|
||||
, public base_from_member<socket_type>
|
||||
|
||||
// Constructs last, destroys first
|
||||
//
|
||||
, public async_http_con_base<multi_con<Services...>, Services...>
|
||||
{
|
||||
// Context to use if we get an SSL handshake
|
||||
boost::asio::ssl::context& ctx_;
|
||||
|
||||
// Holds the data we read during ssl detection
|
||||
beast::static_buffer_n<6> buffer_;
|
||||
|
||||
public:
|
||||
// Constructor
|
||||
//
|
||||
// Additional arguments are simply forwarded to the base class
|
||||
//
|
||||
template<class... Args>
|
||||
multi_con(
|
||||
socket_type&& sock,
|
||||
boost::asio::ssl::context& ctx,
|
||||
Args&&... args)
|
||||
: base_from_member<socket_type>(std::move(sock))
|
||||
, async_http_con_base<multi_con<Services...>, Services...>(std::forward<Args>(args)...)
|
||||
, ctx_(ctx)
|
||||
{
|
||||
}
|
||||
|
||||
// Returns the stream.
|
||||
//
|
||||
// The base class calls this to obtain the object to use for
|
||||
// reading and writing HTTP messages. This allows the same base
|
||||
// class to work with different return types for `stream()` such
|
||||
// as a `boost::asio::ip::tcp::socket&` or a `boost::asio::ssl::stream&`
|
||||
//
|
||||
socket_type&
|
||||
stream()
|
||||
{
|
||||
return this->member;
|
||||
}
|
||||
|
||||
// Called by the port to launch the connection in detect mode
|
||||
void
|
||||
detect()
|
||||
{
|
||||
// The detect function operates asynchronously by reading
|
||||
// in some data from the stream to figure out if its an SSL
|
||||
// handshake. When it completes, it informs us of the result
|
||||
// and also stores the bytes it read in the buffer.
|
||||
//
|
||||
async_detect_ssl(
|
||||
stream(),
|
||||
buffer_,
|
||||
this->strand_.wrap(
|
||||
std::bind(
|
||||
&multi_con::on_detect,
|
||||
this->shared_from_this(),
|
||||
std::placeholders::_1,
|
||||
std::placeholders::_2)));
|
||||
}
|
||||
|
||||
private:
|
||||
// Base class needs to be a friend to call our private members
|
||||
friend class async_http_con_base<multi_con<Services...>, Services...>;
|
||||
|
||||
// Called when the handshake detection is complete
|
||||
//
|
||||
void
|
||||
on_detect(
|
||||
error_code ec,
|
||||
boost::tribool result)
|
||||
{
|
||||
// Report failures if any
|
||||
if(ec)
|
||||
return this->fail("on_detect", ec);
|
||||
|
||||
// Was an SSL handshake detected?
|
||||
if(result)
|
||||
{
|
||||
// Yes, get the remote endpoint since it is
|
||||
// needed to construct the new connection.
|
||||
//
|
||||
endpoint_type ep = stream().remote_endpoint(ec);
|
||||
if(ec)
|
||||
return this->fail("remote_endpoint", ec);
|
||||
|
||||
// Now launch our new connection object
|
||||
//
|
||||
std::make_shared<async_https_con<Services...>>(
|
||||
std::move(stream()),
|
||||
ctx_,
|
||||
"multi_port",
|
||||
this->log_,
|
||||
this->services_,
|
||||
this->id_,
|
||||
ep
|
||||
)->handshake(buffer_.data());
|
||||
|
||||
// When we return the last shared pointer to this
|
||||
// object will go away and `*this` will be destroyed.
|
||||
//
|
||||
return;
|
||||
}
|
||||
|
||||
// No SSL handshake, so start the HTTP connection normally.
|
||||
//
|
||||
// Since we read some bytes from the connection that might
|
||||
// contain an HTTP request, we pass the buffer holding those
|
||||
// bytes to the base class so it can use them.
|
||||
//
|
||||
this->run(buffer_.data());
|
||||
}
|
||||
|
||||
// This is called by the base before running the main loop.
|
||||
//
|
||||
void
|
||||
do_handshake()
|
||||
{
|
||||
// Just run the main loop right away.
|
||||
//
|
||||
this->do_run();
|
||||
}
|
||||
|
||||
// This is called when the other end closes the connection gracefully.
|
||||
//
|
||||
void
|
||||
do_shutdown()
|
||||
{
|
||||
// Attempt a clean TCP/IP shutdown
|
||||
//
|
||||
error_code ec;
|
||||
stream().shutdown(
|
||||
socket_type::shutdown_both,
|
||||
ec);
|
||||
|
||||
// Report failure if any
|
||||
//
|
||||
if(ec)
|
||||
return this->fail("shutdown", ec);
|
||||
}
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/* An asynchronous HTTP and WebSocket port handler, plain or SSL
|
||||
|
||||
This type meets the requirements of @b PortHandler. It supports a
|
||||
variable list of HTTP services in its template parameter list,
|
||||
and provides a synchronous connection implementation to service.
|
||||
|
||||
The port will automatically detect OpenSSL handshakes and establish
|
||||
encrypted connections, otherwise will use a plain unencrypted
|
||||
connection. This all happens through the same port.
|
||||
|
||||
In addition this port can process WebSocket upgrade requests by
|
||||
launching them as a new asynchronous WebSocket connection using
|
||||
either plain or OpenSSL transport.
|
||||
|
||||
This class is split up into two parts, the multi_port_base,
|
||||
and the multi_port, to avoid a recursive type reference when
|
||||
we name the type of the ws_upgrade_service.
|
||||
*/
|
||||
class multi_port_base
|
||||
{
|
||||
protected:
|
||||
// VFALCO We use boost::function to work around a compiler
|
||||
// crash with gcc and clang using libstdc++
|
||||
|
||||
// The types of the on_stream callback
|
||||
using on_new_stream_cb1 = boost::function<void(beast::websocket::stream<socket_type>&)>;
|
||||
using on_new_stream_cb2 = boost::function<void(beast::websocket::stream<ssl_stream<socket_type>>&)>;
|
||||
|
||||
// Reference to the server instance that made us
|
||||
server& instance_;
|
||||
|
||||
// The stream to log to
|
||||
std::ostream& log_;
|
||||
|
||||
// The context holds the SSL certificates the server uses
|
||||
boost::asio::ssl::context& ctx_;
|
||||
|
||||
// Called for each new websocket stream
|
||||
on_new_stream_cb1 cb1_;
|
||||
on_new_stream_cb2 cb2_;
|
||||
|
||||
public:
|
||||
/** Constructor
|
||||
|
||||
@param instance The server instance which owns this port
|
||||
|
||||
@param log The stream to use for logging
|
||||
|
||||
@param ctx The SSL context holding the SSL certificates to use
|
||||
|
||||
@param cb A callback which will be invoked for every new
|
||||
WebSocket connection. This provides an opportunity to change
|
||||
the settings on the stream before it is used. The callback
|
||||
should have this equivalent signature:
|
||||
@code
|
||||
template<class NextLayer>
|
||||
void callback(beast::websocket::stream<NextLayer>&);
|
||||
@endcode
|
||||
In C++14 this can be accomplished with a generic lambda. In
|
||||
C++11 it will be necessary to write out a lambda manually,
|
||||
with a templated operator().
|
||||
*/
|
||||
template<class Callback>
|
||||
multi_port_base(
|
||||
server& instance,
|
||||
std::ostream& log,
|
||||
boost::asio::ssl::context& ctx,
|
||||
Callback const& cb)
|
||||
: instance_(instance)
|
||||
, log_(log)
|
||||
, ctx_(ctx)
|
||||
, cb1_(cb)
|
||||
, cb2_(cb)
|
||||
{
|
||||
}
|
||||
|
||||
/** Accept a WebSocket upgrade request.
|
||||
|
||||
This is used to accept a connection that has already
|
||||
delivered the handshake.
|
||||
|
||||
@param stream The stream corresponding to the connection.
|
||||
|
||||
@param ep The remote endpoint.
|
||||
|
||||
@param req The upgrade request.
|
||||
*/
|
||||
template<class Body, class Fields>
|
||||
void
|
||||
on_upgrade(
|
||||
socket_type&& sock,
|
||||
endpoint_type ep,
|
||||
beast::http::request<Body, Fields>&& req)
|
||||
{
|
||||
// Create the connection and call the version of
|
||||
// run that takes the request since we have it already
|
||||
//
|
||||
std::make_shared<async_ws_con>(
|
||||
std::move(sock),
|
||||
"multi_port",
|
||||
log_,
|
||||
instance_.next_id(),
|
||||
ep,
|
||||
cb1_
|
||||
)->run(std::move(req));
|
||||
}
|
||||
|
||||
/** Accept a WebSocket upgrade request.
|
||||
|
||||
This is used to accept a connection that has already
|
||||
delivered the handshake.
|
||||
|
||||
@param stream The stream corresponding to the connection.
|
||||
|
||||
@param ep The remote endpoint.
|
||||
|
||||
@param req The upgrade request.
|
||||
*/
|
||||
template<class Body, class Fields>
|
||||
void
|
||||
on_upgrade(
|
||||
ssl_stream<socket_type>&& stream,
|
||||
endpoint_type ep,
|
||||
beast::http::request<Body, Fields>&& req)
|
||||
{
|
||||
std::make_shared<async_wss_con>(
|
||||
std::move(stream),
|
||||
"multi_port",
|
||||
log_,
|
||||
instance_.next_id(),
|
||||
ep,
|
||||
cb2_
|
||||
)->run(std::move(req));
|
||||
}
|
||||
};
|
||||
|
||||
/* An asynchronous HTTP and WebSocket port handler, plain or SSL
|
||||
|
||||
This class is the other half of multi_port_base. It gets the
|
||||
Services... variadic type list and owns the service list.
|
||||
*/
|
||||
template<class... Services>
|
||||
class multi_port : public multi_port_base
|
||||
{
|
||||
// The list of services connections created from this port will support
|
||||
service_list<Services...> services_;
|
||||
|
||||
public:
|
||||
/** Constructor
|
||||
|
||||
All arguments are forwarded to the multi_port_base constructor.
|
||||
*/
|
||||
template<class... Args>
|
||||
multi_port(Args&&... args)
|
||||
: multi_port_base(std::forward<Args>(args)...)
|
||||
{
|
||||
}
|
||||
|
||||
/** Initialize a service
|
||||
|
||||
Every service in the list must be initialized exactly once.
|
||||
|
||||
@param args Optional arguments forwarded to the service
|
||||
constructor.
|
||||
|
||||
@tparam Index The 0-based index of the service to initialize.
|
||||
|
||||
@return A reference to the service list. This permits
|
||||
calls to be chained in a single expression.
|
||||
*/
|
||||
template<std::size_t Index, class... Args>
|
||||
void
|
||||
init(error_code& ec, Args&&... args)
|
||||
{
|
||||
services_.template init<Index>(
|
||||
ec,
|
||||
std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
/** Called by the server to provide ownership of the socket for a new connection
|
||||
|
||||
@param sock The socket whose ownership is to be transferred
|
||||
|
||||
@ep The remote endpoint
|
||||
*/
|
||||
void
|
||||
on_accept(
|
||||
socket_type&& sock,
|
||||
endpoint_type ep)
|
||||
{
|
||||
// Create a plain http connection object by transferring
|
||||
// ownership of the socket, then launch it to perform
|
||||
// the SSL handshake detection.
|
||||
//
|
||||
std::make_shared<multi_con<Services...>>(
|
||||
std::move(sock),
|
||||
ctx_,
|
||||
"multi_port",
|
||||
log_,
|
||||
services_,
|
||||
instance_.next_id(),
|
||||
ep
|
||||
)->detect();
|
||||
}
|
||||
};
|
||||
|
||||
} // framework
|
||||
|
||||
#endif
|
||||
Reference in new issue
Block a user