--- /dev/null
+/*
+ * Copyright (c) 2015, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of the WebSocket++ Project nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef WEBSOCKETPP_TRANSPORT_ASIO_HPP
+#define WEBSOCKETPP_TRANSPORT_ASIO_HPP
+
+#include <websocketpp/transport/base/endpoint.hpp>
+#include <websocketpp/transport/asio/connection.hpp>
+#include <websocketpp/transport/asio/security/none.hpp>
+
+#include <websocketpp/uri.hpp>
+#include <websocketpp/logger/levels.hpp>
+
+#include <websocketpp/common/functional.hpp>
+
+#include <sstream>
+#include <string>
+
+namespace websocketpp {
+namespace transport {
+namespace asio {
+
+/// Asio based endpoint transport component
+/**
+ * transport::asio::endpoint implements an endpoint transport component using
+ * Asio.
+ */
+template <typename config>
+class endpoint : public config::socket_type {
+public:
+ /// Type of this endpoint transport component
+ typedef endpoint<config> type;
+
+ /// Type of the concurrency policy
+ typedef typename config::concurrency_type concurrency_type;
+ /// Type of the socket policy
+ typedef typename config::socket_type socket_type;
+ /// Type of the error logging policy
+ typedef typename config::elog_type elog_type;
+ /// Type of the access logging policy
+ typedef typename config::alog_type alog_type;
+
+ /// Type of the socket connection component
+ typedef typename socket_type::socket_con_type socket_con_type;
+ /// Type of a shared pointer to the socket connection component
+ typedef typename socket_con_type::ptr socket_con_ptr;
+
+ /// Type of the connection transport component associated with this
+ /// endpoint transport component
+ typedef asio::connection<config> transport_con_type;
+ /// Type of a shared pointer to the connection transport component
+ /// associated with this endpoint transport component
+ typedef typename transport_con_type::ptr transport_con_ptr;
+
+ /// Type of a pointer to the ASIO io_service being used
+ typedef lib::asio::io_service * io_service_ptr;
+ /// Type of a shared pointer to the acceptor being used
+ typedef lib::shared_ptr<lib::asio::ip::tcp::acceptor> acceptor_ptr;
+ /// Type of a shared pointer to the resolver being used
+ typedef lib::shared_ptr<lib::asio::ip::tcp::resolver> resolver_ptr;
+ /// Type of timer handle
+ typedef lib::shared_ptr<lib::asio::steady_timer> timer_ptr;
+ /// Type of a shared pointer to an io_service work object
+ typedef lib::shared_ptr<lib::asio::io_service::work> work_ptr;
+
+ // generate and manage our own io_service
+ explicit endpoint()
+ : m_io_service(NULL)
+ , m_external_io_service(false)
+ , m_listen_backlog(0)
+ , m_reuse_addr(false)
+ , m_state(UNINITIALIZED)
+ {
+ //std::cout << "transport::asio::endpoint constructor" << std::endl;
+ }
+
+ ~endpoint() {
+ // clean up our io_service if we were initialized with an internal one.
+
+ // Explicitly destroy local objects
+ m_acceptor.reset();
+ m_resolver.reset();
+ m_work.reset();
+ if (m_state != UNINITIALIZED && !m_external_io_service) {
+ delete m_io_service;
+ }
+ }
+
+ /// transport::asio objects are moveable but not copyable or assignable.
+ /// The following code sets this situation up based on whether or not we
+ /// have C++11 support or not
+#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
+ endpoint(const endpoint & src) = delete;
+ endpoint& operator= (const endpoint & rhs) = delete;
+#else
+private:
+ endpoint(const endpoint & src);
+ endpoint & operator= (const endpoint & rhs);
+public:
+#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
+
+#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
+ endpoint (endpoint && src)
+ : config::socket_type(std::move(src))
+ , m_tcp_pre_init_handler(src.m_tcp_pre_init_handler)
+ , m_tcp_post_init_handler(src.m_tcp_post_init_handler)
+ , m_io_service(src.m_io_service)
+ , m_external_io_service(src.m_external_io_service)
+ , m_acceptor(src.m_acceptor)
+ , m_listen_backlog(lib::asio::socket_base::max_connections)
+ , m_reuse_addr(src.m_reuse_addr)
+ , m_elog(src.m_elog)
+ , m_alog(src.m_alog)
+ , m_state(src.m_state)
+ {
+ src.m_io_service = NULL;
+ src.m_external_io_service = false;
+ src.m_acceptor = NULL;
+ src.m_state = UNINITIALIZED;
+ }
+
+ /*endpoint & operator= (const endpoint && rhs) {
+ if (this != &rhs) {
+ m_io_service = rhs.m_io_service;
+ m_external_io_service = rhs.m_external_io_service;
+ m_acceptor = rhs.m_acceptor;
+ m_listen_backlog = rhs.m_listen_backlog;
+ m_reuse_addr = rhs.m_reuse_addr;
+ m_state = rhs.m_state;
+
+ rhs.m_io_service = NULL;
+ rhs.m_external_io_service = false;
+ rhs.m_acceptor = NULL;
+ rhs.m_listen_backlog = lib::asio::socket_base::max_connections;
+ rhs.m_state = UNINITIALIZED;
+
+ // TODO: this needs to be updated
+ }
+ return *this;
+ }*/
+#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
+
+ /// Return whether or not the endpoint produces secure connections.
+ bool is_secure() const {
+ return socket_type::is_secure();
+ }
+
+ /// initialize asio transport with external io_service (exception free)
+ /**
+ * Initialize the ASIO transport policy for this endpoint using the provided
+ * io_service object. asio_init must be called exactly once on any endpoint
+ * that uses transport::asio before it can be used.
+ *
+ * @param ptr A pointer to the io_service to use for asio events
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void init_asio(io_service_ptr ptr, lib::error_code & ec) {
+ if (m_state != UNINITIALIZED) {
+ m_elog->write(log::elevel::library,
+ "asio::init_asio called from the wrong state");
+ using websocketpp::error::make_error_code;
+ ec = make_error_code(websocketpp::error::invalid_state);
+ return;
+ }
+
+ m_alog->write(log::alevel::devel,"asio::init_asio");
+
+ m_io_service = ptr;
+ m_external_io_service = true;
+ m_acceptor = lib::make_shared<lib::asio::ip::tcp::acceptor>(
+ lib::ref(*m_io_service));
+
+ m_state = READY;
+ ec = lib::error_code();
+ }
+
+ /// initialize asio transport with external io_service
+ /**
+ * Initialize the ASIO transport policy for this endpoint using the provided
+ * io_service object. asio_init must be called exactly once on any endpoint
+ * that uses transport::asio before it can be used.
+ *
+ * @param ptr A pointer to the io_service to use for asio events
+ */
+ void init_asio(io_service_ptr ptr) {
+ lib::error_code ec;
+ init_asio(ptr,ec);
+ if (ec) { throw exception(ec); }
+ }
+
+ /// Initialize asio transport with internal io_service (exception free)
+ /**
+ * This method of initialization will allocate and use an internally managed
+ * io_service.
+ *
+ * @see init_asio(io_service_ptr ptr)
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void init_asio(lib::error_code & ec) {
+ // Use a smart pointer until the call is successful and ownership has
+ // successfully been taken. Use unique_ptr when available.
+ // TODO: remove the use of auto_ptr when C++98/03 support is no longer
+ // necessary.
+#ifdef _WEBSOCKETPP_CPP11_MEMORY_
+ lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
+#else
+ lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
+#endif
+ init_asio(service.get(), ec);
+ if( !ec ) service.release(); // Call was successful, transfer ownership
+ m_external_io_service = false;
+ }
+
+ /// Initialize asio transport with internal io_service
+ /**
+ * This method of initialization will allocate and use an internally managed
+ * io_service.
+ *
+ * @see init_asio(io_service_ptr ptr)
+ */
+ void init_asio() {
+ // Use a smart pointer until the call is successful and ownership has
+ // successfully been taken. Use unique_ptr when available.
+ // TODO: remove the use of auto_ptr when C++98/03 support is no longer
+ // necessary.
+#ifdef _WEBSOCKETPP_CPP11_MEMORY_
+ lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
+#else
+ lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
+#endif
+ init_asio( service.get() );
+ // If control got this far without an exception, then ownership has successfully been taken
+ service.release();
+ m_external_io_service = false;
+ }
+
+ /// Sets the tcp pre init handler
+ /**
+ * The tcp pre init handler is called after the raw tcp connection has been
+ * established but before any additional wrappers (proxy connects, TLS
+ * handshakes, etc) have been performed.
+ *
+ * @since 0.3.0
+ *
+ * @param h The handler to call on tcp pre init.
+ */
+ void set_tcp_pre_init_handler(tcp_init_handler h) {
+ m_tcp_pre_init_handler = h;
+ }
+
+ /// Sets the tcp pre init handler (deprecated)
+ /**
+ * The tcp pre init handler is called after the raw tcp connection has been
+ * established but before any additional wrappers (proxy connects, TLS
+ * handshakes, etc) have been performed.
+ *
+ * @deprecated Use set_tcp_pre_init_handler instead
+ *
+ * @param h The handler to call on tcp pre init.
+ */
+ void set_tcp_init_handler(tcp_init_handler h) {
+ set_tcp_pre_init_handler(h);
+ }
+
+ /// Sets the tcp post init handler
+ /**
+ * The tcp post init handler is called after the tcp connection has been
+ * established and all additional wrappers (proxy connects, TLS handshakes,
+ * etc have been performed. This is fired before any bytes are read or any
+ * WebSocket specific handshake logic has been performed.
+ *
+ * @since 0.3.0
+ *
+ * @param h The handler to call on tcp post init.
+ */
+ void set_tcp_post_init_handler(tcp_init_handler h) {
+ m_tcp_post_init_handler = h;
+ }
+
+ /// Sets the maximum length of the queue of pending connections.
+ /**
+ * Sets the maximum length of the queue of pending connections. Increasing
+ * this will allow WebSocket++ to queue additional incoming connections.
+ * Setting it higher may prevent failed connections at high connection rates
+ * but may cause additional latency.
+ *
+ * For this value to take effect you may need to adjust operating system
+ * settings.
+ *
+ * New values affect future calls to listen only.
+ *
+ * A value of zero will use the operating system default. This is the
+ * default value.
+ *
+ * @since 0.3.0
+ *
+ * @param backlog The maximum length of the queue of pending connections
+ */
+ void set_listen_backlog(int backlog) {
+ m_listen_backlog = backlog;
+ }
+
+ /// Sets whether to use the SO_REUSEADDR flag when opening listening sockets
+ /**
+ * Specifies whether or not to use the SO_REUSEADDR TCP socket option. What
+ * this flag does depends on your operating system. Please consult operating
+ * system documentation for more details.
+ *
+ * New values affect future calls to listen only.
+ *
+ * The default is false.
+ *
+ * @since 0.3.0
+ *
+ * @param value Whether or not to use the SO_REUSEADDR option
+ */
+ void set_reuse_addr(bool value) {
+ m_reuse_addr = value;
+ }
+
+ /// Retrieve a reference to the endpoint's io_service
+ /**
+ * The io_service may be an internal or external one. This may be used to
+ * call methods of the io_service that are not explicitly wrapped by the
+ * endpoint.
+ *
+ * This method is only valid after the endpoint has been initialized with
+ * `init_asio`. No error will be returned if it isn't.
+ *
+ * @return A reference to the endpoint's io_service
+ */
+ lib::asio::io_service & get_io_service() {
+ return *m_io_service;
+ }
+
+ /// Get local TCP endpoint
+ /**
+ * Extracts the local endpoint from the acceptor. This represents the
+ * address that WebSocket++ is listening on.
+ *
+ * Sets a bad_descriptor error if the acceptor is not currently listening
+ * or otherwise unavailable.
+ *
+ * @since 0.7.0
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ * @return The local endpoint
+ */
+ lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code & ec) {
+ if (m_acceptor) {
+ return m_acceptor->local_endpoint(ec);
+ } else {
+ ec = lib::asio::error::make_error_code(lib::asio::error::bad_descriptor);
+ return lib::asio::ip::tcp::endpoint();
+ }
+ }
+
+ /// Set up endpoint for listening manually (exception free)
+ /**
+ * Bind the internal acceptor using the specified settings. The endpoint
+ * must have been initialized by calling init_asio before listening.
+ *
+ * @param ep An endpoint to read settings from
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void listen(lib::asio::ip::tcp::endpoint const & ep, lib::error_code & ec)
+ {
+ if (m_state != READY) {
+ m_elog->write(log::elevel::library,
+ "asio::listen called from the wrong state");
+ using websocketpp::error::make_error_code;
+ ec = make_error_code(websocketpp::error::invalid_state);
+ return;
+ }
+
+ m_alog->write(log::alevel::devel,"asio::listen");
+
+ lib::asio::error_code bec;
+
+ m_acceptor->open(ep.protocol(),bec);
+ if (!bec) {
+ m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
+ }
+ if (!bec) {
+ m_acceptor->bind(ep,bec);
+ }
+ if (!bec) {
+ m_acceptor->listen(m_listen_backlog,bec);
+ }
+ if (bec) {
+ if (m_acceptor->is_open()) {
+ m_acceptor->close();
+ }
+ log_err(log::elevel::info,"asio listen",bec);
+ ec = make_error_code(error::pass_through);
+ } else {
+ m_state = LISTENING;
+ ec = lib::error_code();
+ }
+ }
+
+ /// Set up endpoint for listening manually
+ /**
+ * Bind the internal acceptor using the settings specified by the endpoint e
+ *
+ * @param ep An endpoint to read settings from
+ */
+ void listen(lib::asio::ip::tcp::endpoint const & ep) {
+ lib::error_code ec;
+ listen(ep,ec);
+ if (ec) { throw exception(ec); }
+ }
+
+ /// Set up endpoint for listening with protocol and port (exception free)
+ /**
+ * Bind the internal acceptor using the given internet protocol and port.
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * Common options include:
+ * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
+ * - IPv4 only: lib::asio::ip::tcp::v4()
+ *
+ * @param internet_protocol The internet protocol to use.
+ * @param port The port to listen on.
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ template <typename InternetProtocol>
+ void listen(InternetProtocol const & internet_protocol, uint16_t port,
+ lib::error_code & ec)
+ {
+ lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
+ listen(ep,ec);
+ }
+
+ /// Set up endpoint for listening with protocol and port
+ /**
+ * Bind the internal acceptor using the given internet protocol and port.
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * Common options include:
+ * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
+ * - IPv4 only: lib::asio::ip::tcp::v4()
+ *
+ * @param internet_protocol The internet protocol to use.
+ * @param port The port to listen on.
+ */
+ template <typename InternetProtocol>
+ void listen(InternetProtocol const & internet_protocol, uint16_t port)
+ {
+ lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
+ listen(ep);
+ }
+
+ /// Set up endpoint for listening on a port (exception free)
+ /**
+ * Bind the internal acceptor using the given port. The IPv6 protocol with
+ * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
+ * the overload that allows specifying the protocol explicitly.
+ *
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * @param port The port to listen on.
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void listen(uint16_t port, lib::error_code & ec) {
+ listen(lib::asio::ip::tcp::v6(), port, ec);
+ }
+
+ /// Set up endpoint for listening on a port
+ /**
+ * Bind the internal acceptor using the given port. The IPv6 protocol with
+ * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
+ * the overload that allows specifying the protocol explicitly.
+ *
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * @param port The port to listen on.
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void listen(uint16_t port) {
+ listen(lib::asio::ip::tcp::v6(), port);
+ }
+
+ /// Set up endpoint for listening on a host and service (exception free)
+ /**
+ * Bind the internal acceptor using the given host and service. More details
+ * about what host and service can be are available in the Asio
+ * documentation for ip::basic_resolver_query::basic_resolver_query's
+ * constructors.
+ *
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * @param host A string identifying a location. May be a descriptive name or
+ * a numeric address string.
+ * @param service A string identifying the requested service. This may be a
+ * descriptive name or a numeric string corresponding to a port number.
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void listen(std::string const & host, std::string const & service,
+ lib::error_code & ec)
+ {
+ using lib::asio::ip::tcp;
+ tcp::resolver r(*m_io_service);
+ tcp::resolver::query query(host, service);
+ tcp::resolver::iterator endpoint_iterator = r.resolve(query);
+ tcp::resolver::iterator end;
+ if (endpoint_iterator == end) {
+ m_elog->write(log::elevel::library,
+ "asio::listen could not resolve the supplied host or service");
+ ec = make_error_code(error::invalid_host_service);
+ return;
+ }
+ listen(*endpoint_iterator,ec);
+ }
+
+ /// Set up endpoint for listening on a host and service
+ /**
+ * Bind the internal acceptor using the given host and service. More details
+ * about what host and service can be are available in the Asio
+ * documentation for ip::basic_resolver_query::basic_resolver_query's
+ * constructors.
+ *
+ * The endpoint must have been initialized by calling init_asio before
+ * listening.
+ *
+ * @param host A string identifying a location. May be a descriptive name or
+ * a numeric address string.
+ * @param service A string identifying the requested service. This may be a
+ * descriptive name or a numeric string corresponding to a port number.
+ * @param ec Set to indicate what error occurred, if any.
+ */
+ void listen(std::string const & host, std::string const & service)
+ {
+ lib::error_code ec;
+ listen(host,service,ec);
+ if (ec) { throw exception(ec); }
+ }
+
+ /// Stop listening (exception free)
+ /**
+ * Stop listening and accepting new connections. This will not end any
+ * existing connections.
+ *
+ * @since 0.3.0-alpha4
+ * @param ec A status code indicating an error, if any.
+ */
+ void stop_listening(lib::error_code & ec) {
+ if (m_state != LISTENING) {
+ m_elog->write(log::elevel::library,
+ "asio::listen called from the wrong state");
+ using websocketpp::error::make_error_code;
+ ec = make_error_code(websocketpp::error::invalid_state);
+ return;
+ }
+
+ m_acceptor->close();
+ m_state = READY;
+ ec = lib::error_code();
+ }
+
+ /// Stop listening
+ /**
+ * Stop listening and accepting new connections. This will not end any
+ * existing connections.
+ *
+ * @since 0.3.0-alpha4
+ */
+ void stop_listening() {
+ lib::error_code ec;
+ stop_listening(ec);
+ if (ec) { throw exception(ec); }
+ }
+
+ /// Check if the endpoint is listening
+ /**
+ * @return Whether or not the endpoint is listening.
+ */
+ bool is_listening() const {
+ return (m_state == LISTENING);
+ }
+
+ /// wraps the run method of the internal io_service object
+ std::size_t run() {
+ return m_io_service->run();
+ }
+
+ /// wraps the run_one method of the internal io_service object
+ /**
+ * @since 0.3.0-alpha4
+ */
+ std::size_t run_one() {
+ return m_io_service->run_one();
+ }
+
+ /// wraps the stop method of the internal io_service object
+ void stop() {
+ m_io_service->stop();
+ }
+
+ /// wraps the poll method of the internal io_service object
+ std::size_t poll() {
+ return m_io_service->poll();
+ }
+
+ /// wraps the poll_one method of the internal io_service object
+ std::size_t poll_one() {
+ return m_io_service->poll_one();
+ }
+
+ /// wraps the reset method of the internal io_service object
+ void reset() {
+ m_io_service->reset();
+ }
+
+ /// wraps the stopped method of the internal io_service object
+ bool stopped() const {
+ return m_io_service->stopped();
+ }
+
+ /// Marks the endpoint as perpetual, stopping it from exiting when empty
+ /**
+ * Marks the endpoint as perpetual. Perpetual endpoints will not
+ * automatically exit when they run out of connections to process. To stop
+ * a perpetual endpoint call `end_perpetual`.
+ *
+ * An endpoint may be marked perpetual at any time by any thread. It must be
+ * called either before the endpoint has run out of work or before it was
+ * started
+ *
+ * @since 0.3.0
+ */
+ void start_perpetual() {
+ m_work = lib::make_shared<lib::asio::io_service::work>(
+ lib::ref(*m_io_service)
+ );
+ }
+
+ /// Clears the endpoint's perpetual flag, allowing it to exit when empty
+ /**
+ * Clears the endpoint's perpetual flag. This will cause the endpoint's run
+ * method to exit normally when it runs out of connections. If there are
+ * currently active connections it will not end until they are complete.
+ *
+ * @since 0.3.0
+ */
+ void stop_perpetual() {
+ m_work.reset();
+ }
+
+ /// Call back a function after a period of time.
+ /**
+ * Sets a timer that calls back a function after the specified period of
+ * milliseconds. Returns a handle that can be used to cancel the timer.
+ * A cancelled timer will return the error code error::operation_aborted
+ * A timer that expired will return no error.
+ *
+ * @param duration Length of time to wait in milliseconds
+ * @param callback The function to call back when the timer has expired
+ * @return A handle that can be used to cancel the timer if it is no longer
+ * needed.
+ */
+ timer_ptr set_timer(long duration, timer_handler callback) {
+ timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
+ *m_io_service,
+ lib::asio::milliseconds(duration)
+ );
+
+ new_timer->async_wait(
+ lib::bind(
+ &type::handle_timer,
+ this,
+ new_timer,
+ callback,
+ lib::placeholders::_1
+ )
+ );
+
+ return new_timer;
+ }
+
+ /// Timer handler
+ /**
+ * The timer pointer is included to ensure the timer isn't destroyed until
+ * after it has expired.
+ *
+ * @param t Pointer to the timer in question
+ * @param callback The function to call back
+ * @param ec A status code indicating an error, if any.
+ */
+ void handle_timer(timer_ptr, timer_handler callback,
+ lib::asio::error_code const & ec)
+ {
+ if (ec) {
+ if (ec == lib::asio::error::operation_aborted) {
+ callback(make_error_code(transport::error::operation_aborted));
+ } else {
+ m_elog->write(log::elevel::info,
+ "asio handle_timer error: "+ec.message());
+ log_err(log::elevel::info,"asio handle_timer",ec);
+ callback(make_error_code(error::pass_through));
+ }
+ } else {
+ callback(lib::error_code());
+ }
+ }
+
+ /// Accept the next connection attempt and assign it to con (exception free)
+ /**
+ * @param tcon The connection to accept into.
+ * @param callback The function to call when the operation is complete.
+ * @param ec A status code indicating an error, if any.
+ */
+ void async_accept(transport_con_ptr tcon, accept_handler callback,
+ lib::error_code & ec)
+ {
+ if (m_state != LISTENING) {
+ using websocketpp::error::make_error_code;
+ ec = make_error_code(websocketpp::error::async_accept_not_listening);
+ return;
+ }
+
+ m_alog->write(log::alevel::devel, "asio::async_accept");
+
+ if (config::enable_multithreading) {
+ m_acceptor->async_accept(
+ tcon->get_raw_socket(),
+ tcon->get_strand()->wrap(lib::bind(
+ &type::handle_accept,
+ this,
+ callback,
+ lib::placeholders::_1
+ ))
+ );
+ } else {
+ m_acceptor->async_accept(
+ tcon->get_raw_socket(),
+ lib::bind(
+ &type::handle_accept,
+ this,
+ callback,
+ lib::placeholders::_1
+ )
+ );
+ }
+ }
+
+ /// Accept the next connection attempt and assign it to con.
+ /**
+ * @param tcon The connection to accept into.
+ * @param callback The function to call when the operation is complete.
+ */
+ void async_accept(transport_con_ptr tcon, accept_handler callback) {
+ lib::error_code ec;
+ async_accept(tcon,callback,ec);
+ if (ec) { throw exception(ec); }
+ }
+protected:
+ /// Initialize logging
+ /**
+ * The loggers are located in the main endpoint class. As such, the
+ * transport doesn't have direct access to them. This method is called
+ * by the endpoint constructor to allow shared logging from the transport
+ * component. These are raw pointers to member variables of the endpoint.
+ * In particular, they cannot be used in the transport constructor as they
+ * haven't been constructed yet, and cannot be used in the transport
+ * destructor as they will have been destroyed by then.
+ */
+ void init_logging(alog_type* a, elog_type* e) {
+ m_alog = a;
+ m_elog = e;
+ }
+
+ void handle_accept(accept_handler callback, lib::asio::error_code const &
+ asio_ec)
+ {
+ lib::error_code ret_ec;
+
+ m_alog->write(log::alevel::devel, "asio::handle_accept");
+
+ if (asio_ec) {
+ if (asio_ec == lib::asio::errc::operation_canceled) {
+ ret_ec = make_error_code(websocketpp::error::operation_canceled);
+ } else {
+ log_err(log::elevel::info,"asio handle_accept",asio_ec);
+ ret_ec = make_error_code(error::pass_through);
+ }
+ }
+
+ callback(ret_ec);
+ }
+
+ /// Initiate a new connection
+ // TODO: there have to be some more failure conditions here
+ void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb) {
+ using namespace lib::asio::ip;
+
+ // Create a resolver
+ if (!m_resolver) {
+ m_resolver = lib::make_shared<lib::asio::ip::tcp::resolver>(
+ lib::ref(*m_io_service));
+ }
+
+ tcon->set_uri(u);
+
+ std::string proxy = tcon->get_proxy();
+ std::string host;
+ std::string port;
+
+ if (proxy.empty()) {
+ host = u->get_host();
+ port = u->get_port_str();
+ } else {
+ lib::error_code ec;
+
+ uri_ptr pu = lib::make_shared<uri>(proxy);
+
+ if (!pu->get_valid()) {
+ cb(make_error_code(error::proxy_invalid));
+ return;
+ }
+
+ ec = tcon->proxy_init(u->get_authority());
+ if (ec) {
+ cb(ec);
+ return;
+ }
+
+ host = pu->get_host();
+ port = pu->get_port_str();
+ }
+
+ tcp::resolver::query query(host,port);
+
+ if (m_alog->static_test(log::alevel::devel)) {
+ m_alog->write(log::alevel::devel,
+ "starting async DNS resolve for "+host+":"+port);
+ }
+
+ timer_ptr dns_timer;
+
+ dns_timer = tcon->set_timer(
+ config::timeout_dns_resolve,
+ lib::bind(
+ &type::handle_resolve_timeout,
+ this,
+ dns_timer,
+ cb,
+ lib::placeholders::_1
+ )
+ );
+
+ if (config::enable_multithreading) {
+ m_resolver->async_resolve(
+ query,
+ tcon->get_strand()->wrap(lib::bind(
+ &type::handle_resolve,
+ this,
+ tcon,
+ dns_timer,
+ cb,
+ lib::placeholders::_1,
+ lib::placeholders::_2
+ ))
+ );
+ } else {
+ m_resolver->async_resolve(
+ query,
+ lib::bind(
+ &type::handle_resolve,
+ this,
+ tcon,
+ dns_timer,
+ cb,
+ lib::placeholders::_1,
+ lib::placeholders::_2
+ )
+ );
+ }
+ }
+
+ /// DNS resolution timeout handler
+ /**
+ * The timer pointer is included to ensure the timer isn't destroyed until
+ * after it has expired.
+ *
+ * @param dns_timer Pointer to the timer in question
+ * @param callback The function to call back
+ * @param ec A status code indicating an error, if any.
+ */
+ void handle_resolve_timeout(timer_ptr, connect_handler callback,
+ lib::error_code const & ec)
+ {
+ lib::error_code ret_ec;
+
+ if (ec) {
+ if (ec == transport::error::operation_aborted) {
+ m_alog->write(log::alevel::devel,
+ "asio handle_resolve_timeout timer cancelled");
+ return;
+ }
+
+ log_err(log::elevel::devel,"asio handle_resolve_timeout",ec);
+ ret_ec = ec;
+ } else {
+ ret_ec = make_error_code(transport::error::timeout);
+ }
+
+ m_alog->write(log::alevel::devel,"DNS resolution timed out");
+ m_resolver->cancel();
+ callback(ret_ec);
+ }
+
+ void handle_resolve(transport_con_ptr tcon, timer_ptr dns_timer,
+ connect_handler callback, lib::asio::error_code const & ec,
+ lib::asio::ip::tcp::resolver::iterator iterator)
+ {
+ if (ec == lib::asio::error::operation_aborted ||
+ lib::asio::is_neg(dns_timer->expires_from_now()))
+ {
+ m_alog->write(log::alevel::devel,"async_resolve cancelled");
+ return;
+ }
+
+ dns_timer->cancel();
+
+ if (ec) {
+ log_err(log::elevel::info,"asio async_resolve",ec);
+ callback(make_error_code(error::pass_through));
+ return;
+ }
+
+ if (m_alog->static_test(log::alevel::devel)) {
+ std::stringstream s;
+ s << "Async DNS resolve successful. Results: ";
+
+ lib::asio::ip::tcp::resolver::iterator it, end;
+ for (it = iterator; it != end; ++it) {
+ s << (*it).endpoint() << " ";
+ }
+
+ m_alog->write(log::alevel::devel,s.str());
+ }
+
+ m_alog->write(log::alevel::devel,"Starting async connect");
+
+ timer_ptr con_timer;
+
+ con_timer = tcon->set_timer(
+ config::timeout_connect,
+ lib::bind(
+ &type::handle_connect_timeout,
+ this,
+ tcon,
+ con_timer,
+ callback,
+ lib::placeholders::_1
+ )
+ );
+
+ if (config::enable_multithreading) {
+ lib::asio::async_connect(
+ tcon->get_raw_socket(),
+ iterator,
+ tcon->get_strand()->wrap(lib::bind(
+ &type::handle_connect,
+ this,
+ tcon,
+ con_timer,
+ callback,
+ lib::placeholders::_1
+ ))
+ );
+ } else {
+ lib::asio::async_connect(
+ tcon->get_raw_socket(),
+ iterator,
+ lib::bind(
+ &type::handle_connect,
+ this,
+ tcon,
+ con_timer,
+ callback,
+ lib::placeholders::_1
+ )
+ );
+ }
+ }
+
+ /// Asio connect timeout handler
+ /**
+ * The timer pointer is included to ensure the timer isn't destroyed until
+ * after it has expired.
+ *
+ * @param tcon Pointer to the transport connection that is being connected
+ * @param con_timer Pointer to the timer in question
+ * @param callback The function to call back
+ * @param ec A status code indicating an error, if any.
+ */
+ void handle_connect_timeout(transport_con_ptr tcon, timer_ptr,
+ connect_handler callback, lib::error_code const & ec)
+ {
+ lib::error_code ret_ec;
+
+ if (ec) {
+ if (ec == transport::error::operation_aborted) {
+ m_alog->write(log::alevel::devel,
+ "asio handle_connect_timeout timer cancelled");
+ return;
+ }
+
+ log_err(log::elevel::devel,"asio handle_connect_timeout",ec);
+ ret_ec = ec;
+ } else {
+ ret_ec = make_error_code(transport::error::timeout);
+ }
+
+ m_alog->write(log::alevel::devel,"TCP connect timed out");
+ tcon->cancel_socket_checked();
+ callback(ret_ec);
+ }
+
+ void handle_connect(transport_con_ptr tcon, timer_ptr con_timer,
+ connect_handler callback, lib::asio::error_code const & ec)
+ {
+ if (ec == lib::asio::error::operation_aborted ||
+ lib::asio::is_neg(con_timer->expires_from_now()))
+ {
+ m_alog->write(log::alevel::devel,"async_connect cancelled");
+ return;
+ }
+
+ con_timer->cancel();
+
+ if (ec) {
+ log_err(log::elevel::info,"asio async_connect",ec);
+ callback(make_error_code(error::pass_through));
+ return;
+ }
+
+ if (m_alog->static_test(log::alevel::devel)) {
+ m_alog->write(log::alevel::devel,
+ "Async connect to "+tcon->get_remote_endpoint()+" successful.");
+ }
+
+ callback(lib::error_code());
+ }
+
+ /// Initialize a connection
+ /**
+ * init is called by an endpoint once for each newly created connection.
+ * It's purpose is to give the transport policy the chance to perform any
+ * transport specific initialization that couldn't be done via the default
+ * constructor.
+ *
+ * @param tcon A pointer to the transport portion of the connection.
+ *
+ * @return A status code indicating the success or failure of the operation
+ */
+ lib::error_code init(transport_con_ptr tcon) {
+ m_alog->write(log::alevel::devel, "transport::asio::init");
+
+ // Initialize the connection socket component
+ socket_type::init(lib::static_pointer_cast<socket_con_type,
+ transport_con_type>(tcon));
+
+ lib::error_code ec;
+
+ ec = tcon->init_asio(m_io_service);
+ if (ec) {return ec;}
+
+ tcon->set_tcp_pre_init_handler(m_tcp_pre_init_handler);
+ tcon->set_tcp_post_init_handler(m_tcp_post_init_handler);
+
+ return lib::error_code();
+ }
+private:
+ /// Convenience method for logging the code and message for an error_code
+ template <typename error_type>
+ void log_err(log::level l, char const * msg, error_type const & ec) {
+ std::stringstream s;
+ s << msg << " error: " << ec << " (" << ec.message() << ")";
+ m_elog->write(l,s.str());
+ }
+
+ enum state {
+ UNINITIALIZED = 0,
+ READY = 1,
+ LISTENING = 2
+ };
+
+ // Handlers
+ tcp_init_handler m_tcp_pre_init_handler;
+ tcp_init_handler m_tcp_post_init_handler;
+
+ // Network Resources
+ io_service_ptr m_io_service;
+ bool m_external_io_service;
+ acceptor_ptr m_acceptor;
+ resolver_ptr m_resolver;
+ work_ptr m_work;
+
+ // Network constants
+ int m_listen_backlog;
+ bool m_reuse_addr;
+
+ elog_type* m_elog;
+ alog_type* m_alog;
+
+ // Transport state
+ state m_state;
+};
+
+} // namespace asio
+} // namespace transport
+} // namespace websocketpp
+
+#endif // WEBSOCKETPP_TRANSPORT_ASIO_HPP
projects / c11concurrency-benchmarks.git / blobdiff