WebSocket++ 0.8.2
C++ websocket client/server library
endpoint.hpp
1/*
2 * Copyright (c) 2014, Peter Thorson. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution.
11 * * Neither the name of the WebSocket++ Project nor the
12 * names of its contributors may be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 */
27
28#ifndef WEBSOCKETPP_ENDPOINT_HPP
29#define WEBSOCKETPP_ENDPOINT_HPP
30
31#include <websocketpp/connection.hpp>
32
33#include <websocketpp/logger/levels.hpp>
34#include <websocketpp/version.hpp>
35
36#include <string>
37
38namespace websocketpp {
39
40/// Creates and manages connections associated with a WebSocket endpoint
41template <typename connection, typename config>
42class endpoint : public config::transport_type, public config::endpoint_base {
43public:
44 // Import appropriate types from our helper class
45 // See endpoint_types for more details.
46 typedef endpoint<connection,config> type;
47
48 /// Type of the transport component of this endpoint
49 typedef typename config::transport_type transport_type;
50 /// Type of the concurrency component of this endpoint
51 typedef typename config::concurrency_type concurrency_type;
52
53 /// Type of the connections that this endpoint creates
54 typedef connection connection_type;
55 /// Shared pointer to connection_type
56 typedef typename connection_type::ptr connection_ptr;
57 /// Weak pointer to connection type
59
60 /// Type of the transport component of the connections that this endpoint
61 /// creates
63 /// Type of a shared pointer to the transport component of the connections
64 /// that this endpoint creates.
66
67 /// Type of message_handler
69 /// Type of message pointers that this endpoint uses
70 typedef typename connection_type::message_ptr message_ptr;
71
72 /// Type of error logger
73 typedef typename config::elog_type elog_type;
74 /// Type of access logger
75 typedef typename config::alog_type alog_type;
76
77 /// Type of our concurrency policy's scoped lock object
79 /// Type of our concurrency policy's mutex object
80 typedef typename concurrency_type::mutex_type mutex_type;
81
82 /// Type of RNG
83 typedef typename config::rng_type rng_type;
84
85 // TODO: organize these
86 typedef typename connection_type::termination_handler termination_handler;
87
88 // This would be ideal. Requires C++11 though
89 //friend connection;
90
91 explicit endpoint(bool p_is_server)
92 : m_alog(new alog_type(config::alog_level, log::channel_type_hint::access))
93 , m_elog(new elog_type(config::elog_level, log::channel_type_hint::error))
94 , m_user_agent(::websocketpp::user_agent)
95 , m_open_handshake_timeout_dur(config::timeout_open_handshake)
96 , m_close_handshake_timeout_dur(config::timeout_close_handshake)
97 , m_pong_timeout_dur(config::timeout_pong)
98 , m_max_message_size(config::max_message_size)
99 , m_max_http_body_size(config::max_http_body_size)
100 , m_is_server(p_is_server)
101 {
102 m_alog->set_channels(config::alog_level);
103 m_elog->set_channels(config::elog_level);
104
105 m_alog->write(log::alevel::devel, "endpoint constructor");
106
107 transport_type::init_logging(m_alog, m_elog);
108 }
109
110
111 /// Destructor
112 ~endpoint<connection,config>() {}
113
114 #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
115 // no copy constructor because endpoints are not copyable
116 endpoint(endpoint &) = delete;
117
118 // no copy assignment operator because endpoints are not copyable
119 endpoint & operator=(endpoint const &) = delete;
120 #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
121
122 #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
123 /// Move constructor
124 endpoint(endpoint && o)
125 : config::transport_type(std::move(o))
126 , config::endpoint_base(std::move(o))
127 , m_alog(std::move(o.m_alog))
128 , m_elog(std::move(o.m_elog))
129 , m_user_agent(std::move(o.m_user_agent))
130 , m_open_handler(std::move(o.m_open_handler))
131
132 , m_close_handler(std::move(o.m_close_handler))
133 , m_fail_handler(std::move(o.m_fail_handler))
134 , m_ping_handler(std::move(o.m_ping_handler))
135 , m_pong_handler(std::move(o.m_pong_handler))
136 , m_pong_timeout_handler(std::move(o.m_pong_timeout_handler))
137 , m_interrupt_handler(std::move(o.m_interrupt_handler))
138 , m_http_handler(std::move(o.m_http_handler))
139 , m_validate_handler(std::move(o.m_validate_handler))
140 , m_message_handler(std::move(o.m_message_handler))
141
142 , m_open_handshake_timeout_dur(o.m_open_handshake_timeout_dur)
143 , m_close_handshake_timeout_dur(o.m_close_handshake_timeout_dur)
144 , m_pong_timeout_dur(o.m_pong_timeout_dur)
145 , m_max_message_size(o.m_max_message_size)
146 , m_max_http_body_size(o.m_max_http_body_size)
147
148 , m_rng(std::move(o.m_rng))
149 , m_is_server(o.m_is_server)
150 {}
151
152 #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
153 // no move assignment operator because of const member variables
154 endpoint & operator=(endpoint &&) = delete;
155 #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
156
157 #endif // _WEBSOCKETPP_MOVE_SEMANTICS_
158
159
160 /// Returns the user agent string that this endpoint will use
161 /**
162 * Returns the user agent string that this endpoint will use when creating
163 * new connections.
164 *
165 * The default value for this version is stored in websocketpp::user_agent
166 *
167 * @return The user agent string.
168 */
169 std::string get_user_agent() const {
170 scoped_lock_type guard(m_mutex);
171 return m_user_agent;
172 }
173
174 /// Sets the user agent string that this endpoint will use
175 /**
176 * Sets the identifier that this endpoint will use when creating new
177 * connections. Changing this value will only affect future connections.
178 * For client endpoints this will be sent as the "User-Agent" header in
179 * outgoing requests. For server endpoints this will be sent in the "Server"
180 * response header.
181 *
182 * Setting this value to the empty string will suppress the use of the
183 * Server and User-Agent headers. This is typically done to hide
184 * implementation details for security purposes.
185 *
186 * For best results set this before accepting or opening connections.
187 *
188 * The default value for this version is stored in websocketpp::user_agent
189 *
190 * This can be overridden on an individual connection basis by setting a
191 * custom "Server" header during the validate handler or "User-Agent"
192 * header on a connection before calling connect().
193 *
194 * @param ua The string to set the user agent to.
195 */
196 void set_user_agent(std::string const & ua) {
197 scoped_lock_type guard(m_mutex);
198 m_user_agent = ua;
199 }
200
201 /// Returns whether or not this endpoint is a server.
202 /**
203 * @return Whether or not this endpoint is a server
204 */
205 bool is_server() const {
206 return m_is_server;
207 }
208
209 /********************************/
210 /* Pass-through logging adaptor */
211 /********************************/
212
213 /// Set Access logging channel
214 /**
215 * Set the access logger's channel value. The value is a number whose
216 * interpretation depends on the logging policy in use.
217 *
218 * @param channels The channel value(s) to set
219 */
220 void set_access_channels(log::level channels) {
221 m_alog->set_channels(channels);
222 }
223
224 /// Clear Access logging channels
225 /**
226 * Clear the access logger's channel value. The value is a number whose
227 * interpretation depends on the logging policy in use.
228 *
229 * @param channels The channel value(s) to clear
230 */
231 void clear_access_channels(log::level channels) {
232 m_alog->clear_channels(channels);
233 }
234
235 /// Set Error logging channel
236 /**
237 * Set the error logger's channel value. The value is a number whose
238 * interpretation depends on the logging policy in use.
239 *
240 * @param channels The channel value(s) to set
241 */
242 void set_error_channels(log::level channels) {
243 m_elog->set_channels(channels);
244 }
245
246 /// Clear Error logging channels
247 /**
248 * Clear the error logger's channel value. The value is a number whose
249 * interpretation depends on the logging policy in use.
250 *
251 * @param channels The channel value(s) to clear
252 */
253 void clear_error_channels(log::level channels) {
254 m_elog->clear_channels(channels);
255 }
256
257 /// Get reference to access logger
258 /**
259 * @return A reference to the access logger
260 */
261 alog_type & get_alog() {
262 return *m_alog;
263 }
264
265 /// Get reference to error logger
266 /**
267 * @return A reference to the error logger
268 */
269 elog_type & get_elog() {
270 return *m_elog;
271 }
272
273 /*************************/
274 /* Set Handler functions */
275 /*************************/
276
277 void set_open_handler(open_handler h) {
278 m_alog->write(log::alevel::devel,"set_open_handler");
279 scoped_lock_type guard(m_mutex);
280 m_open_handler = h;
281 }
282 void set_close_handler(close_handler h) {
283 m_alog->write(log::alevel::devel,"set_close_handler");
284 scoped_lock_type guard(m_mutex);
285 m_close_handler = h;
286 }
287 void set_fail_handler(fail_handler h) {
288 m_alog->write(log::alevel::devel,"set_fail_handler");
289 scoped_lock_type guard(m_mutex);
290 m_fail_handler = h;
291 }
292 void set_ping_handler(ping_handler h) {
293 m_alog->write(log::alevel::devel,"set_ping_handler");
294 scoped_lock_type guard(m_mutex);
295 m_ping_handler = h;
296 }
297 void set_pong_handler(pong_handler h) {
298 m_alog->write(log::alevel::devel,"set_pong_handler");
299 scoped_lock_type guard(m_mutex);
300 m_pong_handler = h;
301 }
302 void set_pong_timeout_handler(pong_timeout_handler h) {
303 m_alog->write(log::alevel::devel,"set_pong_timeout_handler");
304 scoped_lock_type guard(m_mutex);
305 m_pong_timeout_handler = h;
306 }
307 void set_interrupt_handler(interrupt_handler h) {
308 m_alog->write(log::alevel::devel,"set_interrupt_handler");
309 scoped_lock_type guard(m_mutex);
310 m_interrupt_handler = h;
311 }
312 void set_http_handler(http_handler h) {
313 m_alog->write(log::alevel::devel,"set_http_handler");
314 scoped_lock_type guard(m_mutex);
315 m_http_handler = h;
316 }
317 void set_validate_handler(validate_handler h) {
318 m_alog->write(log::alevel::devel,"set_validate_handler");
319 scoped_lock_type guard(m_mutex);
320 m_validate_handler = h;
321 }
322 void set_message_handler(message_handler h) {
323 m_alog->write(log::alevel::devel,"set_message_handler");
324 scoped_lock_type guard(m_mutex);
325 m_message_handler = h;
326 }
327
328 //////////////////////////////////////////
329 // Connection timeouts and other limits //
330 //////////////////////////////////////////
331
332 /// Set open handshake timeout
333 /**
334 * Sets the length of time the library will wait after an opening handshake
335 * has been initiated before cancelling it. This can be used to prevent
336 * excessive wait times for outgoing clients or excessive resource usage
337 * from broken clients or DoS attacks on servers.
338 *
339 * Connections that time out will have their fail handlers called with the
340 * open_handshake_timeout error code.
341 *
342 * The default value is specified via the compile time config value
343 * 'timeout_open_handshake'. The default value in the core config
344 * is 5000ms. A value of 0 will disable the timer entirely.
345 *
346 * To be effective, the transport you are using must support timers. See
347 * the documentation for your transport policy for details about its
348 * timer support.
349 *
350 * @param dur The length of the open handshake timeout in ms
351 */
352 void set_open_handshake_timeout(long dur) {
353 scoped_lock_type guard(m_mutex);
354 m_open_handshake_timeout_dur = dur;
355 }
356
357 /// Set close handshake timeout
358 /**
359 * Sets the length of time the library will wait after a closing handshake
360 * has been initiated before cancelling it. This can be used to prevent
361 * excessive wait times for outgoing clients or excessive resource usage
362 * from broken clients or DoS attacks on servers.
363 *
364 * Connections that time out will have their close handlers called with the
365 * close_handshake_timeout error code.
366 *
367 * The default value is specified via the compile time config value
368 * 'timeout_close_handshake'. The default value in the core config
369 * is 5000ms. A value of 0 will disable the timer entirely.
370 *
371 * To be effective, the transport you are using must support timers. See
372 * the documentation for your transport policy for details about its
373 * timer support.
374 *
375 * @param dur The length of the close handshake timeout in ms
376 */
377 void set_close_handshake_timeout(long dur) {
378 scoped_lock_type guard(m_mutex);
379 m_close_handshake_timeout_dur = dur;
380 }
381
382 /// Set pong timeout
383 /**
384 * Sets the length of time the library will wait for a pong response to a
385 * ping. This can be used as a keepalive or to detect broken connections.
386 *
387 * Pong responses that time out will have the pong timeout handler called.
388 *
389 * The default value is specified via the compile time config value
390 * 'timeout_pong'. The default value in the core config
391 * is 5000ms. A value of 0 will disable the timer entirely.
392 *
393 * To be effective, the transport you are using must support timers. See
394 * the documentation for your transport policy for details about its
395 * timer support.
396 *
397 * @param dur The length of the pong timeout in ms
398 */
399 void set_pong_timeout(long dur) {
400 scoped_lock_type guard(m_mutex);
401 m_pong_timeout_dur = dur;
402 }
403
404 /// Get default maximum message size
405 /**
406 * Get the default maximum message size that will be used for new
407 * connections created by this endpoint. The maximum message size determines
408 * the point at which the connection will fail a connection with the
409 * message_too_big protocol error.
410 *
411 * The default is set by the max_message_size value from the template config
412 *
413 * @since 0.3.0
414 */
416 return m_max_message_size;
417 }
418
419 /// Set default maximum message size
420 /**
421 * Set the default maximum message size that will be used for new
422 * connections created by this endpoint. Maximum message size determines the
423 * point at which the connection will fail a connection with the
424 * message_too_big protocol error.
425 *
426 * The default is set by the max_message_size value from the template config
427 *
428 * @since 0.3.0
429 *
430 * @param new_value The value to set as the maximum message size.
431 */
432 void set_max_message_size(size_t new_value) {
433 m_max_message_size = new_value;
434 }
435
436 /// Get maximum HTTP message body size
437 /**
438 * Get maximum HTTP message body size. Maximum message body size determines
439 * the point at which the connection will stop reading an HTTP request whose
440 * body is too large.
441 *
442 * The default is set by the max_http_body_size value from the template
443 * config
444 *
445 * @since 0.5.0
446 *
447 * @return The maximum HTTP message body size
448 */
450 return m_max_http_body_size;
451 }
452
453 /// Set maximum HTTP message body size
454 /**
455 * Set maximum HTTP message body size. Maximum message body size determines
456 * the point at which the connection will stop reading an HTTP request whose
457 * body is too large.
458 *
459 * The default is set by the max_http_body_size value from the template
460 * config
461 *
462 * @since 0.5.1
463 *
464 * @param new_value The value to set as the maximum message size.
465 */
466 void set_max_http_body_size(size_t new_value) {
467 m_max_http_body_size = new_value;
468 }
469
470 /*************************************/
471 /* Connection pass through functions */
472 /*************************************/
473
474 /**
475 * These functions act as adaptors to their counterparts in connection. They
476 * can produce one additional type of error, the bad_connection error, that
477 * indicates that the conversion from connection_hdl to connection_ptr
478 * failed due to the connection not existing anymore. Each method has a
479 * default and an exception free varient.
480 */
481
482 void interrupt(connection_hdl hdl, lib::error_code & ec);
483 void interrupt(connection_hdl hdl);
484
485 /// Pause reading of new data (exception free)
486 /**
487 * Signals to the connection to halt reading of new data. While reading is
488 * paused, the connection will stop reading from its associated socket. In
489 * turn this will result in TCP based flow control kicking in and slowing
490 * data flow from the remote endpoint.
491 *
492 * This is useful for applications that push new requests to a queue to be
493 * processed by another thread and need a way to signal when their request
494 * queue is full without blocking the network processing thread.
495 *
496 * Use `resume_reading()` to resume.
497 *
498 * If supported by the transport this is done asynchronously. As such
499 * reading may not stop until the current read operation completes.
500 * Typically you can expect to receive no more bytes after initiating a read
501 * pause than the size of the read buffer.
502 *
503 * If reading is paused for this connection already nothing is changed.
504 */
505 void pause_reading(connection_hdl hdl, lib::error_code & ec);
506
507 /// Pause reading of new data
509
510 /// Resume reading of new data (exception free)
511 /**
512 * Signals to the connection to resume reading of new data after it was
513 * paused by `pause_reading()`.
514 *
515 * If reading is not paused for this connection already nothing is changed.
516 */
517 void resume_reading(connection_hdl hdl, lib::error_code & ec);
518
519 /// Resume reading of new data
521
522 /// Send deferred HTTP Response
523 /**
524 * Sends an http response to an HTTP connection that was deferred. This will
525 * send a complete response including all headers, status line, and body
526 * text. The connection will be closed afterwards.
527 *
528 * Exception free variant
529 *
530 * @since 0.6.0
531 *
532 * @param hdl The connection to send the response on
533 * @param ec A status code, zero on success, non-zero otherwise
534 */
535 void send_http_response(connection_hdl hdl, lib::error_code & ec);
536
537 /// Send deferred HTTP Response (exception free)
538 /**
539 * Sends an http response to an HTTP connection that was deferred. This will
540 * send a complete response including all headers, status line, and body
541 * text. The connection will be closed afterwards.
542 *
543 * Exception variant
544 *
545 * @since 0.6.0
546 *
547 * @param hdl The connection to send the response on
548 */
550
551 /// Create a message and add it to the outgoing send queue (exception free)
552 /**
553 * Convenience method to send a message given a payload string and an opcode
554 *
555 * @param [in] hdl The handle identifying the connection to send via.
556 * @param [in] payload The payload string to generated the message with
557 * @param [in] op The opcode to generated the message with.
558 * @param [out] ec A code to fill in for errors
559 */
560 void send(connection_hdl hdl, std::string const & payload,
561 frame::opcode::value op, lib::error_code & ec);
562 /// Create a message and add it to the outgoing send queue
563 /**
564 * Convenience method to send a message given a payload string and an opcode
565 *
566 * @param [in] hdl The handle identifying the connection to send via.
567 * @param [in] payload The payload string to generated the message with
568 * @param [in] op The opcode to generated the message with.
569 * @param [out] ec A code to fill in for errors
570 */
571 void send(connection_hdl hdl, std::string const & payload,
572 frame::opcode::value op);
573
574 void send(connection_hdl hdl, void const * payload, size_t len,
575 frame::opcode::value op, lib::error_code & ec);
576 void send(connection_hdl hdl, void const * payload, size_t len,
577 frame::opcode::value op);
578
579 void send(connection_hdl hdl, message_ptr msg, lib::error_code & ec);
580 void send(connection_hdl hdl, message_ptr msg);
581
582 void close(connection_hdl hdl, close::status::value const code,
583 std::string const & reason, lib::error_code & ec);
584 void close(connection_hdl hdl, close::status::value const code,
585 std::string const & reason);
586
587 /// Send a ping to a specific connection
588 /**
589 * @since 0.3.0-alpha3
590 *
591 * @param [in] hdl The connection_hdl of the connection to send to.
592 * @param [in] payload The payload string to send.
593 * @param [out] ec A reference to an error code to fill in
594 */
595 void ping(connection_hdl hdl, std::string const & payload,
596 lib::error_code & ec);
597 /// Send a ping to a specific connection
598 /**
599 * Exception variant of `ping`
600 *
601 * @since 0.3.0-alpha3
602 *
603 * @param [in] hdl The connection_hdl of the connection to send to.
604 * @param [in] payload The payload string to send.
605 */
606 void ping(connection_hdl hdl, std::string const & payload);
607
608 /// Send a pong to a specific connection
609 /**
610 * @since 0.3.0-alpha3
611 *
612 * @param [in] hdl The connection_hdl of the connection to send to.
613 * @param [in] payload The payload string to send.
614 * @param [out] ec A reference to an error code to fill in
615 */
616 void pong(connection_hdl hdl, std::string const & payload,
617 lib::error_code & ec);
618 /// Send a pong to a specific connection
619 /**
620 * Exception variant of `pong`
621 *
622 * @since 0.3.0-alpha3
623 *
624 * @param [in] hdl The connection_hdl of the connection to send to.
625 * @param [in] payload The payload string to send.
626 */
627 void pong(connection_hdl hdl, std::string const & payload);
628
629 /// Retrieves a connection_ptr from a connection_hdl (exception free)
630 /**
631 * Converting a weak pointer to shared_ptr is not thread safe because the
632 * pointer could be deleted at any time.
633 *
634 * NOTE: This method may be called by handler to upgrade its handle to a
635 * full connection_ptr. That full connection may then be used safely for the
636 * remainder of the handler body. get_con_from_hdl and the resulting
637 * connection_ptr are NOT safe to use outside the handler loop.
638 *
639 * @param hdl The connection handle to translate
640 *
641 * @return the connection_ptr. May be NULL if the handle was invalid.
642 */
643 connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code & ec) {
644 connection_ptr con = lib::static_pointer_cast<connection_type>(
645 hdl.lock());
646 if (!con) {
647 ec = error::make_error_code(error::bad_connection);
648 }
649 return con;
650 }
651
652 /// Retrieves a connection_ptr from a connection_hdl (exception version)
654 lib::error_code ec;
655 connection_ptr con = this->get_con_from_hdl(hdl,ec);
656 if (ec) {
657 throw exception(ec);
658 }
659 return con;
660 }
661protected:
662 connection_ptr create_connection();
663
664 lib::shared_ptr<alog_type> m_alog;
665 lib::shared_ptr<elog_type> m_elog;
666private:
667 // dynamic settings
668 std::string m_user_agent;
669
670 open_handler m_open_handler;
671 close_handler m_close_handler;
672 fail_handler m_fail_handler;
673 ping_handler m_ping_handler;
674 pong_handler m_pong_handler;
675 pong_timeout_handler m_pong_timeout_handler;
676 interrupt_handler m_interrupt_handler;
677 http_handler m_http_handler;
678 validate_handler m_validate_handler;
679 message_handler m_message_handler;
680
681 long m_open_handshake_timeout_dur;
682 long m_close_handshake_timeout_dur;
683 long m_pong_timeout_dur;
684 size_t m_max_message_size;
685 size_t m_max_http_body_size;
686
687 rng_type m_rng;
688
689 // static settings
690 bool const m_is_server;
691
692 // endpoint state
693 mutable mutex_type m_mutex;
694};
695
696} // namespace websocketpp
697
698#include <websocketpp/impl/endpoint_impl.hpp>
699
700#endif // WEBSOCKETPP_ENDPOINT_HPP
#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.
Definition: basic.hpp:37
Stub for user supplied base class.
Represents an individual WebSocket connection.
Definition: connection.hpp:238
Stub for user supplied base class.
Creates and manages connections associated with a WebSocket endpoint.
Definition: endpoint.hpp:42
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition: endpoint.hpp:466
void set_user_agent(std::string const &ua)
Sets the user agent string that this endpoint will use.
Definition: endpoint.hpp:196
connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code &ec)
Retrieves a connection_ptr from a connection_hdl (exception free)
Definition: endpoint.hpp:643
config::concurrency_type concurrency_type
Type of the concurrency component of this endpoint.
Definition: endpoint.hpp:51
config::alog_type alog_type
Type of access logger.
Definition: endpoint.hpp:75
void ping(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a ping to a specific connection.
alog_type & get_alog()
Get reference to access logger.
Definition: endpoint.hpp:261
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:65
std::string get_user_agent() const
Returns the user agent string that this endpoint will use.
Definition: endpoint.hpp:169
void ping(connection_hdl hdl, std::string const &payload)
Send a ping to a specific connection.
void clear_access_channels(log::level channels)
Clear Access logging channels.
Definition: endpoint.hpp:231
void resume_reading(connection_hdl hdl)
Resume reading of new data.
config::elog_type elog_type
Type of error logger.
Definition: endpoint.hpp:73
elog_type & get_elog()
Get reference to error logger.
Definition: endpoint.hpp:269
bool is_server() const
Returns whether or not this endpoint is a server.
Definition: endpoint.hpp:205
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op, lib::error_code &ec)
Create a message and add it to the outgoing send queue (exception free)
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition: endpoint.hpp:377
connection_type::message_ptr message_ptr
Type of message pointers that this endpoint uses.
Definition: endpoint.hpp:70
void pong(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a pong to a specific connection.
void set_access_channels(log::level channels)
Set Access logging channel.
Definition: endpoint.hpp:220
void set_max_message_size(size_t new_value)
Set default maximum message size.
Definition: endpoint.hpp:432
size_t get_max_message_size() const
Get default maximum message size.
Definition: endpoint.hpp:415
connection_ptr get_con_from_hdl(connection_hdl hdl)
Retrieves a connection_ptr from a connection_hdl (exception version)
Definition: endpoint.hpp:653
connection connection_type
Type of the connections that this endpoint creates.
Definition: endpoint.hpp:54
void set_error_channels(log::level channels)
Set Error logging channel.
Definition: endpoint.hpp:242
config::transport_type transport_type
Type of the transport component of this endpoint.
Definition: endpoint.hpp:49
void clear_error_channels(log::level channels)
Clear Error logging channels.
Definition: endpoint.hpp:253
void resume_reading(connection_hdl hdl, lib::error_code &ec)
Resume reading of new data (exception free)
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op)
Create a message and add it to the outgoing send queue.
connection_type::ptr connection_ptr
Shared pointer to connection_type.
Definition: endpoint.hpp:56
transport_type::transport_con_type transport_con_type
Definition: endpoint.hpp:62
concurrency_type::mutex_type mutex_type
Type of our concurrency policy's mutex object.
Definition: endpoint.hpp:80
void pong(connection_hdl hdl, std::string const &payload)
Send a pong to a specific connection.
void interrupt(connection_hdl hdl, lib::error_code &ec)
void set_pong_timeout(long dur)
Set pong timeout.
Definition: endpoint.hpp:399
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition: endpoint.hpp:449
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition: endpoint.hpp:352
config::rng_type rng_type
Type of RNG.
Definition: endpoint.hpp:83
concurrency_type::scoped_lock_type scoped_lock_type
Type of our concurrency policy's scoped lock object.
Definition: endpoint.hpp:78
void send_http_response(connection_hdl hdl, lib::error_code &ec)
Send deferred HTTP Response.
void pause_reading(connection_hdl hdl, lib::error_code &ec)
Pause reading of new data (exception free)
void send_http_response(connection_hdl hdl)
Send deferred HTTP Response (exception free)
void pause_reading(connection_hdl hdl)
Pause reading of new data.
connection_type::message_handler message_handler
Type of message_handler.
Definition: endpoint.hpp:68
connection_type::weak_ptr connection_weak_ptr
Weak pointer to connection type.
Definition: endpoint.hpp:58
Stub class for use when disabling permessage_deflate extension.
Definition: disabled.hpp:53
err_str_pair negotiate(http::attribute_list const &)
Negotiate extension.
Definition: disabled.hpp:65
lib::error_code compress(std::string const &, std::string &)
Compress bytes.
Definition: disabled.hpp:109
std::string generate_offer() const
Generate extension offer.
Definition: disabled.hpp:99
lib::error_code decompress(uint8_t const *, size_t, std::string &)
Decompress bytes.
Definition: disabled.hpp:120
lib::error_code init(bool)
Initialize state.
Definition: disabled.hpp:76
header_list const & get_headers() const
Return a list of all HTTP headers.
Definition: parser.hpp:179
size_t process_body(char const *buf, size_t len)
Process body data.
Definition: parser.hpp:145
std::string const & get_body() const
Get HTTP body.
Definition: parser.hpp:505
bool get_header_as_plist(std::string const &key, parameter_list &out) const
Extract an HTTP parameter list from a parser header.
Definition: parser.hpp:55
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition: parser.hpp:161
void set_version(std::string const &version)
Set HTTP parser Version.
Definition: parser.hpp:41
void remove_header(std::string const &key)
Remove a header from the parser.
Definition: parser.hpp:87
void set_body(std::string const &value)
Set body content.
Definition: parser.hpp:91
bool body_ready() const
Check if the parser is done parsing the body.
Definition: parser.hpp:599
bool prepare_body()
Prepare the parser to begin parsing body data.
Definition: parser.hpp:119
void set_max_body_size(size_t value)
Set body size limit.
Definition: parser.hpp:542
void replace_header(std::string const &key, std::string const &val)
Set a value for an HTTP header, replacing an existing value.
Definition: parser.hpp:81
void append_header(std::string const &key, std::string const &val)
Append a value to an existing HTTP header.
Definition: parser.hpp:67
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition: parser.hpp:183
std::string const & get_header(std::string const &key) const
Get the value of an HTTP header.
Definition: parser.hpp:45
std::string const & get_version() const
Get the HTTP version string.
Definition: parser.hpp:410
bool parse_parameter_list(std::string const &in, parameter_list &out) const
Extract an HTTP parameter list from a string.
Definition: parser.hpp:107
size_t get_max_body_size() const
Get body size limit.
Definition: parser.hpp:529
Stores, parses, and manipulates HTTP requests.
Definition: request.hpp:50
std::string raw() const
Returns the full raw request (including the body)
Definition: request.hpp:131
std::string const & get_uri() const
Return the requested URI.
Definition: request.hpp:104
std::string const & get_method() const
Return the request method.
Definition: request.hpp:96
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition: request.hpp:41
void set_uri(std::string const &uri)
Set the HTTP uri. Must be a valid HTTP uri.
Definition: request.hpp:159
bool ready() const
Returns whether or not the request is ready for reading.
Definition: request.hpp:82
void set_method(std::string const &method)
Set the HTTP method. Must be a valid HTTP token.
Definition: request.hpp:151
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request)
Definition: request.hpp:141
Stores, parses, and manipulates HTTP responses.
Definition: response.hpp:57
void set_status(status_code::value code)
Set response status code and message.
Definition: response.hpp:191
std::string raw() const
Returns the full raw response.
Definition: response.hpp:178
size_t consume(std::istream &s)
Process bytes in the input buffer (istream version)
Definition: response.hpp:139
bool headers_ready() const
Returns true if the response headers are fully parsed.
Definition: response.hpp:121
bool ready() const
Returns true if the response is ready.
Definition: response.hpp:116
void set_status(status_code::value code, std::string const &msg)
Set response status code and message.
Definition: response.hpp:197
const std::string & get_status_msg() const
Return the response status message.
Definition: response.hpp:157
status_code::value get_status_code() const
Return the response status code.
Definition: response.hpp:152
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition: response.hpp:42
Basic logger that outputs to an ostream.
Definition: basic.hpp:59
void write(level channel, char const *msg)
Write a cstring message to the given channel.
Definition: basic.hpp:151
void write(level channel, std::string const &msg)
Write a string message to the given channel.
Definition: basic.hpp:137
bool recycle(message *)
Recycle a message.
Definition: alloc.hpp:80
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
Definition: alloc.hpp:66
message_ptr get_message()
Get an empty message buffer.
Definition: alloc.hpp:55
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Definition: alloc.hpp:96
Represents a buffer for a single WebSocket message.
Definition: message.hpp:84
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
Definition: message.hpp:107
std::string & get_raw_payload()
Get a non-const reference to the payload string.
Definition: message.hpp:254
void set_header(std::string const &header)
Set prepared frame header.
Definition: message.hpp:234
bool recycle()
Recycle the message.
Definition: message.hpp:316
bool get_compressed() const
Return whether or not the message is flagged as compressed.
Definition: message.hpp:143
void set_payload(std::string const &payload)
Set payload data.
Definition: message.hpp:264
bool get_terminal() const
Get whether or not the message is terminal.
Definition: message.hpp:169
std::string const & get_header() const
Return the prepared frame header.
Definition: message.hpp:224
void set_payload(void const *payload, size_t len)
Set payload data.
Definition: message.hpp:275
bool get_fin() const
Read the fin bit.
Definition: message.hpp:195
void append_payload(void const *payload, size_t len)
Append payload data.
Definition: message.hpp:298
void set_opcode(frame::opcode::value op)
Set the opcode.
Definition: message.hpp:215
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
Definition: message.hpp:135
frame::opcode::value get_opcode() const
Return the message opcode.
Definition: message.hpp:210
void set_terminal(bool value)
Set the terminal flag.
Definition: message.hpp:181
bool get_prepared() const
Return whether or not the message has been prepared for sending.
Definition: message.hpp:125
void append_payload(std::string const &payload)
Append payload data.
Definition: message.hpp:287
void set_compressed(bool value)
Set or clear the compression flag.
Definition: message.hpp:156
message(const con_msg_man_ptr manager)
Construct an empty message.
Definition: message.hpp:96
void set_fin(bool value)
Set the fin bit.
Definition: message.hpp:205
std::string const & get_payload() const
Get a reference to the payload string.
Definition: message.hpp:246
Thread safe stub "random" integer generator.
Definition: none.hpp:46
int_type operator()()
advances the engine's state and returns the generated value
Definition: none.hpp:51
Server endpoint role based on the given config.
void start_accept(lib::error_code &ec)
Starts the server's async connection acceptance loop (exception free)
transport_type::transport_con_type transport_con_type
Type of the connection transport component.
connection_type::ptr connection_ptr
Type of a shared pointer to the connections this server will create.
server< config > type
Type of this endpoint.
endpoint< connection_type, config > endpoint_type
Type of the endpoint component of this server.
config::transport_type transport_type
Type of the endpoint transport component.
connection< config > connection_type
Type of the connections this server will create.
connection_ptr get_connection()
Create and initialize a new connection.
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
void start_accept()
Starts the server's async connection acceptance loop.
config::concurrency_type concurrency_type
Type of the endpoint concurrency component.
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the connection transport component.
Basic Asio connection socket component.
Definition: none.hpp:58
lib::asio::ip::tcp::socket & get_raw_socket()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:124
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection socket component.
Definition: none.hpp:63
void set_socket_init_handler(socket_init_handler h)
Set the socket initialization handler.
Definition: none.hpp:100
connection type
Type of this connection socket component.
Definition: none.hpp:61
lib::asio::ip::tcp::socket & get_socket()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:108
bool is_secure() const
Check whether or not this connection is secure.
Definition: none.hpp:88
lib::shared_ptr< socket_type > socket_ptr
Type of a shared pointer to the socket being used.
Definition: none.hpp:72
static lib::error_code translate_ec(lib::error_code ec)
Definition: none.hpp:292
static lib::error_code translate_ec(ErrorCodeType)
Translate any security policy specific information about an error code.
Definition: none.hpp:284
void set_handle(connection_hdl hdl)
Sets the connection handle.
Definition: none.hpp:234
lib::asio::error_code cancel_socket()
Cancel all async operations on this socket.
Definition: none.hpp:247
void pre_init(init_handler callback)
Pre-initialize security policy.
Definition: none.hpp:204
std::string get_remote_endpoint(lib::error_code &ec) const
Get the remote endpoint address.
Definition: none.hpp:138
void post_init(init_handler callback)
Post-initialize security policy.
Definition: none.hpp:223
lib::error_code init_asio(io_service_ptr service, strand_ptr, bool)
Perform one time initializations.
Definition: none.hpp:165
lib::asio::ip::tcp::socket socket_type
Type of the ASIO socket being used.
Definition: none.hpp:70
ptr get_shared()
Get a shared pointer to this component.
Definition: none.hpp:80
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service strand being used.
Definition: none.hpp:68
lib::asio::ip::tcp::socket & get_next_layer()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:116
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
Definition: none.hpp:66
Basic ASIO endpoint socket component.
Definition: none.hpp:317
void set_socket_init_handler(socket_init_handler h)
Set socket init handler.
Definition: none.hpp:346
lib::error_code init(socket_con_ptr scon)
Initialize a connection.
Definition: none.hpp:359
endpoint type
The type of this endpoint socket component.
Definition: none.hpp:320
bool is_secure() const
Checks whether the endpoint creates secure connections.
Definition: none.hpp:334
connection socket_con_type
The type of the corresponding connection socket component.
Definition: none.hpp:323
Asio based connection transport component.
Definition: connection.hpp:67
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception)
Definition: connection.hpp:261
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition: connection.hpp:173
void set_proxy_basic_auth(std::string const &username, std::string const &password)
Set the basic auth credentials to use (exception)
Definition: connection.hpp:232
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free)
Definition: connection.hpp:250
config::elog_type elog_type
Type of this transport's error logging policy.
Definition: connection.hpp:81
strand_ptr get_strand()
Get a pointer to this connection's strand.
Definition: connection.hpp:366
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
read at least num_bytes bytes into buf and then call handler.
Definition: connection.hpp:820
lib::error_code proxy_init(std::string const &authority)
initialize the proxy buffers and http parsers
Definition: connection.hpp:437
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition: connection.hpp:77
lib::error_code interrupt(interrupt_handler handler)
Trigger the on_interrupt handler.
config::alog_type alog_type
Type of this transport's access logging policy.
Definition: connection.hpp:79
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
Definition: connection.hpp:980
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
Definition: connection.hpp:350
lib::error_code init_asio(io_service_ptr io_service)
Finish constructing the transport.
Definition: connection.hpp:461
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition: connection.hpp:572
void async_shutdown(shutdown_handler callback)
close and clean up the underlying socket
lib::asio::error_code get_transport_ec() const
Get the internal transport error code for a closed/failed connection.
Definition: connection.hpp:389
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition: connection.hpp:75
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
Definition: connection.hpp:89
void set_proxy(std::string const &uri)
Set the proxy to connect through (exception)
Definition: connection.hpp:198
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition: connection.hpp:536
connection< config > type
Type of this connection transport component.
Definition: connection.hpp:70
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
void set_proxy(std::string const &uri, lib::error_code &ec)
Set the proxy to connect through (exception free)
Definition: connection.hpp:189
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
Definition: connection.hpp:93
void set_proxy_basic_auth(std::string const &username, std::string const &password, lib::error_code &ec)
Set the basic auth credentials to use (exception free)
Definition: connection.hpp:217
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
Definition: connection.hpp:906
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
Definition: connection.hpp:939
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition: connection.hpp:72
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition: connection.hpp:313
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition: connection.hpp:158
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
Definition: connection.hpp:742
void set_uri(uri_ptr u)
Set uri hook.
Definition: connection.hpp:130
std::string get_remote_endpoint() const
Get the remote endpoint address.
Definition: connection.hpp:281
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:110
void cancel_socket_checked()
Cancel the underlying socket and log any errors.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition: connection.hpp:144
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service::strand being used.
Definition: connection.hpp:91
void init(init_handler callback)
Initialize transport for reading.
Definition: connection.hpp:411
connection_hdl get_handle() const
Get the connection handle.
Definition: connection.hpp:295
Asio based endpoint transport component.
Definition: endpoint.hpp:54
std::size_t run_one()
wraps the run_one method of the internal io_service object
Definition: endpoint.hpp:648
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition: endpoint.hpp:69
void stop_listening(lib::error_code &ec)
Stop listening (exception free)
Definition: endpoint.hpp:604
config::socket_type socket_type
Type of the socket policy.
Definition: endpoint.hpp:62
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition: endpoint.hpp:87
void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb)
Initiate a new connection.
Definition: endpoint.hpp:849
void init_asio()
Initialize asio transport with internal io_service.
Definition: endpoint.hpp:249
config::elog_type elog_type
Type of the error logging policy.
Definition: endpoint.hpp:64
void init_logging(const lib::shared_ptr< alog_type > &a, const lib::shared_ptr< elog_type > &e)
Initialize logging.
Definition: endpoint.hpp:823
bool is_secure() const
Return whether or not the endpoint produces secure connections.
Definition: endpoint.hpp:172
void init_asio(io_service_ptr ptr)
initialize asio transport with external io_service
Definition: endpoint.hpp:212
lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code &ec)
Get local TCP endpoint.
Definition: endpoint.hpp:395
void set_reuse_addr(bool value)
Sets whether to use the SO_REUSEADDR flag when opening listening sockets.
Definition: endpoint.hpp:363
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition: endpoint.hpp:302
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer handler.
Definition: endpoint.hpp:745
void start_perpetual()
Marks the endpoint as perpetual, stopping it from exiting when empty.
Definition: endpoint.hpp:689
void stop()
wraps the stop method of the internal io_service object
Definition: endpoint.hpp:653
std::size_t run()
wraps the run method of the internal io_service object
Definition: endpoint.hpp:640
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition: endpoint.hpp:317
void set_listen_backlog(int backlog)
Sets the maximum length of the queue of pending connections.
Definition: endpoint.hpp:342
bool stopped() const
wraps the stopped method of the internal io_service object
Definition: endpoint.hpp:673
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition: endpoint.hpp:717
void init_asio(io_service_ptr ptr, lib::error_code &ec)
initialize asio transport with external io_service (exception free)
Definition: endpoint.hpp:185
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition: endpoint.hpp:71
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition: endpoint.hpp:1113
asio::connection< config > transport_con_type
Definition: endpoint.hpp:75
void init_asio(lib::error_code &ec)
Initialize asio transport with internal io_service (exception free)
Definition: endpoint.hpp:227
void async_accept(transport_con_ptr tcon, accept_handler callback)
Accept the next connection attempt and assign it to con.
Definition: endpoint.hpp:807
void listen(uint16_t port)
Set up endpoint for listening on a port.
Definition: endpoint.hpp:536
void listen(std::string const &host, std::string const &service, lib::error_code &ec)
Set up endpoint for listening on a host and service (exception free)
Definition: endpoint.hpp:556
endpoint< config > type
Type of this endpoint transport component.
Definition: endpoint.hpp:57
lib::asio::io_service & get_io_service()
Retrieve a reference to the endpoint's io_service.
Definition: endpoint.hpp:378
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition: endpoint.hpp:60
std::size_t poll()
wraps the poll method of the internal io_service object
Definition: endpoint.hpp:658
void stop_perpetual()
Clears the endpoint's perpetual flag, allowing it to exit when empty.
Definition: endpoint.hpp:701
lib::shared_ptr< lib::asio::ip::tcp::acceptor > acceptor_ptr
Type of a shared pointer to the acceptor being used.
Definition: endpoint.hpp:83
void listen(lib::asio::ip::tcp::endpoint const &ep)
Set up endpoint for listening manually.
Definition: endpoint.hpp:460
void handle_resolve_timeout(timer_ptr, connect_handler callback, lib::error_code const &ec)
DNS resolution timeout handler.
Definition: endpoint.hpp:944
void listen(lib::asio::ip::tcp::endpoint const &ep, lib::error_code &ec)
Set up endpoint for listening manually (exception free)
Definition: endpoint.hpp:412
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:78
lib::shared_ptr< lib::asio::io_service::work > work_ptr
Type of a shared pointer to an io_service work object.
Definition: endpoint.hpp:89
void reset()
wraps the reset method of the internal io_service object
Definition: endpoint.hpp:668
void set_tcp_pre_bind_handler(tcp_pre_bind_handler h)
Sets the tcp pre bind handler.
Definition: endpoint.hpp:274
config::alog_type alog_type
Type of the access logging policy.
Definition: endpoint.hpp:66
lib::asio::io_service * io_service_ptr
Type of a pointer to the ASIO io_service being used.
Definition: endpoint.hpp:81
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition: endpoint.hpp:502
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition: endpoint.hpp:288
void listen(std::string const &host, std::string const &service)
Set up endpoint for listening on a host and service.
Definition: endpoint.hpp:589
void handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
Definition: endpoint.hpp:1053
void async_accept(transport_con_ptr tcon, accept_handler callback, lib::error_code &ec)
Accept the next connection attempt and assign it to con (exception free)
Definition: endpoint.hpp:768
std::size_t poll_one()
wraps the poll_one method of the internal io_service object
Definition: endpoint.hpp:663
void listen(InternetProtocol const &internet_protocol, uint16_t port, lib::error_code &ec)
Set up endpoint for listening with protocol and port (exception free)
Definition: endpoint.hpp:481
void listen(uint16_t port, lib::error_code &ec)
Set up endpoint for listening on a port (exception free)
Definition: endpoint.hpp:520
bool is_listening() const
Check if the endpoint is listening.
Definition: endpoint.hpp:635
void stop_listening()
Stop listening.
Definition: endpoint.hpp:625
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition: endpoint.hpp:85
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition: endpoint.hpp:92
Asio transport error category.
Definition: base.hpp:184
Error category related to asio transport socket policies.
Definition: base.hpp:110
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition: connection.hpp:65
connection_hdl get_handle() const
Get the connection handle.
Definition: connection.hpp:313
config::alog_type alog_type
Type of this transport's access logging policy.
Definition: connection.hpp:70
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
Definition: connection.hpp:580
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
Definition: connection.hpp:593
void set_write_handler(write_handler h)
Sets the write handler.
Definition: connection.hpp:350
void set_secure(bool value)
Set whether or not this connection is secure.
Definition: connection.hpp:257
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition: connection.hpp:400
connection< config > type
Type of this connection transport component.
Definition: connection.hpp:63
config::elog_type elog_type
Type of this transport's error logging policy.
Definition: connection.hpp:72
void fatal_error()
Signal transport error.
Definition: connection.hpp:235
size_t read_some(char const *buf, size_t len)
Manual input supply (read some)
Definition: connection.hpp:165
size_t read_all(char const *buf, size_t len)
Manual input supply (read all)
Definition: connection.hpp:188
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
Definition: connection.hpp:487
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED)
Definition: connection.hpp:208
config::concurrency_type concurrency_type
transport concurrency policy
Definition: connection.hpp:68
void init(init_handler handler)
Initialize the connection transport.
Definition: connection.hpp:410
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
Definition: connection.hpp:327
void set_remote_endpoint(std::string value)
Set human readable remote endpoint address.
Definition: connection.hpp:289
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
Definition: connection.hpp:142
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
Definition: connection.hpp:380
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition: connection.hpp:271
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
Definition: connection.hpp:305
void set_handle(connection_hdl hdl)
Set Connection Handle.
Definition: connection.hpp:565
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
Definition: connection.hpp:104
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
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather)
Definition: connection.hpp:527
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:93
iostream::connection< config > transport_con_type
Definition: endpoint.hpp:62
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition: endpoint.hpp:56
void set_write_handler(write_handler h)
Sets the write handler.
Definition: endpoint.hpp:134
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition: endpoint.hpp:154
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition: endpoint.hpp:116
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition: endpoint.hpp:51
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:65
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition: endpoint.hpp:183
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition: endpoint.hpp:197
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
Definition: endpoint.hpp:171
endpoint type
Type of this endpoint transport component.
Definition: endpoint.hpp:49
void register_ostream(std::ostream *o)
Register a default output stream.
Definition: endpoint.hpp:80
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition: endpoint.hpp:54
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition: endpoint.hpp:102
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition: endpoint.hpp:58
iostream transport error category
Definition: base.hpp:85
std::string get_query() const
Return the query portion.
Definition: uri.hpp:294
#define _WEBSOCKETPP_CONSTEXPR_TOKEN_
Definition: cpp11.hpp:132
#define _WEBSOCKETPP_NOEXCEPT_TOKEN_
Definition: cpp11.hpp:113
#define __has_extension
Definition: cpp11.hpp:40
#define __has_feature(x)
Definition: cpp11.hpp:37
A package of types and methods for manipulating WebSocket close status'.
Definition: close.hpp:47
uint16_t value
The type of a close code value.
Definition: close.hpp:49
A package of types and methods for manipulating WebSocket close codes.
Definition: close.hpp:45
Concurrency handling support.
Definition: basic.hpp:34
Library level error codes.
Definition: error.hpp:44
@ general
Catch-all library error.
Definition: error.hpp:47
@ unrequested_subprotocol
Selected subprotocol was not requested by the client.
Definition: error.hpp:102
@ invalid_port
Invalid port in URI.
Definition: error.hpp:120
@ client_only
Attempted to use a client specific feature on a server endpoint.
Definition: error.hpp:105
@ http_connection_ended
HTTP connection ended.
Definition: error.hpp:111
@ async_accept_not_listening
Definition: error.hpp:124
@ operation_canceled
The requested operation was canceled.
Definition: error.hpp:127
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
Definition: error.hpp:68
@ http_parse_error
HTTP parse error.
Definition: error.hpp:143
@ reserved_close_code
Close code is in a reserved range.
Definition: error.hpp:80
@ con_creation_failed
Connection creation attempted failed.
Definition: error.hpp:99
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
Definition: error.hpp:71
@ invalid_state
The connection was in the wrong state for this operation.
Definition: error.hpp:74
@ extension_neg_failed
Extension negotiation failed.
Definition: error.hpp:146
@ rejected
Connection rejected.
Definition: error.hpp:130
@ unsupported_version
Unsupported WebSocket protocol version.
Definition: error.hpp:140
@ invalid_utf8
Invalid UTF-8.
Definition: error.hpp:86
@ invalid_close_code
Close code is invalid.
Definition: error.hpp:83
@ server_only
Attempted to use a server specific feature on a client endpoint.
Definition: error.hpp:108
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
Definition: error.hpp:57
@ close_handshake_timeout
WebSocket close handshake timed out.
Definition: error.hpp:117
@ invalid_subprotocol
Invalid subprotocol.
Definition: error.hpp:89
@ bad_close_code
Unable to parse close code.
Definition: error.hpp:77
@ open_handshake_timeout
WebSocket opening handshake timed out.
Definition: error.hpp:114
@ invalid_version
Invalid WebSocket protocol version.
Definition: error.hpp:137
@ send_queue_full
send attempted when endpoint write queue was full
Definition: error.hpp:50
@ test
Unit testing utility error code.
Definition: error.hpp:96
@ invalid_uri
An invalid uri was supplied.
Definition: error.hpp:65
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition: disabled.hpp:44
Constants related to frame and payload limits.
Definition: frame.hpp:145
static uint8_t const close_reason_size
Maximum size of close frame reason.
Definition: frame.hpp:169
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127)
Definition: frame.hpp:162
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
Definition: frame.hpp:153
static unsigned int const max_header_length
Maximum length of a WebSocket header.
Definition: frame.hpp:150
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
Definition: frame.hpp:159
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
Definition: frame.hpp:156
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Definition: frame.hpp:147
Constants and utility functions related to WebSocket opcodes.
Definition: frame.hpp:76
bool invalid(value v)
Check if an opcode is invalid.
Definition: frame.hpp:130
bool reserved(value v)
Check if an opcode is reserved.
Definition: frame.hpp:118
bool is_control(value v)
Check if an opcode is for a control frame.
Definition: frame.hpp:139
Data structures and utility functions for manipulating WebSocket frames.
Definition: frame.hpp:45
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
Definition: frame.hpp:469
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
Definition: frame.hpp:366
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
Definition: frame.hpp:50
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition: frame.hpp:393
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
Definition: frame.hpp:384
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
Definition: frame.hpp:573
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Definition: frame.hpp:431
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Definition: frame.hpp:830
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
Definition: frame.hpp:645
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Definition: frame.hpp:52
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
Definition: frame.hpp:375
bool get_masked(basic_header const &h)
check whether the frame is masked
Definition: frame.hpp:402
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
Definition: frame.hpp:357
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place)
Definition: frame.hpp:675
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
Definition: frame.hpp:540
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place)
Definition: frame.hpp:857
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition: frame.hpp:321
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
Definition: frame.hpp:612
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition: frame.hpp:339
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
Definition: frame.hpp:411
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
Definition: frame.hpp:768
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place)
Definition: frame.hpp:731
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
Definition: frame.hpp:348
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition: frame.hpp:445
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
Definition: frame.hpp:330
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
Definition: frame.hpp:555
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
Definition: frame.hpp:702
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
Definition: frame.hpp:489
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
Definition: frame.hpp:516
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
Definition: frame.hpp:48
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place)
Definition: frame.hpp:805
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
Definition: frame.hpp:595
HTTP handling support.
Definition: request.hpp:37
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
Definition: constants.hpp:68
static char const header_separator[]
Literal value of the HTTP header separator.
Definition: constants.hpp:59
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition: constants.hpp:53
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
Definition: constants.hpp:71
bool is_not_token_char(unsigned char c)
Is the character a non-token.
Definition: constants.hpp:103
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
Definition: constants.hpp:65
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
Definition: constants.hpp:56
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
Definition: constants.hpp:111
static char const header_token[]
invalid HTTP token characters
Definition: constants.hpp:78
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
Definition: constants.hpp:116
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
Definition: constants.hpp:45
bool is_token_char(unsigned char c)
Is the character a token.
Definition: constants.hpp:98
static std::string const empty_header
Literal value of an empty header.
Definition: constants.hpp:62
Stub RNG policy that always returns 0.
Definition: none.hpp:35
Random number generation policies.
lib::function< void(connection_hdl, lib::asio::ip::tcp::socket &)> socket_init_handler
The signature of the socket init handler for this socket policy.
Definition: none.hpp:51
Asio transport errors.
Definition: base.hpp:161
lib::error_category const & get_category()
Get a reference to a static copy of the asio transport error category.
Definition: base.hpp:211
lib::error_code make_error_code(error::value e)
Create an error code with the given value and the asio transport category.
Definition: base.hpp:217
@ proxy_invalid
Invalid Proxy URI.
Definition: base.hpp:177
@ pass_through
there was an error in the underlying transport library
Definition: base.hpp:171
@ proxy_failed
The connection to the requested proxy server failed.
Definition: base.hpp:174
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: base.hpp:168
@ invalid_host_service
Invalid host or service.
Definition: base.hpp:180
Errors related to asio transport sockets.
Definition: base.hpp:75
@ missing_tls_init_handler
Required tls_init handler not present.
Definition: base.hpp:99
@ invalid_state
A function was called in a state that it was illegal to do so.
Definition: base.hpp:86
@ tls_failed_sni_hostname
Failed to set TLS SNI hostname.
Definition: base.hpp:105
@ tls_handshake_failed
TLS Handshake Failed.
Definition: base.hpp:102
@ tls_handshake_timeout
TLS Handshake Timeout.
Definition: base.hpp:93
@ pass_through
pass_through from underlying library
Definition: base.hpp:96
Transport policy that uses asio.
Definition: endpoint.hpp:46
Generic transport related errors.
Definition: connection.hpp:146
@ pass_through
underlying transport pass through
Definition: connection.hpp:153
@ operation_not_supported
Operation not supported.
Definition: connection.hpp:165
@ operation_aborted
Operation aborted.
Definition: connection.hpp:162
@ tls_error
Other TLS error.
Definition: connection.hpp:180
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: connection.hpp:156
@ action_after_shutdown
read or write after shutdown
Definition: connection.hpp:177
@ tls_short_read
TLS short read.
Definition: connection.hpp:171
@ double_read
async_read called while another async_read was in progress
Definition: connection.hpp:159
iostream transport errors
Definition: base.hpp:64
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: base.hpp:71
@ double_read
async_read called while another async_read was in progress
Definition: base.hpp:74
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
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Definition: base.hpp:112
Transport policy that uses STL iostream for I/O and does not support timers.
Definition: endpoint.hpp:43
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
Definition: base.hpp:57
lib::function< lib::error_code(connection_hdl)> shutdown_handler
Definition: base.hpp:61
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
Transport policies provide network connectivity and timers.
Definition: endpoint.hpp:45
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
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
Definition: connection.hpp:135
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
Definition: connection.hpp:132
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
Definition: endpoint.hpp:69
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
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
Definition: endpoint.hpp:72
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
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
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
Generic non-websocket specific utility functions and data structures.
Definition: utilities.hpp:39
std::string to_hex(std::string const &input)
Convert std::string to ascii printed string of hex digits.
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)
Definition: utilities.hpp:101
std::string string_replace_all(std::string subject, std::string const &search, std::string const &replace)
Replace all occurrances of a substring with another.
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive)
Definition: utilities.hpp:123
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
std::string to_lower(std::string const &in)
Convert a string to lowercase.
Namespace for the WebSocket++ project.
std::string base64_decode(std::string const &input)
Decode a base64 encoded string into a string of raw bytes.
Definition: base64.hpp:131
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
Definition: connection.hpp:109
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
Definition: connection.hpp:69
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
Definition: connection.hpp:116
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
Definition: connection.hpp:151
std::string base64_encode(std::string const &input)
Encode a string into a base64 string.
Definition: base64.hpp:119
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
Definition: connection.hpp:59
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
Definition: connection.hpp:91
static uint16_t const uri_default_secure_port
Default port for wss://.
Definition: uri.hpp:47
lib::function< void(connection_hdl)> fail_handler
The type and function signature of a fail handler.
Definition: connection.hpp:79
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
static uint16_t const uri_default_port
Default port for ws://.
Definition: uri.hpp:45
lib::function< bool(connection_hdl, std::string)> ping_handler
The type and function signature of a ping handler.
Definition: connection.hpp:101
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition: uri.hpp:352
std::pair< lib::error_code, std::string > err_str_pair
Combination error code / string type for returning two values.
Definition: error.hpp:41
lib::function< bool(connection_hdl)> validate_handler
The type and function signature of a validate handler.
Definition: connection.hpp:129
static bool is_base64(unsigned char c)
Test whether a character is a valid base64 character.
Definition: base64.hpp:53
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
Definition: base64.hpp:66
#define TYP_BIGE
Definition: network.hpp:53
#define TYP_SMLE
Definition: network.hpp:52
#define TYP_INIT
Definition: network.hpp:51
Server config with asio transport and TLS disabled.
Definition: asio_no_tls.hpp:38
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
Definition: core.hpp:137
static const long timeout_connect
Length of time to wait for TCP connect.
Definition: core.hpp:134
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
Definition: core.hpp:131
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
Definition: core.hpp:121
static const long timeout_socket_pre_init
Default timer values (in ms)
Definition: core.hpp:118
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Definition: core.hpp:128
Server config with iostream transport.
Definition: core.hpp:68
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
Definition: core.hpp:93
static const websocketpp::log::level elog_level
Default static error logging channels.
Definition: core.hpp:176
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
Definition: core.hpp:142
static const size_t max_http_body_size
Default maximum http body size.
Definition: core.hpp:252
static const long timeout_open_handshake
Default timer values (in ms)
Definition: core.hpp:152
static const size_t max_message_size
Default maximum message size.
Definition: core.hpp:240
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
Definition: core.hpp:213
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
Definition: core.hpp:154
static const websocketpp::log::level alog_level
Default static access logging channels.
Definition: core.hpp:189
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition: core.hpp:88
static const long timeout_pong
Length of time to wait for a pong after a ping.
Definition: core.hpp:156
static const bool silent_close
Suppresses the return of detailed connection close information.
Definition: core.hpp:228
static bool const enable_multithreading
Definition: core.hpp:98
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
Definition: core.hpp:204
static const bool enable_extensions
Global flag for enabling/disabling extensions.
Definition: core.hpp:255
static const int client_version
WebSocket Protocol version to use as a client.
Definition: core.hpp:164
The constant size component of a WebSocket frame header.
Definition: frame.hpp:189
The variable size component of a WebSocket frame header.
Definition: frame.hpp:235
Package of log levels for logging access events.
Definition: levels.hpp:112
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition: levels.hpp:164
static level const fail
One line for each failed WebSocket connection with details.
Definition: levels.hpp:147
static level const none
Special aggregate value representing "no levels".
Definition: levels.hpp:114
static level const debug_handshake
Extra information about opening handshakes.
Definition: levels.hpp:137
static level const devel
Development messages (warning: very chatty)
Definition: levels.hpp:141
static level const all
Special aggregate value representing "all levels".
Definition: levels.hpp:152
static level const debug_close
Extra information about closing handshakes.
Definition: levels.hpp:139
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty)
Definition: levels.hpp:129
static level const connect
Information about new connections.
Definition: levels.hpp:121
static level const app
Special channel for application specific logs. Not used by the library.
Definition: levels.hpp:143
static level const frame_header
One line per frame, includes the full frame header.
Definition: levels.hpp:127
static level const message_payload
Reserved.
Definition: levels.hpp:133
static level const endpoint
Reserved.
Definition: levels.hpp:135
static level const message_header
Reserved.
Definition: levels.hpp:131
static level const control
One line per control frame.
Definition: levels.hpp:125
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
Definition: levels.hpp:123
static level const access_core
Definition: levels.hpp:150
static level const http
Access related to HTTP requests.
Definition: levels.hpp:145
Package of values for hinting at the nature of a given logger.
Definition: levels.hpp:46
static value const none
No information.
Definition: levels.hpp:51
static value const access
Access log.
Definition: levels.hpp:53
static value const error
Error log.
Definition: levels.hpp:55
uint32_t value
Type of a channel type hint value.
Definition: levels.hpp:48
Package of log levels for logging errors.
Definition: levels.hpp:59
static level const devel
Low level debugging information (warning: very chatty)
Definition: levels.hpp:63
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition: levels.hpp:91
static level const library
Definition: levels.hpp:66
static level const info
Definition: levels.hpp:69
static level const all
Special aggregate value representing "all levels".
Definition: levels.hpp:80
static level const fatal
Definition: levels.hpp:78
static level const none
Special aggregate value representing "no levels".
Definition: levels.hpp:61
static level const rerror
Definition: levels.hpp:75
static level const warn
Definition: levels.hpp:72
A simple utility buffer class.
Definition: connection.hpp:138
Helper less than functor for case insensitive find.
Definition: utilities.hpp:75
Helper functor for case insensitive find.
Definition: utilities.hpp:49
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
Definition: utilities.hpp:63
my_equal(std::locale const &loc)
Construct the functor with the given locale.
Definition: utilities.hpp:54
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Two byte conversion union.
Definition: frame.hpp:55
Four byte conversion union.
Definition: frame.hpp:61
Eight byte conversion union.
Definition: frame.hpp:67