Loading...
Searching...
No Matches
connection.hpp
/*
* Copyright (c) 2014, 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_CONNECTION_HPP
#define WEBSOCKETPP_CONNECTION_HPP
#include <websocketpp/close.hpp>
#include <websocketpp/error.hpp>
#include <websocketpp/frame.hpp>
#include <websocketpp/logger/levels.hpp>
#include <websocketpp/processors/processor.hpp>
#include <websocketpp/transport/base/connection.hpp>
#include <websocketpp/http/constants.hpp>
#include <websocketpp/common/connection_hdl.hpp>
#include <websocketpp/common/cpp11.hpp>
#include <websocketpp/common/functional.hpp>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
namespace websocketpp {
/// The type and function signature of an open handler
/**
* The open handler is called once for every successful WebSocket connection
* attempt. Either the fail handler or the open handler will be called for each
* WebSocket connection attempt. HTTP Connections that did not attempt to
* upgrade the connection to the WebSocket protocol will trigger the http
* handler instead of fail/open.
*/
typedef lib::function<void(connection_hdl)> open_handler;
/// The type and function signature of a close handler
/**
* The close handler is called once for every successfully established
* connection after it is no longer capable of sending or receiving new messages
*
* The close handler will be called exactly once for every connection for which
* the open handler was called.
*/
typedef lib::function<void(connection_hdl)> close_handler;
/// The type and function signature of a fail handler
/**
* The fail handler is called once for every unsuccessful WebSocket connection
* attempt. Either the fail handler or the open handler will be called for each
* WebSocket connection attempt. HTTP Connections that did not attempt to
* upgrade the connection to the WebSocket protocol will trigger the http
* handler instead of fail/open.
*/
typedef lib::function<void(connection_hdl)> fail_handler;
/// The type and function signature of an interrupt handler
/**
* The interrupt handler is called when a connection receives an interrupt
* request from the application. Interrupts allow the application to trigger a
* handler to be run in the absence of a WebSocket level handler trigger (like
* a new message).
*
* This is typically used by another application thread to schedule some tasks
* that can only be run from within the handler chain for thread safety reasons.
*/
typedef lib::function<void(connection_hdl)> interrupt_handler;
/// The type and function signature of a ping handler
/**
* The ping handler is called when the connection receives a WebSocket ping
* control frame. The string argument contains the ping payload. The payload is
* a binary string up to 126 bytes in length. The ping handler returns a bool,
* true if a pong response should be sent, false if the pong response should be
* suppressed.
*/
typedef lib::function<bool(connection_hdl,std::string)> ping_handler;
/// The type and function signature of a pong handler
/**
* The pong handler is called when the connection receives a WebSocket pong
* control frame. The string argument contains the pong payload. The payload is
* a binary string up to 126 bytes in length.
*/
typedef lib::function<void(connection_hdl,std::string)> pong_handler;
/// The type and function signature of a pong timeout handler
/**
* The pong timeout handler is called when a ping goes unanswered by a pong for
* longer than the locally specified timeout period.
*/
typedef lib::function<void(connection_hdl,std::string)> pong_timeout_handler;
/// The type and function signature of a validate handler
/**
* The validate handler is called after a WebSocket handshake has been received
* and processed but before it has been accepted. This gives the application a
* chance to implement connection details specific policies for accepting
* connections and the ability to negotiate extensions and subprotocols.
*
* The validate handler return value indicates whether or not the connection
* should be accepted. Additional methods may be called during the function to
* set response headers, set HTTP return/error codes, etc.
*/
typedef lib::function<bool(connection_hdl)> validate_handler;
/// The type and function signature of a http handler
/**
* The http handler is called when an HTTP connection is made that does not
* attempt to upgrade the connection to the WebSocket protocol. This allows
* WebSocket++ servers to respond to these requests with regular HTTP responses.
*
* This can be used to deliver error pages & dashboards and to deliver static
* files such as the base HTML & JavaScript for an otherwise single page
* WebSocket application.
*
* Note: WebSocket++ is designed to be a high performance WebSocket server. It
* is not tuned to provide a full featured, high performance, HTTP web server
* solution. The HTTP handler is appropriate only for low volume HTTP traffic.
* If you expect to serve high volumes of HTTP traffic a dedicated HTTP web
* server is strongly recommended.
*
* The default HTTP handler will return a 426 Upgrade Required error. Custom
* handlers may override the response status code to deliver any type of
* response.
*/
typedef lib::function<void(connection_hdl)> http_handler;
//
typedef lib::function<void(lib::error_code const & ec, size_t bytes_transferred)> read_handler;
typedef lib::function<void(lib::error_code const & ec)> write_frame_handler;
// constants related to the default WebSocket protocol versions available
#ifdef _WEBSOCKETPP_INITIALIZER_LISTS_ // simplified C++11 version
/// Container that stores the list of protocol versions supported
/**
* @todo Move this to configs to allow compile/runtime disabling or enabling
* of protocol versions
*/
static std::vector<int> const versions_supported = {0,7,8,13};
#else
/// Helper array to get around lack of initializer lists pre C++11
static int const helper[] = {0,7,8,13};
/// Container that stores the list of protocol versions supported
/**
* @todo Move this to configs to allow compile/runtime disabling or enabling
* of protocol versions
*/
static std::vector<int> const versions_supported(helper,helper+4);
#endif
namespace session {
namespace state {
// externally visible session state (states based on the RFC)
enum value {
connecting = 0,
open = 1,
closing = 2,
closed = 3
};
} // namespace state
namespace fail {
namespace status {
enum value {
GOOD = 0, // no failure yet!
SYSTEM = 1, // system call returned error, check that code
WEBSOCKET = 2, // websocket close codes contain error
UNKNOWN = 3, // No failure information is available
TIMEOUT_TLS = 4, // TLS handshake timed out
TIMEOUT_WS = 5 // WS handshake timed out
};
} // namespace status
} // namespace fail
namespace internal_state {
// More granular internal states. These are used for multi-threaded
// connection synchronization and preventing values that are not yet or no
// longer available from being used.
enum value {
USER_INIT = 0,
TRANSPORT_INIT = 1,
READ_HTTP_REQUEST = 2,
WRITE_HTTP_REQUEST = 3,
READ_HTTP_RESPONSE = 4,
WRITE_HTTP_RESPONSE = 5,
PROCESS_HTTP_REQUEST = 6,
PROCESS_CONNECTION = 7
};
} // namespace internal_state
namespace http_state {
// states to keep track of the progress of http connections
enum value {
init = 0,
deferred = 1,
headers_written = 2,
body_written = 3,
closed = 4
};
} // namespace http_state
} // namespace session
/// Represents an individual WebSocket connection
template <typename config>
class connection
: public config::transport_type::transport_con_type
, public config::connection_base
{
public:
/// Type of this connection
typedef connection<config> type;
/// Type of a shared pointer to this connection
typedef lib::shared_ptr<type> ptr;
/// Type of a weak pointer to this connection
typedef lib::weak_ptr<type> weak_ptr;
/// Type of the concurrency component of this connection
typedef typename config::concurrency_type concurrency_type;
/// Type of the access logging policy
typedef typename config::alog_type alog_type;
/// Type of the error logging policy
typedef typename config::elog_type elog_type;
/// Type of the transport component of this connection
typedef typename config::transport_type::transport_con_type
transport_con_type;
/// Type of a shared pointer to the transport component of this connection
typedef typename transport_con_type::ptr transport_con_ptr;
typedef lib::function<void(ptr)> termination_handler;
typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
typedef typename concurrency_type::mutex_type mutex_type;
typedef typename config::request_type request_type;
typedef typename config::response_type response_type;
typedef typename config::message_type message_type;
typedef typename message_type::ptr message_ptr;
typedef typename config::con_msg_manager_type con_msg_manager_type;
typedef typename con_msg_manager_type::ptr con_msg_manager_ptr;
/// Type of RNG
typedef typename config::rng_type rng_type;
typedef processor::processor<config> processor_type;
typedef lib::shared_ptr<processor_type> processor_ptr;
// Message handler (needs to know message type)
typedef lib::function<void(connection_hdl,message_ptr)> message_handler;
/// Type of a pointer to a transport timer handle
typedef typename transport_con_type::timer_ptr timer_ptr;
// Misc Convenience Types
typedef session::internal_state::value istate_type;
private:
enum terminate_status {
failed = 1,
closed,
unknown
};
public:
explicit connection(bool p_is_server, std::string const & ua, const lib::shared_ptr<alog_type>& alog,
const lib::shared_ptr<elog_type>& elog, rng_type & rng)
: transport_con_type(p_is_server, alog, elog)
, m_handle_read_frame(lib::bind(
&type::handle_read_frame,
this,
lib::placeholders::_1,
lib::placeholders::_2
))
, m_write_frame_handler(lib::bind(
&type::handle_write_frame,
this,
lib::placeholders::_1
))
, m_user_agent(ua)
, m_open_handshake_timeout_dur(config::timeout_open_handshake)
, m_close_handshake_timeout_dur(config::timeout_close_handshake)
, m_pong_timeout_dur(config::timeout_pong)
, m_max_message_size(config::max_message_size)
, m_state(session::state::connecting)
, m_internal_state(session::internal_state::USER_INIT)
, m_msg_manager(new con_msg_manager_type())
, m_send_buffer_size(0)
, m_write_flag(false)
, m_read_flag(true)
, m_is_server(p_is_server)
, m_alog(alog)
, m_elog(elog)
, m_rng(rng)
, m_local_close_code(close::status::abnormal_close)
, m_remote_close_code(close::status::abnormal_close)
, m_is_http(false)
, m_http_state(session::http_state::init)
, m_was_clean(false)
{
m_alog->write(log::alevel::devel,"connection constructor");
}
/// Get a shared pointer to this component
ptr get_shared() {
return lib::static_pointer_cast<type>(transport_con_type::get_shared());
}
///////////////////////////
// Set Handler Callbacks //
///////////////////////////
/// Set open handler
/**
* The open handler is called after the WebSocket handshake is complete and
* the connection is considered OPEN.
*
* @param h The new open_handler
*/
void set_open_handler(open_handler h) {
m_open_handler = h;
}
/// Set close handler
/**
* The close handler is called immediately after the connection is closed.
*
* @param h The new close_handler
*/
void set_close_handler(close_handler h) {
m_close_handler = h;
}
/// Set fail handler
/**
* The fail handler is called whenever the connection fails while the
* handshake is bring processed.
*
* @param h The new fail_handler
*/
void set_fail_handler(fail_handler h) {
m_fail_handler = h;
}
/// Set ping handler
/**
* The ping handler is called whenever the connection receives a ping
* control frame. The ping payload is included.
*
* The ping handler's return time controls whether or not a pong is
* sent in response to this ping. Returning false will suppress the
* return pong. If no ping handler is set a pong will be sent.
*
* @param h The new ping_handler
*/
void set_ping_handler(ping_handler h) {
m_ping_handler = h;
}
/// Set pong handler
/**
* The pong handler is called whenever the connection receives a pong
* control frame. The pong payload is included.
*
* @param h The new pong_handler
*/
void set_pong_handler(pong_handler h) {
m_pong_handler = h;
}
/// Set pong timeout handler
/**
* If the transport component being used supports timers, the pong timeout
* handler is called whenever a pong control frame is not received with the
* configured timeout period after the application sends a ping.
*
* The config setting `timeout_pong` controls the length of the timeout
* period. It is specified in milliseconds.
*
* This can be used to probe the health of the remote endpoint's WebSocket
* implementation. This does not guarantee that the remote application
* itself is still healthy but can be a useful diagnostic.
*
* Note: receipt of this callback doesn't mean the pong will never come.
* This functionality will not suppress delivery of the pong in question
* should it arrive after the timeout.
*
* @param h The new pong_timeout_handler
*/
void set_pong_timeout_handler(pong_timeout_handler h) {
m_pong_timeout_handler = h;
}
/// Set interrupt handler
/**
* The interrupt handler is called whenever the connection is manually
* interrupted by the application.
*
* @param h The new interrupt_handler
*/
void set_interrupt_handler(interrupt_handler h) {
m_interrupt_handler = h;
}
/// Set http handler
/**
* The http handler is called after an HTTP request other than a WebSocket
* upgrade request is received. It allows a WebSocket++ server to respond
* to regular HTTP requests on the same port as it processes WebSocket
* connections. This can be useful for hosting error messages, flash
* policy files, status pages, and other simple HTTP responses. It is not
* intended to be used as a primary web server.
*
* @param h The new http_handler
*/
void set_http_handler(http_handler h) {
m_http_handler = h;
}
/// Set validate handler
/**
* The validate handler is called after a WebSocket handshake has been
* parsed but before a response is returned. It provides the application
* a chance to examine the request and determine whether or not it wants
* to accept the connection.
*
* Returning false from the validate handler will reject the connection.
* If no validate handler is present, all connections will be allowed.
*
* @param h The new validate_handler
*/
void set_validate_handler(validate_handler h) {
m_validate_handler = h;
}
/// Set message handler
/**
* The message handler is called after a new message has been received.
*
* @param h The new message_handler
*/
void set_message_handler(message_handler h) {
m_message_handler = h;
}
//////////////////////////////////////////
// Connection timeouts and other limits //
//////////////////////////////////////////
/// Set open handshake timeout
/**
* Sets the length of time the library will wait after an opening handshake
* has been initiated before cancelling it. This can be used to prevent
* excessive wait times for outgoing clients or excessive resource usage
* from broken clients or DoS attacks on servers.
*
* Connections that time out will have their fail handlers called with the
* open_handshake_timeout error code.
*
* The default value is specified via the compile time config value
* 'timeout_open_handshake'. The default value in the core config
* is 5000ms. A value of 0 will disable the timer entirely.
*
* To be effective, the transport you are using must support timers. See
* the documentation for your transport policy for details about its
* timer support.
*
* @param dur The length of the open handshake timeout in ms
*/
void set_open_handshake_timeout(long dur) {
m_open_handshake_timeout_dur = dur;
}
/// Set close handshake timeout
/**
* Sets the length of time the library will wait after a closing handshake
* has been initiated before cancelling it. This can be used to prevent
* excessive wait times for outgoing clients or excessive resource usage
* from broken clients or DoS attacks on servers.
*
* Connections that time out will have their close handlers called with the
* close_handshake_timeout error code.
*
* The default value is specified via the compile time config value
* 'timeout_close_handshake'. The default value in the core config
* is 5000ms. A value of 0 will disable the timer entirely.
*
* To be effective, the transport you are using must support timers. See
* the documentation for your transport policy for details about its
* timer support.
*
* @param dur The length of the close handshake timeout in ms
*/
void set_close_handshake_timeout(long dur) {
m_close_handshake_timeout_dur = dur;
}
/// Set pong timeout
/**
* Sets the length of time the library will wait for a pong response to a
* ping. This can be used as a keepalive or to detect broken connections.
*
* Pong responses that time out will have the pong timeout handler called.
*
* The default value is specified via the compile time config value
* 'timeout_pong'. The default value in the core config
* is 5000ms. A value of 0 will disable the timer entirely.
*
* To be effective, the transport you are using must support timers. See
* the documentation for your transport policy for details about its
* timer support.
*
* @param dur The length of the pong timeout in ms
*/
void set_pong_timeout(long dur) {
m_pong_timeout_dur = dur;
}
/// Get maximum message size
/**
* Get maximum message size. Maximum message size determines the point at
* which the connection will fail with the message_too_big protocol error.
*
* The default is set by the endpoint that creates the connection.
*
* @since 0.3.0
*/
size_t get_max_message_size() const {
return m_max_message_size;
}
/// Set maximum message size
/**
* Set maximum message size. Maximum message size determines the point at
* which the connection will fail with the message_too_big protocol error.
* This value may be changed during the connection.
*
* The default is set by the endpoint that creates the connection.
*
* @since 0.3.0
*
* @param new_value The value to set as the maximum message size.
*/
void set_max_message_size(size_t new_value) {
m_max_message_size = new_value;
if (m_processor) {
m_processor->set_max_message_size(new_value);
}
}
/// Get maximum HTTP message body size
/**
* Get maximum HTTP message body size. Maximum message body size determines
* the point at which the connection will stop reading an HTTP request whose
* body is too large.
*
* The default is set by the endpoint that creates the connection.
*
* @since 0.5.0
*
* @return The maximum HTTP message body size
*/
size_t get_max_http_body_size() const {
return m_request.get_max_body_size();
}
/// Set maximum HTTP message body size
/**
* Set maximum HTTP message body size. Maximum message body size determines
* the point at which the connection will stop reading an HTTP request whose
* body is too large.
*
* The default is set by the endpoint that creates the connection.
*
* @since 0.5.0
*
* @param new_value The value to set as the maximum message size.
*/
void set_max_http_body_size(size_t new_value) {
m_request.set_max_body_size(new_value);
}
//////////////////////////////////
// Uncategorized public methods //
//////////////////////////////////
/// Get the size of the outgoing write buffer (in payload bytes)
/**
* Retrieves the number of bytes in the outgoing write buffer that have not
* already been dispatched to the transport layer. This represents the bytes
* that are presently cancelable without uncleanly ending the websocket
* connection
*
* This method invokes the m_write_lock mutex
*
* @return The current number of bytes in the outgoing send buffer.
*/
size_t get_buffered_amount() const;
/// Get the size of the outgoing write buffer (in payload bytes)
/**
* @deprecated use `get_buffered_amount` instead
*/
size_t buffered_amount() const {
return get_buffered_amount();
}
////////////////////
// Action Methods //
////////////////////
/// Create a message and then add it to the outgoing send queue
/**
* Convenience method to send a message given a payload string and
* optionally an opcode. Default opcode is utf8 text.
*
* This method locks the m_write_lock mutex
*
* @param payload The payload string to generated the message with
*
* @param op The opcode to generated the message with. Default is
* frame::opcode::text
*/
lib::error_code send(std::string const & payload, frame::opcode::value op =
frame::opcode::text);
/// Send a message (raw array overload)
/**
* Convenience method to send a message given a raw array and optionally an
* opcode. Default opcode is binary.
*
* This method locks the m_write_lock mutex
*
* @param payload A pointer to the array containing the bytes to send.
*
* @param len Length of the array.
*
* @param op The opcode to generated the message with. Default is
* frame::opcode::binary
*/
lib::error_code send(void const * payload, size_t len, frame::opcode::value
op = frame::opcode::binary);
/// Add a message to the outgoing send queue
/**
* If presented with a prepared message it is added without validation or
* framing. If presented with an unprepared message it is validated, framed,
* and then added
*
* Errors are returned via an exception
* \todo make exception system_error rather than error_code
*
* This method invokes the m_write_lock mutex
*
* @param msg A message_ptr to the message to send.
*/
lib::error_code send(message_ptr msg);
/// Asynchronously invoke handler::on_interrupt
/**
* Signals to the connection to asynchronously invoke the on_interrupt
* callback for this connection's handler once it is safe to do so.
*
* When the on_interrupt handler callback is called it will be from
* within the transport event loop with all the thread safety features
* guaranteed by the transport to regular handlers
*
* Multiple interrupt signals can be active at once on the same connection
*
* @return An error code
*/
lib::error_code interrupt();
/// Transport interrupt callback
void handle_interrupt();
/// Pause reading of new data
/**
* Signals to the connection to halt reading of new data. While reading is paused,
* the connection will stop reading from its associated socket. In turn this will
* result in TCP based flow control kicking in and slowing data flow from the remote
* endpoint.
*
* This is useful for applications that push new requests to a queue to be processed
* by another thread and need a way to signal when their request queue is full without
* blocking the network processing thread.
*
* Use `resume_reading()` to resume.
*
* If supported by the transport this is done asynchronously. As such reading may not
* stop until the current read operation completes. Typically you can expect to
* receive no more bytes after initiating a read pause than the size of the read
* buffer.
*
* If reading is paused for this connection already nothing is changed.
*/
lib::error_code pause_reading();
/// Pause reading callback
void handle_pause_reading();
/// Resume reading of new data
/**
* Signals to the connection to resume reading of new data after it was paused by
* `pause_reading()`.
*
* If reading is not paused for this connection already nothing is changed.
*/
lib::error_code resume_reading();
/// Resume reading callback
void handle_resume_reading();
/// Send a ping
/**
* Initiates a ping with the given payload/
*
* There is no feedback directly from ping except in cases of immediately
* detectable errors. Feedback will be provided via on_pong or
* on_pong_timeout callbacks.
*
* Ping locks the m_write_lock mutex
*
* @param payload Payload to be used for the ping
*/
void ping(std::string const & payload);
/// exception free variant of ping
void ping(std::string const & payload, lib::error_code & ec);
/// Utility method that gets called back when the ping timer expires
void handle_pong_timeout(std::string payload, lib::error_code const & ec);
/// Send a pong
/**
* Initiates a pong with the given payload.
*
* There is no feedback from a pong once sent.
*
* Pong locks the m_write_lock mutex
*
* @param payload Payload to be used for the pong
*/
void pong(std::string const & payload);
/// exception free variant of pong
void pong(std::string const & payload, lib::error_code & ec);
/// Close the connection
/**
* Initiates the close handshake process.
*
* If close returns successfully the connection will be in the closing
* state and no additional messages may be sent. All messages sent prior
* to calling close will be written out before the connection is closed.
*
* If no reason is specified none will be sent. If no code is specified
* then no code will be sent.
*
* The handler's on_close callback will be called once the close handshake
* is complete.
*
* Reasons will be automatically truncated to the maximum length (123 bytes)
* if necessary.
*
* @param code The close code to send
* @param reason The close reason to send
*/
void close(close::status::value const code, std::string const & reason);
/// exception free variant of close
void close(close::status::value const code, std::string const & reason,
lib::error_code & ec);
////////////////////////////////////////////////
// Pass-through access to the uri information //
////////////////////////////////////////////////
/// Returns the secure flag from the connection URI
/**
* This value is available after the HTTP request has been fully read and
* may be called from any thread.
*
* @return Whether or not the connection URI is flagged secure.
*/
bool get_secure() const;
/// Returns the host component of the connection URI
/**
* This value is available after the HTTP request has been fully read and
* may be called from any thread.
*
* @return The host component of the connection URI
*/
std::string const & get_host() const;
/// Returns the resource component of the connection URI
/**
* This value is available after the HTTP request has been fully read and
* may be called from any thread.
*
* @return The resource component of the connection URI
*/
std::string const & get_resource() const;
/// Returns the port component of the connection URI
/**
* This value is available after the HTTP request has been fully read and
* may be called from any thread.
*
* @return The port component of the connection URI
*/
uint16_t get_port() const;
/// Gets the connection URI
/**
* This should really only be called by internal library methods unless you
* really know what you are doing.
*
* @return A pointer to the connection's URI
*/
uri_ptr get_uri() const;
/// Sets the connection URI
/**
* This should really only be called by internal library methods unless you
* really know what you are doing.
*
* @param uri The new URI to set
*/
void set_uri(uri_ptr uri);
/////////////////////////////
// Subprotocol negotiation //
/////////////////////////////
/// Gets the negotiated subprotocol
/**
* Retrieves the subprotocol that was negotiated during the handshake. This
* method is valid in the open handler and later.
*
* @return The negotiated subprotocol
*/
std::string const & get_subprotocol() const;
/// Gets all of the subprotocols requested by the client
/**
* Retrieves the subprotocols that were requested during the handshake. This
* method is valid in the validate handler and later.
*
* @return A vector of the requested subprotocol
*/
std::vector<std::string> const & get_requested_subprotocols() const;
/// Adds the given subprotocol string to the request list (exception free)
/**
* Adds a subprotocol to the list to send with the opening handshake. This
* may be called multiple times to request more than one. If the server
* supports one of these, it may choose one. If so, it will return it
* in it's handshake response and the value will be available via
* get_subprotocol(). Subprotocol requests should be added in order of
* preference.
*
* @param[in] request The subprotocol to request
* @param[out] ec A status code describing the outcome of the operation
*/
void add_subprotocol(std::string const & request, lib::error_code & ec);
/// Adds the given subprotocol string to the request list (exception)
/**
* Adds a subprotocol to the list to send with the opening handshake. This
* may be called multiple times to request more than one. If the server
* supports one of these, it may choose one. If so, it will return it
* in it's handshake response and the value will be available via
* get_subprotocol(). Subprotocol requests should be added in order of
* preference.
*
* @param[in] request The subprotocol to request
*/
void add_subprotocol(std::string const & request);
/// Select a subprotocol to use (exception free)
/**
* Indicates which subprotocol should be used for this connection. Valid
* only during the validate handler callback. Subprotocol selected must have
* been requested by the client. Consult get_requested_subprotocols() for a
* list of valid subprotocols.
*
* This member function is valid on server endpoints/connections only
*
* @param[in] value The subprotocol to select
* @param[out] ec A status code describing the outcome of the operation
*/
void select_subprotocol(std::string const & value, lib::error_code & ec);
/// Select a subprotocol to use (exception)
/**
* Indicates which subprotocol should be used for this connection. Valid
* only during the validate handler callback. Subprotocol selected must have
* been requested by the client. Consult get_requested_subprotocols() for a
* list of valid subprotocols.
*
* This member function is valid on server endpoints/connections only
*
* @param[in] value The subprotocol to select
*/
void select_subprotocol(std::string const & value);
/////////////////////////////////////////////////////////////
// Pass-through access to the request and response objects //
/////////////////////////////////////////////////////////////
/// Retrieve a request header
/**
* Retrieve the value of a header from the handshake HTTP request.
*
* @param[in] key Name of the header to get
* @return The value of the header
*/
std::string const & get_request_header(std::string const & key) const;
/// Retrieve a request body
/**
* Retrieve the value of the request body. This value is typically used with
* PUT and POST requests to upload files or other data. Only HTTP
* connections will ever have bodies. WebSocket connection's will always
* have blank bodies.
*
* @return The value of the request body.
*/
std::string const & get_request_body() const;
/// Retrieve a response header
/**
* Retrieve the value of a header from the handshake HTTP request.
*
* @param[in] key Name of the header to get
* @return The value of the header
*/
std::string const & get_response_header(std::string const & key) const;
/// Get response HTTP status code
/**
* Gets the response status code
*
* @since 0.7.0
*
* @return The response status code sent
*/
http::status_code::value get_response_code() const {
return m_response.get_status_code();
}
/// Get response HTTP status message
/**
* Gets the response status message
*
* @since 0.7.0
*
* @return The response status message sent
*/
std::string const & get_response_msg() const {
return m_response.get_status_msg();
}
/// Set response status code and message (exception free)
/**
* Sets the response status code to `code` and looks up the corresponding
* message for standard codes. Non-standard codes will be entered as Unknown
* use set_status(status_code::value,std::string) overload to set both
* values explicitly.
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @since 0.9.0
*
* @param[in] code Code to set
* @param[in] msg Message to set
* @param[out] ec A status code describing the outcome of the operation
* @see websocketpp::http::parser::response::set_status
* @see websocketpp::http::status_code::value (list of valid codes)
*/
void set_status(http::status_code::value code, lib::error_code & ec);
#ifndef _WEBSOCKETPP_NO_EXCEPTIONS_
/// Set response status code and message (exception)
/**
* Sets the response status code and message to independent custom values.
* use set_status(status_code::value) to set the code and have the standard
* message be automatically set.
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @param[in] code Code to set
* @param[in] msg Message to set
* @throw websocketpp::exception
* @see websocketpp::http::parser::response::set_status()
* @see websocketpp::http::status_code::value (list of valid codes)
*/
void set_status(http::status_code::value code);
#endif // _WEBSOCKETPP_NO_EXCEPTIONS_
/// Set response status code and message (exception free)
/**
* Sets the response status code and message to independent custom values.
* use set_status(status_code::value) to set the code and have the standard
* message be automatically set.
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @since 0.9.0
*
* @param[in] code Code to set
* @param[in] msg Message to set
* @param[out] ec A status code describing the outcome of the operation
* @see websocketpp::http::response::set_status()
* @see websocketpp::http::status_code::value (list of valid codes)
*/
void set_status(http::status_code::value code, std::string const & msg,
lib::error_code & ec);
/// Set response status code and message (exception)
/**
* Sets the response status code and message to independent custom values.
* use set_status(status_code::value) to set the code and have the standard
* message be automatically set.
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @param[in] code Code to set
* @param[in] msg Message to set
* @throw websocketpp::exception
* @see websocketpp::http::parser::response::set_status()
* @see websocketpp::http::status_code::value (list of valid codes)
*/
void set_status(http::status_code::value code, std::string const & msg);
/// Set response body content (exception free)
/**
* Set the body content of the HTTP response to the parameter string. Note
* set_body will also set the Content-Length HTTP header to the appropriate
* value. If you want the Content-Length header to be something else set it
* to something else after calling set_body
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @since 0.9.0
*
* @param[in] value String data to include as the body content.
* @param[out] ec A status code describing the outcome of the operation
* @see websocketpp::http::response::set_body
* @see set_body(std::string const &) (exception version)
*/
void set_body(std::string const & value, lib::error_code & ec);
#ifndef _WEBSOCKETPP_NO_EXCEPTIONS_
/// Set response body content (exception)
/**
* Set the body content of the HTTP response to the parameter string. Note
* set_body will also set the Content-Length HTTP header to the appropriate
* value. If you want the Content-Length header to be something else set it
* to something else after calling set_body
*
* This member function is valid only from the http() and validate() handler
* callbacks.
*
* @param[in] value String data to include as the body content.
* @throw websocketpp::exception
* @see websocketpp::http::response::set_body
* @see set_body(std::string const &, lib::error_code &)
* (exception free version)
*/
void set_body(std::string const & value);
#endif // _WEBSOCKETPP_NO_EXCEPTIONS_
#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
/// @copydoc websocketpp::connection::set_body(std::string const &, lib::error_code &)
void set_body(std::string && value, lib::error_code & ec);
#ifndef _WEBSOCKETPP_NO_EXCEPTIONS_
/// @copydoc websocketpp::connection::set_body(std::string const &)
void set_body(std::string && value);
#endif // _WEBSOCKETPP_NO_EXCEPTIONS_
#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
/// Append a header (exception free)
/**
* Set the value of a header in the handshake HTTP request or response. If
* a header with this name already exists the value will be appended to the
* existing header to form a comma separated list of values. Use
* `connection::replace_header` to overwrite existing values.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @since 0.9.0
*
* @param[in] key Name of the header to set
* @param[in] val Value to add
* @param[out] ec A status code describing the outcome of the operation
* @see connection::replace_header
* @see websocketpp::http::parser::parser::append_header
* @see append_header(std::string const &, std::string const &)
* (exception version)
*/
void append_header(std::string const & key, std::string const & val,
lib::error_code & ec);
/// Append a header (exception)
/**
* Set the value of a header in the handshake HTTP request or response. If
* a header with this name already exists the value will be appended to the
* existing header to form a comma separated list of values. Use
* `connection::replace_header` to overwrite existing values.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @param[in] key Name of the header to set
* @param[in] val Value to add
* @throw websocketpp::exception
* @see connection::replace_header
* @see websocketpp::http::parser::parser::append_header
* @see append_header(std::string const &, std::string const &,
* lib::error_code &) (exception free version)
*/
void append_header(std::string const & key, std::string const & val);
/// Replace a header (exception free)
/**
* Set the value of a header in the handshake HTTP request or response. If
* a header with this name already exists the old value will be replaced
* Use `connection::append_header` to append to a list of existing values.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @param[in] key Name of the header to set
* @param[in] val Value to set
* @param[out] ec A status code describing the outcome of the operation
* @see connection::append_header
* @see websocketpp::http::parser::parser::replace_header
* @see replace_header(std::string const &, std::string const &)
* (exception version)
*/
void replace_header(std::string const & key, std::string const & val,
lib::error_code & ec);
/// Replace a header (exception)
/**
* Set the value of a header in the handshake HTTP request or response. If
* a header with this name already exists the old value will be replaced
* Use `connection::append_header` to append to a list of existing values.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @param[in] key Name of the header to set
* @param[in] val Value to set
* @throw websocketpp::exception
* @see connection::append_header
* @see websocketpp::http::parser::parser::replace_header
* @see replace_header(std::string const & key, std::string const & val,
* lib::error_code & ec) (exception free version)
*/
void replace_header(std::string const & key, std::string const & val);
/// Remove a header (exception free)
/**
* Removes a header from the handshake HTTP request or response.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @param[in] key The name of the header to remove
* @param[out] ec A status code describing the outcome of the operation
* @see websocketpp::http::parser::parser::remove_header
* @see remove_header(std::string const &) (exception version)
*/
void remove_header(std::string const & key, lib::error_code & ec);
/// Remove a header (exception)
/**
* Removes a header from the handshake HTTP request or response.
*
* *When can this member function be called?*
* - Servers: Valid from the http and validate handlers
* - Clients: Valid before websocketpp::client::connect() has been called
*
* @param[in] key The name of the header to remove
* @throw websocketpp::exception
* @see websocketpp::http::parser::parser::remove_header
* @see remove_header(std::string const &, lib::error_code &)
* (exception free version)
*/
void remove_header(std::string const & key);
/// Get request object
/**
* Direct access to request object. This can be used to call methods of the
* request object that are not part of the standard request API that
* connection wraps.
*
* Note use of this method involves using behavior specific to the
* configured HTTP policy. Such behavior may not work with alternate HTTP
* policies.
*
* @since 0.3.0-alpha3
*
* @return A const reference to the raw request object
*/
request_type const & get_request() const {
return m_request;
}
/// Get response object
/**
* Direct access to the HTTP response sent or received as a part of the
* opening handshake. This can be used to call methods of the response
* object that are not part of the standard request API that connection
* wraps.
*
* Note use of this method involves using behavior specific to the
* configured HTTP policy. Such behavior may not work with alternate HTTP
* policies.
*
* @since 0.7.0
*
* @return A const reference to the raw response object
*/
response_type const & get_response() const {
return m_response;
}
/// Defer HTTP Response until later (Exception free)
/**
* Used in the http handler to defer the HTTP response for this connection
* until later. Handshake timers will be canceled and the connection will
* be left open until `send_http_response` or an equivalent is called.
*
* Warning: deferred connections won't time out and as a result can tie up
* resources.
*
* @since 0.6.0
*
* @return A status code, zero on success, non-zero otherwise
*/
lib::error_code defer_http_response();
/// Send deferred HTTP Response (exception free)
/**
* Sends an http response to an HTTP connection that was deferred. This will
* send a complete response including all headers, status line, and body
* text. The connection will be closed afterwards.
*
* @since 0.6.0
*
* @param ec A status code, zero on success, non-zero otherwise
*/
void send_http_response(lib::error_code & ec);
/// Send deferred HTTP Response
void send_http_response();
// TODO HTTPNBIO: write_headers
// function that processes headers + status so far and writes it to the wire
// beginning the HTTP response body state. This method will ignore anything
// in the response body.
// TODO HTTPNBIO: write_body_message
// queues the specified message_buffer for async writing
// TODO HTTPNBIO: finish connection
//
// TODO HTTPNBIO: write_response
// Writes the whole response, headers + body and closes the connection
/////////////////////////////////////////////////////////////
// Pass-through access to the other connection information //
/////////////////////////////////////////////////////////////
/// Get Connection Handle
/**
* The connection handle is a token that can be shared outside the
* WebSocket++ core for the purposes of identifying a connection and
* sending it messages.
*
* @return A handle to the connection
*/
connection_hdl get_handle() const {
return m_connection_hdl;
}
/// Get whether or not this connection is part of a server or client
/**
* @return whether or not the connection is attached to a server endpoint
*/
bool is_server() const {
return m_is_server;
}
/// Return the same origin policy origin value from the opening request.
/**
* This value is available after the HTTP request has been fully read and
* may be called from any thread.
*
* @return The connection's origin value from the opening handshake.
*/
std::string const & get_origin() const;
/// Return the connection state.
/**
* Values can be connecting, open, closing, and closed
*
* @return The connection's current state.
*/
session::state::value get_state() const;
/// Get the WebSocket close code sent by this endpoint.
/**
* @return The WebSocket close code sent by this endpoint.
*/
close::status::value get_local_close_code() const {
return m_local_close_code;
}
/// Get the WebSocket close reason sent by this endpoint.
/**
* @return The WebSocket close reason sent by this endpoint.
*/
std::string const & get_local_close_reason() const {
return m_local_close_reason;
}
/// Get the WebSocket close code sent by the remote endpoint.
/**
* @return The WebSocket close code sent by the remote endpoint.
*/
close::status::value get_remote_close_code() const {
return m_remote_close_code;
}
/// Get the WebSocket close reason sent by the remote endpoint.
/**
* @return The WebSocket close reason sent by the remote endpoint.
*/
std::string const & get_remote_close_reason() const {
return m_remote_close_reason;
}
/// Get the internal error code for a closed/failed connection
/**
* Retrieves a machine readable detailed error code indicating the reason
* that the connection was closed or failed. Valid only after the close or
* fail handler is called.
*
* @return Error code indicating the reason the connection was closed or
* failed
*/
lib::error_code get_ec() const {
return m_ec;
}
/// Get a message buffer
/**
* Warning: The API related to directly sending message buffers may change
* before the 1.0 release. If you plan to use it, please keep an eye on any
* breaking changes notifications in future release notes. Also if you have
* any feedback about usage and capabilities now is a great time to provide
* it.
*
* Message buffers are used to store message payloads and other message
* metadata.
*
* The size parameter is a hint only. Your final payload does not need to
* match it. There may be some performance benefits if the initial size
* guess is equal to or slightly higher than the final payload size.
*
* @param op The opcode for the new message
* @param size A hint to optimize the initial allocation of payload space.
* @return A new message buffer
*/
message_ptr get_message(websocketpp::frame::opcode::value op, size_t size)
const
{
return m_msg_manager->get_message(op, size);
}
////////////////////////////////////////////////////////////////////////
// The remaining public member functions are for internal/policy use //
// only. Do not call from application code unless you understand what //
// you are doing. //
////////////////////////////////////////////////////////////////////////
void read_handshake(size_t num_bytes);
void handle_read_handshake(lib::error_code const & ec,
size_t bytes_transferred);
void handle_read_http_response(lib::error_code const & ec,
size_t bytes_transferred);
void handle_write_http_response(lib::error_code const & ec);
void handle_send_http_request(lib::error_code const & ec);
void handle_open_handshake_timeout(lib::error_code const & ec);
void handle_close_handshake_timeout(lib::error_code const & ec);
void handle_read_frame(lib::error_code const & ec, size_t bytes_transferred);
void read_frame();
/// Get array of WebSocket protocol versions that this connection supports.
std::vector<int> const & get_supported_versions() const;
/// Sets the handler for a terminating connection. Should only be used
/// internally by the endpoint class.
void set_termination_handler(termination_handler new_handler);
void terminate(lib::error_code const & ec);
void handle_terminate(terminate_status tstat, lib::error_code const & ec);
/// Checks if there are frames in the send queue and if there are sends one
/**
* \todo unit tests
*
* This method locks the m_write_lock mutex
*/
void write_frame();
/// Process the results of a frame write operation and start the next write
/**
* \todo unit tests
*
* This method locks the m_write_lock mutex
*
* @param terminate Whether or not to terminate the connection upon
* completion of this write.
*
* @param ec A status code from the transport layer, zero on success,
* non-zero otherwise.
*/
void handle_write_frame(lib::error_code const & ec);
// protected:
// This set of methods would really like to be protected, but doing so
// requires that the endpoint be able to friend the connection. This is
// allowed with C++11, but not prior versions
/// Start the connection state machine
void start();
/// Set Connection Handle
/**
* The connection handle is a token that can be shared outside the
* WebSocket++ core for the purposes of identifying a connection and
* sending it messages.
*
* @param hdl A connection_hdl that the connection will use to refer
* to itself.
*/
void set_handle(connection_hdl hdl) {
m_connection_hdl = hdl;
transport_con_type::set_handle(hdl);
}
protected:
void handle_transport_init(lib::error_code const & ec);
/// Set m_processor based on information in m_request. Set m_response
/// status and return an error code indicating status.
lib::error_code initialize_processor();
/// Perform WebSocket handshake validation of m_request using m_processor.
/// set m_response and return an error code indicating status.
lib::error_code process_handshake_request();
private:
/// Completes m_response, serializes it, and sends it out on the wire.
void write_http_response(lib::error_code const & ec);
/// Sends an opening WebSocket connect request
void send_http_request();
/// Alternate path for write_http_response in error conditions
void write_http_response_error(lib::error_code const & ec);
/// Process control message
/**
*
*/
void process_control_frame(message_ptr msg);
/// Send close acknowledgement
/**
* If no arguments are present no close code/reason will be specified.
*
* Note: the close code/reason values provided here may be overridden by
* other settings (such as silent close).
*
* @param code The close code to send
* @param reason The close reason to send
* @return A status code, zero on success, non-zero otherwise
*/
lib::error_code send_close_ack(close::status::value code =
close::status::blank, std::string const & reason = std::string());
/// Send close frame
/**
* If no arguments are present no close code/reason will be specified.
*
* Note: the close code/reason values provided here may be overridden by
* other settings (such as silent close).
*
* The ack flag determines what to do in the case of a blank status and
* whether or not to terminate the TCP connection after sending it.
*
* @param code The close code to send
* @param reason The close reason to send
* @param ack Whether or not this is an acknowledgement close frame
* @return A status code, zero on success, non-zero otherwise
*/
lib::error_code send_close_frame(close::status::value code =
close::status::blank, std::string const & reason = std::string(), bool ack = false,
bool terminal = false);
/// Get a pointer to a new WebSocket protocol processor for a given version
/**
* @param version Version number of the WebSocket protocol to get a
* processor for. Negative values indicate invalid/unknown versions and will
* always return a null ptr
*
* @return A shared_ptr to a new instance of the appropriate processor or a
* null ptr if there is no installed processor that matches the version
* number.
*/
processor_ptr get_processor(int version) const;
/// Add a message to the write queue
/**
* Adds a message to the write queue and updates any associated shared state
*
* Must be called while holding m_write_lock
*
* @todo unit tests
*
* @param msg The message to push
*/
void write_push(message_ptr msg);
/// Pop a message from the write queue
/**
* Removes and returns a message from the write queue and updates any
* associated shared state.
*
* Must be called while holding m_write_lock
*
* @todo unit tests
*
* @return the message_ptr at the front of the queue
*/
message_ptr write_pop();
/// Prints information about the incoming connection to the access log
/**
* Prints information about the incoming connection to the access log.
* Includes: connection type, websocket version, remote endpoint, user agent
* path, status code.
*/
void log_open_result();
/// Prints information about a connection being closed to the access log
/**
* Includes: local and remote close codes and reasons
*/
void log_close_result();
/// Prints information about a connection being failed to the access log
/**
* Includes: error code and message for why it was failed
*/
void log_fail_result();
/// Prints information about HTTP connections
/**
* Includes: TODO
*/
void log_http_result();
/// Prints information about an arbitrary error code on the specified channel
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());
}
// internal handler functions
read_handler m_handle_read_frame;
write_frame_handler m_write_frame_handler;
// static settings
std::string const m_user_agent;
/// Pointer to the connection handle
connection_hdl m_connection_hdl;
/// Handler objects
open_handler m_open_handler;
close_handler m_close_handler;
fail_handler m_fail_handler;
ping_handler m_ping_handler;
pong_handler m_pong_handler;
pong_timeout_handler m_pong_timeout_handler;
interrupt_handler m_interrupt_handler;
http_handler m_http_handler;
validate_handler m_validate_handler;
message_handler m_message_handler;
/// constant values
long m_open_handshake_timeout_dur;
long m_close_handshake_timeout_dur;
long m_pong_timeout_dur;
size_t m_max_message_size;
/// External connection state
/**
* Lock: m_connection_state_lock
*/
session::state::value m_state;
/// Internal connection state
/**
* Lock: m_connection_state_lock
*/
istate_type m_internal_state;
mutable mutex_type m_connection_state_lock;
/// The lock used to protect the message queue
/**
* Serializes access to the write queue as well as shared state within the
* processor.
*/
mutex_type m_write_lock;
// connection resources
char m_buf[config::connection_read_buffer_size];
size_t m_buf_cursor;
termination_handler m_termination_handler;
con_msg_manager_ptr m_msg_manager;
timer_ptr m_handshake_timer;
timer_ptr m_ping_timer;
/// @todo this is not memory efficient. this value is not used after the
/// handshake.
std::string m_handshake_buffer;
/// Pointer to the processor object for this connection
/**
* The processor provides functionality that is specific to the WebSocket
* protocol version that the client has negotiated. It also contains all of
* the state necessary to encode and decode the incoming and outgoing
* WebSocket byte streams
*
* Use of the prepare_data_frame method requires lock: m_write_lock
*/
processor_ptr m_processor;
/// Queue of unsent outgoing messages
/**
* Lock: m_write_lock
*/
std::queue<message_ptr> m_send_queue;
/// Size in bytes of the outstanding payloads in the write queue
/**
* Lock: m_write_lock
*/
size_t m_send_buffer_size;
/// buffer holding the various parts of the current message being written
/**
* Lock m_write_lock
*/
std::vector<transport::buffer> m_send_buffer;
/// a list of pointers to hold on to the messages being written to keep them
/// from going out of scope before the write is complete.
std::vector<message_ptr> m_current_msgs;
/// True if there is currently an outstanding transport write
/**
* Lock m_write_lock
*/
bool m_write_flag;
/// True if this connection is presently reading new data
bool m_read_flag;
// connection data
request_type m_request;
response_type m_response;
uri_ptr m_uri;
std::string m_subprotocol;
// connection data that might not be necessary to keep around for the life
// of the whole connection.
std::vector<std::string> m_requested_subprotocols;
bool const m_is_server;
const lib::shared_ptr<alog_type> m_alog;
const lib::shared_ptr<elog_type> m_elog;
rng_type & m_rng;
// Close state
/// Close code that was sent on the wire by this endpoint
close::status::value m_local_close_code;
/// Close reason that was sent on the wire by this endpoint
std::string m_local_close_reason;
/// Close code that was received on the wire from the remote endpoint
close::status::value m_remote_close_code;
/// Close reason that was received on the wire from the remote endpoint
std::string m_remote_close_reason;
/// Detailed internal error code
lib::error_code m_ec;
/// A flag that gets set once it is determined that the connection is an
/// HTTP connection and not a WebSocket one.
bool m_is_http;
/// A flag that gets set when the completion of an http connection is
/// deferred until later.
session::http_state::value m_http_state;
bool m_was_clean;
};
} // namespace websocketpp
#include <websocketpp/impl/connection_impl.hpp>
#endif // WEBSOCKETPP_CONNECTION_HPP
_WEBSOCKETPP_CPP11_FUNCTIONAL_
#define _WEBSOCKETPP_CPP11_FUNCTIONAL_
Definition boost_config.hpp:41
_WEBSOCKETPP_CPP11_THREAD_
#define _WEBSOCKETPP_CPP11_THREAD_
Definition boost_config.hpp:61
_WEBSOCKETPP_CPP11_MEMORY_
#define _WEBSOCKETPP_CPP11_MEMORY_
Definition boost_config.hpp:40
_WEBSOCKETPP_CPP11_SYSTEM_ERROR_
#define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
Definition boost_config.hpp:57
_WEBSOCKETPP_INITIALIZER_LISTS_
#define _WEBSOCKETPP_INITIALIZER_LISTS_
Definition boost_config.hpp:65
broadcast_server
Definition simple_broadcast_server.cpp:13
websocketpp::concurrency::basic
Concurrency policy that uses std::mutex / boost::mutex.
Definition basic.hpp:37
websocketpp::connection_base
Stub for user supplied base class.
Definition connection_base.hpp:34
websocketpp::connection
Represents an individual WebSocket connection.
Definition connection.hpp:238
websocketpp::connection::get_shared
ptr get_shared()
Get a shared pointer to this component.
Definition connection.hpp:336
websocketpp::connection::handle_interrupt
void handle_interrupt()
Transport interrupt callback.
Definition connection_impl.hpp:359
websocketpp::connection::set_message_handler
void set_message_handler(message_handler h)
Set message handler.
Definition connection.hpp:473
websocketpp::connection::interrupt
lib::error_code interrupt()
Asynchronously invoke handler::on_interrupt.
Definition connection_impl.hpp:347
websocketpp::connection::start
void start()
Start the connection state machine.
Definition connection_impl.hpp:820
websocketpp::connection::get_request_body
std::string const & get_request_body() const
Retrieve a request body.
Definition connection_impl.hpp:544
websocketpp::connection::transport_con_type
config::transport_type::transport_con_type transport_con_type
Type of the transport component of this connection.
Definition connection.hpp:256
websocketpp::connection::set_close_handler
void set_close_handler(close_handler h)
Set close handler.
Definition connection.hpp:361
websocketpp::connection::send
lib::error_code send(message_ptr msg)
Add a message to the outgoing send queue.
websocketpp::connection::alog_type
config::alog_type alog_type
Type of the access logging policy.
Definition connection.hpp:250
websocketpp::connection::get_response_code
http::status_code::value get_response_code() const
Get response HTTP status code.
Definition connection.hpp:981
websocketpp::connection::defer_http_response
lib::error_code defer_http_response()
Defer HTTP Response until later (Exception free).
Definition connection_impl.hpp:763
websocketpp::connection::resume_reading
lib::error_code resume_reading()
Resume reading of new data.
Definition connection_impl.hpp:384
websocketpp::connection::get_secure
bool get_secure() const
Returns the secure flag from the connection URI.
Definition connection_impl.hpp:412
websocketpp::connection::set_close_handshake_timeout
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition connection.hpp:525
websocketpp::connection::get_buffered_amount
size_t get_buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes).
Definition connection_impl.hpp:71
websocketpp::connection::get_origin
std::string const & get_origin() const
Return the same origin policy origin value from the opening request.
Definition connection_impl.hpp:65
websocketpp::connection::get_host
std::string const & get_host() const
Returns the host component of the connection URI.
Definition connection_impl.hpp:418
websocketpp::connection::get_response
response_type const & get_response() const
Get response object.
Definition connection.hpp:1272
websocketpp::connection::set_max_message_size
void set_max_message_size(size_t new_value)
Set maximum message size.
Definition connection.hpp:575
websocketpp::connection::get_resource
std::string const & get_resource() const
Returns the resource component of the connection URI.
Definition connection_impl.hpp:424
websocketpp::connection::process_handshake_request
lib::error_code process_handshake_request()
Definition connection_impl.hpp:1288
websocketpp::connection::handle_pause_reading
void handle_pause_reading()
Pause reading callback.
Definition connection_impl.hpp:378
websocketpp::connection::get_supported_versions
std::vector< int > const & get_supported_versions() const
Get array of WebSocket protocol versions that this connection supports.
Definition connection_impl.hpp:2070
websocketpp::connection::send
lib::error_code send(void const *payload, size_t len, frame::opcode::value op=frame::opcode::binary)
Send a message (raw array overload).
Definition connection_impl.hpp:94
websocketpp::connection::get_uri
uri_ptr get_uri() const
Gets the connection URI.
Definition connection_impl.hpp:436
websocketpp::connection::get_handle
connection_hdl get_handle() const
Get Connection Handle.
Definition connection.hpp:1334
websocketpp::connection::send_http_response
void send_http_response(lib::error_code &ec)
Send deferred HTTP Response (exception free).
Definition connection_impl.hpp:788
websocketpp::connection::type
connection< config > type
Type of this connection.
Definition connection.hpp:241
websocketpp::connection::set_http_handler
void set_http_handler(http_handler h)
Set http handler.
Definition connection.hpp:447
websocketpp::connection::get_response_msg
std::string const & get_response_msg() const
Get response HTTP status message.
Definition connection.hpp:993
websocketpp::connection::elog_type
config::elog_type elog_type
Type of the error logging policy.
Definition connection.hpp:252
websocketpp::connection::get_message
message_ptr get_message(websocketpp::frame::opcode::value op, size_t size) const
Get a message buffer.
Definition connection.hpp:1428
websocketpp::connection::handle_write_frame
void handle_write_frame(lib::error_code const &ec)
Process the results of a frame write operation and start the next write.
Definition connection_impl.hpp:2028
websocketpp::connection::get_local_close_code
close::status::value get_local_close_code() const
Get the WebSocket close code sent by this endpoint.
Definition connection.hpp:1368
websocketpp::connection::get_ec
lib::error_code get_ec() const
Get the internal error code for a closed/failed connection.
Definition connection.hpp:1405
websocketpp::connection::set_status
void set_status(http::status_code::value code, lib::error_code &ec)
Set response status code and message (exception free).
Definition connection_impl.hpp:555
websocketpp::connection::set_fail_handler
void set_fail_handler(fail_handler h)
Set fail handler.
Definition connection.hpp:372
websocketpp::connection::write_frame
void write_frame()
Checks if there are frames in the send queue and if there are sends one.
Definition connection_impl.hpp:1932
websocketpp::connection::get_state
session::state::value get_state() const
Return the connection state.
Definition connection_impl.hpp:77
websocketpp::connection::set_status
void set_status(http::status_code::value code)
Set response status code and message (exception).
Definition connection_impl.hpp:567
websocketpp::connection::get_max_http_body_size
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition connection.hpp:594
websocketpp::connection::concurrency_type
config::concurrency_type concurrency_type
Type of the concurrency component of this connection.
Definition connection.hpp:248
websocketpp::connection::timer_ptr
transport_con_type::timer_ptr timer_ptr
Type of a pointer to a transport timer handle.
Definition connection.hpp:284
websocketpp::connection::set_validate_handler
void set_validate_handler(validate_handler h)
Set validate handler.
Definition connection.hpp:463
websocketpp::connection::set_interrupt_handler
void set_interrupt_handler(interrupt_handler h)
Set interrupt handler.
Definition connection.hpp:432
websocketpp::connection::buffered_amount
size_t buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes).
Definition connection.hpp:635
websocketpp::connection::send_http_response
void send_http_response()
Send deferred HTTP Response.
Definition connection_impl.hpp:805
websocketpp::connection::get_remote_close_code
close::status::value get_remote_close_code() const
Get the WebSocket close code sent by the remote endpoint.
Definition connection.hpp:1384
websocketpp::connection::set_open_handler
void set_open_handler(open_handler h)
Set open handler.
Definition connection.hpp:351
websocketpp::connection::is_server
bool is_server() const
Get whether or not this connection is part of a server or client.
Definition connection.hpp:1342
websocketpp::connection::ptr
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection.
Definition connection.hpp:243
websocketpp::connection::get_remote_close_reason
std::string const & get_remote_close_reason() const
Get the WebSocket close reason sent by the remote endpoint.
Definition connection.hpp:1392
websocketpp::connection::set_pong_timeout
void set_pong_timeout(long dur)
Set pong timeout.
Definition connection.hpp:546
websocketpp::connection::initialize_processor
lib::error_code initialize_processor()
Definition connection_impl.hpp:1246
websocketpp::connection::set_uri
void set_uri(uri_ptr uri)
Sets the connection URI.
Definition connection_impl.hpp:442
websocketpp::connection::set_termination_handler
void set_termination_handler(termination_handler new_handler)
Definition connection_impl.hpp:53
websocketpp::connection::get_request
request_type const & get_request() const
Get request object.
Definition connection.hpp:1253
websocketpp::connection::set_max_http_body_size
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition connection.hpp:610
websocketpp::connection::transport_con_ptr
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the transport component of this connection.
Definition connection.hpp:258
websocketpp::connection::set_open_handshake_timeout
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition connection.hpp:501
websocketpp::connection::pause_reading
lib::error_code pause_reading()
Pause reading of new data.
Definition connection_impl.hpp:366
websocketpp::connection::handle_resume_reading
void handle_resume_reading()
Resume reading callback.
Definition connection_impl.hpp:396
websocketpp::connection::get_requested_subprotocols
std::vector< std::string > const & get_requested_subprotocols() const
Gets all of the subprotocols requested by the client.
Definition connection_impl.hpp:459
websocketpp::connection::get_subprotocol
std::string const & get_subprotocol() const
Gets the negotiated subprotocol.
Definition connection_impl.hpp:453
websocketpp::connection::set_handle
void set_handle(connection_hdl hdl)
Set Connection Handle.
Definition connection.hpp:1507
websocketpp::connection::read_frame
void read_frame()
Issue a new transport read unless reading is paused.
Definition connection_impl.hpp:1225
websocketpp::connection::get_port
uint16_t get_port() const
Returns the port component of the connection URI.
Definition connection_impl.hpp:430
websocketpp::connection::get_local_close_reason
std::string const & get_local_close_reason() const
Get the WebSocket close reason sent by this endpoint.
Definition connection.hpp:1376
websocketpp::connection::get_max_message_size
size_t get_max_message_size() const
Get maximum message size.
Definition connection.hpp:559
websocketpp::connection::rng_type
config::rng_type rng_type
Type of RNG.
Definition connection.hpp:275
websocketpp::endpoint_base
Stub for user supplied base class.
Definition endpoint_base.hpp:34
websocketpp::endpoint
Creates and manages connections associated with a WebSocket endpoint.
Definition endpoint.hpp:44
websocketpp::endpoint::set_max_http_body_size
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition endpoint.hpp:468
websocketpp::endpoint::get_con_from_hdl
connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code &ec)
Retrieves a connection_ptr from a connection_hdl (exception free).
Definition endpoint.hpp:644
websocketpp::endpoint::concurrency_type
config::concurrency_type concurrency_type
Type of the concurrency component of this endpoint.
Definition endpoint.hpp:53
websocketpp::endpoint::alog_type
config::alog_type alog_type
Type of access logger.
Definition endpoint.hpp:77
websocketpp::endpoint::get_alog
alog_type & get_alog()
Get reference to access logger.
Definition endpoint.hpp:263
websocketpp::endpoint::transport_con_ptr
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:67
websocketpp::endpoint::get_user_agent
std::string get_user_agent() const
Returns the user agent string that this endpoint will use.
Definition endpoint.hpp:171
websocketpp::endpoint::clear_access_channels
void clear_access_channels(log::level channels)
Clear Access logging channels.
Definition endpoint.hpp:233
websocketpp::endpoint::resume_reading
void resume_reading(connection_hdl hdl)
Resume reading of new data.
Definition endpoint_impl.hpp:205
websocketpp::endpoint::elog_type
config::elog_type elog_type
Type of error logger.
Definition endpoint.hpp:75
websocketpp::endpoint::get_elog
elog_type & get_elog()
Get reference to error logger.
Definition endpoint.hpp:271
websocketpp::endpoint::is_server
bool is_server() const
Returns whether or not this endpoint is a server.
Definition endpoint.hpp:207
websocketpp::endpoint::~endpoint
~endpoint()
Destructor.
Definition endpoint.hpp:114
websocketpp::endpoint::set_close_handshake_timeout
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition endpoint.hpp:379
websocketpp::endpoint::message_ptr
connection_type::message_ptr message_ptr
Type of message pointers that this endpoint uses.
Definition endpoint.hpp:72
websocketpp::endpoint::set_access_channels
void set_access_channels(log::level channels)
Set Access logging channel.
Definition endpoint.hpp:222
websocketpp::endpoint::set_max_message_size
void set_max_message_size(size_t new_value)
Set default maximum message size.
Definition endpoint.hpp:434
websocketpp::endpoint::get_max_message_size
size_t get_max_message_size() const
Get default maximum message size.
Definition endpoint.hpp:417
websocketpp::endpoint::get_con_from_hdl
connection_ptr get_con_from_hdl(connection_hdl hdl)
Retrieves a connection_ptr from a connection_hdl (exception version).
Definition endpoint.hpp:655
websocketpp::endpoint::connection_type
connection connection_type
Type of the connections that this endpoint creates.
Definition endpoint.hpp:56
websocketpp::endpoint::set_error_channels
void set_error_channels(log::level channels)
Set Error logging channel.
Definition endpoint.hpp:244
websocketpp::endpoint::transport_type
config::transport_type transport_type
Type of the transport component of this endpoint.
Definition endpoint.hpp:51
websocketpp::endpoint::clear_error_channels
void clear_error_channels(log::level channels)
Clear Error logging channels.
Definition endpoint.hpp:255
websocketpp::endpoint::resume_reading
void resume_reading(connection_hdl hdl, lib::error_code &ec)
Resume reading of new data (exception free).
Definition endpoint_impl.hpp:114
websocketpp::endpoint::connection_ptr
connection_type::ptr connection_ptr
Shared pointer to connection_type.
Definition endpoint.hpp:58
websocketpp::endpoint::transport_con_type
transport_type::transport_con_type transport_con_type
Definition endpoint.hpp:64
websocketpp::endpoint::mutex_type
concurrency_type::mutex_type mutex_type
Type of our concurrency policy's mutex object.
Definition endpoint.hpp:82
websocketpp::endpoint::interrupt
void interrupt(connection_hdl hdl, lib::error_code &ec)
Definition endpoint_impl.hpp:94
websocketpp::endpoint::set_pong_timeout
void set_pong_timeout(long dur)
Set pong timeout.
Definition endpoint.hpp:401
websocketpp::endpoint::get_max_http_body_size
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition endpoint.hpp:451
websocketpp::endpoint::set_open_handshake_timeout
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition endpoint.hpp:354
websocketpp::endpoint::rng_type
config::rng_type rng_type
Type of RNG.
Definition endpoint.hpp:85
websocketpp::endpoint::scoped_lock_type
concurrency_type::scoped_lock_type scoped_lock_type
Type of our concurrency policy's scoped lock object.
Definition endpoint.hpp:80
websocketpp::endpoint::send_http_response
void send_http_response(connection_hdl hdl, lib::error_code &ec)
Send deferred HTTP Response.
Definition endpoint_impl.hpp:123
websocketpp::endpoint::pause_reading
void pause_reading(connection_hdl hdl, lib::error_code &ec)
Pause reading of new data (exception free).
Definition endpoint_impl.hpp:105
websocketpp::endpoint::send_http_response
void send_http_response(connection_hdl hdl)
Send deferred HTTP Response (exception free).
Definition endpoint_impl.hpp:212
websocketpp::endpoint::pause_reading
void pause_reading(connection_hdl hdl)
Pause reading of new data.
Definition endpoint_impl.hpp:198
websocketpp::endpoint::message_handler
connection_type::message_handler message_handler
Type of message_handler.
Definition endpoint.hpp:70
websocketpp::endpoint::connection_weak_ptr
connection_type::weak_ptr connection_weak_ptr
Weak pointer to connection type.
Definition endpoint.hpp:60
websocketpp::error::category
Definition error.hpp:153
websocketpp::exception
Definition error.hpp:256
websocketpp::extensions::error::category
Definition extension.hpp:61
websocketpp::extensions::permessage_deflate::disabled
Stub class for use when disabling permessage_deflate extension.
Definition disabled.hpp:53
websocketpp::extensions::permessage_deflate::disabled::is_implemented
bool is_implemented() const
Definition disabled.hpp:82
websocketpp::extensions::permessage_deflate::disabled::negotiate
err_str_pair negotiate(http::attribute_list const &)
Negotiate extension.
Definition disabled.hpp:65
websocketpp::extensions::permessage_deflate::disabled::is_enabled
bool is_enabled() const
Definition disabled.hpp:88
websocketpp::extensions::permessage_deflate::disabled::generate_offer
std::string generate_offer() const
Generate extension offer.
Definition disabled.hpp:99
websocketpp::extensions::permessage_deflate::disabled::init
lib::error_code init(bool)
Initialize state.
Definition disabled.hpp:76
websocketpp::http::error::category
HTTP parser error category.
Definition constants.hpp:399
websocketpp::http::exception
An exception type specific to HTTP errors.
Definition constants.hpp:300
websocketpp::http::parser::parser
Base HTTP parser.
Definition parser.hpp:398
websocketpp::http::parser::parser::get_headers
header_list const & get_headers() const
Return a list of all HTTP headers.
Definition parser.hpp:211
websocketpp::http::parser::parser::get_body
std::string const & get_body() const
Get HTTP body.
Definition parser.hpp:515
websocketpp::http::parser::parser::body_ready
bool body_ready() const
Check if the parser is done parsing the body.
Definition parser.hpp:618
websocketpp::http::parser::parser::set_max_body_size
void set_max_body_size(size_t value)
Set body size limit.
Definition parser.hpp:555
websocketpp::http::parser::parser::prepare_body
bool prepare_body(lib::error_code &ec)
Prepare the parser to begin parsing body data.
Definition parser.hpp:143
websocketpp::http::parser::parser::raw_headers
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition parser.hpp:215
websocketpp::http::parser::parser::process_body
size_t process_body(char const *buf, size_t len, lib::error_code &ec)
Process body data.
Definition parser.hpp:172
websocketpp::http::parser::parser::get_version
std::string const & get_version() const
Get the HTTP version string.
Definition parser.hpp:410
websocketpp::http::parser::parser::get_max_body_size
size_t get_max_body_size() const
Get body size limit.
Definition parser.hpp:542
websocketpp::http::parser::parser::process_header
lib::error_code process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition parser.hpp:191
websocketpp::http::parser::request
Stores, parses, and manipulates HTTP requests.
Definition request.hpp:50
websocketpp::http::parser::request::raw
std::string raw() const
Returns the full raw request (including the body).
Definition request.hpp:195
websocketpp::http::parser::request::get_uri
std::string const & get_uri() const
Return the requested URI.
Definition request.hpp:123
websocketpp::http::parser::request::get_method
std::string const & get_method() const
Return the request method.
Definition request.hpp:107
websocketpp::http::parser::request::ready
bool ready() const
Returns whether or not the request is ready for reading.
Definition request.hpp:85
websocketpp::http::parser::request::consume
size_t consume(char const *buf, size_t len, lib::error_code &ec)
Process bytes in the input buffer.
Definition request.hpp:41
websocketpp::http::parser::request::raw_head
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request).
Definition request.hpp:205
websocketpp::http::parser::response
Stores, parses, and manipulates HTTP responses.
Definition response.hpp:57
websocketpp::http::parser::response::raw
std::string raw() const
Returns the full raw response.
Definition response.hpp:246
websocketpp::http::parser::response::consume
size_t consume(char const *buf, size_t len, lib::error_code &ec)
Process bytes in the input buffer.
Definition response.hpp:42
websocketpp::http::parser::response::headers_ready
bool headers_ready() const
Returns true if the response headers are fully parsed.
Definition response.hpp:149
websocketpp::http::parser::response::consume
size_t consume(std::istream &s, lib::error_code &ec)
Process bytes in the input buffer (istream version).
Definition response.hpp:189
websocketpp::http::parser::response::set_status
lib::error_code set_status(status_code::value code)
Set response status code and message.
Definition response.hpp:259
websocketpp::http::parser::response::ready
bool ready() const
Returns true if the response is ready.
Definition response.hpp:144
websocketpp::http::parser::response::get_status_msg
const std::string & get_status_msg() const
Return the response status message.
Definition response.hpp:190
websocketpp::http::parser::response::get_status_code
status_code::value get_status_code() const
Return the response status code.
Definition response.hpp:185
websocketpp::log::basic
Basic logger that outputs to an ostream.
Definition basic.hpp:59
websocketpp::log::basic::write
void write(level channel, char const *msg)
Write a cstring message to the given channel.
Definition basic.hpp:151
websocketpp::log::basic::basic
basic(basic< concurrency, names > const &other)
Copy constructor.
Definition basic.hpp:87
websocketpp::log::basic::~basic
~basic()
Destructor.
Definition basic.hpp:84
websocketpp::message_buffer::alloc::con_msg_manager
Definition alloc.hpp:43
websocketpp::message_buffer::alloc::con_msg_manager::recycle
bool recycle(message *)
Recycle a message.
Definition alloc.hpp:80
websocketpp::message_buffer::alloc::con_msg_manager::get_message
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
Definition alloc.hpp:66
websocketpp::message_buffer::alloc::con_msg_manager::get_message
message_ptr get_message()
Get an empty message buffer.
Definition alloc.hpp:55
websocketpp::message_buffer::alloc::endpoint_msg_manager
Definition alloc.hpp:88
websocketpp::message_buffer::alloc::endpoint_msg_manager::get_manager
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Definition alloc.hpp:96
websocketpp::message_buffer::message
Represents a buffer for a single WebSocket message.
Definition message.hpp:84
websocketpp::message_buffer::message::message
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
Definition message.hpp:107
websocketpp::message_buffer::message::get_raw_payload
std::string & get_raw_payload()
Get a non-const reference to the payload string.
Definition message.hpp:254
websocketpp::message_buffer::message::recycle
bool recycle()
Recycle the message.
Definition message.hpp:316
websocketpp::message_buffer::message::get_compressed
bool get_compressed() const
Return whether or not the message is flagged as compressed.
Definition message.hpp:143
websocketpp::message_buffer::message::get_terminal
bool get_terminal() const
Get whether or not the message is terminal.
Definition message.hpp:169
websocketpp::message_buffer::message::get_header
std::string const & get_header() const
Return the prepared frame header.
Definition message.hpp:224
websocketpp::message_buffer::message::set_payload
void set_payload(void const *payload, size_t len)
Set payload data.
Definition message.hpp:275
websocketpp::message_buffer::message::get_fin
bool get_fin() const
Read the fin bit.
Definition message.hpp:195
websocketpp::message_buffer::message::append_payload
void append_payload(void const *payload, size_t len)
Append payload data.
Definition message.hpp:298
websocketpp::message_buffer::message::set_opcode
void set_opcode(frame::opcode::value op)
Set the opcode.
Definition message.hpp:215
websocketpp::message_buffer::message::set_prepared
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
Definition message.hpp:135
websocketpp::message_buffer::message::get_opcode
frame::opcode::value get_opcode() const
Return the message opcode.
Definition message.hpp:210
websocketpp::message_buffer::message::set_terminal
void set_terminal(bool value)
Set the terminal flag.
Definition message.hpp:181
websocketpp::message_buffer::message::get_prepared
bool get_prepared() const
Return whether or not the message has been prepared for sending.
Definition message.hpp:125
websocketpp::message_buffer::message::set_compressed
void set_compressed(bool value)
Set or clear the compression flag.
Definition message.hpp:156
websocketpp::message_buffer::message::message
message(const con_msg_man_ptr manager)
Construct an empty message.
Definition message.hpp:96
websocketpp::message_buffer::message::set_fin
void set_fin(bool value)
Set the fin bit.
Definition message.hpp:205
websocketpp::message_buffer::message::get_payload
std::string const & get_payload() const
Get a reference to the payload string.
Definition message.hpp:246
websocketpp::processor::processor
WebSocket protocol processor abstract base class.
Definition processor.hpp:160
websocketpp::random::none::int_generator
Thread safe stub "random" integer generator.
Definition none.hpp:46
websocketpp::random::none::int_generator::operator()
int_type operator()()
advances the engine's state and returns the generated value
Definition none.hpp:51
websocketpp::server
Server endpoint role based on the given config.
Definition server_endpoint.hpp:44
websocketpp::server::transport_con_type
transport_type::transport_con_type transport_con_type
Type of the connection transport component.
Definition server_endpoint.hpp:60
websocketpp::server::connection_ptr
connection_type::ptr connection_ptr
Type of a shared pointer to the connections this server will create.
Definition server_endpoint.hpp:57
websocketpp::server::type
server< config > type
Type of this endpoint.
Definition server_endpoint.hpp:47
websocketpp::server::start_accept
void start_accept(accept_loop_handler completion_handler)
Starts the server's async connection acceptance loop (exception free).
Definition server_endpoint.hpp:209
websocketpp::server::endpoint_type
endpoint< connection_type, config > endpoint_type
Type of the endpoint component of this server.
Definition server_endpoint.hpp:65
websocketpp::server::transport_type
config::transport_type transport_type
Type of the endpoint transport component.
Definition server_endpoint.hpp:52
websocketpp::server::connection_type
connection< config > connection_type
Type of the connections this server will create.
Definition server_endpoint.hpp:55
websocketpp::server::get_connection
connection_ptr get_connection(lib::error_code &ec)
Create and initialize a new connection.
Definition server_endpoint.hpp:133
websocketpp::server::get_connection
connection_ptr get_connection()
Create and initialize a new connection.
Definition server_endpoint.hpp:114
websocketpp::server::accept_loop_handler
lib::function< void(lib::error_code const &, lib::error_code const &)> accept_loop_handler
The type and signature of the callback passed to the start_accept method.
Definition server_endpoint.hpp:68
websocketpp::server::~server
~server()
Destructor.
Definition server_endpoint.hpp:78
websocketpp::server::concurrency_type
config::concurrency_type concurrency_type
Type of the endpoint concurrency component.
Definition server_endpoint.hpp:50
websocketpp::server::transport_con_ptr
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the connection transport component.
Definition server_endpoint.hpp:62
websocketpp::transport::asio::basic_socket::connection
Basic Asio connection socket component.
Definition none.hpp:58
websocketpp::transport::asio::basic_socket::connection::get_raw_socket
lib::asio::ip::tcp::socket & get_raw_socket()
Retrieve a pointer to the underlying socket.
Definition none.hpp:124
websocketpp::transport::asio::basic_socket::connection::ptr
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection socket component.
Definition none.hpp:63
websocketpp::transport::asio::basic_socket::connection::set_socket_init_handler
void set_socket_init_handler(socket_init_handler h)
Set the socket initialization handler.
Definition none.hpp:100
websocketpp::transport::asio::basic_socket::connection::set_uri
void set_uri(uri_ptr)
Set uri hook.
Definition none.hpp:190
websocketpp::transport::asio::basic_socket::connection::type
connection type
Type of this connection socket component.
Definition none.hpp:61
websocketpp::transport::asio::basic_socket::connection::strand_ptr
lib::shared_ptr< lib::asio::io_context::strand > strand_ptr
Type of a pointer to the Asio io_context strand being used.
Definition none.hpp:68
websocketpp::transport::asio::basic_socket::connection::get_socket
lib::asio::ip::tcp::socket & get_socket()
Retrieve a pointer to the underlying socket.
Definition none.hpp:108
websocketpp::transport::asio::basic_socket::connection::is_secure
bool is_secure() const
Check whether or not this connection is secure.
Definition none.hpp:88
websocketpp::transport::asio::basic_socket::connection::socket_ptr
lib::shared_ptr< socket_type > socket_ptr
Type of a shared pointer to the socket being used.
Definition none.hpp:72
websocketpp::transport::asio::basic_socket::connection::translate_ec
static lib::error_code translate_ec(lib::error_code ec)
Definition none.hpp:293
websocketpp::transport::asio::basic_socket::connection::translate_ec
static lib::error_code translate_ec(ErrorCodeType)
Translate any security policy specific information about an error code.
Definition none.hpp:285
websocketpp::transport::asio::basic_socket::connection::set_handle
void set_handle(connection_hdl hdl)
Sets the connection handle.
Definition none.hpp:235
websocketpp::transport::asio::basic_socket::connection::cancel_socket
lib::asio::error_code cancel_socket()
Cancel all async operations on this socket.
Definition none.hpp:248
websocketpp::transport::asio::basic_socket::connection::pre_init
void pre_init(init_handler callback)
Pre-initialize security policy.
Definition none.hpp:201
websocketpp::transport::asio::basic_socket::connection::get_remote_endpoint
std::string get_remote_endpoint(lib::error_code &ec) const
Get the remote endpoint address.
Definition none.hpp:138
websocketpp::transport::asio::basic_socket::connection::io_context_ptr
lib::asio::io_context * io_context_ptr
Type of a pointer to the Asio io_context being used.
Definition none.hpp:66
websocketpp::transport::asio::basic_socket::connection::post_init
void post_init(init_handler callback)
Post-initialize security policy.
Definition none.hpp:224
websocketpp::transport::asio::basic_socket::connection::socket_type
lib::asio::ip::tcp::socket socket_type
Type of the ASIO socket being used.
Definition none.hpp:70
websocketpp::transport::asio::basic_socket::connection::init_asio
lib::error_code init_asio(io_context_ptr context, strand_ptr, bool)
Perform one time initializations.
Definition none.hpp:166
websocketpp::transport::asio::basic_socket::connection::get_shared
ptr get_shared()
Get a shared pointer to this component.
Definition none.hpp:80
websocketpp::transport::asio::basic_socket::connection::get_next_layer
lib::asio::ip::tcp::socket & get_next_layer()
Retrieve a pointer to the underlying socket.
Definition none.hpp:116
websocketpp::transport::asio::basic_socket::endpoint
Basic ASIO endpoint socket component.
Definition none.hpp:318
websocketpp::transport::asio::basic_socket::endpoint::set_socket_init_handler
void set_socket_init_handler(socket_init_handler h)
Set socket init handler.
Definition none.hpp:347
websocketpp::transport::asio::basic_socket::endpoint::init
lib::error_code init(socket_con_ptr scon)
Initialize a connection.
Definition none.hpp:360
websocketpp::transport::asio::basic_socket::endpoint::type
endpoint type
The type of this endpoint socket component.
Definition none.hpp:321
websocketpp::transport::asio::basic_socket::endpoint::is_secure
bool is_secure() const
Checks whether the endpoint creates secure connections.
Definition none.hpp:335
websocketpp::transport::asio::basic_socket::endpoint::socket_con_type
connection socket_con_type
The type of the corresponding connection socket component.
Definition none.hpp:324
websocketpp::transport::asio::basic_socket::endpoint::socket_con_ptr
socket_con_type::ptr socket_con_ptr
Definition none.hpp:327
websocketpp::transport::asio::connection
Asio based connection transport component.
Definition connection.hpp:67
websocketpp::transport::asio::connection::set_proxy_timeout
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception).
Definition connection.hpp:266
websocketpp::transport::asio::connection::set_tcp_post_init_handler
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition connection.hpp:173
websocketpp::transport::asio::connection::set_proxy_timeout
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free).
Definition connection.hpp:254
websocketpp::transport::asio::connection::elog_type
config::elog_type elog_type
Type of this transport's error logging policy.
Definition connection.hpp:81
websocketpp::transport::asio::connection::get_strand
strand_ptr get_strand()
Get a pointer to this connection's strand.
Definition connection.hpp:372
websocketpp::transport::asio::connection::async_read_at_least
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
read at least num_bytes bytes into buf and then call handler.
Definition connection.hpp:835
websocketpp::transport::asio::connection::socket_con_ptr
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition connection.hpp:77
websocketpp::transport::asio::connection::interrupt
lib::error_code interrupt(interrupt_handler handler)
Trigger the on_interrupt handler.
Definition connection.hpp:1031
websocketpp::transport::asio::connection::strand_ptr
lib::shared_ptr< lib::asio::io_context::strand > strand_ptr
Type of a pointer to the Asio io_context::strand being used.
Definition connection.hpp:91
websocketpp::transport::asio::connection::alog_type
config::alog_type alog_type
Type of this transport's access logging policy.
Definition connection.hpp:79
websocketpp::transport::asio::connection::io_context_ptr
lib::asio::io_context * io_context_ptr
Type of a pointer to the Asio io_context being used.
Definition connection.hpp:89
websocketpp::transport::asio::connection::handle_async_write
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
Definition connection.hpp:998
websocketpp::transport::asio::connection::handle_timer
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
Definition connection.hpp:356
websocketpp::transport::asio::connection::handle_post_init
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition connection.hpp:578
websocketpp::transport::asio::connection::init_asio
lib::error_code init_asio(io_context_ptr io_context)
Finish constructing the transport.
Definition connection.hpp:467
websocketpp::transport::asio::connection::async_shutdown
void async_shutdown(shutdown_handler callback)
close and clean up the underlying socket
Definition connection.hpp:1054
websocketpp::transport::asio::connection::get_transport_ec
lib::asio::error_code get_transport_ec() const
Get the internal transport error code for a closed/failed connection.
Definition connection.hpp:395
websocketpp::transport::asio::connection::socket_con_type
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition connection.hpp:75
websocketpp::transport::asio::connection::handle_post_init_timeout
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition connection.hpp:542
websocketpp::transport::asio::connection::type
connection< config > type
Type of this connection transport component.
Definition connection.hpp:70
websocketpp::transport::asio::connection::handle_async_shutdown_timeout
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
Definition connection.hpp:1088
websocketpp::transport::asio::connection::timer_ptr
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
Definition connection.hpp:93
websocketpp::transport::asio::connection::async_write
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
Definition connection.hpp:921
websocketpp::transport::asio::connection::async_write
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
Definition connection.hpp:954
websocketpp::transport::asio::connection::ptr
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition connection.hpp:72
websocketpp::transport::asio::connection::set_timer
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition connection.hpp:319
websocketpp::transport::asio::connection::set_tcp_init_handler
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated).
Definition connection.hpp:158
websocketpp::transport::asio::connection::handle_proxy_read
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
Definition connection.hpp:747
websocketpp::transport::asio::connection::set_uri
void set_uri(uri_ptr u)
Set uri hook.
Definition connection.hpp:130
websocketpp::transport::asio::connection::get_remote_endpoint
std::string get_remote_endpoint() const
Get the remote endpoint address.
Definition connection.hpp:287
websocketpp::transport::asio::connection::get_shared
ptr get_shared()
Get a shared pointer to this component.
Definition connection.hpp:110
websocketpp::transport::asio::connection::cancel_socket_checked
void cancel_socket_checked()
Cancel the underlying socket and log any errors.
Definition connection.hpp:1152
websocketpp::transport::asio::connection::set_handle
void set_handle(connection_hdl hdl)
Set Connection Handle.
Definition connection.hpp:1022
websocketpp::transport::asio::connection::set_tcp_pre_init_handler
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition connection.hpp:144
websocketpp::transport::asio::connection::init
void init(init_handler callback)
Initialize transport for reading.
Definition connection.hpp:417
websocketpp::transport::asio::connection::get_handle
connection_hdl get_handle() const
Get the connection handle.
Definition connection.hpp:301
websocketpp::transport::asio::custom_alloc_handler
Definition base.hpp:92
websocketpp::transport::asio::endpoint
Asio based endpoint transport component.
Definition endpoint.hpp:54
websocketpp::transport::asio::endpoint::work_guard_ptr
lib::shared_ptr< lib::asio::executor_work_guard< lib::asio::io_context::executor_type > > work_guard_ptr
Type of a shared pointer to an io_context work object.
Definition endpoint.hpp:89
websocketpp::transport::asio::endpoint::run_one
std::size_t run_one()
wraps the run_one method of the internal io_context object
Definition endpoint.hpp:671
websocketpp::transport::asio::endpoint::socket_con_type
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition endpoint.hpp:69
websocketpp::transport::asio::endpoint::stop_listening
void stop_listening(lib::error_code &ec)
Stop listening (exception free).
Definition endpoint.hpp:546
websocketpp::transport::asio::endpoint::socket_type
config::socket_type socket_type
Type of the socket policy.
Definition endpoint.hpp:62
websocketpp::transport::asio::endpoint::timer_ptr
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition endpoint.hpp:87
websocketpp::transport::asio::endpoint::async_connect
void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:874
websocketpp::transport::asio::endpoint::init_asio
void init_asio()
Initialize asio transport with internal io_context.
Definition endpoint.hpp:252
websocketpp::transport::asio::endpoint::elog_type
config::elog_type elog_type
Type of the error logging policy.
Definition endpoint.hpp:64
websocketpp::transport::asio::endpoint::init_logging
void init_logging(const lib::shared_ptr< alog_type > &a, const lib::shared_ptr< elog_type > &e)
Initialize logging.
Definition endpoint.hpp:848
websocketpp::transport::asio::endpoint::io_context_ptr
lib::asio::io_context * io_context_ptr
Type of a pointer to the ASIO io_context being used.
Definition endpoint.hpp:81
websocketpp::transport::asio::endpoint::is_secure
bool is_secure() const
Return whether or not the endpoint produces secure connections.
Definition endpoint.hpp:172
websocketpp::transport::asio::endpoint::get_local_endpoint
lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code &ec)
Get local TCP endpoint.
Definition endpoint.hpp:399
websocketpp::transport::asio::endpoint::set_reuse_addr
void set_reuse_addr(bool value)
Sets whether to use the SO_REUSEADDR flag when opening listening sockets.
Definition endpoint.hpp:367
websocketpp::transport::asio::endpoint::set_tcp_init_handler
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated).
Definition endpoint.hpp:306
websocketpp::transport::asio::endpoint::handle_timer
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer handler.
Definition endpoint.hpp:768
websocketpp::transport::asio::endpoint::start_perpetual
void start_perpetual()
Marks the endpoint as perpetual, stopping it from exiting when empty.
Definition endpoint.hpp:712
websocketpp::transport::asio::endpoint::stop
void stop()
wraps the stop method of the internal io_context object
Definition endpoint.hpp:676
websocketpp::transport::asio::endpoint::run
std::size_t run()
wraps the run method of the internal io_context object
Definition endpoint.hpp:663
websocketpp::transport::asio::endpoint::set_tcp_post_init_handler
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition endpoint.hpp:321
websocketpp::transport::asio::endpoint::set_listen_backlog
void set_listen_backlog(int backlog)
Sets the maximum length of the queue of pending connections.
Definition endpoint.hpp:346
websocketpp::transport::asio::endpoint::stopped
bool stopped() const
wraps the stopped method of the internal io_context object
Definition endpoint.hpp:696
websocketpp::transport::asio::endpoint::set_timer
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition endpoint.hpp:740
websocketpp::transport::asio::endpoint::socket_con_ptr
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition endpoint.hpp:71
websocketpp::transport::asio::endpoint::init
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition endpoint.hpp:1138
websocketpp::transport::asio::endpoint::transport_con_type
asio::connection< config > transport_con_type
Definition endpoint.hpp:75
websocketpp::transport::asio::endpoint::init_asio
void init_asio(lib::error_code &ec)
Initialize asio transport with internal io_context (exception free).
Definition endpoint.hpp:229
websocketpp::transport::asio::endpoint::async_accept
void async_accept(transport_con_ptr tcon, accept_handler callback)
Accept the next connection attempt and assign it to con.
Definition endpoint.hpp:831
websocketpp::transport::asio::endpoint::listen
void listen(uint16_t port)
Set up endpoint for listening on a port.
Definition endpoint.hpp:607
websocketpp::transport::asio::endpoint::type
endpoint< config > type
Type of this endpoint transport component.
Definition endpoint.hpp:57
websocketpp::transport::asio::endpoint::init_asio
void init_asio(io_context_ptr ptr, lib::error_code &ec)
initialize asio transport with external io_context (exception free)
Definition endpoint.hpp:185
websocketpp::transport::asio::endpoint::concurrency_type
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition endpoint.hpp:60
websocketpp::transport::asio::endpoint::poll
std::size_t poll()
wraps the poll method of the internal io_context object
Definition endpoint.hpp:681
websocketpp::transport::asio::endpoint::stop_perpetual
void stop_perpetual()
Clears the endpoint's perpetual flag, allowing it to exit when empty.
Definition endpoint.hpp:724
websocketpp::transport::asio::endpoint::init_asio
void init_asio(io_context_ptr ptr)
initialize asio transport with external io_context
Definition endpoint.hpp:213
websocketpp::transport::asio::endpoint::acceptor_ptr
lib::shared_ptr< lib::asio::ip::tcp::acceptor > acceptor_ptr
Type of a shared pointer to the acceptor being used.
Definition endpoint.hpp:83
websocketpp::transport::asio::endpoint::listen
void listen(lib::asio::ip::tcp::endpoint const &ep)
Set up endpoint for listening manually.
Definition endpoint.hpp:569
websocketpp::transport::asio::endpoint::get_io_context
lib::asio::io_context & get_io_context()
Retrieve a reference to the endpoint's io_context.
Definition endpoint.hpp:382
websocketpp::transport::asio::endpoint::handle_resolve_timeout
void handle_resolve_timeout(timer_ptr, connect_handler callback, lib::error_code const &ec)
DNS resolution timeout handler.
Definition endpoint.hpp:969
websocketpp::transport::asio::endpoint::listen
void listen(lib::asio::ip::tcp::endpoint const &ep, lib::error_code &ec)
Set up endpoint for listening manually (exception free).
Definition endpoint.hpp:416
websocketpp::transport::asio::endpoint::transport_con_ptr
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:78
websocketpp::transport::asio::endpoint::reset
void reset()
wraps the restart method of the internal io_context object
Definition endpoint.hpp:691
websocketpp::transport::asio::endpoint::set_tcp_pre_bind_handler
void set_tcp_pre_bind_handler(tcp_pre_bind_handler h)
Sets the tcp pre bind handler.
Definition endpoint.hpp:278
websocketpp::transport::asio::endpoint::alog_type
config::alog_type alog_type
Type of the access logging policy.
Definition endpoint.hpp:66
websocketpp::transport::asio::endpoint::listen
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition endpoint.hpp:589
websocketpp::transport::asio::endpoint::set_tcp_pre_init_handler
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition endpoint.hpp:292
websocketpp::transport::asio::endpoint::handle_connect_timeout
void handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
Definition endpoint.hpp:1078
websocketpp::transport::asio::endpoint::async_accept
void async_accept(transport_con_ptr tcon, accept_handler callback, lib::error_code &ec)
Accept the next connection attempt and assign it to con (exception free).
Definition endpoint.hpp:791
websocketpp::transport::asio::endpoint::poll_one
std::size_t poll_one()
wraps the poll_one method of the internal io_context object
Definition endpoint.hpp:686
websocketpp::transport::asio::endpoint::listen
void listen(InternetProtocol const &internet_protocol, uint16_t port, lib::error_code &ec)
Set up endpoint for listening with protocol and port (exception free).
Definition endpoint.hpp:471
websocketpp::transport::asio::endpoint::listen
void listen(uint16_t port, lib::error_code &ec)
Set up endpoint for listening on a port (exception free).
Definition endpoint.hpp:490
websocketpp::transport::asio::endpoint::is_listening
bool is_listening() const
Check if the endpoint is listening.
Definition endpoint.hpp:658
websocketpp::transport::asio::endpoint::stop_listening
void stop_listening()
Stop listening.
Definition endpoint.hpp:647
websocketpp::transport::asio::endpoint::resolver_ptr
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition endpoint.hpp:85
websocketpp::transport::asio::endpoint::tcp_pre_bind_handler
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition endpoint.hpp:92
websocketpp::transport::asio::error::category
Asio transport error category.
Definition base.hpp:184
websocketpp::transport::asio::handler_allocator
Definition base.hpp:52
websocketpp::transport::asio::socket::socket_category
Error category related to asio transport socket policies.
Definition base.hpp:110
websocketpp::transport::error::category
Definition connection.hpp:183
websocketpp::transport::iostream::connection
Definition connection.hpp:60
websocketpp::transport::iostream::connection::ptr
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition connection.hpp:65
websocketpp::transport::iostream::connection::get_handle
connection_hdl get_handle() const
Get the connection handle.
Definition connection.hpp:313
websocketpp::transport::iostream::connection::alog_type
config::alog_type alog_type
Type of this transport's access logging policy.
Definition connection.hpp:70
websocketpp::transport::iostream::connection::dispatch
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present).
Definition connection.hpp:580
websocketpp::transport::iostream::connection::set_uri
void set_uri(uri_ptr)
Set uri hook.
Definition connection.hpp:121
websocketpp::transport::iostream::connection::async_shutdown
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
Definition connection.hpp:593
websocketpp::transport::iostream::connection::set_write_handler
void set_write_handler(write_handler h)
Sets the write handler.
Definition connection.hpp:350
websocketpp::transport::iostream::connection::set_secure
void set_secure(bool value)
Set whether or not this connection is secure.
Definition connection.hpp:257
websocketpp::transport::iostream::connection::set_shutdown_handler
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition connection.hpp:400
websocketpp::transport::iostream::connection::type
connection< config > type
Type of this connection transport component.
Definition connection.hpp:63
websocketpp::transport::iostream::connection::elog_type
config::elog_type elog_type
Type of this transport's error logging policy.
Definition connection.hpp:72
websocketpp::transport::iostream::connection::fatal_error
void fatal_error()
Signal transport error.
Definition connection.hpp:235
websocketpp::transport::iostream::connection::read_some
size_t read_some(char const *buf, size_t len)
Manual input supply (read some).
Definition connection.hpp:165
websocketpp::transport::iostream::connection::read_all
size_t read_all(char const *buf, size_t len)
Manual input supply (read all).
Definition connection.hpp:188
websocketpp::transport::iostream::connection::async_write
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
Definition connection.hpp:487
websocketpp::transport::iostream::connection::readsome
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED).
Definition connection.hpp:208
websocketpp::transport::iostream::connection::concurrency_type
config::concurrency_type concurrency_type
transport concurrency policy
Definition connection.hpp:68
websocketpp::transport::iostream::connection::init
void init(init_handler handler)
Initialize the connection transport.
Definition connection.hpp:410
websocketpp::transport::iostream::connection::set_timer
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
Definition connection.hpp:327
websocketpp::transport::iostream::connection::eof
void eof()
Signal EOF.
Definition connection.hpp:219
websocketpp::transport::iostream::connection::operator>>
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
Definition connection.hpp:142
websocketpp::transport::iostream::connection::set_vector_write_handler
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
Definition connection.hpp:380
websocketpp::transport::iostream::connection::is_secure
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition connection.hpp:271
websocketpp::transport::iostream::connection::get_remote_endpoint
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
Definition connection.hpp:305
websocketpp::transport::iostream::connection::set_handle
void set_handle(connection_hdl hdl)
Set Connection Handle.
Definition connection.hpp:565
websocketpp::transport::iostream::connection::register_ostream
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
Definition connection.hpp:104
websocketpp::transport::iostream::connection::async_read_at_least
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
Initiate an async_read for at least num_bytes bytes into buf.
Definition connection.hpp:439
websocketpp::transport::iostream::connection::async_write
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather).
Definition connection.hpp:527
websocketpp::transport::iostream::connection::get_shared
ptr get_shared()
Get a shared pointer to this component.
Definition connection.hpp:93
websocketpp::transport::iostream::endpoint
Definition endpoint.hpp:46
websocketpp::transport::iostream::endpoint::transport_con_type
iostream::connection< config > transport_con_type
Definition endpoint.hpp:62
websocketpp::transport::iostream::endpoint::elog_type
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition endpoint.hpp:56
websocketpp::transport::iostream::endpoint::set_write_handler
void set_write_handler(write_handler h)
Sets the write handler.
Definition endpoint.hpp:134
websocketpp::transport::iostream::endpoint::set_shutdown_handler
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition endpoint.hpp:154
websocketpp::transport::iostream::endpoint::is_secure
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition endpoint.hpp:116
websocketpp::transport::iostream::endpoint::ptr
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition endpoint.hpp:51
websocketpp::transport::iostream::endpoint::transport_con_ptr
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:65
websocketpp::transport::iostream::endpoint::async_connect
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:183
websocketpp::transport::iostream::endpoint::init
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition endpoint.hpp:197
websocketpp::transport::iostream::endpoint::init_logging
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
Definition endpoint.hpp:171
websocketpp::transport::iostream::endpoint::type
endpoint type
Type of this endpoint transport component.
Definition endpoint.hpp:49
websocketpp::transport::iostream::endpoint::register_ostream
void register_ostream(std::ostream *o)
Register a default output stream.
Definition endpoint.hpp:80
websocketpp::transport::iostream::endpoint::concurrency_type
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition endpoint.hpp:54
websocketpp::transport::iostream::endpoint::set_secure
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition endpoint.hpp:102
websocketpp::transport::iostream::endpoint::alog_type
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition endpoint.hpp:58
websocketpp::transport::iostream::error::category
iostream transport error category
Definition base.hpp:85
websocketpp::uri
Definition uri.hpp:397
websocketpp::uri::get_query
std::string get_query() const
Return the query portion.
Definition uri.hpp:732
websocketpp::uri::is_ipv6_literal
bool is_ipv6_literal() const
Definition uri.hpp:651
_WEBSOCKETPP_CONSTEXPR_TOKEN_
#define _WEBSOCKETPP_CONSTEXPR_TOKEN_
Definition cpp11.hpp:134
_WEBSOCKETPP_NOEXCEPT_TOKEN_
#define _WEBSOCKETPP_NOEXCEPT_TOKEN_
Definition cpp11.hpp:115
__has_extension
#define __has_extension
Definition cpp11.hpp:40
__has_feature
#define __has_feature(x)
Definition cpp11.hpp:37
websocketpp::close::status
A package of types and methods for manipulating WebSocket close status'.
Definition close.hpp:47
websocketpp::close::status::blank
static value const blank
A blank value for internal use.
Definition close.hpp:52
websocketpp::close::status::abnormal_close
static value const abnormal_close
A dummy value to indicate that the connection was closed abnormally.
Definition close.hpp:104
websocketpp::close::status::value
uint16_t value
The type of a close code value.
Definition close.hpp:49
websocketpp::close
A package of types and methods for manipulating WebSocket close codes.
Definition close.hpp:45
websocketpp::concurrency
Concurrency handling support.
Definition basic.hpp:34
websocketpp::error
Library level error codes.
Definition error.hpp:44
websocketpp::error::value
value
Definition error.hpp:45
websocketpp::error::general
@ general
Catch-all library error.
Definition error.hpp:47
websocketpp::error::unrequested_subprotocol
@ unrequested_subprotocol
Selected subprotocol was not requested by the client.
Definition error.hpp:102
websocketpp::error::invalid_port
@ invalid_port
Invalid port in URI.
Definition error.hpp:120
websocketpp::error::client_only
@ client_only
Attempted to use a client specific feature on a server endpoint.
Definition error.hpp:105
websocketpp::error::http_connection_ended
@ http_connection_ended
HTTP connection ended.
Definition error.hpp:111
websocketpp::error::async_accept_not_listening
@ async_accept_not_listening
Definition error.hpp:124
websocketpp::error::operation_canceled
@ operation_canceled
The requested operation was canceled.
Definition error.hpp:127
websocketpp::error::endpoint_unavailable
@ endpoint_unavailable
Definition error.hpp:62
websocketpp::error::no_outgoing_buffers
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
Definition error.hpp:68
websocketpp::error::http_parse_error
@ http_parse_error
HTTP parse error.
Definition error.hpp:143
websocketpp::error::reserved_close_code
@ reserved_close_code
Close code is in a reserved range.
Definition error.hpp:80
websocketpp::error::con_creation_failed
@ con_creation_failed
Connection creation attempted failed.
Definition error.hpp:99
websocketpp::error::no_incoming_buffers
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
Definition error.hpp:71
websocketpp::error::invalid_state
@ invalid_state
The connection was in the wrong state for this operation.
Definition error.hpp:74
websocketpp::error::extension_neg_failed
@ extension_neg_failed
Extension negotiation failed.
Definition error.hpp:146
websocketpp::error::rejected
@ rejected
Connection rejected.
Definition error.hpp:130
websocketpp::error::unsupported_version
@ unsupported_version
Unsupported WebSocket protocol version.
Definition error.hpp:140
websocketpp::error::invalid_utf8
@ invalid_utf8
Invalid UTF-8.
Definition error.hpp:86
websocketpp::error::bad_connection
@ bad_connection
Definition error.hpp:93
websocketpp::error::payload_violation
@ payload_violation
Definition error.hpp:54
websocketpp::error::invalid_close_code
@ invalid_close_code
Close code is invalid.
Definition error.hpp:83
websocketpp::error::server_only
@ server_only
Attempted to use a server specific feature on a client endpoint.
Definition error.hpp:108
websocketpp::error::endpoint_not_secure
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
Definition error.hpp:57
websocketpp::error::close_handshake_timeout
@ close_handshake_timeout
WebSocket close handshake timed out.
Definition error.hpp:117
websocketpp::error::invalid_subprotocol
@ invalid_subprotocol
Invalid subprotocol.
Definition error.hpp:89
websocketpp::error::bad_close_code
@ bad_close_code
Unable to parse close code.
Definition error.hpp:77
websocketpp::error::open_handshake_timeout
@ open_handshake_timeout
WebSocket opening handshake timed out.
Definition error.hpp:114
websocketpp::error::upgrade_required
@ upgrade_required
Definition error.hpp:134
websocketpp::error::invalid_version
@ invalid_version
Invalid WebSocket protocol version.
Definition error.hpp:137
websocketpp::error::transport_error
@ transport_error
General transport error, consult more specific transport error code.
Definition error.hpp:149
websocketpp::error::send_queue_full
@ send_queue_full
send attempted when endpoint write queue was full
Definition error.hpp:50
websocketpp::error::test
@ test
Unit testing utility error code.
Definition error.hpp:96
websocketpp::error::invalid_uri
@ invalid_uri
An invalid uri was supplied.
Definition error.hpp:65
websocketpp::extensions::permessage_deflate
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition disabled.hpp:44
websocketpp::extensions
Definition disabled.hpp:43
websocketpp::frame::limits
Constants related to frame and payload limits.
Definition frame.hpp:145
websocketpp::frame::limits::close_reason_size
static uint8_t const close_reason_size
Maximum size of close frame reason.
Definition frame.hpp:169
websocketpp::frame::limits::payload_size_jumbo
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127).
Definition frame.hpp:162
websocketpp::frame::limits::max_extended_header_length
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:153
websocketpp::frame::limits::max_header_length
static unsigned int const max_header_length
Maximum length of a WebSocket header.
Definition frame.hpp:150
websocketpp::frame::limits::payload_size_extended
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126).
Definition frame.hpp:159
websocketpp::frame::limits::payload_size_basic
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
Definition frame.hpp:156
websocketpp::frame::limits::basic_header_length
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Definition frame.hpp:147
websocketpp::frame::opcode
Constants and utility functions related to WebSocket opcodes.
Definition frame.hpp:76
websocketpp::frame::opcode::invalid
bool invalid(value v)
Check if an opcode is invalid.
Definition frame.hpp:130
websocketpp::frame::opcode::reserved
bool reserved(value v)
Check if an opcode is reserved.
Definition frame.hpp:118
websocketpp::frame::opcode::is_control
bool is_control(value v)
Check if an opcode is for a control frame.
Definition frame.hpp:139
websocketpp::frame
Data structures and utility functions for manipulating WebSocket frames.
Definition frame.hpp:45
websocketpp::frame::get_masking_key_offset
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
Definition frame.hpp:469
websocketpp::frame::set_rsv2
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
Definition frame.hpp:366
websocketpp::frame::MAX_HEADER_LENGTH
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
Definition frame.hpp:50
websocketpp::frame::get_opcode
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition frame.hpp:393
websocketpp::frame::set_rsv3
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
Definition frame.hpp:384
websocketpp::frame::get_payload_size
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
Definition frame.hpp:573
websocketpp::frame::get_basic_size
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Definition frame.hpp:431
websocketpp::frame::byte_mask_circ
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Definition frame.hpp:830
websocketpp::frame::byte_mask
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
Definition frame.hpp:645
websocketpp::frame::MAX_EXTENDED_HEADER_LENGTH
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:52
websocketpp::frame::get_rsv3
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
Definition frame.hpp:375
websocketpp::frame::get_masked
bool get_masked(basic_header const &h)
check whether the frame is masked
Definition frame.hpp:402
websocketpp::frame::get_rsv2
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
Definition frame.hpp:357
websocketpp::frame::byte_mask
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place).
Definition frame.hpp:675
websocketpp::frame::get_extended_size
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
Definition frame.hpp:540
websocketpp::frame::byte_mask_circ
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place).
Definition frame.hpp:857
websocketpp::frame::get_fin
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition frame.hpp:321
websocketpp::frame::circshift_prepared_key
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
Definition frame.hpp:612
websocketpp::frame::get_rsv1
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition frame.hpp:339
websocketpp::frame::set_masked
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
Definition frame.hpp:411
websocketpp::frame::word_mask_circ
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
Definition frame.hpp:768
websocketpp::frame::word_mask_exact
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place).
Definition frame.hpp:731
websocketpp::frame::set_rsv1
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
Definition frame.hpp:348
websocketpp::frame::get_header_len
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition frame.hpp:445
websocketpp::frame::set_fin
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
Definition frame.hpp:330
websocketpp::frame::get_jumbo_size
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
Definition frame.hpp:555
websocketpp::frame::word_mask_exact
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
Definition frame.hpp:702
websocketpp::frame::prepare_header
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
Definition frame.hpp:489
websocketpp::frame::get_masking_key
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
Definition frame.hpp:516
websocketpp::frame::BASIC_HEADER_LENGTH
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
Definition frame.hpp:48
websocketpp::frame::word_mask_circ
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place).
Definition frame.hpp:805
websocketpp::frame::prepare_masking_key
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
Definition frame.hpp:595
websocketpp::http::error
HTTP parser errors.
Definition constants.hpp:325
websocketpp::http::error::get_status_code
status_code::value get_status_code(error::value value)
Get the HTTP status code associated with the error.
Definition constants.hpp:367
websocketpp::http::error::get_category
lib::error_category const & get_category()
Get a reference to a static copy of the asio transport error category.
Definition constants.hpp:438
websocketpp::http::error::value
value
Definition constants.hpp:326
websocketpp::http::error::unknown_transfer_encoding
@ unknown_transfer_encoding
The transfer encoding is unknown.
Definition constants.hpp:344
websocketpp::http::error::istream_bad
@ istream_bad
An istream read command returned with the bad flag set.
Definition constants.hpp:359
websocketpp::http::error::invalid_format
@ invalid_format
The specified data contains illegal characters for the context.
Definition constants.hpp:332
websocketpp::http::error::body_too_large
@ body_too_large
The body value is larger than the configured maximum size.
Definition constants.hpp:338
websocketpp::http::error::incomplete_request
@ incomplete_request
The request was missing some required values.
Definition constants.hpp:353
websocketpp::http::error::unsupported_transfer_encoding
@ unsupported_transfer_encoding
The transfer encoding is not supported.
Definition constants.hpp:341
websocketpp::http::error::incomplete_status_line
@ incomplete_status_line
The response status line was missing some required values.
Definition constants.hpp:356
websocketpp::http::error::missing_header_separator
@ missing_header_separator
A header line was missing a separator.
Definition constants.hpp:347
websocketpp::http::error::istream_overread
@ istream_overread
Definition constants.hpp:363
websocketpp::http::error::general
@ general
Definition constants.hpp:329
websocketpp::http::error::invalid_header_name
@ invalid_header_name
The header name specified contains illegal characters.
Definition constants.hpp:335
websocketpp::http::error::request_header_fields_too_large
@ request_header_fields_too_large
The request headers are larger than the configured maximum size.
Definition constants.hpp:350
websocketpp::http::error::make_error_code
lib::error_code make_error_code(error::value e)
Create an error code with the given value and the asio transport category.
Definition constants.hpp:444
websocketpp::http::status_code
HTTP Status codes.
Definition constants.hpp:124
websocketpp::http::status_code::get_string
std::string get_string(value code)
Given a status code value, return the default status message.
Definition constants.hpp:189
websocketpp::http::status_code::value
value
Known values for HTTP Status codes.
Definition constants.hpp:126
websocketpp::http
HTTP handling support.
Definition request.hpp:37
websocketpp::http::max_body_size
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
Definition constants.hpp:71
websocketpp::http::header_separator
static char const header_separator[]
Literal value of the HTTP header separator.
Definition constants.hpp:62
websocketpp::http::parameter_list
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition constants.hpp:56
websocketpp::http::istream_buffer
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
Definition constants.hpp:74
websocketpp::http::is_not_token_char
bool is_not_token_char(unsigned char c)
Is the character a non-token.
Definition constants.hpp:106
websocketpp::http::max_header_size
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
Definition constants.hpp:68
websocketpp::http::header_delimiter
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
Definition constants.hpp:59
websocketpp::http::is_whitespace_char
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
Definition constants.hpp:114
websocketpp::http::header_token
static char const header_token[]
invalid HTTP token characters
Definition constants.hpp:81
websocketpp::http::is_not_whitespace_char
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
Definition constants.hpp:119
websocketpp::http::attribute_list
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
Definition constants.hpp:48
websocketpp::http::is_token_char
bool is_token_char(unsigned char c)
Is the character a token.
Definition constants.hpp:101
websocketpp::http::empty_header
static std::string const empty_header
Literal value of an empty header.
Definition constants.hpp:65
websocketpp::processor
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition processor.hpp:59
websocketpp::random::none
Stub RNG policy that always returns 0.
Definition none.hpp:35
websocketpp::random
Random number generation policies.
Definition random_device.hpp:34
websocketpp::transport::asio::basic_socket
Definition none.hpp:47
websocketpp::transport::asio::basic_socket::socket_init_handler
lib::function< void(connection_hdl, lib::asio::ip::tcp::socket &)> socket_init_handler
The signature of the socket init handler for this socket policy.
Definition none.hpp:51
websocketpp::transport::asio::error
Asio transport errors.
Definition base.hpp:161
websocketpp::transport::asio::error::get_category
lib::error_category const & get_category()
Get a reference to a static copy of the asio transport error category.
Definition base.hpp:211
websocketpp::transport::asio::error::make_error_code
lib::error_code make_error_code(error::value e)
Create an error code with the given value and the asio transport category.
Definition base.hpp:217
websocketpp::transport::asio::error::value
value
Definition base.hpp:162
websocketpp::transport::asio::error::proxy_invalid
@ proxy_invalid
Invalid Proxy URI.
Definition base.hpp:177
websocketpp::transport::asio::error::pass_through
@ pass_through
there was an error in the underlying transport library
Definition base.hpp:171
websocketpp::transport::asio::error::proxy_failed
@ proxy_failed
The connection to the requested proxy server failed.
Definition base.hpp:174
websocketpp::transport::asio::error::general
@ general
Definition base.hpp:165
websocketpp::transport::asio::error::invalid_num_bytes
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition base.hpp:168
websocketpp::transport::asio::error::invalid_host_service
@ invalid_host_service
Invalid host or service.
Definition base.hpp:180
websocketpp::transport::asio::socket::error
Errors related to asio transport sockets.
Definition base.hpp:75
websocketpp::transport::asio::socket::error::value
value
Definition base.hpp:76
websocketpp::transport::asio::socket::error::socket
@ socket
Definition base.hpp:83
websocketpp::transport::asio::socket::error::missing_tls_init_handler
@ missing_tls_init_handler
Required tls_init handler not present.
Definition base.hpp:99
websocketpp::transport::asio::socket::error::invalid_tls_context
@ invalid_tls_context
Definition base.hpp:90
websocketpp::transport::asio::socket::error::invalid_state
@ invalid_state
A function was called in a state that it was illegal to do so.
Definition base.hpp:86
websocketpp::transport::asio::socket::error::tls_failed_sni_hostname
@ tls_failed_sni_hostname
Failed to set TLS SNI hostname.
Definition base.hpp:105
websocketpp::transport::asio::socket::error::tls_handshake_failed
@ tls_handshake_failed
TLS Handshake Failed.
Definition base.hpp:102
websocketpp::transport::asio::socket::error::tls_handshake_timeout
@ tls_handshake_timeout
TLS Handshake Timeout.
Definition base.hpp:93
websocketpp::transport::asio::socket::error::pass_through
@ pass_through
pass_through from underlying library
Definition base.hpp:96
websocketpp::transport::asio::socket::error::security
@ security
Definition base.hpp:79
websocketpp::transport::asio
Transport policy that uses asio.
Definition endpoint.hpp:46
websocketpp::transport::error
Generic transport related errors.
Definition connection.hpp:146
websocketpp::transport::error::value
value
Definition connection.hpp:147
websocketpp::transport::error::timeout
@ timeout
Timer expired.
Definition connection.hpp:174
websocketpp::transport::error::general
@ general
Definition connection.hpp:150
websocketpp::transport::error::pass_through
@ pass_through
underlying transport pass through
Definition connection.hpp:153
websocketpp::transport::error::eof
@ eof
End of file.
Definition connection.hpp:168
websocketpp::transport::error::operation_not_supported
@ operation_not_supported
Operation not supported.
Definition connection.hpp:165
websocketpp::transport::error::operation_aborted
@ operation_aborted
Operation aborted.
Definition connection.hpp:162
websocketpp::transport::error::tls_error
@ tls_error
Other TLS error.
Definition connection.hpp:180
websocketpp::transport::error::invalid_num_bytes
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition connection.hpp:156
websocketpp::transport::error::action_after_shutdown
@ action_after_shutdown
read or write after shutdown
Definition connection.hpp:177
websocketpp::transport::error::tls_short_read
@ tls_short_read
TLS short read.
Definition connection.hpp:171
websocketpp::transport::error::double_read
@ double_read
async_read called while another async_read was in progress
Definition connection.hpp:159
websocketpp::transport::iostream::error
iostream transport errors
Definition base.hpp:64
websocketpp::transport::iostream::error::value
value
Definition base.hpp:65
websocketpp::transport::iostream::error::general
@ general
Definition base.hpp:68
websocketpp::transport::iostream::error::output_stream_required
@ output_stream_required
Definition base.hpp:78
websocketpp::transport::iostream::error::invalid_num_bytes
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition base.hpp:71
websocketpp::transport::iostream::error::double_read
@ double_read
async_read called while another async_read was in progress
Definition base.hpp:74
websocketpp::transport::iostream::error::bad_stream
@ bad_stream
stream error
Definition base.hpp:81
websocketpp::transport::iostream::error::make_error_code
lib::error_code make_error_code(error::value e)
Get an error code with the given value and the iostream transport category.
Definition base.hpp:118
websocketpp::transport::iostream::error::get_category
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Definition base.hpp:112
websocketpp::transport::iostream
Transport policy that uses STL iostream for I/O and does not support timers.
Definition endpoint.hpp:43
websocketpp::transport::iostream::vector_write_handler
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
Definition base.hpp:57
websocketpp::transport::iostream::shutdown_handler
lib::function< lib::error_code(connection_hdl)> shutdown_handler
Definition base.hpp:61
websocketpp::transport::iostream::write_handler
lib::function< lib::error_code(connection_hdl, char const *, size_t)> write_handler
The type and signature of the callback used by iostream transport to write.
Definition base.hpp:48
websocketpp::transport
Transport policies provide network connectivity and timers.
Definition endpoint.hpp:45
websocketpp::transport::read_handler
lib::function< void(lib::error_code const &, size_t)> read_handler
The type and signature of the callback passed to the read method.
Definition connection.hpp:120
websocketpp::transport::dispatch_handler
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
Definition connection.hpp:135
websocketpp::transport::interrupt_handler
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
Definition connection.hpp:132
websocketpp::transport::accept_handler
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
Definition endpoint.hpp:80
websocketpp::transport::timer_handler
lib::function< void(lib::error_code const &)> timer_handler
The type and signature of the callback passed to the read method.
Definition connection.hpp:126
websocketpp::transport::connect_handler
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
Definition endpoint.hpp:83
websocketpp::transport::write_handler
lib::function< void(lib::error_code const &)> write_handler
The type and signature of the callback passed to the write method.
Definition connection.hpp:123
websocketpp::transport::init_handler
lib::function< void(lib::error_code const &)> init_handler
The type and signature of the callback passed to the init hook.
Definition connection.hpp:117
websocketpp::transport::shutdown_handler
lib::function< void(lib::error_code const &)> shutdown_handler
The type and signature of the callback passed to the shutdown method.
Definition connection.hpp:129
websocketpp::uri_helper
A group of helper methods for parsing and validating URIs against RFC 3986.
Definition uri.hpp:52
websocketpp::uri_helper::digit
bool digit(char c)
RFC3986 digit character test.
Definition uri.hpp:184
websocketpp::uri_helper::gen_delim
bool gen_delim(char c)
RFC3986 generic delimiter character test.
Definition uri.hpp:78
websocketpp::uri_helper::digit
bool digit(std::string::const_iterator it)
RFC3986 digit character test (iterator version).
Definition uri.hpp:195
websocketpp::uri_helper::ipv4_literal
bool ipv4_literal(std::string::const_iterator start, std::string::const_iterator end)
Tests a range for a valid IPv4 literal.
Definition uri.hpp:250
websocketpp::uri_helper::sub_delim
bool sub_delim(char c)
RFC3986 subcomponent delimiter character test.
Definition uri.hpp:100
websocketpp::uri_helper::reg_name
bool reg_name(std::string::const_iterator start, std::string::const_iterator end)
Tests a range for validity for a registry name.
Definition uri.hpp:373
websocketpp::uri_helper::pct_encoded
bool pct_encoded(std::string::const_iterator it)
RFC3986 per cent encoded character test.
Definition uri.hpp:211
websocketpp::uri_helper::scheme
bool scheme(char c)
RFC3986 scheme character test.
Definition uri.hpp:165
websocketpp::uri_helper::unreserved
bool unreserved(char c)
RFC3986 unreserved character test.
Definition uri.hpp:61
websocketpp::uri_helper::reg_name
bool reg_name(char c)
Tests a character for validity for a registry name.
Definition uri.hpp:361
websocketpp::uri_helper::hex4
bool hex4(std::string::const_iterator start, std::string::const_iterator end)
Tests a range for a valid IPv6 hex quad.
Definition uri.hpp:279
websocketpp::uri_helper::dec_octet
bool dec_octet(std::string::const_iterator start, std::string::const_iterator end)
Tests a range for a valid IPv4 decimal octet.
Definition uri.hpp:223
websocketpp::uri_helper::ipv6_literal
bool ipv6_literal(std::string::const_iterator start, std::string::const_iterator end)
Tests a range for a valid IPv6 literal.
Definition uri.hpp:299
websocketpp::uri_helper::hexdigit
bool hexdigit(char c)
RFC3986 hex digit character test.
Definition uri.hpp:128
websocketpp::utility
Generic non-websocket specific utility functions and data structures.
Definition utilities.hpp:39
websocketpp::utility::to_hex
std::string to_hex(uint8_t const *input, size_t length)
Convert byte array (uint8_t) to ascii printed string of hex digits.
Definition utilities_impl.hpp:41
websocketpp::utility::ci_find_substr
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive).
Definition utilities.hpp:101
websocketpp::utility::ci_find_substr
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive).
Definition utilities.hpp:123
websocketpp::utility::to_hex
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
Definition utilities_impl.hpp:55
websocketpp
Namespace for the WebSocket++ project.
Definition asio_no_tls_client.hpp:34
websocketpp::pong_handler
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
Definition connection.hpp:109
websocketpp::close_handler
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
Definition connection.hpp:69
websocketpp::pong_timeout_handler
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
Definition connection.hpp:116
websocketpp::http_handler
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
Definition connection.hpp:151
websocketpp::open_handler
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
Definition connection.hpp:59
websocketpp::interrupt_handler
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
Definition connection.hpp:91
websocketpp::uri_default_secure_port
static uint16_t const uri_default_secure_port
Default port for wss://.
Definition uri.hpp:47
websocketpp::fail_handler
lib::function< void(connection_hdl)> fail_handler
The type and function signature of a fail handler.
Definition connection.hpp:79
websocketpp::connection_hdl
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
Definition connection_hdl.hpp:48
websocketpp::uri_default_port
static uint16_t const uri_default_port
Default port for ws://.
Definition uri.hpp:45
websocketpp::ping_handler
lib::function< bool(connection_hdl, std::string)> ping_handler
The type and function signature of a ping handler.
Definition connection.hpp:101
websocketpp::user_agent
static char const user_agent[]
Default user agent string.
Definition version.hpp:57
websocketpp::uri_ptr
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition uri.hpp:791
websocketpp::err_str_pair
std::pair< lib::error_code, std::string > err_str_pair
Combination error code / string type for returning two values.
Definition error.hpp:41
websocketpp::validate_handler
lib::function< bool(connection_hdl)> validate_handler
The type and function signature of a validate handler.
Definition connection.hpp:129
websocketpp::is_base64
static bool is_base64(unsigned char c)
Test whether a character is a valid base64 character.
Definition base64.hpp:53
websocketpp::base64_encode
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
Definition base64.hpp:66
TYP_BIGE
#define TYP_BIGE
Definition network.hpp:53
TYP_SMLE
#define TYP_SMLE
Definition network.hpp:52
TYP_INIT
#define TYP_INIT
Definition network.hpp:51
is_error_code_enum< websocketpp::error::value >
Definition error.hpp:249
is_error_code_enum< websocketpp::extensions::error::value >
Definition extension.hpp:97
is_error_code_enum< websocketpp::http::error::value >
Definition constants.hpp:454
is_error_code_enum< websocketpp::transport::asio::error::value >
Definition base.hpp:228
is_error_code_enum< websocketpp::transport::error::value >
Definition connection.hpp:233
is_error_code_enum< websocketpp::transport::iostream::error::value >
Definition base.hpp:128
websocketpp::config::asio::transport_config
Definition asio_no_tls.hpp:56
websocketpp::config::asio
Server config with asio transport and TLS disabled.
Definition asio_no_tls.hpp:38
websocketpp::config::core::permessage_deflate_config
Extension specific settings:
Definition core.hpp:260
websocketpp::config::core::permessage_deflate_config::minimum_outgoing_window_bits
static const uint8_t minimum_outgoing_window_bits
Definition core.hpp:272
websocketpp::config::core::permessage_deflate_config::allow_disabling_context_takeover
static const bool allow_disabling_context_takeover
Definition core.hpp:265
websocketpp::config::core::transport_config
Definition core.hpp:100
websocketpp::config::core::transport_config::timeout_socket_shutdown
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
Definition core.hpp:137
websocketpp::config::core::transport_config::timeout_connect
static const long timeout_connect
Length of time to wait for TCP connect.
Definition core.hpp:134
websocketpp::config::core::transport_config::timeout_dns_resolve
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
Definition core.hpp:131
websocketpp::config::core::transport_config::timeout_proxy
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
Definition core.hpp:121
websocketpp::config::core::transport_config::timeout_socket_pre_init
static const long timeout_socket_pre_init
Default timer values (in ms).
Definition core.hpp:118
websocketpp::config::core::transport_config::enable_multithreading
static bool const enable_multithreading
Definition core.hpp:110
websocketpp::config::core::transport_config::timeout_socket_post_init
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Definition core.hpp:128
websocketpp::config::core
Server config with iostream transport.
Definition core.hpp:68
websocketpp::config::core::rng_type
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
Definition core.hpp:93
websocketpp::config::core::elog_level
static const websocketpp::log::level elog_level
Default static error logging channels.
Definition core.hpp:176
websocketpp::config::core::transport_type
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
Definition core.hpp:142
websocketpp::config::core::max_http_body_size
static const size_t max_http_body_size
Default maximum http body size.
Definition core.hpp:252
websocketpp::config::core::timeout_open_handshake
static const long timeout_open_handshake
Default timer values (in ms).
Definition core.hpp:152
websocketpp::config::core::max_message_size
static const size_t max_message_size
Default maximum message size.
Definition core.hpp:240
websocketpp::config::core::drop_on_protocol_error
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
Definition core.hpp:213
websocketpp::config::core::timeout_close_handshake
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
Definition core.hpp:154
websocketpp::config::core::alog_level
static const websocketpp::log::level alog_level
Default static access logging channels.
Definition core.hpp:189
websocketpp::config::core::elog_type
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition core.hpp:88
websocketpp::config::core::timeout_pong
static const long timeout_pong
Length of time to wait for a pong after a ping.
Definition core.hpp:156
websocketpp::config::core::silent_close
static const bool silent_close
Suppresses the return of detailed connection close information.
Definition core.hpp:228
websocketpp::config::core::enable_multithreading
static bool const enable_multithreading
Definition core.hpp:98
websocketpp::config::core::connection_read_buffer_size
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
Definition core.hpp:204
websocketpp::config::core::enable_extensions
static const bool enable_extensions
Global flag for enabling/disabling extensions.
Definition core.hpp:255
websocketpp::config::core::client_version
static const int client_version
WebSocket Protocol version to use as a client.
Definition core.hpp:164
websocketpp::frame::basic_header
The constant size component of a WebSocket frame header.
Definition frame.hpp:189
websocketpp::frame::extended_header
The variable size component of a WebSocket frame header.
Definition frame.hpp:235
websocketpp::log::alevel
Package of log levels for logging access events.
Definition levels.hpp:112
websocketpp::log::alevel::channel_name
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:164
websocketpp::log::alevel::fail
static level const fail
One line for each failed WebSocket connection with details.
Definition levels.hpp:147
websocketpp::log::alevel::none
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:114
websocketpp::log::alevel::debug_handshake
static level const debug_handshake
Extra information about opening handshakes.
Definition levels.hpp:137
websocketpp::log::alevel::devel
static level const devel
Development messages (warning: very chatty).
Definition levels.hpp:141
websocketpp::log::alevel::all
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:152
websocketpp::log::alevel::debug_close
static level const debug_close
Extra information about closing handshakes.
Definition levels.hpp:139
websocketpp::log::alevel::frame_payload
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty).
Definition levels.hpp:129
websocketpp::log::alevel::connect
static level const connect
Information about new connections.
Definition levels.hpp:121
websocketpp::log::alevel::app
static level const app
Special channel for application specific logs. Not used by the library.
Definition levels.hpp:143
websocketpp::log::alevel::frame_header
static level const frame_header
One line per frame, includes the full frame header.
Definition levels.hpp:127
websocketpp::log::alevel::message_payload
static level const message_payload
Reserved.
Definition levels.hpp:133
websocketpp::log::alevel::endpoint
static level const endpoint
Reserved.
Definition levels.hpp:135
websocketpp::log::alevel::message_header
static level const message_header
Reserved.
Definition levels.hpp:131
websocketpp::log::alevel::control
static level const control
One line per control frame.
Definition levels.hpp:125
websocketpp::log::alevel::disconnect
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
Definition levels.hpp:123
websocketpp::log::alevel::access_core
static level const access_core
Definition levels.hpp:150
websocketpp::log::alevel::http
static level const http
Access related to HTTP requests.
Definition levels.hpp:145
websocketpp::log::channel_type_hint
Package of values for hinting at the nature of a given logger.
Definition levels.hpp:46
websocketpp::log::channel_type_hint::none
static value const none
No information.
Definition levels.hpp:51
websocketpp::log::channel_type_hint::access
static value const access
Access log.
Definition levels.hpp:53
websocketpp::log::channel_type_hint::error
static value const error
Error log.
Definition levels.hpp:55
websocketpp::log::channel_type_hint::value
uint32_t value
Type of a channel type hint value.
Definition levels.hpp:48
websocketpp::log::elevel
Package of log levels for logging errors.
Definition levels.hpp:59
websocketpp::log::elevel::devel
static level const devel
Low level debugging information (warning: very chatty).
Definition levels.hpp:63
websocketpp::log::elevel::channel_name
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:91
websocketpp::log::elevel::library
static level const library
Definition levels.hpp:66
websocketpp::log::elevel::info
static level const info
Definition levels.hpp:69
websocketpp::log::elevel::all
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:80
websocketpp::log::elevel::fatal
static level const fatal
Definition levels.hpp:78
websocketpp::log::elevel::none
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:61
websocketpp::log::elevel::rerror
static level const rerror
Definition levels.hpp:75
websocketpp::log::elevel::warn
static level const warn
Definition levels.hpp:72
websocketpp::transport::buffer
A simple utility buffer class.
Definition connection.hpp:138
websocketpp::transport::iostream::timer
Definition connection.hpp:55
websocketpp::utility::ci_less::nocase_compare
Definition utilities.hpp:77
websocketpp::utility::ci_less
Helper less than functor for case insensitive find.
Definition utilities.hpp:75
websocketpp::utility::my_equal
Helper functor for case insensitive find.
Definition utilities.hpp:49
websocketpp::utility::my_equal::operator()
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
Definition utilities.hpp:63
websocketpp::utility::my_equal::my_equal
my_equal(std::locale const &loc)
Construct the functor with the given locale.
Definition utilities.hpp:54
_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
Definition system_error.hpp:78
_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Definition system_error.hpp:77
websocketpp::frame::uint16_converter
Two byte conversion union.
Definition frame.hpp:55
websocketpp::frame::uint32_converter
Four byte conversion union.
Definition frame.hpp:61
websocketpp::frame::uint64_converter
Eight byte conversion union.
Definition frame.hpp:67