WebSocket++ 0.8.2
C++ websocket client/server library
Loading...
Searching...
No Matches
connection.hpp
1/*
2 * Copyright (c) 2015, 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_TRANSPORT_ASIO_CON_HPP
29#define WEBSOCKETPP_TRANSPORT_ASIO_CON_HPP
30
31#include <websocketpp/transport/asio/base.hpp>
32
33#include <websocketpp/transport/base/connection.hpp>
34
35#include <websocketpp/logger/levels.hpp>
36#include <websocketpp/http/constants.hpp>
37
38#include <websocketpp/base64/base64.hpp>
39#include <websocketpp/error.hpp>
40#include <websocketpp/uri.hpp>
41
42#include <websocketpp/common/asio.hpp>
43#include <websocketpp/common/chrono.hpp>
44#include <websocketpp/common/cpp11.hpp>
45#include <websocketpp/common/memory.hpp>
46#include <websocketpp/common/functional.hpp>
47#include <websocketpp/common/connection_hdl.hpp>
48
49#include <istream>
50#include <sstream>
51#include <string>
52#include <vector>
53
54namespace websocketpp {
55namespace transport {
56namespace asio {
57
58typedef lib::function<void(connection_hdl)> tcp_init_handler;
59
60/// Asio based connection transport component
61/**
62 * transport::asio::connection implements a connection transport component using
63 * Asio that works with the transport::asio::endpoint endpoint transport
64 * component.
65 */
66template <typename config>
67class connection : public config::socket_type::socket_con_type {
68public:
69 /// Type of this connection transport component
70 typedef connection<config> type;
71 /// Type of a shared pointer to this connection transport component
72 typedef lib::shared_ptr<type> ptr;
73
74 /// Type of the socket connection component
75 typedef typename config::socket_type::socket_con_type socket_con_type;
76 /// Type of a shared pointer to the socket connection component
77 typedef typename socket_con_type::ptr socket_con_ptr;
78 /// Type of this transport's access logging policy
79 typedef typename config::alog_type alog_type;
80 /// Type of this transport's error logging policy
81 typedef typename config::elog_type elog_type;
82
83 typedef typename config::request_type request_type;
84 typedef typename request_type::ptr request_ptr;
85 typedef typename config::response_type response_type;
86 typedef typename response_type::ptr response_ptr;
87
88 /// Type of a pointer to the Asio io_service being used
89 typedef lib::asio::io_service * io_service_ptr;
90 /// Type of a pointer to the Asio io_service::strand being used
91 typedef lib::shared_ptr<lib::asio::io_service::strand> strand_ptr;
92 /// Type of a pointer to the Asio timer class
93 typedef lib::shared_ptr<lib::asio::steady_timer> timer_ptr;
94
95 // connection is friends with its associated endpoint to allow the endpoint
96 // to call private/protected utility methods that we don't want to expose
97 // to the public api.
98 friend class endpoint<config>;
99
100 // generate and manage our own io_service
101 explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
102 : m_is_server(is_server)
103 , m_alog(alog)
104 , m_elog(elog)
105 {
106 m_alog->write(log::alevel::devel,"asio con transport constructor");
107 }
108
109 /// Get a shared pointer to this component
110 ptr get_shared() {
111 return lib::static_pointer_cast<type>(socket_con_type::get_shared());
112 }
113
114 bool is_secure() const {
115 return socket_con_type::is_secure();
116 }
117
118 /// Set uri hook
119 /**
120 * Called by the endpoint as a connection is being established to provide
121 * the uri being connected to to the transport layer.
122 *
123 * This transport policy doesn't use the uri except to forward it to the
124 * socket layer.
125 *
126 * @since 0.6.0
127 *
128 * @param u The uri to set
129 */
130 void set_uri(uri_ptr u) {
131 socket_con_type::set_uri(u);
132 }
133
134 /// Sets the tcp pre init handler
135 /**
136 * The tcp pre init handler is called after the raw tcp connection has been
137 * established but before any additional wrappers (proxy connects, TLS
138 * handshakes, etc) have been performed.
139 *
140 * @since 0.3.0
141 *
142 * @param h The handler to call on tcp pre init.
143 */
144 void set_tcp_pre_init_handler(tcp_init_handler h) {
145 m_tcp_pre_init_handler = h;
146 }
147
148 /// Sets the tcp pre init handler (deprecated)
149 /**
150 * The tcp pre init handler is called after the raw tcp connection has been
151 * established but before any additional wrappers (proxy connects, TLS
152 * handshakes, etc) have been performed.
153 *
154 * @deprecated Use set_tcp_pre_init_handler instead
155 *
156 * @param h The handler to call on tcp pre init.
157 */
158 void set_tcp_init_handler(tcp_init_handler h) {
160 }
161
162 /// Sets the tcp post init handler
163 /**
164 * The tcp post init handler is called after the tcp connection has been
165 * established and all additional wrappers (proxy connects, TLS handshakes,
166 * etc have been performed. This is fired before any bytes are read or any
167 * WebSocket specific handshake logic has been performed.
168 *
169 * @since 0.3.0
170 *
171 * @param h The handler to call on tcp post init.
172 */
173 void set_tcp_post_init_handler(tcp_init_handler h) {
174 m_tcp_post_init_handler = h;
175 }
176
177 /// Set the proxy to connect through (exception free)
178 /**
179 * The URI passed should be a complete URI including scheme. For example:
180 * http://proxy.example.com:8080/
181 *
182 * The proxy must be set up as an explicit (CONNECT) proxy allowed to
183 * connect to the port you specify. Traffic to the proxy is not encrypted.
184 *
185 * @param uri The full URI of the proxy to connect to.
186 *
187 * @param ec A status value
188 */
189 void set_proxy(std::string const & uri, lib::error_code & ec) {
190 // TODO: return errors for illegal URIs here?
191 // TODO: should https urls be illegal for the moment?
192 m_proxy = uri;
193 m_proxy_data = lib::make_shared<proxy_data>();
194 ec = lib::error_code();
195 }
196
197 /// Set the proxy to connect through (exception)
198 void set_proxy(std::string const & uri) {
199 lib::error_code ec;
200 set_proxy(uri,ec);
201 if (ec) { throw exception(ec); }
202 }
203
204 /// Set the basic auth credentials to use (exception free)
205 /**
206 * The URI passed should be a complete URI including scheme. For example:
207 * http://proxy.example.com:8080/
208 *
209 * The proxy must be set up as an explicit proxy
210 *
211 * @param username The username to send
212 *
213 * @param password The password to send
214 *
215 * @param ec A status value
216 */
217 void set_proxy_basic_auth(std::string const & username, std::string const &
218 password, lib::error_code & ec)
219 {
220 if (!m_proxy_data) {
221 ec = make_error_code(websocketpp::error::invalid_state);
222 return;
223 }
224
225 // TODO: username can't contain ':'
226 std::string val = "Basic "+base64_encode(username + ":" + password);
227 m_proxy_data->req.replace_header("Proxy-Authorization",val);
228 ec = lib::error_code();
229 }
230
231 /// Set the basic auth credentials to use (exception)
232 void set_proxy_basic_auth(std::string const & username, std::string const &
233 password)
234 {
235 lib::error_code ec;
236 set_proxy_basic_auth(username,password,ec);
237 if (ec) { throw exception(ec); }
238 }
239
240 /// Set the proxy timeout duration (exception free)
241 /**
242 * Duration is in milliseconds. Default value is based on the transport
243 * config
244 *
245 * @param duration The number of milliseconds to wait before aborting the
246 * proxy connection.
247 *
248 * @param ec A status value
249 */
250 void set_proxy_timeout(long duration, lib::error_code & ec) {
251 if (!m_proxy_data) {
252 ec = make_error_code(websocketpp::error::invalid_state);
253 return;
254 }
255
256 m_proxy_data->timeout_proxy = duration;
257 ec = lib::error_code();
258 }
259
260 /// Set the proxy timeout duration (exception)
261 void set_proxy_timeout(long duration) {
262 lib::error_code ec;
263 set_proxy_timeout(duration,ec);
264 if (ec) { throw exception(ec); }
265 }
266
267 std::string const & get_proxy() const {
268 return m_proxy;
269 }
270
271 /// Get the remote endpoint address
272 /**
273 * The iostream transport has no information about the ultimate remote
274 * endpoint. It will return the string "iostream transport". To indicate
275 * this.
276 *
277 * TODO: allow user settable remote endpoint addresses if this seems useful
278 *
279 * @return A string identifying the address of the remote endpoint
280 */
281 std::string get_remote_endpoint() const {
282 lib::error_code ec;
283
284 std::string ret = socket_con_type::get_remote_endpoint(ec);
285
286 if (ec) {
287 m_elog->write(log::elevel::info,ret);
288 return "Unknown";
289 } else {
290 return ret;
291 }
292 }
293
294 /// Get the connection handle
295 connection_hdl get_handle() const {
296 return m_connection_hdl;
297 }
298
299 /// Call back a function after a period of time.
300 /**
301 * Sets a timer that calls back a function after the specified period of
302 * milliseconds. Returns a handle that can be used to cancel the timer.
303 * A cancelled timer will return the error code error::operation_aborted
304 * A timer that expired will return no error.
305 *
306 * @param duration Length of time to wait in milliseconds
307 *
308 * @param callback The function to call back when the timer has expired
309 *
310 * @return A handle that can be used to cancel the timer if it is no longer
311 * needed.
312 */
313 timer_ptr set_timer(long duration, timer_handler callback) {
314 timer_ptr new_timer(
315 new lib::asio::steady_timer(
316 *m_io_service,
317 lib::asio::milliseconds(duration))
318 );
319
320 if (config::enable_multithreading) {
321 new_timer->async_wait(m_strand->wrap(lib::bind(
322 &type::handle_timer, get_shared(),
323 new_timer,
324 callback,
325 lib::placeholders::_1
326 )));
327 } else {
328 new_timer->async_wait(lib::bind(
330 new_timer,
331 callback,
332 lib::placeholders::_1
333 ));
334 }
335
336 return new_timer;
337 }
338
339 /// Timer callback
340 /**
341 * The timer pointer is included to ensure the timer isn't destroyed until
342 * after it has expired.
343 *
344 * TODO: candidate for protected status
345 *
346 * @param post_timer Pointer to the timer in question
347 * @param callback The function to call back
348 * @param ec The status code
349 */
350 void handle_timer(timer_ptr, timer_handler callback,
351 lib::asio::error_code const & ec)
352 {
353 if (ec) {
354 if (ec == lib::asio::error::operation_aborted) {
355 callback(make_error_code(transport::error::operation_aborted));
356 } else {
357 log_err(log::elevel::info,"asio handle_timer",ec);
358 callback(make_error_code(error::pass_through));
359 }
360 } else {
361 callback(lib::error_code());
362 }
363 }
364
365 /// Get a pointer to this connection's strand
367 return m_strand;
368 }
369
370 /// Get the internal transport error code for a closed/failed connection
371 /**
372 * Retrieves a machine readable detailed error code indicating the reason
373 * that the connection was closed or failed. Valid only after the close or
374 * fail handler is called.
375 *
376 * Primarily used if you are using mismatched asio / system_error
377 * implementations such as `boost::asio` with `std::system_error`. In these
378 * cases the transport error type is different than the library error type
379 * and some WebSocket++ functions that return transport errors via the
380 * library error code type will be coerced into a catch all `pass_through`
381 * or `tls_error` error. This method will return the original machine
382 * readable transport error in the native type.
383 *
384 * @since 0.7.0
385 *
386 * @return Error code indicating the reason the connection was closed or
387 * failed
388 */
389 lib::asio::error_code get_transport_ec() const {
390 return m_tec;
391 }
392
393 /// Initialize transport for reading
394 /**
395 * init_asio is called once immediately after construction to initialize
396 * Asio components to the io_service
397 *
398 * The transport initialization sequence consists of the following steps:
399 * - Pre-init: the underlying socket is initialized to the point where
400 * bytes may be written. No bytes are actually written in this stage
401 * - Proxy negotiation: if a proxy is set, a request is made to it to start
402 * a tunnel to the final destination. This stage ends when the proxy is
403 * ready to forward the
404 * next byte to the remote endpoint.
405 * - Post-init: Perform any i/o with the remote endpoint, such as setting up
406 * tunnels for encryption. This stage ends when the connection is ready to
407 * read or write the WebSocket handshakes. At this point the original
408 * callback function is called.
409 */
410protected:
411 void init(init_handler callback) {
412 if (m_alog->static_test(log::alevel::devel)) {
413 m_alog->write(log::alevel::devel,"asio connection init");
414 }
415
416 // TODO: pre-init timeout. Right now no implemented socket policies
417 // actually have an asyncronous pre-init
418
419 socket_con_type::pre_init(
420 lib::bind(
421 &type::handle_pre_init,
423 callback,
424 lib::placeholders::_1
425 )
426 );
427 }
428
429 /// initialize the proxy buffers and http parsers
430 /**
431 *
432 * @param authority The address of the server we want the proxy to tunnel to
433 * in the format of a URI authority (host:port)
434 *
435 * @return Status code indicating what errors occurred, if any
436 */
437 lib::error_code proxy_init(std::string const & authority) {
438 if (!m_proxy_data) {
439 return websocketpp::error::make_error_code(
441 }
442 m_proxy_data->req.set_version("HTTP/1.1");
443 m_proxy_data->req.set_method("CONNECT");
444
445 m_proxy_data->req.set_uri(authority);
446 m_proxy_data->req.replace_header("Host",authority);
447
448 return lib::error_code();
449 }
450
451 /// Finish constructing the transport
452 /**
453 * init_asio is called once immediately after construction to initialize
454 * Asio components to the io_service.
455 *
456 * @param io_service A pointer to the io_service to register with this
457 * connection
458 *
459 * @return Status code for the success or failure of the initialization
460 */
461 lib::error_code init_asio (io_service_ptr io_service) {
462 m_io_service = io_service;
463
464 if (config::enable_multithreading) {
465 m_strand.reset(new lib::asio::io_service::strand(*io_service));
466 }
467
468 lib::error_code ec = socket_con_type::init_asio(io_service, m_strand,
469 m_is_server);
470
471 return ec;
472 }
473
474 void handle_pre_init(init_handler callback, lib::error_code const & ec) {
475 if (m_alog->static_test(log::alevel::devel)) {
476 m_alog->write(log::alevel::devel,"asio connection handle pre_init");
477 }
478
479 if (m_tcp_pre_init_handler) {
480 m_tcp_pre_init_handler(m_connection_hdl);
481 }
482
483 if (ec) {
484 callback(ec);
485 }
486
487 // If we have a proxy set issue a proxy connect, otherwise skip to
488 // post_init
489 if (!m_proxy.empty()) {
490 proxy_write(callback);
491 } else {
492 post_init(callback);
493 }
494 }
495
496 void post_init(init_handler callback) {
497 if (m_alog->static_test(log::alevel::devel)) {
498 m_alog->write(log::alevel::devel,"asio connection post_init");
499 }
500
501 timer_ptr post_timer;
502
503 if (config::timeout_socket_post_init > 0) {
504 post_timer = set_timer(
505 config::timeout_socket_post_init,
506 lib::bind(
507 &type::handle_post_init_timeout,
508 get_shared(),
509 post_timer,
510 callback,
511 lib::placeholders::_1
512 )
513 );
514 }
515
516 socket_con_type::post_init(
517 lib::bind(
520 post_timer,
521 callback,
522 lib::placeholders::_1
523 )
524 );
525 }
526
527 /// Post init timeout callback
528 /**
529 * The timer pointer is included to ensure the timer isn't destroyed until
530 * after it has expired.
531 *
532 * @param post_timer Pointer to the timer in question
533 * @param callback The function to call back
534 * @param ec The status code
535 */
537 lib::error_code const & ec)
538 {
539 lib::error_code ret_ec;
540
541 if (ec) {
543 m_alog->write(log::alevel::devel,
544 "asio post init timer cancelled");
545 return;
546 }
547
548 log_err(log::elevel::devel,"asio handle_post_init_timeout",ec);
549 ret_ec = ec;
550 } else {
551 if (socket_con_type::get_ec()) {
552 ret_ec = socket_con_type::get_ec();
553 } else {
554 ret_ec = make_error_code(transport::error::timeout);
555 }
556 }
557
558 m_alog->write(log::alevel::devel, "Asio transport post-init timed out");
560 callback(ret_ec);
561 }
562
563 /// Post init timeout callback
564 /**
565 * The timer pointer is included to ensure the timer isn't destroyed until
566 * after it has expired.
567 *
568 * @param post_timer Pointer to the timer in question
569 * @param callback The function to call back
570 * @param ec The status code
571 */
572 void handle_post_init(timer_ptr post_timer, init_handler callback,
573 lib::error_code const & ec)
574 {
576 (post_timer && lib::asio::is_neg(post_timer->expires_from_now())))
577 {
578 m_alog->write(log::alevel::devel,"post_init cancelled");
579 return;
580 }
581
582 if (post_timer) {
583 post_timer->cancel();
584 }
585
586 if (m_alog->static_test(log::alevel::devel)) {
587 m_alog->write(log::alevel::devel,"asio connection handle_post_init");
588 }
589
590 if (m_tcp_post_init_handler) {
591 m_tcp_post_init_handler(m_connection_hdl);
592 }
593
594 callback(ec);
595 }
596
597 void proxy_write(init_handler callback) {
598 if (m_alog->static_test(log::alevel::devel)) {
599 m_alog->write(log::alevel::devel,"asio connection proxy_write");
600 }
601
602 if (!m_proxy_data) {
603 m_elog->write(log::elevel::library,
604 "assertion failed: !m_proxy_data in asio::connection::proxy_write");
605 callback(make_error_code(error::general));
606 return;
607 }
608
609 m_proxy_data->write_buf = m_proxy_data->req.raw();
610
611 m_bufs.push_back(lib::asio::buffer(m_proxy_data->write_buf.data(),
612 m_proxy_data->write_buf.size()));
613
614 m_alog->write(log::alevel::devel,m_proxy_data->write_buf);
615
616 // Set a timer so we don't wait forever for the proxy to respond
617 m_proxy_data->timer = this->set_timer(
618 m_proxy_data->timeout_proxy,
619 lib::bind(
620 &type::handle_proxy_timeout,
622 callback,
623 lib::placeholders::_1
624 )
625 );
626
627 // Send proxy request
628 if (config::enable_multithreading) {
629 lib::asio::async_write(
630 socket_con_type::get_next_layer(),
631 m_bufs,
632 m_strand->wrap(lib::bind(
633 &type::handle_proxy_write, get_shared(),
634 callback,
635 lib::placeholders::_1
636 ))
637 );
638 } else {
639 lib::asio::async_write(
640 socket_con_type::get_next_layer(),
641 m_bufs,
642 lib::bind(
643 &type::handle_proxy_write, get_shared(),
644 callback,
645 lib::placeholders::_1
646 )
647 );
648 }
649 }
650
651 void handle_proxy_timeout(init_handler callback, lib::error_code const & ec)
652 {
654 m_alog->write(log::alevel::devel,
655 "asio handle_proxy_write timer cancelled");
656 return;
657 } else if (ec) {
658 log_err(log::elevel::devel,"asio handle_proxy_write",ec);
659 callback(ec);
660 } else {
661 m_alog->write(log::alevel::devel,
662 "asio handle_proxy_write timer expired");
664 callback(make_error_code(transport::error::timeout));
665 }
666 }
667
668 void handle_proxy_write(init_handler callback,
669 lib::asio::error_code const & ec)
670 {
671 if (m_alog->static_test(log::alevel::devel)) {
672 m_alog->write(log::alevel::devel,
673 "asio connection handle_proxy_write");
674 }
675
676 m_bufs.clear();
677
678 // Timer expired or the operation was aborted for some reason.
679 // Whatever aborted it will be issuing the callback so we are safe to
680 // return
681 if (ec == lib::asio::error::operation_aborted ||
682 lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
683 {
684 m_elog->write(log::elevel::devel,"write operation aborted");
685 return;
686 }
687
688 if (ec) {
689 log_err(log::elevel::info,"asio handle_proxy_write",ec);
690 m_proxy_data->timer->cancel();
691 callback(make_error_code(error::pass_through));
692 return;
693 }
694
695 proxy_read(callback);
696 }
697
698 void proxy_read(init_handler callback) {
699 if (m_alog->static_test(log::alevel::devel)) {
700 m_alog->write(log::alevel::devel,"asio connection proxy_read");
701 }
702
703 if (!m_proxy_data) {
704 m_elog->write(log::elevel::library,
705 "assertion failed: !m_proxy_data in asio::connection::proxy_read");
706 m_proxy_data->timer->cancel();
707 callback(make_error_code(error::general));
708 return;
709 }
710
711 if (config::enable_multithreading) {
712 lib::asio::async_read_until(
713 socket_con_type::get_next_layer(),
714 m_proxy_data->read_buf,
715 "\r\n\r\n",
716 m_strand->wrap(lib::bind(
717 &type::handle_proxy_read, get_shared(),
718 callback,
719 lib::placeholders::_1, lib::placeholders::_2
720 ))
721 );
722 } else {
723 lib::asio::async_read_until(
724 socket_con_type::get_next_layer(),
725 m_proxy_data->read_buf,
726 "\r\n\r\n",
727 lib::bind(
728 &type::handle_proxy_read, get_shared(),
729 callback,
730 lib::placeholders::_1, lib::placeholders::_2
731 )
732 );
733 }
734 }
735
736 /// Proxy read callback
737 /**
738 * @param init_handler The function to call back
739 * @param ec The status code
740 * @param bytes_transferred The number of bytes read
741 */
742 void handle_proxy_read(init_handler callback,
743 lib::asio::error_code const & ec, size_t)
744 {
745 if (m_alog->static_test(log::alevel::devel)) {
746 m_alog->write(log::alevel::devel,
747 "asio connection handle_proxy_read");
748 }
749
750 // Timer expired or the operation was aborted for some reason.
751 // Whatever aborted it will be issuing the callback so we are safe to
752 // return
753 if (ec == lib::asio::error::operation_aborted ||
754 lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
755 {
756 m_elog->write(log::elevel::devel,"read operation aborted");
757 return;
758 }
759
760 // At this point there is no need to wait for the timer anymore
761 m_proxy_data->timer->cancel();
762
763 if (ec) {
764 m_elog->write(log::elevel::info,
765 "asio handle_proxy_read error: "+ec.message());
766 callback(make_error_code(error::pass_through));
767 } else {
768 if (!m_proxy_data) {
769 m_elog->write(log::elevel::library,
770 "assertion failed: !m_proxy_data in asio::connection::handle_proxy_read");
771 callback(make_error_code(error::general));
772 return;
773 }
774
775 std::istream input(&m_proxy_data->read_buf);
776
777 m_proxy_data->res.consume(input);
778
779 if (!m_proxy_data->res.headers_ready()) {
780 // we read until the headers were done in theory but apparently
781 // they aren't. Internal endpoint error.
782 callback(make_error_code(error::general));
783 return;
784 }
785
786 m_alog->write(log::alevel::devel,m_proxy_data->res.raw());
787
788 if (m_proxy_data->res.get_status_code() != http::status_code::ok) {
789 // got an error response back
790 // TODO: expose this error in a programmatically accessible way?
791 // if so, see below for an option on how to do this.
792 std::stringstream s;
793 s << "Proxy connection error: "
794 << m_proxy_data->res.get_status_code()
795 << " ("
796 << m_proxy_data->res.get_status_msg()
797 << ")";
798 m_elog->write(log::elevel::info,s.str());
799 callback(make_error_code(error::proxy_failed));
800 return;
801 }
802
803 // we have successfully established a connection to the proxy, now
804 // we can continue and the proxy will transparently forward the
805 // WebSocket connection.
806
807 // TODO: decide if we want an on_proxy callback that would allow
808 // access to the proxy response.
809
810 // free the proxy buffers and req/res objects as they aren't needed
811 // anymore
812 m_proxy_data.reset();
813
814 // Continue with post proxy initialization
815 post_init(callback);
816 }
817 }
818
819 /// read at least num_bytes bytes into buf and then call handler.
820 void async_read_at_least(size_t num_bytes, char *buf, size_t len,
821 read_handler handler)
822 {
823 if (m_alog->static_test(log::alevel::devel)) {
824 std::stringstream s;
825 s << "asio async_read_at_least: " << num_bytes;
826 m_alog->write(log::alevel::devel,s.str());
827 }
828
829 // TODO: safety vs speed ?
830 // maybe move into an if devel block
831 /*if (num_bytes > len) {
832 m_elog->write(log::elevel::devel,
833 "asio async_read_at_least error::invalid_num_bytes");
834 handler(make_error_code(transport::error::invalid_num_bytes),
835 size_t(0));
836 return;
837 }*/
838
839 if (config::enable_multithreading) {
840 lib::asio::async_read(
841 socket_con_type::get_socket(),
842 lib::asio::buffer(buf,len),
843 lib::asio::transfer_at_least(num_bytes),
844 m_strand->wrap(make_custom_alloc_handler(
845 m_read_handler_allocator,
846 lib::bind(
847 &type::handle_async_read, get_shared(),
848 handler,
849 lib::placeholders::_1, lib::placeholders::_2
850 )
851 ))
852 );
853 } else {
854 lib::asio::async_read(
855 socket_con_type::get_socket(),
856 lib::asio::buffer(buf,len),
857 lib::asio::transfer_at_least(num_bytes),
858 make_custom_alloc_handler(
859 m_read_handler_allocator,
860 lib::bind(
861 &type::handle_async_read, get_shared(),
862 handler,
863 lib::placeholders::_1, lib::placeholders::_2
864 )
865 )
866 );
867 }
868
869 }
870
871 void handle_async_read(read_handler handler, lib::asio::error_code const & ec,
872 size_t bytes_transferred)
873 {
874 m_alog->write(log::alevel::devel, "asio con handle_async_read");
875
876 // translate asio error codes into more lib::error_codes
877 lib::error_code tec;
878 if (ec == lib::asio::error::eof) {
879 tec = make_error_code(transport::error::eof);
880 } else if (ec) {
881 // We don't know much more about the error at this point. As our
882 // socket/security policy if it knows more:
883 tec = socket_con_type::translate_ec(ec);
884 m_tec = ec;
885
886 if (tec == transport::error::tls_error ||
888 {
889 // These are aggregate/catch all errors. Log some human readable
890 // information to the info channel to give library users some
891 // more details about why the upstream method may have failed.
892 log_err(log::elevel::info,"asio async_read_at_least",ec);
893 }
894 }
895 if (handler) {
896 handler(tec,bytes_transferred);
897 } else {
898 // This can happen in cases where the connection is terminated while
899 // the transport is waiting on a read.
900 m_alog->write(log::alevel::devel,
901 "handle_async_read called with null read handler");
902 }
903 }
904
905 /// Initiate a potentially asyncronous write of the given buffer
906 void async_write(const char* buf, size_t len, write_handler handler) {
907 m_bufs.push_back(lib::asio::buffer(buf,len));
908
909 if (config::enable_multithreading) {
910 lib::asio::async_write(
911 socket_con_type::get_socket(),
912 m_bufs,
913 m_strand->wrap(make_custom_alloc_handler(
914 m_write_handler_allocator,
915 lib::bind(
916 &type::handle_async_write, get_shared(),
917 handler,
918 lib::placeholders::_1, lib::placeholders::_2
919 )
920 ))
921 );
922 } else {
923 lib::asio::async_write(
924 socket_con_type::get_socket(),
925 m_bufs,
926 make_custom_alloc_handler(
927 m_write_handler_allocator,
928 lib::bind(
929 &type::handle_async_write, get_shared(),
930 handler,
931 lib::placeholders::_1, lib::placeholders::_2
932 )
933 )
934 );
935 }
936 }
937
938 /// Initiate a potentially asyncronous write of the given buffers
939 void async_write(std::vector<buffer> const & bufs, write_handler handler) {
940 std::vector<buffer>::const_iterator it;
941
942 for (it = bufs.begin(); it != bufs.end(); ++it) {
943 m_bufs.push_back(lib::asio::buffer((*it).buf,(*it).len));
944 }
945
946 if (config::enable_multithreading) {
947 lib::asio::async_write(
948 socket_con_type::get_socket(),
949 m_bufs,
950 m_strand->wrap(make_custom_alloc_handler(
951 m_write_handler_allocator,
952 lib::bind(
953 &type::handle_async_write, get_shared(),
954 handler,
955 lib::placeholders::_1, lib::placeholders::_2
956 )
957 ))
958 );
959 } else {
960 lib::asio::async_write(
961 socket_con_type::get_socket(),
962 m_bufs,
963 make_custom_alloc_handler(
964 m_write_handler_allocator,
965 lib::bind(
966 &type::handle_async_write, get_shared(),
967 handler,
968 lib::placeholders::_1, lib::placeholders::_2
969 )
970 )
971 );
972 }
973 }
974
975 /// Async write callback
976 /**
977 * @param ec The status code
978 * @param bytes_transferred The number of bytes read
979 */
980 void handle_async_write(write_handler handler, lib::asio::error_code const & ec, size_t) {
981 m_bufs.clear();
982 lib::error_code tec;
983 if (ec) {
984 log_err(log::elevel::info,"asio async_write",ec);
985 tec = make_error_code(transport::error::pass_through);
986 }
987 if (handler) {
988 handler(tec);
989 } else {
990 // This can happen in cases where the connection is terminated while
991 // the transport is waiting on a read.
992 m_alog->write(log::alevel::devel,
993 "handle_async_write called with null write handler");
994 }
995 }
996
997 /// Set Connection Handle
998 /**
999 * See common/connection_hdl.hpp for information
1000 *
1001 * @param hdl A connection_hdl that the transport will use to refer
1002 * to itself
1003 */
1004 void set_handle(connection_hdl hdl) {
1005 m_connection_hdl = hdl;
1006 socket_con_type::set_handle(hdl);
1007 }
1008
1009 /// Trigger the on_interrupt handler
1010 /**
1011 * This needs to be thread safe
1012 */
1013 lib::error_code interrupt(interrupt_handler handler) {
1014 if (config::enable_multithreading) {
1015 m_io_service->post(m_strand->wrap(handler));
1016 } else {
1017 m_io_service->post(handler);
1018 }
1019 return lib::error_code();
1020 }
1021
1022 lib::error_code dispatch(dispatch_handler handler) {
1023 if (config::enable_multithreading) {
1024 m_io_service->post(m_strand->wrap(handler));
1025 } else {
1026 m_io_service->post(handler);
1027 }
1028 return lib::error_code();
1029 }
1030
1031 /*void handle_interrupt(interrupt_handler handler) {
1032 handler();
1033 }*/
1034
1035 /// close and clean up the underlying socket
1036 void async_shutdown(shutdown_handler callback) {
1037 if (m_alog->static_test(log::alevel::devel)) {
1038 m_alog->write(log::alevel::devel,"asio connection async_shutdown");
1039 }
1040
1041 timer_ptr shutdown_timer;
1042 shutdown_timer = set_timer(
1043 config::timeout_socket_shutdown,
1044 lib::bind(
1045 &type::handle_async_shutdown_timeout,
1046 get_shared(),
1047 shutdown_timer,
1048 callback,
1049 lib::placeholders::_1
1050 )
1051 );
1052
1053 socket_con_type::async_shutdown(
1054 lib::bind(
1055 &type::handle_async_shutdown,
1057 shutdown_timer,
1058 callback,
1059 lib::placeholders::_1
1060 )
1061 );
1062 }
1063
1064 /// Async shutdown timeout handler
1065 /**
1066 * @param shutdown_timer A pointer to the timer to keep it in scope
1067 * @param callback The function to call back
1068 * @param ec The status code
1069 */
1071 lib::error_code const & ec)
1072 {
1073 lib::error_code ret_ec;
1074
1075 if (ec) {
1077 m_alog->write(log::alevel::devel,
1078 "asio socket shutdown timer cancelled");
1079 return;
1080 }
1081
1082 log_err(log::elevel::devel,"asio handle_async_shutdown_timeout",ec);
1083 ret_ec = ec;
1084 } else {
1085 ret_ec = make_error_code(transport::error::timeout);
1086 }
1087
1088 m_alog->write(log::alevel::devel,
1089 "Asio transport socket shutdown timed out");
1091 callback(ret_ec);
1092 }
1093
1094 void handle_async_shutdown(timer_ptr shutdown_timer, shutdown_handler
1095 callback, lib::asio::error_code const & ec)
1096 {
1097 if (ec == lib::asio::error::operation_aborted ||
1098 lib::asio::is_neg(shutdown_timer->expires_from_now()))
1099 {
1100 m_alog->write(log::alevel::devel,"async_shutdown cancelled");
1101 return;
1102 }
1103
1104 shutdown_timer->cancel();
1105
1106 lib::error_code tec;
1107 if (ec) {
1108 if (ec == lib::asio::error::not_connected) {
1109 // The socket was already closed when we tried to close it. This
1110 // happens periodically (usually if a read or write fails
1111 // earlier and if it is a real error will be caught at another
1112 // level of the stack.
1113 } else {
1114 // We don't know anything more about this error, give our
1115 // socket/security policy a crack at it.
1116 tec = socket_con_type::translate_ec(ec);
1117 m_tec = ec;
1118
1119 // all other errors are effectively pass through errors of
1120 // some sort so print some detail on the info channel for
1121 // library users to look up if needed.
1122 log_err(log::elevel::info,"asio async_shutdown",ec);
1123 }
1124 } else {
1125 if (m_alog->static_test(log::alevel::devel)) {
1126 m_alog->write(log::alevel::devel,
1127 "asio con handle_async_shutdown");
1128 }
1129 }
1130 callback(tec);
1131 }
1132
1133 /// Cancel the underlying socket and log any errors
1134 void cancel_socket_checked() {
1135 lib::asio::error_code cec = socket_con_type::cancel_socket();
1136 if (cec) {
1137 if (cec == lib::asio::error::operation_not_supported) {
1138 // cancel not supported on this OS, ignore and log at dev level
1139 m_alog->write(log::alevel::devel, "socket cancel not supported");
1140 } else {
1141 log_err(log::elevel::warn, "socket cancel failed", cec);
1142 }
1143 }
1144 }
1145
1146private:
1147 /// Convenience method for logging the code and message for an error_code
1148 template <typename error_type>
1149 void log_err(log::level l, const char * msg, const error_type & ec) {
1150 std::stringstream s;
1151 s << msg << " error: " << ec << " (" << ec.message() << ")";
1152 m_elog->write(l,s.str());
1153 }
1154
1155 // static settings
1156 const bool m_is_server;
1157 lib::shared_ptr<alog_type> m_alog;
1158 lib::shared_ptr<elog_type> m_elog;
1159
1160 struct proxy_data {
1161 proxy_data() : timeout_proxy(config::timeout_proxy) {}
1162
1163 request_type req;
1164 response_type res;
1165 std::string write_buf;
1166 lib::asio::streambuf read_buf;
1167 long timeout_proxy;
1168 timer_ptr timer;
1169 };
1170
1171 std::string m_proxy;
1172 lib::shared_ptr<proxy_data> m_proxy_data;
1173
1174 // transport resources
1175 io_service_ptr m_io_service;
1176 strand_ptr m_strand;
1177 connection_hdl m_connection_hdl;
1178
1179 std::vector<lib::asio::const_buffer> m_bufs;
1180
1181 /// Detailed internal error code
1182 lib::asio::error_code m_tec;
1183
1184 // Handlers
1185 tcp_init_handler m_tcp_pre_init_handler;
1186 tcp_init_handler m_tcp_post_init_handler;
1187
1188 handler_allocator m_read_handler_allocator;
1189 handler_allocator m_write_handler_allocator;
1190};
1191
1192
1193} // namespace asio
1194} // namespace transport
1195} // namespace websocketpp
1196
1197#endif // WEBSOCKETPP_TRANSPORT_ASIO_CON_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.
Stub for user supplied base class.
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
std::string generate_offer() const
Generate extension offer.
Definition disabled.hpp:99
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
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition parser.hpp:161
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
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition parser.hpp:183
std::string const & get_version() const
Get the HTTP version string.
Definition parser.hpp:410
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
bool ready() const
Returns whether or not the request is ready for reading.
Definition request.hpp:82
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
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
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
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
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 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.
Basic ASIO endpoint socket component.
Definition none.hpp:317
Asio based connection transport component.
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception)
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free)
config::elog_type elog_type
Type of this transport's error logging policy.
strand_ptr get_strand()
Get a pointer to this connection's strand.
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.
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
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.
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
lib::error_code init_asio(io_service_ptr io_service)
Finish constructing the transport.
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
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.
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
connection< config > type
Type of this connection transport component.
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
void set_uri(uri_ptr u)
Set uri hook.
std::string get_remote_endpoint() const
Get the remote endpoint address.
ptr get_shared()
Get a shared pointer to this component.
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.
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service::strand being used.
void init(init_handler callback)
Initialize transport for reading.
connection_hdl get_handle() const
Get the connection handle.
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.
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
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 handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
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
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 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
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
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
@ 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.
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.
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.
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.
Asio transport errors.
Definition base.hpp:161
Transport policy that uses asio.
Definition endpoint.hpp:46
Generic transport related errors.
@ pass_through
underlying transport pass through
@ operation_not_supported
Operation not supported.
@ operation_aborted
Operation aborted.
@ 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
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.
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.
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.
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.
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.
Definition utilities.hpp:39
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://.
Definition uri.hpp:47
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::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
#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.
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.
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