WebSocket++ 0.8.2
C++ websocket client/server library
Loading...
Searching...
No Matches
endpoint.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_HPP
29#define WEBSOCKETPP_TRANSPORT_ASIO_HPP
30
31#include <websocketpp/transport/base/endpoint.hpp>
32#include <websocketpp/transport/asio/connection.hpp>
33#include <websocketpp/transport/asio/security/none.hpp>
34
35#include <websocketpp/uri.hpp>
36#include <websocketpp/logger/levels.hpp>
37
38#include <websocketpp/common/asio.hpp>
39#include <websocketpp/common/functional.hpp>
40
41#include <sstream>
42#include <string>
43
44namespace websocketpp {
45namespace transport {
46namespace asio {
47
48/// Asio based endpoint transport component
49/**
50 * transport::asio::endpoint implements an endpoint transport component using
51 * Asio.
52 */
53template <typename config>
54class endpoint : public config::socket_type {
55public:
56 /// Type of this endpoint transport component
57 typedef endpoint<config> type;
58
59 /// Type of the concurrency policy
60 typedef typename config::concurrency_type concurrency_type;
61 /// Type of the socket policy
62 typedef typename config::socket_type socket_type;
63 /// Type of the error logging policy
64 typedef typename config::elog_type elog_type;
65 /// Type of the access logging policy
66 typedef typename config::alog_type alog_type;
67
68 /// Type of the socket connection component
70 /// Type of a shared pointer to the socket connection component
72
73 /// Type of the connection transport component associated with this
74 /// endpoint transport component
76 /// Type of a shared pointer to the connection transport component
77 /// associated with this endpoint transport component
79
80 /// Type of a pointer to the ASIO io_service being used
81 typedef lib::asio::io_service * io_service_ptr;
82 /// Type of a shared pointer to the acceptor being used
83 typedef lib::shared_ptr<lib::asio::ip::tcp::acceptor> acceptor_ptr;
84 /// Type of a shared pointer to the resolver being used
85 typedef lib::shared_ptr<lib::asio::ip::tcp::resolver> resolver_ptr;
86 /// Type of timer handle
87 typedef lib::shared_ptr<lib::asio::steady_timer> timer_ptr;
88 /// Type of a shared pointer to an io_service work object
89 typedef lib::shared_ptr<lib::asio::io_service::work> work_ptr;
90
91 /// Type of socket pre-bind handler
92 typedef lib::function<lib::error_code(acceptor_ptr)> tcp_pre_bind_handler;
93
94 // generate and manage our own io_service
95 explicit endpoint()
96 : m_io_service(NULL)
97 , m_external_io_service(false)
98 , m_listen_backlog(lib::asio::socket_base::max_connections)
99 , m_reuse_addr(false)
100 , m_state(UNINITIALIZED)
101 {
102 //std::cout << "transport::asio::endpoint constructor" << std::endl;
103 }
104
105 ~endpoint() {
106 // clean up our io_service if we were initialized with an internal one.
107
108 // Explicitly destroy local objects
109 m_acceptor.reset();
110 m_resolver.reset();
111 m_work.reset();
112 if (m_state != UNINITIALIZED && !m_external_io_service) {
113 delete m_io_service;
114 }
115 }
116
117 /// transport::asio objects are moveable but not copyable or assignable.
118 /// The following code sets this situation up based on whether or not we
119 /// have C++11 support or not
120#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
121 endpoint(const endpoint & src) = delete;
122 endpoint& operator= (const endpoint & rhs) = delete;
123#else
124private:
125 endpoint(const endpoint & src);
126 endpoint & operator= (const endpoint & rhs);
127public:
128#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
129
130#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
131 endpoint (endpoint && src)
132 : config::socket_type(std::move(src))
133 , m_tcp_pre_init_handler(src.m_tcp_pre_init_handler)
134 , m_tcp_post_init_handler(src.m_tcp_post_init_handler)
135 , m_io_service(src.m_io_service)
136 , m_external_io_service(src.m_external_io_service)
137 , m_acceptor(src.m_acceptor)
138 , m_listen_backlog(lib::asio::socket_base::max_connections)
139 , m_reuse_addr(src.m_reuse_addr)
140 , m_elog(src.m_elog)
141 , m_alog(src.m_alog)
142 , m_state(src.m_state)
143 {
144 src.m_io_service = NULL;
145 src.m_external_io_service = false;
146 src.m_acceptor = NULL;
147 src.m_state = UNINITIALIZED;
148 }
149
150 /*endpoint & operator= (const endpoint && rhs) {
151 if (this != &rhs) {
152 m_io_service = rhs.m_io_service;
153 m_external_io_service = rhs.m_external_io_service;
154 m_acceptor = rhs.m_acceptor;
155 m_listen_backlog = rhs.m_listen_backlog;
156 m_reuse_addr = rhs.m_reuse_addr;
157 m_state = rhs.m_state;
158
159 rhs.m_io_service = NULL;
160 rhs.m_external_io_service = false;
161 rhs.m_acceptor = NULL;
162 rhs.m_listen_backlog = lib::asio::socket_base::max_connections;
163 rhs.m_state = UNINITIALIZED;
164
165 // TODO: this needs to be updated
166 }
167 return *this;
168 }*/
169#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
170
171 /// Return whether or not the endpoint produces secure connections.
172 bool is_secure() const {
173 return socket_type::is_secure();
174 }
175
176 /// initialize asio transport with external io_service (exception free)
177 /**
178 * Initialize the ASIO transport policy for this endpoint using the provided
179 * io_service object. asio_init must be called exactly once on any endpoint
180 * that uses transport::asio before it can be used.
181 *
182 * @param ptr A pointer to the io_service to use for asio events
183 * @param ec Set to indicate what error occurred, if any.
184 */
185 void init_asio(io_service_ptr ptr, lib::error_code & ec) {
186 if (m_state != UNINITIALIZED) {
187 m_elog->write(log::elevel::library,
188 "asio::init_asio called from the wrong state");
189 using websocketpp::error::make_error_code;
190 ec = make_error_code(websocketpp::error::invalid_state);
191 return;
192 }
193
194 m_alog->write(log::alevel::devel,"asio::init_asio");
195
196 m_io_service = ptr;
197 m_external_io_service = true;
198 m_acceptor.reset(new lib::asio::ip::tcp::acceptor(*m_io_service));
199
200 m_state = READY;
201 ec = lib::error_code();
202 }
203
204 /// initialize asio transport with external io_service
205 /**
206 * Initialize the ASIO transport policy for this endpoint using the provided
207 * io_service object. asio_init must be called exactly once on any endpoint
208 * that uses transport::asio before it can be used.
209 *
210 * @param ptr A pointer to the io_service to use for asio events
211 */
213 lib::error_code ec;
214 init_asio(ptr,ec);
215 if (ec) { throw exception(ec); }
216 }
217
218 /// Initialize asio transport with internal io_service (exception free)
219 /**
220 * This method of initialization will allocate and use an internally managed
221 * io_service.
222 *
223 * @see init_asio(io_service_ptr ptr)
224 *
225 * @param ec Set to indicate what error occurred, if any.
226 */
227 void init_asio(lib::error_code & ec) {
228 // Use a smart pointer until the call is successful and ownership has
229 // successfully been taken. Use unique_ptr when available.
230 // TODO: remove the use of auto_ptr when C++98/03 support is no longer
231 // necessary.
233 lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
234#else
235 lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
236#endif
237 init_asio(service.get(), ec);
238 if( !ec ) service.release(); // Call was successful, transfer ownership
239 m_external_io_service = false;
240 }
241
242 /// Initialize asio transport with internal io_service
243 /**
244 * This method of initialization will allocate and use an internally managed
245 * io_service.
246 *
247 * @see init_asio(io_service_ptr ptr)
248 */
249 void init_asio() {
250 // Use a smart pointer until the call is successful and ownership has
251 // successfully been taken. Use unique_ptr when available.
252 // TODO: remove the use of auto_ptr when C++98/03 support is no longer
253 // necessary.
255 lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
256#else
257 lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
258#endif
259 init_asio( service.get() );
260 // If control got this far without an exception, then ownership has successfully been taken
261 service.release();
262 m_external_io_service = false;
263 }
264
265 /// Sets the tcp pre bind handler
266 /**
267 * The tcp pre bind handler is called after the listen acceptor has
268 * been created but before the socket bind is performed.
269 *
270 * @since 0.8.0
271 *
272 * @param h The handler to call on tcp pre bind init.
273 */
275 m_tcp_pre_bind_handler = h;
276 }
277
278 /// Sets the tcp pre init handler
279 /**
280 * The tcp pre init handler is called after the raw tcp connection has been
281 * established but before any additional wrappers (proxy connects, TLS
282 * handshakes, etc) have been performed.
283 *
284 * @since 0.3.0
285 *
286 * @param h The handler to call on tcp pre init.
287 */
288 void set_tcp_pre_init_handler(tcp_init_handler h) {
289 m_tcp_pre_init_handler = h;
290 }
291
292 /// Sets the tcp pre init handler (deprecated)
293 /**
294 * The tcp pre init handler is called after the raw tcp connection has been
295 * established but before any additional wrappers (proxy connects, TLS
296 * handshakes, etc) have been performed.
297 *
298 * @deprecated Use set_tcp_pre_init_handler instead
299 *
300 * @param h The handler to call on tcp pre init.
301 */
302 void set_tcp_init_handler(tcp_init_handler h) {
304 }
305
306 /// Sets the tcp post init handler
307 /**
308 * The tcp post init handler is called after the tcp connection has been
309 * established and all additional wrappers (proxy connects, TLS handshakes,
310 * etc have been performed. This is fired before any bytes are read or any
311 * WebSocket specific handshake logic has been performed.
312 *
313 * @since 0.3.0
314 *
315 * @param h The handler to call on tcp post init.
316 */
317 void set_tcp_post_init_handler(tcp_init_handler h) {
318 m_tcp_post_init_handler = h;
319 }
320
321 /// Sets the maximum length of the queue of pending connections.
322 /**
323 * Sets the maximum length of the queue of pending connections. Increasing
324 * this will allow WebSocket++ to queue additional incoming connections.
325 * Setting it higher may prevent failed connections at high connection rates
326 * but may cause additional latency.
327 *
328 * For this value to take effect you may need to adjust operating system
329 * settings.
330 *
331 * New values affect future calls to listen only.
332 *
333 * The default value is specified as *::asio::socket_base::max_connections
334 * which uses the operating system defined maximum queue length. Your OS
335 * may restrict or silently lower this value. A value of zero may cause
336 * all connections to be rejected.
337 *
338 * @since 0.3.0
339 *
340 * @param backlog The maximum length of the queue of pending connections
341 */
342 void set_listen_backlog(int backlog) {
343 m_listen_backlog = backlog;
344 }
345
346 /// Sets whether to use the SO_REUSEADDR flag when opening listening sockets
347 /**
348 * Specifies whether or not to use the SO_REUSEADDR TCP socket option. What
349 * this flag does depends on your operating system.
350 *
351 * Please consult operating system documentation for more details. There
352 * may be security consequences to enabling this option.
353 *
354 * New values affect future calls to listen only so set this value prior to
355 * calling listen.
356 *
357 * The default is false.
358 *
359 * @since 0.3.0
360 *
361 * @param value Whether or not to use the SO_REUSEADDR option
362 */
363 void set_reuse_addr(bool value) {
364 m_reuse_addr = value;
365 }
366
367 /// Retrieve a reference to the endpoint's io_service
368 /**
369 * The io_service may be an internal or external one. This may be used to
370 * call methods of the io_service that are not explicitly wrapped by the
371 * endpoint.
372 *
373 * This method is only valid after the endpoint has been initialized with
374 * `init_asio`. No error will be returned if it isn't.
375 *
376 * @return A reference to the endpoint's io_service
377 */
378 lib::asio::io_service & get_io_service() {
379 return *m_io_service;
380 }
381
382 /// Get local TCP endpoint
383 /**
384 * Extracts the local endpoint from the acceptor. This represents the
385 * address that WebSocket++ is listening on.
386 *
387 * Sets a bad_descriptor error if the acceptor is not currently listening
388 * or otherwise unavailable.
389 *
390 * @since 0.7.0
391 *
392 * @param ec Set to indicate what error occurred, if any.
393 * @return The local endpoint
394 */
395 lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code & ec) {
396 if (m_acceptor) {
397 return m_acceptor->local_endpoint(ec);
398 } else {
399 ec = lib::asio::error::make_error_code(lib::asio::error::bad_descriptor);
400 return lib::asio::ip::tcp::endpoint();
401 }
402 }
403
404 /// Set up endpoint for listening manually (exception free)
405 /**
406 * Bind the internal acceptor using the specified settings. The endpoint
407 * must have been initialized by calling init_asio before listening.
408 *
409 * @param ep An endpoint to read settings from
410 * @param ec Set to indicate what error occurred, if any.
411 */
412 void listen(lib::asio::ip::tcp::endpoint const & ep, lib::error_code & ec)
413 {
414 if (m_state != READY) {
415 m_elog->write(log::elevel::library,
416 "asio::listen called from the wrong state");
417 using websocketpp::error::make_error_code;
418 ec = make_error_code(websocketpp::error::invalid_state);
419 return;
420 }
421
422 m_alog->write(log::alevel::devel,"asio::listen");
423
424 lib::asio::error_code bec;
425
426 m_acceptor->open(ep.protocol(),bec);
427 if (bec) {ec = clean_up_listen_after_error(bec);return;}
428
429 m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
430 if (bec) {ec = clean_up_listen_after_error(bec);return;}
431
432 // if a TCP pre-bind handler is present, run it
433 if (m_tcp_pre_bind_handler) {
434 ec = m_tcp_pre_bind_handler(m_acceptor);
435 if (ec) {
436 ec = clean_up_listen_after_error(ec);
437 return;
438 }
439 }
440
441 m_acceptor->bind(ep,bec);
442 if (bec) {ec = clean_up_listen_after_error(bec);return;}
443
444 m_acceptor->listen(m_listen_backlog,bec);
445 if (bec) {ec = clean_up_listen_after_error(bec);return;}
446
447 // Success
448 m_state = LISTENING;
449 ec = lib::error_code();
450 }
451
452
453
454 /// Set up endpoint for listening manually
455 /**
456 * Bind the internal acceptor using the settings specified by the endpoint e
457 *
458 * @param ep An endpoint to read settings from
459 */
460 void listen(lib::asio::ip::tcp::endpoint const & ep) {
461 lib::error_code ec;
462 listen(ep,ec);
463 if (ec) { throw exception(ec); }
464 }
465
466 /// Set up endpoint for listening with protocol and port (exception free)
467 /**
468 * Bind the internal acceptor using the given internet protocol and port.
469 * The endpoint must have been initialized by calling init_asio before
470 * listening.
471 *
472 * Common options include:
473 * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
474 * - IPv4 only: lib::asio::ip::tcp::v4()
475 *
476 * @param internet_protocol The internet protocol to use.
477 * @param port The port to listen on.
478 * @param ec Set to indicate what error occurred, if any.
479 */
480 template <typename InternetProtocol>
481 void listen(InternetProtocol const & internet_protocol, uint16_t port,
482 lib::error_code & ec)
483 {
484 lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
485 listen(ep,ec);
486 }
487
488 /// Set up endpoint for listening with protocol and port
489 /**
490 * Bind the internal acceptor using the given internet protocol and port.
491 * The endpoint must have been initialized by calling init_asio before
492 * listening.
493 *
494 * Common options include:
495 * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
496 * - IPv4 only: lib::asio::ip::tcp::v4()
497 *
498 * @param internet_protocol The internet protocol to use.
499 * @param port The port to listen on.
500 */
501 template <typename InternetProtocol>
502 void listen(InternetProtocol const & internet_protocol, uint16_t port)
503 {
504 lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
505 listen(ep);
506 }
507
508 /// Set up endpoint for listening on a port (exception free)
509 /**
510 * Bind the internal acceptor using the given port. The IPv6 protocol with
511 * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
512 * the overload that allows specifying the protocol explicitly.
513 *
514 * The endpoint must have been initialized by calling init_asio before
515 * listening.
516 *
517 * @param port The port to listen on.
518 * @param ec Set to indicate what error occurred, if any.
519 */
520 void listen(uint16_t port, lib::error_code & ec) {
521 listen(lib::asio::ip::tcp::v6(), port, ec);
522 }
523
524 /// Set up endpoint for listening on a port
525 /**
526 * Bind the internal acceptor using the given port. The IPv6 protocol with
527 * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
528 * the overload that allows specifying the protocol explicitly.
529 *
530 * The endpoint must have been initialized by calling init_asio before
531 * listening.
532 *
533 * @param port The port to listen on.
534 * @param ec Set to indicate what error occurred, if any.
535 */
536 void listen(uint16_t port) {
537 listen(lib::asio::ip::tcp::v6(), port);
538 }
539
540 /// Set up endpoint for listening on a host and service (exception free)
541 /**
542 * Bind the internal acceptor using the given host and service. More details
543 * about what host and service can be are available in the Asio
544 * documentation for ip::basic_resolver_query::basic_resolver_query's
545 * constructors.
546 *
547 * The endpoint must have been initialized by calling init_asio before
548 * listening.
549 *
550 * @param host A string identifying a location. May be a descriptive name or
551 * a numeric address string.
552 * @param service A string identifying the requested service. This may be a
553 * descriptive name or a numeric string corresponding to a port number.
554 * @param ec Set to indicate what error occurred, if any.
555 */
556 void listen(std::string const & host, std::string const & service,
557 lib::error_code & ec)
558 {
559 using lib::asio::ip::tcp;
560 tcp::resolver r(*m_io_service);
561 tcp::resolver::query query(host, service);
562 tcp::resolver::iterator endpoint_iterator = r.resolve(query);
563 tcp::resolver::iterator end;
564 if (endpoint_iterator == end) {
565 m_elog->write(log::elevel::library,
566 "asio::listen could not resolve the supplied host or service");
568 return;
569 }
570 listen(*endpoint_iterator,ec);
571 }
572
573 /// Set up endpoint for listening on a host and service
574 /**
575 * Bind the internal acceptor using the given host and service. More details
576 * about what host and service can be are available in the Asio
577 * documentation for ip::basic_resolver_query::basic_resolver_query's
578 * constructors.
579 *
580 * The endpoint must have been initialized by calling init_asio before
581 * listening.
582 *
583 * @param host A string identifying a location. May be a descriptive name or
584 * a numeric address string.
585 * @param service A string identifying the requested service. This may be a
586 * descriptive name or a numeric string corresponding to a port number.
587 * @param ec Set to indicate what error occurred, if any.
588 */
589 void listen(std::string const & host, std::string const & service)
590 {
591 lib::error_code ec;
592 listen(host,service,ec);
593 if (ec) { throw exception(ec); }
594 }
595
596 /// Stop listening (exception free)
597 /**
598 * Stop listening and accepting new connections. This will not end any
599 * existing connections.
600 *
601 * @since 0.3.0-alpha4
602 * @param ec A status code indicating an error, if any.
603 */
604 void stop_listening(lib::error_code & ec) {
605 if (m_state != LISTENING) {
606 m_elog->write(log::elevel::library,
607 "asio::listen called from the wrong state");
608 using websocketpp::error::make_error_code;
609 ec = make_error_code(websocketpp::error::invalid_state);
610 return;
611 }
612
613 m_acceptor->close();
614 m_state = READY;
615 ec = lib::error_code();
616 }
617
618 /// Stop listening
619 /**
620 * Stop listening and accepting new connections. This will not end any
621 * existing connections.
622 *
623 * @since 0.3.0-alpha4
624 */
626 lib::error_code ec;
627 stop_listening(ec);
628 if (ec) { throw exception(ec); }
629 }
630
631 /// Check if the endpoint is listening
632 /**
633 * @return Whether or not the endpoint is listening.
634 */
635 bool is_listening() const {
636 return (m_state == LISTENING);
637 }
638
639 /// wraps the run method of the internal io_service object
640 std::size_t run() {
641 return m_io_service->run();
642 }
643
644 /// wraps the run_one method of the internal io_service object
645 /**
646 * @since 0.3.0-alpha4
647 */
648 std::size_t run_one() {
649 return m_io_service->run_one();
650 }
651
652 /// wraps the stop method of the internal io_service object
653 void stop() {
654 m_io_service->stop();
655 }
656
657 /// wraps the poll method of the internal io_service object
658 std::size_t poll() {
659 return m_io_service->poll();
660 }
661
662 /// wraps the poll_one method of the internal io_service object
663 std::size_t poll_one() {
664 return m_io_service->poll_one();
665 }
666
667 /// wraps the reset method of the internal io_service object
668 void reset() {
669 m_io_service->reset();
670 }
671
672 /// wraps the stopped method of the internal io_service object
673 bool stopped() const {
674 return m_io_service->stopped();
675 }
676
677 /// Marks the endpoint as perpetual, stopping it from exiting when empty
678 /**
679 * Marks the endpoint as perpetual. Perpetual endpoints will not
680 * automatically exit when they run out of connections to process. To stop
681 * a perpetual endpoint call `end_perpetual`.
682 *
683 * An endpoint may be marked perpetual at any time by any thread. It must be
684 * called either before the endpoint has run out of work or before it was
685 * started
686 *
687 * @since 0.3.0
688 */
690 m_work.reset(new lib::asio::io_service::work(*m_io_service));
691 }
692
693 /// Clears the endpoint's perpetual flag, allowing it to exit when empty
694 /**
695 * Clears the endpoint's perpetual flag. This will cause the endpoint's run
696 * method to exit normally when it runs out of connections. If there are
697 * currently active connections it will not end until they are complete.
698 *
699 * @since 0.3.0
700 */
702 m_work.reset();
703 }
704
705 /// Call back a function after a period of time.
706 /**
707 * Sets a timer that calls back a function after the specified period of
708 * milliseconds. Returns a handle that can be used to cancel the timer.
709 * A cancelled timer will return the error code error::operation_aborted
710 * A timer that expired will return no error.
711 *
712 * @param duration Length of time to wait in milliseconds
713 * @param callback The function to call back when the timer has expired
714 * @return A handle that can be used to cancel the timer if it is no longer
715 * needed.
716 */
717 timer_ptr set_timer(long duration, timer_handler callback) {
718 timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
719 *m_io_service,
720 lib::asio::milliseconds(duration)
721 );
722
723 new_timer->async_wait(
724 lib::bind(
726 this,
727 new_timer,
728 callback,
729 lib::placeholders::_1
730 )
731 );
732
733 return new_timer;
734 }
735
736 /// Timer handler
737 /**
738 * The timer pointer is included to ensure the timer isn't destroyed until
739 * after it has expired.
740 *
741 * @param t Pointer to the timer in question
742 * @param callback The function to call back
743 * @param ec A status code indicating an error, if any.
744 */
746 lib::asio::error_code const & ec)
747 {
748 if (ec) {
749 if (ec == lib::asio::error::operation_aborted) {
750 callback(make_error_code(transport::error::operation_aborted));
751 } else {
752 m_elog->write(log::elevel::info,
753 "asio handle_timer error: "+ec.message());
754 log_err(log::elevel::info,"asio handle_timer",ec);
755 callback(socket_con_type::translate_ec(ec));
756 }
757 } else {
758 callback(lib::error_code());
759 }
760 }
761
762 /// Accept the next connection attempt and assign it to con (exception free)
763 /**
764 * @param tcon The connection to accept into.
765 * @param callback The function to call when the operation is complete.
766 * @param ec A status code indicating an error, if any.
767 */
769 lib::error_code & ec)
770 {
771 if (m_state != LISTENING || !m_acceptor) {
772 using websocketpp::error::make_error_code;
774 return;
775 }
776
777 m_alog->write(log::alevel::devel, "asio::async_accept");
778
779 if (config::enable_multithreading) {
780 m_acceptor->async_accept(
781 tcon->get_raw_socket(),
782 tcon->get_strand()->wrap(lib::bind(
783 &type::handle_accept,
784 this,
785 callback,
786 lib::placeholders::_1
787 ))
788 );
789 } else {
790 m_acceptor->async_accept(
791 tcon->get_raw_socket(),
792 lib::bind(
793 &type::handle_accept,
794 this,
795 callback,
796 lib::placeholders::_1
797 )
798 );
799 }
800 }
801
802 /// Accept the next connection attempt and assign it to con.
803 /**
804 * @param tcon The connection to accept into.
805 * @param callback The function to call when the operation is complete.
806 */
808 lib::error_code ec;
809 async_accept(tcon,callback,ec);
810 if (ec) { throw exception(ec); }
811 }
812protected:
813 /// Initialize logging
814 /**
815 * The loggers are located in the main endpoint class. As such, the
816 * transport doesn't have direct access to them. This method is called
817 * by the endpoint constructor to allow shared logging from the transport
818 * component. These are raw pointers to member variables of the endpoint.
819 * In particular, they cannot be used in the transport constructor as they
820 * haven't been constructed yet, and cannot be used in the transport
821 * destructor as they will have been destroyed by then.
822 */
823 void init_logging(const lib::shared_ptr<alog_type>& a, const lib::shared_ptr<elog_type>& e) {
824 m_alog = a;
825 m_elog = e;
826 }
827
828 void handle_accept(accept_handler callback, lib::asio::error_code const &
829 asio_ec)
830 {
831 lib::error_code ret_ec;
832
833 m_alog->write(log::alevel::devel, "asio::handle_accept");
834
835 if (asio_ec) {
836 if (asio_ec == lib::asio::errc::operation_canceled) {
837 ret_ec = make_error_code(websocketpp::error::operation_canceled);
838 } else {
839 log_err(log::elevel::info,"asio handle_accept",asio_ec);
840 ret_ec = socket_con_type::translate_ec(asio_ec);
841 }
842 }
843
844 callback(ret_ec);
845 }
846
847 /// Initiate a new connection
848 // TODO: there have to be some more failure conditions here
850 using namespace lib::asio::ip;
851
852 // Create a resolver
853 if (!m_resolver) {
854 m_resolver.reset(new lib::asio::ip::tcp::resolver(*m_io_service));
855 }
856
857 tcon->set_uri(u);
858
859 std::string proxy = tcon->get_proxy();
860 std::string host;
861 std::string port;
862
863 if (proxy.empty()) {
864 host = u->get_host();
865 port = u->get_port_str();
866 } else {
867 lib::error_code ec;
868
869 uri_ptr pu = lib::make_shared<uri>(proxy);
870
871 if (!pu->get_valid()) {
873 return;
874 }
875
876 ec = tcon->proxy_init(u->get_authority());
877 if (ec) {
878 cb(ec);
879 return;
880 }
881
882 host = pu->get_host();
883 port = pu->get_port_str();
884 }
885
886 tcp::resolver::query query(host,port);
887
888 if (m_alog->static_test(log::alevel::devel)) {
889 m_alog->write(log::alevel::devel,
890 "starting async DNS resolve for "+host+":"+port);
891 }
892
893 timer_ptr dns_timer;
894
895 dns_timer = tcon->set_timer(
896 config::timeout_dns_resolve,
897 lib::bind(
899 this,
900 dns_timer,
901 cb,
902 lib::placeholders::_1
903 )
904 );
905
906 if (config::enable_multithreading) {
907 m_resolver->async_resolve(
908 query,
909 tcon->get_strand()->wrap(lib::bind(
910 &type::handle_resolve,
911 this,
912 tcon,
913 dns_timer,
914 cb,
915 lib::placeholders::_1,
916 lib::placeholders::_2
917 ))
918 );
919 } else {
920 m_resolver->async_resolve(
921 query,
922 lib::bind(
923 &type::handle_resolve,
924 this,
925 tcon,
926 dns_timer,
927 cb,
928 lib::placeholders::_1,
929 lib::placeholders::_2
930 )
931 );
932 }
933 }
934
935 /// DNS resolution timeout handler
936 /**
937 * The timer pointer is included to ensure the timer isn't destroyed until
938 * after it has expired.
939 *
940 * @param dns_timer Pointer to the timer in question
941 * @param callback The function to call back
942 * @param ec A status code indicating an error, if any.
943 */
945 lib::error_code const & ec)
946 {
947 lib::error_code ret_ec;
948
949 if (ec) {
951 m_alog->write(log::alevel::devel,
952 "asio handle_resolve_timeout timer cancelled");
953 return;
954 }
955
956 log_err(log::elevel::devel,"asio handle_resolve_timeout",ec);
957 ret_ec = ec;
958 } else {
959 ret_ec = make_error_code(transport::error::timeout);
960 }
961
962 m_alog->write(log::alevel::devel,"DNS resolution timed out");
963 m_resolver->cancel();
964 callback(ret_ec);
965 }
966
967 void handle_resolve(transport_con_ptr tcon, timer_ptr dns_timer,
968 connect_handler callback, lib::asio::error_code const & ec,
969 lib::asio::ip::tcp::resolver::iterator iterator)
970 {
971 if (ec == lib::asio::error::operation_aborted ||
972 lib::asio::is_neg(dns_timer->expires_from_now()))
973 {
974 m_alog->write(log::alevel::devel,"async_resolve cancelled");
975 return;
976 }
977
978 dns_timer->cancel();
979
980 if (ec) {
981 log_err(log::elevel::info,"asio async_resolve",ec);
982 callback(socket_con_type::translate_ec(ec));
983 return;
984 }
985
986 if (m_alog->static_test(log::alevel::devel)) {
987 std::stringstream s;
988 s << "Async DNS resolve successful. Results: ";
989
990 lib::asio::ip::tcp::resolver::iterator it, end;
991 for (it = iterator; it != end; ++it) {
992 s << (*it).endpoint() << " ";
993 }
994
995 m_alog->write(log::alevel::devel,s.str());
996 }
997
998 m_alog->write(log::alevel::devel,"Starting async connect");
999
1000 timer_ptr con_timer;
1001
1002 con_timer = tcon->set_timer(
1003 config::timeout_connect,
1004 lib::bind(
1006 this,
1007 tcon,
1008 con_timer,
1009 callback,
1010 lib::placeholders::_1
1011 )
1012 );
1013
1014 if (config::enable_multithreading) {
1015 lib::asio::async_connect(
1016 tcon->get_raw_socket(),
1017 iterator,
1018 tcon->get_strand()->wrap(lib::bind(
1019 &type::handle_connect,
1020 this,
1021 tcon,
1022 con_timer,
1023 callback,
1024 lib::placeholders::_1
1025 ))
1026 );
1027 } else {
1028 lib::asio::async_connect(
1029 tcon->get_raw_socket(),
1030 iterator,
1031 lib::bind(
1032 &type::handle_connect,
1033 this,
1034 tcon,
1035 con_timer,
1036 callback,
1037 lib::placeholders::_1
1038 )
1039 );
1040 }
1041 }
1042
1043 /// Asio connect timeout handler
1044 /**
1045 * The timer pointer is included to ensure the timer isn't destroyed until
1046 * after it has expired.
1047 *
1048 * @param tcon Pointer to the transport connection that is being connected
1049 * @param con_timer Pointer to the timer in question
1050 * @param callback The function to call back
1051 * @param ec A status code indicating an error, if any.
1052 */
1054 connect_handler callback, lib::error_code const & ec)
1055 {
1056 lib::error_code ret_ec;
1057
1058 if (ec) {
1060 m_alog->write(log::alevel::devel,
1061 "asio handle_connect_timeout timer cancelled");
1062 return;
1063 }
1064
1065 log_err(log::elevel::devel,"asio handle_connect_timeout",ec);
1066 ret_ec = ec;
1067 } else {
1068 ret_ec = make_error_code(transport::error::timeout);
1069 }
1070
1071 m_alog->write(log::alevel::devel,"TCP connect timed out");
1072 tcon->cancel_socket_checked();
1073 callback(ret_ec);
1074 }
1075
1076 void handle_connect(transport_con_ptr tcon, timer_ptr con_timer,
1077 connect_handler callback, lib::asio::error_code const & ec)
1078 {
1079 if (ec == lib::asio::error::operation_aborted ||
1080 lib::asio::is_neg(con_timer->expires_from_now()))
1081 {
1082 m_alog->write(log::alevel::devel,"async_connect cancelled");
1083 return;
1084 }
1085
1086 con_timer->cancel();
1087
1088 if (ec) {
1089 log_err(log::elevel::info,"asio async_connect",ec);
1090 callback(socket_con_type::translate_ec(ec));
1091 return;
1092 }
1093
1094 if (m_alog->static_test(log::alevel::devel)) {
1095 m_alog->write(log::alevel::devel,
1096 "Async connect to "+tcon->get_remote_endpoint()+" successful.");
1097 }
1098
1099 callback(lib::error_code());
1100 }
1101
1102 /// Initialize a connection
1103 /**
1104 * init is called by an endpoint once for each newly created connection.
1105 * It's purpose is to give the transport policy the chance to perform any
1106 * transport specific initialization that couldn't be done via the default
1107 * constructor.
1108 *
1109 * @param tcon A pointer to the transport portion of the connection.
1110 *
1111 * @return A status code indicating the success or failure of the operation
1112 */
1113 lib::error_code init(transport_con_ptr tcon) {
1114 m_alog->write(log::alevel::devel, "transport::asio::init");
1115
1116 // Initialize the connection socket component
1117 socket_type::init(lib::static_pointer_cast<socket_con_type,
1118 transport_con_type>(tcon));
1119
1120 lib::error_code ec;
1121
1122 ec = tcon->init_asio(m_io_service);
1123 if (ec) {return ec;}
1124
1125 tcon->set_tcp_pre_init_handler(m_tcp_pre_init_handler);
1126 tcon->set_tcp_post_init_handler(m_tcp_post_init_handler);
1127
1128 return lib::error_code();
1129 }
1130private:
1131 /// Convenience method for logging the code and message for an error_code
1132 template <typename error_type>
1133 void log_err(log::level l, char const * msg, error_type const & ec) {
1134 std::stringstream s;
1135 s << msg << " error: " << ec << " (" << ec.message() << ")";
1136 m_elog->write(l,s.str());
1137 }
1138
1139 /// Helper for cleaning up in the listen method after an error
1140 template <typename error_type>
1141 lib::error_code clean_up_listen_after_error(error_type const & ec) {
1142 if (m_acceptor->is_open()) {
1143 m_acceptor->close();
1144 }
1145 log_err(log::elevel::info,"asio listen",ec);
1146 return socket_con_type::translate_ec(ec);
1147 }
1148
1149 enum state {
1150 UNINITIALIZED = 0,
1151 READY = 1,
1152 LISTENING = 2
1153 };
1154
1155 // Handlers
1156 tcp_pre_bind_handler m_tcp_pre_bind_handler;
1157 tcp_init_handler m_tcp_pre_init_handler;
1158 tcp_init_handler m_tcp_post_init_handler;
1159
1160 // Network Resources
1161 io_service_ptr m_io_service;
1162 bool m_external_io_service;
1163 acceptor_ptr m_acceptor;
1164 resolver_ptr m_resolver;
1165 work_ptr m_work;
1166
1167 // Network constants
1168 int m_listen_backlog;
1169 bool m_reuse_addr;
1170
1171 lib::shared_ptr<elog_type> m_elog;
1172 lib::shared_ptr<alog_type> m_alog;
1173
1174 // Transport state
1175 state m_state;
1176};
1177
1178} // namespace asio
1179} // namespace transport
1180} // namespace websocketpp
1181
1182#endif // WEBSOCKETPP_TRANSPORT_ASIO_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 pool.hpp:101
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.
Asio based endpoint transport component.
Definition base.hpp:143
std::size_t run_one()
wraps the run_one method of the internal io_service object
Definition endpoint.hpp:648
void stop_listening(lib::error_code &ec)
Stop listening (exception free)
Definition endpoint.hpp:604
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition endpoint.hpp:60
asio::connection< config > transport_con_type
Definition endpoint.hpp:75
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
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
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition endpoint.hpp:69
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
config::socket_type socket_type
Type of the socket policy.
Definition endpoint.hpp:62
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition endpoint.hpp:71
config::elog_type elog_type
Type of the error logging policy.
Definition endpoint.hpp:64
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:78
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
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
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
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition endpoint.hpp:87
lib::asio::io_service & get_io_service()
Retrieve a reference to the endpoint's io_service.
Definition endpoint.hpp:378
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
endpoint< config > type
Type of this endpoint transport component.
Definition endpoint.hpp:57
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition endpoint.hpp:85
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
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition endpoint.hpp:92
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
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition endpoint.hpp:502
lib::asio::io_service * io_service_ptr
Type of a pointer to the ASIO io_service being used.
Definition endpoint.hpp:81
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition endpoint.hpp:288
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 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
config::alog_type alog_type
Type of the access logging policy.
Definition endpoint.hpp:66
bool is_listening() const
Check if the endpoint is listening.
Definition endpoint.hpp:635
void stop_listening()
Stop listening.
Definition endpoint.hpp:625
connection_hdl get_handle() const
Get the connection handle.
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
config::concurrency_type concurrency_type
transport concurrency policy
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.
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)
config::elog_type elog_type
Type of this transport's error logging policy.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
config::alog_type alog_type
Type of this transport's access logging policy.
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)
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.
connection< config > type
Type of this connection transport component.
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:65
void set_write_handler(write_handler h)
Sets the write handler.
Definition endpoint.hpp:134
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition endpoint.hpp:54
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
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:183
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition endpoint.hpp:58
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
iostream::connection< config > transport_con_type
Definition endpoint.hpp:62
void register_ostream(std::ostream *o)
Register a default output stream.
Definition endpoint.hpp:80
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition endpoint.hpp:102
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition endpoint.hpp:56
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition endpoint.hpp:51
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
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
@ invalid_host_service
Invalid host or service.
Definition base.hpp:180
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
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition core.hpp:88
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
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
uint32_t value
Type of a channel type hint value.
Definition levels.hpp:48
static value const access
Access log.
Definition levels.hpp:53
static value const error
Error log.
Definition levels.hpp:55
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