2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
28#ifndef WEBSOCKETPP_LOGGER_BASIC_HPP
29#define WEBSOCKETPP_LOGGER_BASIC_HPP
32
33
34
35
36
37
38
39
40
41
43#include <websocketpp/logger/levels.hpp>
45#include <websocketpp/common/cpp11.hpp>
46#include <websocketpp/common/stdint.hpp>
47#include <websocketpp/common/time.hpp>
58template <
typename concurrency,
typename names>
63 : m_static_channels(0xffffffff)
64 , m_dynamic_channels(0)
67 basic<concurrency,names>(std::ostream * out)
68 : m_static_channels(0xffffffff)
69 , m_dynamic_channels(0)
74 : m_static_channels(c)
75 , m_dynamic_channels(0)
78 basic<concurrency,names>(level c, std::ostream * out)
79 : m_static_channels(c)
80 , m_dynamic_channels(0)
84 ~basic<concurrency,names>() {}
87 basic<concurrency,names>(
basic<concurrency,names>
const & other)
88 : m_static_channels(other.m_static_channels)
89 , m_dynamic_channels(other.m_dynamic_channels)
93#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
95 basic<concurrency,names> & operator=(
basic<concurrency,names>
const &) =
delete;
98#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
100 basic<concurrency,names>(
basic<concurrency,names> && other)
101 : m_static_channels(other.m_static_channels)
102 , m_dynamic_channels(other.m_dynamic_channels)
106#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
108 basic<concurrency,names> & operator=(
basic<concurrency,names> &&) =
delete;
113 void set_ostream(std::ostream * out = &std::cout) {
117 void set_channels(level channels) {
118 if (channels == names::none) {
119 clear_channels(names::all);
123 scoped_lock_type lock(m_lock);
124 m_dynamic_channels |= (channels & m_static_channels);
127 void clear_channels(level channels) {
128 scoped_lock_type lock(m_lock);
129 m_dynamic_channels &= ~channels;
134
135
136
137 void write(level channel, std::string
const & msg) {
138 scoped_lock_type lock(m_lock);
139 if (!
this->dynamic_test(channel)) {
return; }
140 *m_out <<
"[" << timestamp <<
"] "
141 <<
"[" << names::channel_name(channel) <<
"] "
148
149
150
151 void write(level channel,
char const * msg) {
152 scoped_lock_type lock(m_lock);
153 if (!
this->dynamic_test(channel)) {
return; }
154 *m_out <<
"[" << timestamp <<
"] "
155 <<
"[" << names::channel_name(channel) <<
"] "
161 return ((channel & m_static_channels) != 0);
164 bool dynamic_test(level channel) {
165 return ((channel & m_dynamic_channels) != 0);
169 typedef typename concurrency::scoped_lock_type scoped_lock_type;
170 typedef typename concurrency::mutex_type mutex_type;
179 static std::ostream & timestamp(std::ostream & os) {
180 std::time_t t = std::time(NULL);
181 std::tm lt = lib::localtime(t);
182 #ifdef _WEBSOCKETPP_PUTTIME_
183 return os << std::put_time(<,
"%Y-%m-%d %H:%M:%S");
186 size_t result = std::strftime(buffer,
sizeof(buffer),
"%Y-%m-%d %H:%M:%S",<);
187 return os << (result == 0 ?
"Unknown" : buffer);
191 level
const m_static_channels;
192 level m_dynamic_channels;
193 std::ostream * m_out;
#define _WEBSOCKETPP_CPP11_FUNCTIONAL_
#define _WEBSOCKETPP_CPP11_THREAD_
#define _WEBSOCKETPP_CPP11_MEMORY_
#define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
Concurrency policy that uses std::mutex / boost::mutex.
Stub for user supplied base class.
Stub for user supplied base class.
Stub class for use when disabling permessage_deflate extension.
header_list const & get_headers() const
Return a list of all HTTP headers.
size_t process_body(char const *buf, size_t len)
Process body data.
std::string const & get_body() const
Get HTTP body.
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
bool body_ready() const
Check if the parser is done parsing the body.
bool prepare_body()
Prepare the parser to begin parsing body data.
void set_max_body_size(size_t value)
Set body size limit.
std::string raw_headers() const
Generate and return the HTTP headers as a string.
std::string const & get_version() const
Get the HTTP version string.
size_t get_max_body_size() const
Get body size limit.
Stores, parses, and manipulates HTTP requests.
std::string raw() const
Returns the full raw request (including the body)
std::string const & get_uri() const
Return the requested URI.
std::string const & get_method() const
Return the request method.
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
bool ready() const
Returns whether or not the request is ready for reading.
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request)
Stores, parses, and manipulates HTTP responses.
void set_status(status_code::value code)
Set response status code and message.
std::string raw() const
Returns the full raw response.
size_t consume(std::istream &s)
Process bytes in the input buffer (istream version)
bool headers_ready() const
Returns true if the response headers are fully parsed.
bool ready() const
Returns true if the response is ready.
const std::string & get_status_msg() const
Return the response status message.
status_code::value get_status_code() const
Return the response status code.
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Basic logger that outputs to an ostream.
void write(level channel, char const *msg)
Write a cstring message to the given channel.
bool recycle(message *)
Recycle a message.
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
message_ptr get_message()
Get an empty message buffer.
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Represents a buffer for a single WebSocket message.
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
std::string & get_raw_payload()
Get a non-const reference to the payload string.
bool recycle()
Recycle the message.
bool get_compressed() const
Return whether or not the message is flagged as compressed.
bool get_terminal() const
Get whether or not the message is terminal.
std::string const & get_header() const
Return the prepared frame header.
void set_payload(void const *payload, size_t len)
Set payload data.
bool get_fin() const
Read the fin bit.
void append_payload(void const *payload, size_t len)
Append payload data.
void set_opcode(frame::opcode::value op)
Set the opcode.
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
frame::opcode::value get_opcode() const
Return the message opcode.
void set_terminal(bool value)
Set the terminal flag.
bool get_prepared() const
Return whether or not the message has been prepared for sending.
void set_compressed(bool value)
Set or clear the compression flag.
message(const con_msg_man_ptr manager)
Construct an empty message.
void set_fin(bool value)
Set the fin bit.
std::string const & get_payload() const
Get a reference to the payload string.
Thread safe stub "random" integer generator.
Server endpoint role based on the given config.
Basic ASIO endpoint socket component.
Asio based endpoint transport component.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
connection_hdl get_handle() const
Get the connection handle.
config::alog_type alog_type
Type of this transport's access logging policy.
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
void set_uri(uri_ptr)
Set uri hook.
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
void set_write_handler(write_handler h)
Sets the write handler.
void set_secure(bool value)
Set whether or not this connection is secure.
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
connection< config > type
Type of this connection transport component.
config::elog_type elog_type
Type of this transport's error logging policy.
void fatal_error()
Signal transport error.
size_t read_some(char const *buf, size_t len)
Manual input supply (read some)
size_t read_all(char const *buf, size_t len)
Manual input supply (read all)
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED)
config::concurrency_type concurrency_type
transport concurrency policy
void init(init_handler handler)
Initialize the connection transport.
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
bool is_secure() const
Tests whether or not the underlying transport is secure.
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
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.
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather)
ptr get_shared()
Get a shared pointer to this component.
iostream::connection< config > transport_con_type
config::elog_type elog_type
Type of this endpoint's error logging policy.
void set_write_handler(write_handler h)
Sets the write handler.
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
bool is_secure() const
Tests whether or not the underlying transport is secure.
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
transport_con_type::ptr transport_con_ptr
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
endpoint type
Type of this endpoint transport component.
void register_ostream(std::ostream *o)
Register a default output stream.
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
config::alog_type alog_type
Type of this endpoint's access logging policy.
iostream transport error category
std::string get_query() const
Return the query portion.
#define _WEBSOCKETPP_CONSTEXPR_TOKEN_
#define _WEBSOCKETPP_NOEXCEPT_TOKEN_
Concurrency handling support.
Library level error codes.
@ general
Catch-all library error.
@ unrequested_subprotocol
Selected subprotocol was not requested by the client.
@ invalid_port
Invalid port in URI.
@ client_only
Attempted to use a client specific feature on a server endpoint.
@ http_connection_ended
HTTP connection ended.
@ async_accept_not_listening
@ operation_canceled
The requested operation was canceled.
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
@ http_parse_error
HTTP parse error.
@ reserved_close_code
Close code is in a reserved range.
@ con_creation_failed
Connection creation attempted failed.
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
@ invalid_state
The connection was in the wrong state for this operation.
@ extension_neg_failed
Extension negotiation failed.
@ rejected
Connection rejected.
@ unsupported_version
Unsupported WebSocket protocol version.
@ invalid_utf8
Invalid UTF-8.
@ invalid_close_code
Close code is invalid.
@ server_only
Attempted to use a server specific feature on a client endpoint.
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
@ close_handshake_timeout
WebSocket close handshake timed out.
@ invalid_subprotocol
Invalid subprotocol.
@ bad_close_code
Unable to parse close code.
@ open_handshake_timeout
WebSocket opening handshake timed out.
@ invalid_version
Invalid WebSocket protocol version.
@ send_queue_full
send attempted when endpoint write queue was full
@ test
Unit testing utility error code.
@ invalid_uri
An invalid uri was supplied.
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Constants related to frame and payload limits.
static uint8_t const close_reason_size
Maximum size of close frame reason.
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127)
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
static unsigned int const max_header_length
Maximum length of a WebSocket header.
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Constants and utility functions related to WebSocket opcodes.
bool invalid(value v)
Check if an opcode is invalid.
bool reserved(value v)
Check if an opcode is reserved.
bool is_control(value v)
Check if an opcode is for a control frame.
Data structures and utility functions for manipulating WebSocket frames.
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
bool get_masked(basic_header const &h)
check whether the frame is masked
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place)
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place)
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place)
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place)
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
static char const header_separator[]
Literal value of the HTTP header separator.
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
bool is_not_token_char(unsigned char c)
Is the character a non-token.
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
static char const header_token[]
invalid HTTP token characters
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
bool is_token_char(unsigned char c)
Is the character a token.
static std::string const empty_header
Literal value of an empty header.
Stub RNG policy that always returns 0.
Random number generation policies.
Transport policy that uses asio.
Generic transport related errors.
@ pass_through
underlying transport pass through
@ operation_not_supported
Operation not supported.
@ operation_aborted
Operation aborted.
@ tls_error
Other TLS error.
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
@ action_after_shutdown
read or write after shutdown
@ tls_short_read
TLS short read.
@ double_read
async_read called while another async_read was in progress
iostream transport errors
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
@ double_read
async_read called while another async_read was in progress
lib::error_code make_error_code(error::value e)
Get an error code with the given value and the iostream transport category.
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Transport policy that uses STL iostream for I/O and does not support timers.
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
lib::function< lib::error_code(connection_hdl)> shutdown_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.
Transport policies provide network connectivity and timers.
lib::function< void(lib::error_code const &, size_t)> read_handler
The type and signature of the callback passed to the read method.
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
lib::function< void(lib::error_code const &)> timer_handler
The type and signature of the callback passed to the read method.
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
lib::function< void(lib::error_code const &)> write_handler
The type and signature of the callback passed to the write method.
lib::function< void(lib::error_code const &)> init_handler
The type and signature of the callback passed to the init hook.
lib::function< void(lib::error_code const &)> shutdown_handler
The type and signature of the callback passed to the shutdown method.
Generic non-websocket specific utility functions and data structures.
std::string to_hex(uint8_t const *input, size_t length)
Convert byte array (uint8_t) to ascii printed string of hex digits.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive)
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
Namespace for the WebSocket++ project.
static uint16_t const uri_default_secure_port
Default port for wss://.
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
static uint16_t const uri_default_port
Default port for ws://.
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
std::pair< lib::error_code, std::string > err_str_pair
Combination error code / string type for returning two values.
Server config with asio transport and TLS disabled.
Extension specific settings:
static const uint8_t minimum_outgoing_window_bits
static const bool allow_disabling_context_takeover
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
static const long timeout_connect
Length of time to wait for TCP connect.
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
static const long timeout_socket_pre_init
Default timer values (in ms)
static bool const enable_multithreading
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Server config with iostream transport.
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
static const websocketpp::log::level elog_level
Default static error logging channels.
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
static const size_t max_http_body_size
Default maximum http body size.
static const long timeout_open_handshake
Default timer values (in ms)
static const size_t max_message_size
Default maximum message size.
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
static const websocketpp::log::level alog_level
Default static access logging channels.
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
static const long timeout_pong
Length of time to wait for a pong after a ping.
static const bool silent_close
Suppresses the return of detailed connection close information.
static bool const enable_multithreading
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
static const bool enable_extensions
Global flag for enabling/disabling extensions.
static const int client_version
WebSocket Protocol version to use as a client.
Package of log levels for logging access events.
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
static level const fail
One line for each failed WebSocket connection with details.
static level const none
Special aggregate value representing "no levels".
static level const debug_handshake
Extra information about opening handshakes.
static level const devel
Development messages (warning: very chatty)
static level const all
Special aggregate value representing "all levels".
static level const debug_close
Extra information about closing handshakes.
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty)
static level const connect
Information about new connections.
static level const app
Special channel for application specific logs. Not used by the library.
static level const frame_header
One line per frame, includes the full frame header.
static level const message_payload
Reserved.
static level const endpoint
Reserved.
static level const message_header
Reserved.
static level const control
One line per control frame.
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
static level const access_core
static level const http
Access related to HTTP requests.
Package of values for hinting at the nature of a given logger.
static value const none
No information.
static value const access
Access log.
static value const error
Error log.
uint32_t value
Type of a channel type hint value.
Package of log levels for logging errors.
static level const devel
Low level debugging information (warning: very chatty)
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
static level const library
static level const all
Special aggregate value representing "all levels".
static level const none
Special aggregate value representing "no levels".
static level const rerror
A simple utility buffer class.
Helper less than functor for case insensitive find.
Helper functor for case insensitive find.
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
my_equal(std::locale const &loc)
Construct the functor with the given locale.
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Two byte conversion union.
Four byte conversion union.
Eight byte conversion union.