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_TRANSPORT_IOSTREAM_CON_HPP
#define WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
#include <websocketpp/transport/iostream/base.hpp>
#include <websocketpp/transport/base/connection.hpp>
#include <websocketpp/uri.hpp>
#include <websocketpp/logger/levels.hpp>
#include <websocketpp/common/connection_hdl.hpp>
#include <websocketpp/common/memory.hpp>
#include <websocketpp/common/platforms.hpp>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
namespace websocketpp {
namespace transport {
namespace iostream {
/// Empty timer class to stub out for timer functionality that iostream
/// transport doesn't support
struct timer {
void cancel() {}
};
template <typename config>
class connection : public lib::enable_shared_from_this< connection<config> > {
public:
/// Type of this connection transport component
typedef connection<config> type;
/// Type of a shared pointer to this connection transport component
typedef lib::shared_ptr<type> ptr;
/// transport concurrency policy
typedef typename config::concurrency_type concurrency_type;
/// Type of this transport's access logging policy
typedef typename config::alog_type alog_type;
/// Type of this transport's error logging policy
typedef typename config::elog_type elog_type;
// Concurrency policy types
typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
typedef typename concurrency_type::mutex_type mutex_type;
typedef lib::shared_ptr<timer> timer_ptr;
explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
: m_output_stream(NULL)
, m_reading(false)
, m_is_server(is_server)
, m_is_secure(false)
, m_alog(alog)
, m_elog(elog)
, m_remote_endpoint("iostream transport")
{
m_alog->write(log::alevel::devel,"iostream con transport constructor");
}
/// Get a shared pointer to this component
ptr get_shared() {
return type::shared_from_this();
}
/// Register a std::ostream with the transport for writing output
/**
* Register a std::ostream with the transport. All future writes will be
* done to this output stream.
*
* @param o A pointer to the ostream to use for output.
*/
void register_ostream(std::ostream * o) {
// TODO: lock transport state?
scoped_lock_type lock(m_read_mutex);
m_output_stream = o;
}
/// Set uri hook
/**
* Called by the endpoint as a connection is being established to provide
* the uri being connected to to the transport layer.
*
* This transport policy doesn't use the uri so it is ignored.
*
* @since 0.6.0
*
* @param u The uri to set
*/
void set_uri(uri_ptr) {}
/// Overloaded stream input operator
/**
* Attempts to read input from the given stream into the transport. Bytes
* will be extracted from the input stream to fulfill any pending reads.
* Input in this manner will only read until the current read buffer has
* been filled. Then it will signal the library to process the input. If the
* library's input handler adds a new async_read, additional bytes will be
* read, otherwise the input operation will end.
*
* When this function returns one of the following conditions is true:
* - There is no outstanding read operation
* - There are no more bytes available in the input stream
*
* You can use tellg() on the input stream to determine if all of the input
* bytes were read or not.
*
* If there is no pending read operation when the input method is called, it
* will return immediately and tellg() will not have changed.
*/
friend std::istream & operator>> (std::istream & in, type & t) {
// this serializes calls to external read.
scoped_lock_type lock(t.m_read_mutex);
t.read(in);
return in;
}
/// Manual input supply (read some)
/**
* Copies bytes from buf into WebSocket++'s input buffers. Bytes will be
* copied from the supplied buffer to fulfill any pending library reads. It
* will return the number of bytes successfully processed. If there are no
* pending reads read_some will return immediately. Not all of the bytes may
* be able to be read in one call.
*
* @since 0.3.0-alpha4
*
* @param buf Char buffer to read into the websocket
* @param len Length of buf
* @return The number of characters from buf actually read.
*/
size_t read_some(char const * buf, size_t len) {
// this serializes calls to external read.
scoped_lock_type lock(m_read_mutex);
return this->read_some_impl(buf,len);
}
/// Manual input supply (read all)
/**
* Similar to read_some, but continues to read until all bytes in the
* supplied buffer have been read or the connection runs out of read
* requests.
*
* This method still may not read all of the bytes in the input buffer. if
* it doesn't it indicates that the connection was most likely closed or
* is in an error state where it is no longer accepting new input.
*
* @since 0.3.0
*
* @param buf Char buffer to read into the websocket
* @param len Length of buf
* @return The number of characters from buf actually read.
*/
size_t read_all(char const * buf, size_t len) {
// this serializes calls to external read.
scoped_lock_type lock(m_read_mutex);
size_t total_read = 0;
size_t temp_read = 0;
do {
temp_read = this->read_some_impl(buf+total_read,len-total_read);
total_read += temp_read;
} while (temp_read != 0 && total_read < len);
return total_read;
}
/// Manual input supply (DEPRECATED)
/**
* @deprecated DEPRECATED in favor of read_some()
* @see read_some()
*/
size_t readsome(char const * buf, size_t len) {
return this->read_some(buf,len);
}
/// Signal EOF
/**
* Signals to the transport that data stream being read has reached EOF and
* that no more bytes may be read or written to/from the transport.
*
* @since 0.3.0-alpha4
*/
void eof() {
// this serializes calls to external read.
scoped_lock_type lock(m_read_mutex);
if (m_reading) {
complete_read(make_error_code(transport::error::eof));
}
}
/// Signal transport error
/**
* Signals to the transport that a fatal data stream error has occurred and
* that no more bytes may be read or written to/from the transport.
*
* @since 0.3.0-alpha4
*/
void fatal_error() {
// this serializes calls to external read.
scoped_lock_type lock(m_read_mutex);
if (m_reading) {
complete_read(make_error_code(transport::error::pass_through));
}
}
/// Set whether or not this connection is secure
/**
* The iostream transport does not provide any security features. As such
* it defaults to returning false when `is_secure` is called. However, the
* iostream transport may be used to wrap an external socket API that may
* provide secure transport. This method allows that external API to flag
* whether or not this connection is secure so that users of the WebSocket++
* API will get more accurate information.
*
* @since 0.3.0-alpha4
*
* @param value Whether or not this connection is secure.
*/
void set_secure(bool value) {
m_is_secure = value;
}
/// Tests whether or not the underlying transport is secure
/**
* iostream transport will return false always because it has no information
* about the ultimate remote endpoint. This may or may not be accurate
* depending on the real source of bytes being input. The `set_secure`
* method may be used to flag connections that are secured by an external
* API
*
* @return Whether or not the underlying transport is secure
*/
bool is_secure() const {
return m_is_secure;
}
/// Set human readable remote endpoint address
/**
* Sets the remote endpoint address returned by `get_remote_endpoint`. This
* value should be a human readable string that describes the remote
* endpoint. Typically an IP address or hostname, perhaps with a port. But
* may be something else depending on the nature of the underlying
* transport.
*
* If none is set the default is "iostream transport".
*
* @since 0.3.0-alpha4
*
* @param value The remote endpoint address to set.
*/
void set_remote_endpoint(std::string value) {
m_remote_endpoint = value;
}
/// Get human readable remote endpoint address
/**
* The iostream transport has no information about the ultimate remote
* endpoint. It will return the string "iostream transport". The
* `set_remote_endpoint` method may be used by external network code to set
* a more accurate value.
*
* This value is used in access and error logs and is available to the end
* application for including in user facing interfaces and messages.
*
* @return A string identifying the address of the remote endpoint
*/
std::string get_remote_endpoint() const {
return m_remote_endpoint;
}
/// Get the connection handle
/**
* @return The handle for this connection.
*/
connection_hdl get_handle() const {
return m_connection_hdl;
}
/// Call back a function after a period of time.
/**
* Timers are not implemented in this transport. The timer pointer will
* always be empty. The handler will never be called.
*
* @param duration Length of time to wait in milliseconds
* @param callback The function to call back when the timer has expired
* @return A handle that can be used to cancel the timer if it is no longer
* needed.
*/
timer_ptr set_timer(long, timer_handler) {
return timer_ptr();
}
/// Sets the write handler
/**
* The write handler is called when the iostream transport receives data
* that needs to be written to the appropriate output location. This handler
* can be used in place of registering an ostream for output.
*
* The signature of the handler is
* `lib::error_code (connection_hdl, char const *, size_t)` The
* code returned will be reported and logged by the core library.
*
* See also, set_vector_write_handler, for an optional write handler that
* allows more efficient handling of multiple writes at once.
*
* @see set_vector_write_handler
*
* @since 0.5.0
*
* @param h The handler to call when data is to be written.
*/
void set_write_handler(write_handler h) {
m_write_handler = h;
}
/// Sets the vectored write handler
/**
* The vectored write handler is called when the iostream transport receives
* multiple chunks of data that need to be written to the appropriate output
* location. This handler can be used in conjunction with the write_handler
* in place of registering an ostream for output.
*
* The sequence of buffers represents bytes that should be written
* consecutively and it is suggested to group the buffers into as few next
* layer packets as possible. Vector write is used to allow implementations
* that support it to coalesce writes into a single TCP packet or TLS
* segment for improved efficiency.
*
* This is an optional handler. If it is not defined then multiple calls
* will be made to the standard write handler.
*
* The signature of the handler is
* `lib::error_code (connection_hdl, std::vector<websocketpp::transport::buffer>
* const & bufs)`. The code returned will be reported and logged by the core
* library. The `websocketpp::transport::buffer` type is a struct with two
* data members. buf (char const *) and len (size_t).
*
* @since 0.6.0
*
* @param h The handler to call when vectored data is to be written.
*/
void set_vector_write_handler(vector_write_handler h) {
m_vector_write_handler = h;
}
/// Sets the shutdown handler
/**
* The shutdown handler is called when the iostream transport receives a
* notification from the core library that it is finished with all read and
* write operations and that the underlying transport can be cleaned up.
*
* If you are using iostream transport with another socket library, this is
* a good time to close/shutdown the socket for this connection.
*
* The signature of the handler is `lib::error_code (connection_hdl)`. The
* code returned will be reported and logged by the core library.
*
* @since 0.5.0
*
* @param h The handler to call on connection shutdown.
*/
void set_shutdown_handler(shutdown_handler h) {
m_shutdown_handler = h;
}
protected:
/// Initialize the connection transport
/**
* Initialize the connection's transport component.
*
* @param handler The `init_handler` to call when initialization is done
*/
void init(init_handler handler) {
m_alog->write(log::alevel::devel,"iostream connection init");
handler(lib::error_code());
}
/// Initiate an async_read for at least num_bytes bytes into buf
/**
* Initiates an async_read request for at least num_bytes bytes. The input
* will be read into buf. A maximum of len bytes will be input. When the
* operation is complete, handler will be called with the status and number
* of bytes read.
*
* This method may or may not call handler from within the initial call. The
* application should be prepared to accept either.
*
* The application should never call this method a second time before it has
* been called back for the first read. If this is done, the second read
* will be called back immediately with a double_read error.
*
* If num_bytes or len are zero handler will be called back immediately
* indicating success.
*
* @param num_bytes Don't call handler until at least this many bytes have
* been read.
* @param buf The buffer to read bytes into
* @param len The size of buf. At maximum, this many bytes will be read.
* @param handler The callback to invoke when the operation is complete or
* ends in an error
*/
void async_read_at_least(size_t num_bytes, char *buf, size_t len,
read_handler handler)
{
std::stringstream s;
s << "iostream_con async_read_at_least: " << num_bytes;
m_alog->write(log::alevel::devel,s.str());
if (num_bytes > len) {
handler(make_error_code(error::invalid_num_bytes),size_t(0));
return;
}
if (m_reading == true) {
handler(make_error_code(error::double_read),size_t(0));
return;
}
if (num_bytes == 0 || len == 0) {
handler(lib::error_code(),size_t(0));
return;
}
m_buf = buf;
m_len = len;
m_bytes_needed = num_bytes;
m_read_handler = handler;
m_cursor = 0;
m_reading = true;
}
/// Asyncronous Transport Write
/**
* Write len bytes in buf to the output method. Call handler to report
* success or failure. handler may or may not be called during async_write,
* but it must be safe for this to happen.
*
* Will return 0 on success. Other possible errors (not exhaustive)
* output_stream_required: No output stream was registered to write to
* bad_stream: a ostream pass through error
*
* This method will attempt to write to the registered ostream first. If an
* ostream is not registered it will use the write handler. If neither are
* registered then an error is passed up to the connection.
*
* @param buf buffer to read bytes from
* @param len number of bytes to write
* @param handler Callback to invoke with operation status.
*/
void async_write(char const * buf, size_t len, transport::write_handler
handler)
{
m_alog->write(log::alevel::devel,"iostream_con async_write");
// TODO: lock transport state?
lib::error_code ec;
if (m_output_stream) {
m_output_stream->write(buf,len);
if (m_output_stream->bad()) {
ec = make_error_code(error::bad_stream);
}
} else if (m_write_handler) {
ec = m_write_handler(m_connection_hdl, buf, len);
} else {
ec = make_error_code(error::output_stream_required);
}
handler(ec);
}
/// Asyncronous Transport Write (scatter-gather)
/**
* Write a sequence of buffers to the output method. Call handler to report
* success or failure. handler may or may not be called during async_write,
* but it must be safe for this to happen.
*
* Will return 0 on success. Other possible errors (not exhaustive)
* output_stream_required: No output stream was registered to write to
* bad_stream: a ostream pass through error
*
* This method will attempt to write to the registered ostream first. If an
* ostream is not registered it will use the write handler. If neither are
* registered then an error is passed up to the connection.
*
* @param bufs vector of buffers to write
* @param handler Callback to invoke with operation status.
*/
void async_write(std::vector<buffer> const & bufs, transport::write_handler
handler)
{
m_alog->write(log::alevel::devel,"iostream_con async_write buffer list");
// TODO: lock transport state?
lib::error_code ec;
if (m_output_stream) {
std::vector<buffer>::const_iterator it;
for (it = bufs.begin(); it != bufs.end(); it++) {
m_output_stream->write((*it).buf,(*it).len);
if (m_output_stream->bad()) {
ec = make_error_code(error::bad_stream);
break;
}
}
} else if (m_vector_write_handler) {
ec = m_vector_write_handler(m_connection_hdl, bufs);
} else if (m_write_handler) {
std::vector<buffer>::const_iterator it;
for (it = bufs.begin(); it != bufs.end(); it++) {
ec = m_write_handler(m_connection_hdl, (*it).buf, (*it).len);
if (ec) {break;}
}
} else {
ec = make_error_code(error::output_stream_required);
}
handler(ec);
}
/// Set Connection Handle
/**
* @param hdl The new handle
*/
void set_handle(connection_hdl hdl) {
m_connection_hdl = hdl;
}
/// Call given handler back within the transport's event system (if present)
/**
* Invoke a callback within the transport's event system if it has one. If
* it doesn't, the handler will be invoked immediately before this function
* returns.
*
* @param handler The callback to invoke
*
* @return Whether or not the transport was able to register the handler for
* callback.
*/
lib::error_code dispatch(dispatch_handler handler) {
handler();
return lib::error_code();
}
/// Perform cleanup on socket shutdown_handler
/**
* If a shutdown handler is set, call it and pass through its return error
* code. Otherwise assume there is nothing to do and pass through a success
* code.
*
* @param handler The `shutdown_handler` to call back when complete
*/
void async_shutdown(transport::shutdown_handler handler) {
lib::error_code ec;
if (m_shutdown_handler) {
ec = m_shutdown_handler(m_connection_hdl);
}
handler(ec);
}
private:
void read(std::istream &in) {
m_alog->write(log::alevel::devel,"iostream_con read");
while (in.good()) {
if (!m_reading) {
m_elog->write(log::elevel::devel,"write while not reading");
break;
}
in.read(m_buf+m_cursor,static_cast<std::streamsize>(m_len-m_cursor));
if (in.gcount() == 0) {
m_elog->write(log::elevel::devel,"read zero bytes");
break;
}
m_cursor += static_cast<size_t>(in.gcount());
// TODO: error handling
if (in.bad()) {
m_reading = false;
complete_read(make_error_code(error::bad_stream));
}
if (m_cursor >= m_bytes_needed) {
m_reading = false;
complete_read(lib::error_code());
}
}
}
size_t read_some_impl(char const * buf, size_t len) {
m_alog->write(log::alevel::devel,"iostream_con read_some");
if (!m_reading) {
m_elog->write(log::elevel::devel,"write while not reading");
return 0;
}
size_t bytes_to_copy = (std::min)(len,m_len-m_cursor);
std::copy(buf,buf+bytes_to_copy,m_buf+m_cursor);
m_cursor += bytes_to_copy;
if (m_cursor >= m_bytes_needed) {
complete_read(lib::error_code());
}
return bytes_to_copy;
}
/// Signal that a requested read is complete
/**
* Sets the reading flag to false and returns the handler that should be
* called back with the result of the read. The cursor position that is sent
* is whatever the value of m_cursor is.
*
* It MUST NOT be called when m_reading is false.
* it MUST be called while holding the read lock
*
* It is important to use this method rather than directly setting/calling
* m_read_handler back because this function makes sure to delete the
* locally stored handler which contains shared pointers that will otherwise
* cause circular reference based memory leaks.
*
* @param ec The error code to forward to the read handler
*/
void complete_read(lib::error_code const & ec) {
m_reading = false;
read_handler handler = m_read_handler;
m_read_handler = read_handler();
handler(ec,m_cursor);
}
// Read space (Protected by m_read_mutex)
char * m_buf;
size_t m_len;
size_t m_bytes_needed;
read_handler m_read_handler;
size_t m_cursor;
// transport resources
std::ostream * m_output_stream;
connection_hdl m_connection_hdl;
write_handler m_write_handler;
vector_write_handler m_vector_write_handler;
shutdown_handler m_shutdown_handler;
bool m_reading;
bool const m_is_server;
bool m_is_secure;
lib::shared_ptr<alog_type> m_alog;
lib::shared_ptr<elog_type> m_elog;
std::string m_remote_endpoint;
// This lock ensures that only one thread can edit read data for this
// connection. This is a very coarse lock that is basically locked all the
// time. The nature of the connection is such that it cannot be
// parallelized, the locking is here to prevent intra-connection concurrency
// in order to allow inter-connection concurrency.
mutex_type m_read_mutex;
};
} // namespace iostream
} // namespace transport
} // namespace websocketpp
#endif // WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_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_SYSTEM_ERROR_
#define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
Definition boost_config.hpp:57
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::endpoint_base
Stub for user supplied base class.
Definition endpoint_base.hpp:34
websocketpp::extensions::permessage_deflate::disabled
Stub class for use when disabling permessage_deflate extension.
Definition disabled.hpp:53
websocketpp::http::parser::request
Stores, parses, and manipulates HTTP requests.
Definition request.hpp:50
websocketpp::http::parser::response
Stores, parses, and manipulates HTTP responses.
Definition response.hpp:57
websocketpp::log::basic
Basic logger that outputs to an ostream.
Definition basic.hpp:59
websocketpp::message_buffer::alloc::con_msg_manager
Definition alloc.hpp:43
websocketpp::message_buffer::alloc::endpoint_msg_manager
Definition alloc.hpp:88
websocketpp::random::none::int_generator
Thread safe stub "random" integer generator.
Definition none.hpp:46
websocketpp::server
Server endpoint role based on the given config.
Definition server_endpoint.hpp:44
websocketpp::transport::asio::basic_socket::endpoint
Basic ASIO endpoint socket component.
Definition none.hpp:318
websocketpp::transport::asio::endpoint
Asio based endpoint transport component.
Definition endpoint.hpp:54
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
__has_extension
#define __has_extension
Definition cpp11.hpp:40
__has_feature
#define __has_feature(x)
Definition cpp11.hpp:37
websocketpp::concurrency
Concurrency handling support.
Definition basic.hpp:34
websocketpp::extensions::permessage_deflate
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition disabled.hpp:44
websocketpp::extensions
Definition disabled.hpp:43
websocketpp::http
HTTP handling support.
Definition request.hpp:37
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
Transport policy that uses asio.
Definition endpoint.hpp:46
websocketpp::transport::error
Generic transport related errors.
Definition connection.hpp:146
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::iostream::error
iostream transport errors
Definition base.hpp:64
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
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::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
Namespace for the WebSocket++ project.
Definition asio_no_tls_client.hpp:34
websocketpp::connection_hdl
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
Definition connection_hdl.hpp:48
websocketpp::uri_ptr
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition uri.hpp:791
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::log::alevel
Package of log levels for logging access events.
Definition levels.hpp:112
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::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::all
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:80
websocketpp::transport::iostream::timer
Definition connection.hpp:55