thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-02-07 13:27:13 +01:00
Code Releases Activity
SqMod/module/Vendor/WebSocketPP/websocketpp/connection.hpp
Sandu Liviu Catalin 95705e87c8 Initial preparations for CURL and Discord integration.
2021-01-27 07:27:48 +02:00

1643 lines
57 KiB
C++
Raw Blame History

/*
* 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 absense 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);
/// Asyncronously invoke handler::on_inturrupt
/**
* Signals to the connection to asyncronously invoke the on_inturrupt
* callback for this connection's handler once it is safe to do so.
*
* When the on_inturrupt 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 inturrupt signals can be active at once on the same connection
*
* @return An error code
*/
lib::error_code interrupt();
/// Transport inturrupt 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 negotated 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 reponse and the value will be available via
* get_subprotocol(). Subprotocol requests should be added in order of
* preference.
*
* @param request The subprotocol to request
* @param ec A reference to an error code that will be filled in the case of
* errors
*/
void add_subprotocol(std::string const & request, lib::error_code & ec);
/// Adds the given subprotocol string to the request list
/**
* 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 reponse and the value will be available via
* get_subprotocol(). Subprotocol requests should be added in order of
* preference.
*
* @param 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 value The subprotocol to select
* @param ec A reference to an error code that will be filled in the case of
* errors
*/
void select_subprotocol(std::string const & value, lib::error_code & ec);
/// Select a subprotocol to use
/**
* 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 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 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 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
/**
* 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.
*
* @param code Code to set
* @param msg Message to set
* @see websocketpp::http::response::set_status
*/
void set_status(http::status_code::value code);
/// Set response status code and message
/**
* 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 code Code to set
* @param msg Message to set
* @see websocketpp::http::response::set_status
*/
void set_status(http::status_code::value code, std::string const & msg);
/// Set response body content
/**
* 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 value String data to include as the body content.
* @see websocketpp::http::response::set_body
*/
void set_body(std::string const & value);
/// Append a header
/**
* 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.
*
* This member function is valid only from the http() and validate() handler
* callbacks, or to a client connection before connect has been called.
*
* @param key Name of the header to set
* @param val Value to add
* @see replace_header
* @see websocketpp::http::parser::append_header
*/
void append_header(std::string const & key, std::string const & val);
/// Replace a header
/**
* 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.
*
* This member function is valid only from the http() and validate() handler
* callbacks, or to a client connection before connect has been called.
*
* @param key Name of the header to set
* @param val Value to set
* @see append_header
* @see websocketpp::http::parser::replace_header
*/
void replace_header(std::string const & key, std::string const & val);
/// Remove a header
/**
* Removes a header from the response.
*
* This member function is valid only from the http() and validate() handler
* callbacks, or to a client connection before connect has been called.
*
* @param key The name of the header to remove
* @see websocketpp::http::parser::remove_header
*/
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 overrided 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 overrided 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 writen
/**
* 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
View Git Blame Copy Permalink