WebSocket++ 0.8.2
C++ websocket client/server library
connection.hpp
1/*
2 * Copyright (c) 2014, Peter Thorson. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution.
11 * * Neither the name of the WebSocket++ Project nor the
12 * names of its contributors may be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 */
27
28#ifndef WEBSOCKETPP_CONNECTION_HPP
29#define WEBSOCKETPP_CONNECTION_HPP
30
31#include <websocketpp/close.hpp>
32#include <websocketpp/error.hpp>
33#include <websocketpp/frame.hpp>
34
35#include <websocketpp/logger/levels.hpp>
36#include <websocketpp/processors/processor.hpp>
37#include <websocketpp/transport/base/connection.hpp>
38#include <websocketpp/http/constants.hpp>
39
40#include <websocketpp/common/connection_hdl.hpp>
41#include <websocketpp/common/cpp11.hpp>
42#include <websocketpp/common/functional.hpp>
43
44#include <queue>
45#include <sstream>
46#include <string>
47#include <vector>
48
49namespace websocketpp {
50
51/// The type and function signature of an open handler
52/**
53 * The open handler is called once for every successful WebSocket connection
54 * attempt. Either the fail handler or the open handler will be called for each
55 * WebSocket connection attempt. HTTP Connections that did not attempt to
56 * upgrade the connection to the WebSocket protocol will trigger the http
57 * handler instead of fail/open.
58 */
59typedef lib::function<void(connection_hdl)> open_handler;
60
61/// The type and function signature of a close handler
62/**
63 * The close handler is called once for every successfully established
64 * connection after it is no longer capable of sending or receiving new messages
65 *
66 * The close handler will be called exactly once for every connection for which
67 * the open handler was called.
68 */
69typedef lib::function<void(connection_hdl)> close_handler;
70
71/// The type and function signature of a fail handler
72/**
73 * The fail handler is called once for every unsuccessful WebSocket connection
74 * attempt. Either the fail handler or the open handler will be called for each
75 * WebSocket connection attempt. HTTP Connections that did not attempt to
76 * upgrade the connection to the WebSocket protocol will trigger the http
77 * handler instead of fail/open.
78 */
79typedef lib::function<void(connection_hdl)> fail_handler;
80
81/// The type and function signature of an interrupt handler
82/**
83 * The interrupt handler is called when a connection receives an interrupt
84 * request from the application. Interrupts allow the application to trigger a
85 * handler to be run in the absense of a WebSocket level handler trigger (like
86 * a new message).
87 *
88 * This is typically used by another application thread to schedule some tasks
89 * that can only be run from within the handler chain for thread safety reasons.
90 */
91typedef lib::function<void(connection_hdl)> interrupt_handler;
92
93/// The type and function signature of a ping handler
94/**
95 * The ping handler is called when the connection receives a WebSocket ping
96 * control frame. The string argument contains the ping payload. The payload is
97 * a binary string up to 126 bytes in length. The ping handler returns a bool,
98 * true if a pong response should be sent, false if the pong response should be
99 * suppressed.
100 */
101typedef lib::function<bool(connection_hdl,std::string)> ping_handler;
102
103/// The type and function signature of a pong handler
104/**
105 * The pong handler is called when the connection receives a WebSocket pong
106 * control frame. The string argument contains the pong payload. The payload is
107 * a binary string up to 126 bytes in length.
108 */
109typedef lib::function<void(connection_hdl,std::string)> pong_handler;
110
111/// The type and function signature of a pong timeout handler
112/**
113 * The pong timeout handler is called when a ping goes unanswered by a pong for
114 * longer than the locally specified timeout period.
115 */
116typedef lib::function<void(connection_hdl,std::string)> pong_timeout_handler;
117
118/// The type and function signature of a validate handler
119/**
120 * The validate handler is called after a WebSocket handshake has been received
121 * and processed but before it has been accepted. This gives the application a
122 * chance to implement connection details specific policies for accepting
123 * connections and the ability to negotiate extensions and subprotocols.
124 *
125 * The validate handler return value indicates whether or not the connection
126 * should be accepted. Additional methods may be called during the function to
127 * set response headers, set HTTP return/error codes, etc.
128 */
129typedef lib::function<bool(connection_hdl)> validate_handler;
130
131/// The type and function signature of a http handler
132/**
133 * The http handler is called when an HTTP connection is made that does not
134 * attempt to upgrade the connection to the WebSocket protocol. This allows
135 * WebSocket++ servers to respond to these requests with regular HTTP responses.
136 *
137 * This can be used to deliver error pages & dashboards and to deliver static
138 * files such as the base HTML & JavaScript for an otherwise single page
139 * WebSocket application.
140 *
141 * Note: WebSocket++ is designed to be a high performance WebSocket server. It
142 * is not tuned to provide a full featured, high performance, HTTP web server
143 * solution. The HTTP handler is appropriate only for low volume HTTP traffic.
144 * If you expect to serve high volumes of HTTP traffic a dedicated HTTP web
145 * server is strongly recommended.
146 *
147 * The default HTTP handler will return a 426 Upgrade Required error. Custom
148 * handlers may override the response status code to deliver any type of
149 * response.
150 */
151typedef lib::function<void(connection_hdl)> http_handler;
152
153//
154typedef lib::function<void(lib::error_code const & ec, size_t bytes_transferred)> read_handler;
155typedef lib::function<void(lib::error_code const & ec)> write_frame_handler;
156
157// constants related to the default WebSocket protocol versions available
158#ifdef _WEBSOCKETPP_INITIALIZER_LISTS_ // simplified C++11 version
159 /// Container that stores the list of protocol versions supported
160 /**
161 * @todo Move this to configs to allow compile/runtime disabling or enabling
162 * of protocol versions
163 */
164 static std::vector<int> const versions_supported = {0,7,8,13};
165#else
166 /// Helper array to get around lack of initializer lists pre C++11
167 static int const helper[] = {0,7,8,13};
168 /// Container that stores the list of protocol versions supported
169 /**
170 * @todo Move this to configs to allow compile/runtime disabling or enabling
171 * of protocol versions
172 */
173 static std::vector<int> const versions_supported(helper,helper+4);
174#endif
175
176namespace session {
177namespace state {
178 // externally visible session state (states based on the RFC)
179 enum value {
180 connecting = 0,
181 open = 1,
182 closing = 2,
183 closed = 3
184 };
185} // namespace state
186
187
188namespace fail {
189namespace status {
190 enum value {
191 GOOD = 0, // no failure yet!
192 SYSTEM = 1, // system call returned error, check that code
193 WEBSOCKET = 2, // websocket close codes contain error
194 UNKNOWN = 3, // No failure information is available
195 TIMEOUT_TLS = 4, // TLS handshake timed out
196 TIMEOUT_WS = 5 // WS handshake timed out
197 };
198} // namespace status
199} // namespace fail
200
201namespace internal_state {
202 // More granular internal states. These are used for multi-threaded
203 // connection synchronization and preventing values that are not yet or no
204 // longer available from being used.
205
206 enum value {
207 USER_INIT = 0,
208 TRANSPORT_INIT = 1,
209 READ_HTTP_REQUEST = 2,
210 WRITE_HTTP_REQUEST = 3,
211 READ_HTTP_RESPONSE = 4,
212 WRITE_HTTP_RESPONSE = 5,
213 PROCESS_HTTP_REQUEST = 6,
214 PROCESS_CONNECTION = 7
215 };
216} // namespace internal_state
217
218
219namespace http_state {
220 // states to keep track of the progress of http connections
221
222 enum value {
223 init = 0,
224 deferred = 1,
225 headers_written = 2,
226 body_written = 3,
227 closed = 4
228 };
229} // namespace http_state
230
231} // namespace session
232
233/// Represents an individual WebSocket connection
234template <typename config>
235class connection
236 : public config::transport_type::transport_con_type
237 , public config::connection_base
238{
239public:
240 /// Type of this connection
241 typedef connection<config> type;
242 /// Type of a shared pointer to this connection
243 typedef lib::shared_ptr<type> ptr;
244 /// Type of a weak pointer to this connection
245 typedef lib::weak_ptr<type> weak_ptr;
246
247 /// Type of the concurrency component of this connection
248 typedef typename config::concurrency_type concurrency_type;
249 /// Type of the access logging policy
250 typedef typename config::alog_type alog_type;
251 /// Type of the error logging policy
252 typedef typename config::elog_type elog_type;
253
254 /// Type of the transport component of this connection
255 typedef typename config::transport_type::transport_con_type
257 /// Type of a shared pointer to the transport component of this connection
258 typedef typename transport_con_type::ptr transport_con_ptr;
259
260 typedef lib::function<void(ptr)> termination_handler;
261
262 typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
263 typedef typename concurrency_type::mutex_type mutex_type;
264
265 typedef typename config::request_type request_type;
266 typedef typename config::response_type response_type;
267
268 typedef typename config::message_type message_type;
269 typedef typename message_type::ptr message_ptr;
270
271 typedef typename config::con_msg_manager_type con_msg_manager_type;
272 typedef typename con_msg_manager_type::ptr con_msg_manager_ptr;
273
274 /// Type of RNG
275 typedef typename config::rng_type rng_type;
276
277 typedef processor::processor<config> processor_type;
278 typedef lib::shared_ptr<processor_type> processor_ptr;
279
280 // Message handler (needs to know message type)
281 typedef lib::function<void(connection_hdl,message_ptr)> message_handler;
282
283 /// Type of a pointer to a transport timer handle
284 typedef typename transport_con_type::timer_ptr timer_ptr;
285
286 // Misc Convenience Types
287 typedef session::internal_state::value istate_type;
288
289private:
290 enum terminate_status {
291 failed = 1,
292 closed,
293 unknown
294 };
295public:
296
297 explicit connection(bool p_is_server, std::string const & ua, const lib::shared_ptr<alog_type>& alog,
298 const lib::shared_ptr<elog_type>& elog, rng_type & rng)
299 : transport_con_type(p_is_server, alog, elog)
300 , m_handle_read_frame(lib::bind(
301 &type::handle_read_frame,
302 this,
303 lib::placeholders::_1,
304 lib::placeholders::_2
305 ))
306 , m_write_frame_handler(lib::bind(
307 &type::handle_write_frame,
308 this,
309 lib::placeholders::_1
310 ))
311 , m_user_agent(ua)
312 , m_open_handshake_timeout_dur(config::timeout_open_handshake)
313 , m_close_handshake_timeout_dur(config::timeout_close_handshake)
314 , m_pong_timeout_dur(config::timeout_pong)
315 , m_max_message_size(config::max_message_size)
316 , m_state(session::state::connecting)
317 , m_internal_state(session::internal_state::USER_INIT)
318 , m_msg_manager(new con_msg_manager_type())
319 , m_send_buffer_size(0)
320 , m_write_flag(false)
321 , m_read_flag(true)
322 , m_is_server(p_is_server)
323 , m_alog(alog)
324 , m_elog(elog)
325 , m_rng(rng)
326 , m_local_close_code(close::status::abnormal_close)
327 , m_remote_close_code(close::status::abnormal_close)
328 , m_is_http(false)
329 , m_http_state(session::http_state::init)
330 , m_was_clean(false)
331 {
332 m_alog->write(log::alevel::devel,"connection constructor");
333 }
334
335 /// Get a shared pointer to this component
336 ptr get_shared() {
337 return lib::static_pointer_cast<type>(transport_con_type::get_shared());
338 }
339
340 ///////////////////////////
341 // Set Handler Callbacks //
342 ///////////////////////////
343
344 /// Set open handler
345 /**
346 * The open handler is called after the WebSocket handshake is complete and
347 * the connection is considered OPEN.
348 *
349 * @param h The new open_handler
350 */
352 m_open_handler = h;
353 }
354
355 /// Set close handler
356 /**
357 * The close handler is called immediately after the connection is closed.
358 *
359 * @param h The new close_handler
360 */
362 m_close_handler = h;
363 }
364
365 /// Set fail handler
366 /**
367 * The fail handler is called whenever the connection fails while the
368 * handshake is bring processed.
369 *
370 * @param h The new fail_handler
371 */
373 m_fail_handler = h;
374 }
375
376 /// Set ping handler
377 /**
378 * The ping handler is called whenever the connection receives a ping
379 * control frame. The ping payload is included.
380 *
381 * The ping handler's return time controls whether or not a pong is
382 * sent in response to this ping. Returning false will suppress the
383 * return pong. If no ping handler is set a pong will be sent.
384 *
385 * @param h The new ping_handler
386 */
388 m_ping_handler = h;
389 }
390
391 /// Set pong handler
392 /**
393 * The pong handler is called whenever the connection receives a pong
394 * control frame. The pong payload is included.
395 *
396 * @param h The new pong_handler
397 */
399 m_pong_handler = h;
400 }
401
402 /// Set pong timeout handler
403 /**
404 * If the transport component being used supports timers, the pong timeout
405 * handler is called whenever a pong control frame is not received with the
406 * configured timeout period after the application sends a ping.
407 *
408 * The config setting `timeout_pong` controls the length of the timeout
409 * period. It is specified in milliseconds.
410 *
411 * This can be used to probe the health of the remote endpoint's WebSocket
412 * implementation. This does not guarantee that the remote application
413 * itself is still healthy but can be a useful diagnostic.
414 *
415 * Note: receipt of this callback doesn't mean the pong will never come.
416 * This functionality will not suppress delivery of the pong in question
417 * should it arrive after the timeout.
418 *
419 * @param h The new pong_timeout_handler
420 */
422 m_pong_timeout_handler = h;
423 }
424
425 /// Set interrupt handler
426 /**
427 * The interrupt handler is called whenever the connection is manually
428 * interrupted by the application.
429 *
430 * @param h The new interrupt_handler
431 */
433 m_interrupt_handler = h;
434 }
435
436 /// Set http handler
437 /**
438 * The http handler is called after an HTTP request other than a WebSocket
439 * upgrade request is received. It allows a WebSocket++ server to respond
440 * to regular HTTP requests on the same port as it processes WebSocket
441 * connections. This can be useful for hosting error messages, flash
442 * policy files, status pages, and other simple HTTP responses. It is not
443 * intended to be used as a primary web server.
444 *
445 * @param h The new http_handler
446 */
448 m_http_handler = h;
449 }
450
451 /// Set validate handler
452 /**
453 * The validate handler is called after a WebSocket handshake has been
454 * parsed but before a response is returned. It provides the application
455 * a chance to examine the request and determine whether or not it wants
456 * to accept the connection.
457 *
458 * Returning false from the validate handler will reject the connection.
459 * If no validate handler is present, all connections will be allowed.
460 *
461 * @param h The new validate_handler
462 */
464 m_validate_handler = h;
465 }
466
467 /// Set message handler
468 /**
469 * The message handler is called after a new message has been received.
470 *
471 * @param h The new message_handler
472 */
473 void set_message_handler(message_handler h) {
474 m_message_handler = h;
475 }
476
477 //////////////////////////////////////////
478 // Connection timeouts and other limits //
479 //////////////////////////////////////////
480
481 /// Set open handshake timeout
482 /**
483 * Sets the length of time the library will wait after an opening handshake
484 * has been initiated before cancelling it. This can be used to prevent
485 * excessive wait times for outgoing clients or excessive resource usage
486 * from broken clients or DoS attacks on servers.
487 *
488 * Connections that time out will have their fail handlers called with the
489 * open_handshake_timeout error code.
490 *
491 * The default value is specified via the compile time config value
492 * 'timeout_open_handshake'. The default value in the core config
493 * is 5000ms. A value of 0 will disable the timer entirely.
494 *
495 * To be effective, the transport you are using must support timers. See
496 * the documentation for your transport policy for details about its
497 * timer support.
498 *
499 * @param dur The length of the open handshake timeout in ms
500 */
501 void set_open_handshake_timeout(long dur) {
502 m_open_handshake_timeout_dur = dur;
503 }
504
505 /// Set close handshake timeout
506 /**
507 * Sets the length of time the library will wait after a closing handshake
508 * has been initiated before cancelling it. This can be used to prevent
509 * excessive wait times for outgoing clients or excessive resource usage
510 * from broken clients or DoS attacks on servers.
511 *
512 * Connections that time out will have their close handlers called with the
513 * close_handshake_timeout error code.
514 *
515 * The default value is specified via the compile time config value
516 * 'timeout_close_handshake'. The default value in the core config
517 * is 5000ms. A value of 0 will disable the timer entirely.
518 *
519 * To be effective, the transport you are using must support timers. See
520 * the documentation for your transport policy for details about its
521 * timer support.
522 *
523 * @param dur The length of the close handshake timeout in ms
524 */
525 void set_close_handshake_timeout(long dur) {
526 m_close_handshake_timeout_dur = dur;
527 }
528
529 /// Set pong timeout
530 /**
531 * Sets the length of time the library will wait for a pong response to a
532 * ping. This can be used as a keepalive or to detect broken connections.
533 *
534 * Pong responses that time out will have the pong timeout handler called.
535 *
536 * The default value is specified via the compile time config value
537 * 'timeout_pong'. The default value in the core config
538 * is 5000ms. A value of 0 will disable the timer entirely.
539 *
540 * To be effective, the transport you are using must support timers. See
541 * the documentation for your transport policy for details about its
542 * timer support.
543 *
544 * @param dur The length of the pong timeout in ms
545 */
546 void set_pong_timeout(long dur) {
547 m_pong_timeout_dur = dur;
548 }
549
550 /// Get maximum message size
551 /**
552 * Get maximum message size. Maximum message size determines the point at
553 * which the connection will fail with the message_too_big protocol error.
554 *
555 * The default is set by the endpoint that creates the connection.
556 *
557 * @since 0.3.0
558 */
560 return m_max_message_size;
561 }
562
563 /// Set maximum message size
564 /**
565 * Set maximum message size. Maximum message size determines the point at
566 * which the connection will fail with the message_too_big protocol error.
567 * This value may be changed during the connection.
568 *
569 * The default is set by the endpoint that creates the connection.
570 *
571 * @since 0.3.0
572 *
573 * @param new_value The value to set as the maximum message size.
574 */
575 void set_max_message_size(size_t new_value) {
576 m_max_message_size = new_value;
577 if (m_processor) {
578 m_processor->set_max_message_size(new_value);
579 }
580 }
581
582 /// Get maximum HTTP message body size
583 /**
584 * Get maximum HTTP message body size. Maximum message body size determines
585 * the point at which the connection will stop reading an HTTP request whose
586 * body is too large.
587 *
588 * The default is set by the endpoint that creates the connection.
589 *
590 * @since 0.5.0
591 *
592 * @return The maximum HTTP message body size
593 */
595 return m_request.get_max_body_size();
596 }
597
598 /// Set maximum HTTP message body size
599 /**
600 * Set maximum HTTP message body size. Maximum message body size determines
601 * the point at which the connection will stop reading an HTTP request whose
602 * body is too large.
603 *
604 * The default is set by the endpoint that creates the connection.
605 *
606 * @since 0.5.0
607 *
608 * @param new_value The value to set as the maximum message size.
609 */
610 void set_max_http_body_size(size_t new_value) {
611 m_request.set_max_body_size(new_value);
612 }
613
614 //////////////////////////////////
615 // Uncategorized public methods //
616 //////////////////////////////////
617
618 /// Get the size of the outgoing write buffer (in payload bytes)
619 /**
620 * Retrieves the number of bytes in the outgoing write buffer that have not
621 * already been dispatched to the transport layer. This represents the bytes
622 * that are presently cancelable without uncleanly ending the websocket
623 * connection
624 *
625 * This method invokes the m_write_lock mutex
626 *
627 * @return The current number of bytes in the outgoing send buffer.
628 */
630
631 /// Get the size of the outgoing write buffer (in payload bytes)
632 /**
633 * @deprecated use `get_buffered_amount` instead
634 */
635 size_t buffered_amount() const {
636 return get_buffered_amount();
637 }
638
639 ////////////////////
640 // Action Methods //
641 ////////////////////
642
643 /// Create a message and then add it to the outgoing send queue
644 /**
645 * Convenience method to send a message given a payload string and
646 * optionally an opcode. Default opcode is utf8 text.
647 *
648 * This method locks the m_write_lock mutex
649 *
650 * @param payload The payload string to generated the message with
651 *
652 * @param op The opcode to generated the message with. Default is
653 * frame::opcode::text
654 */
655 lib::error_code send(std::string const & payload, frame::opcode::value op =
656 frame::opcode::text);
657
658 /// Send a message (raw array overload)
659 /**
660 * Convenience method to send a message given a raw array and optionally an
661 * opcode. Default opcode is binary.
662 *
663 * This method locks the m_write_lock mutex
664 *
665 * @param payload A pointer to the array containing the bytes to send.
666 *
667 * @param len Length of the array.
668 *
669 * @param op The opcode to generated the message with. Default is
670 * frame::opcode::binary
671 */
672 lib::error_code send(void const * payload, size_t len, frame::opcode::value
673 op = frame::opcode::binary);
674
675 /// Add a message to the outgoing send queue
676 /**
677 * If presented with a prepared message it is added without validation or
678 * framing. If presented with an unprepared message it is validated, framed,
679 * and then added
680 *
681 * Errors are returned via an exception
682 * \todo make exception system_error rather than error_code
683 *
684 * This method invokes the m_write_lock mutex
685 *
686 * @param msg A message_ptr to the message to send.
687 */
688 lib::error_code send(message_ptr msg);
689
690 /// Asyncronously invoke handler::on_inturrupt
691 /**
692 * Signals to the connection to asyncronously invoke the on_inturrupt
693 * callback for this connection's handler once it is safe to do so.
694 *
695 * When the on_inturrupt handler callback is called it will be from
696 * within the transport event loop with all the thread safety features
697 * guaranteed by the transport to regular handlers
698 *
699 * Multiple inturrupt signals can be active at once on the same connection
700 *
701 * @return An error code
702 */
703 lib::error_code interrupt();
704
705 /// Transport inturrupt callback
706 void handle_interrupt();
707
708 /// Pause reading of new data
709 /**
710 * Signals to the connection to halt reading of new data. While reading is paused,
711 * the connection will stop reading from its associated socket. In turn this will
712 * result in TCP based flow control kicking in and slowing data flow from the remote
713 * endpoint.
714 *
715 * This is useful for applications that push new requests to a queue to be processed
716 * by another thread and need a way to signal when their request queue is full without
717 * blocking the network processing thread.
718 *
719 * Use `resume_reading()` to resume.
720 *
721 * If supported by the transport this is done asynchronously. As such reading may not
722 * stop until the current read operation completes. Typically you can expect to
723 * receive no more bytes after initiating a read pause than the size of the read
724 * buffer.
725 *
726 * If reading is paused for this connection already nothing is changed.
727 */
729
730 /// Pause reading callback
732
733 /// Resume reading of new data
734 /**
735 * Signals to the connection to resume reading of new data after it was paused by
736 * `pause_reading()`.
737 *
738 * If reading is not paused for this connection already nothing is changed.
739 */
741
742 /// Resume reading callback
744
745 /// Send a ping
746 /**
747 * Initiates a ping with the given payload/
748 *
749 * There is no feedback directly from ping except in cases of immediately
750 * detectable errors. Feedback will be provided via on_pong or
751 * on_pong_timeout callbacks.
752 *
753 * Ping locks the m_write_lock mutex
754 *
755 * @param payload Payload to be used for the ping
756 */
757 void ping(std::string const & payload);
758
759 /// exception free variant of ping
760 void ping(std::string const & payload, lib::error_code & ec);
761
762 /// Utility method that gets called back when the ping timer expires
763 void handle_pong_timeout(std::string payload, lib::error_code const & ec);
764
765 /// Send a pong
766 /**
767 * Initiates a pong with the given payload.
768 *
769 * There is no feedback from a pong once sent.
770 *
771 * Pong locks the m_write_lock mutex
772 *
773 * @param payload Payload to be used for the pong
774 */
775 void pong(std::string const & payload);
776
777 /// exception free variant of pong
778 void pong(std::string const & payload, lib::error_code & ec);
779
780 /// Close the connection
781 /**
782 * Initiates the close handshake process.
783 *
784 * If close returns successfully the connection will be in the closing
785 * state and no additional messages may be sent. All messages sent prior
786 * to calling close will be written out before the connection is closed.
787 *
788 * If no reason is specified none will be sent. If no code is specified
789 * then no code will be sent.
790 *
791 * The handler's on_close callback will be called once the close handshake
792 * is complete.
793 *
794 * Reasons will be automatically truncated to the maximum length (123 bytes)
795 * if necessary.
796 *
797 * @param code The close code to send
798 * @param reason The close reason to send
799 */
800 void close(close::status::value const code, std::string const & reason);
801
802 /// exception free variant of close
803 void close(close::status::value const code, std::string const & reason,
804 lib::error_code & ec);
805
806 ////////////////////////////////////////////////
807 // Pass-through access to the uri information //
808 ////////////////////////////////////////////////
809
810 /// Returns the secure flag from the connection URI
811 /**
812 * This value is available after the HTTP request has been fully read and
813 * may be called from any thread.
814 *
815 * @return Whether or not the connection URI is flagged secure.
816 */
817 bool get_secure() const;
818
819 /// Returns the host component of the connection URI
820 /**
821 * This value is available after the HTTP request has been fully read and
822 * may be called from any thread.
823 *
824 * @return The host component of the connection URI
825 */
826 std::string const & get_host() const;
827
828 /// Returns the resource component of the connection URI
829 /**
830 * This value is available after the HTTP request has been fully read and
831 * may be called from any thread.
832 *
833 * @return The resource component of the connection URI
834 */
835 std::string const & get_resource() const;
836
837 /// Returns the port component of the connection URI
838 /**
839 * This value is available after the HTTP request has been fully read and
840 * may be called from any thread.
841 *
842 * @return The port component of the connection URI
843 */
844 uint16_t get_port() const;
845
846 /// Gets the connection URI
847 /**
848 * This should really only be called by internal library methods unless you
849 * really know what you are doing.
850 *
851 * @return A pointer to the connection's URI
852 */
853 uri_ptr get_uri() const;
854
855 /// Sets the connection URI
856 /**
857 * This should really only be called by internal library methods unless you
858 * really know what you are doing.
859 *
860 * @param uri The new URI to set
861 */
862 void set_uri(uri_ptr uri);
863
864 /////////////////////////////
865 // Subprotocol negotiation //
866 /////////////////////////////
867
868 /// Gets the negotated subprotocol
869 /**
870 * Retrieves the subprotocol that was negotiated during the handshake. This
871 * method is valid in the open handler and later.
872 *
873 * @return The negotiated subprotocol
874 */
875 std::string const & get_subprotocol() const;
876
877 /// Gets all of the subprotocols requested by the client
878 /**
879 * Retrieves the subprotocols that were requested during the handshake. This
880 * method is valid in the validate handler and later.
881 *
882 * @return A vector of the requested subprotocol
883 */
885
886 /// Adds the given subprotocol string to the request list (exception free)
887 /**
888 * Adds a subprotocol to the list to send with the opening handshake. This
889 * may be called multiple times to request more than one. If the server
890 * supports one of these, it may choose one. If so, it will return it
891 * in it's handshake reponse and the value will be available via
892 * get_subprotocol(). Subprotocol requests should be added in order of
893 * preference.
894 *
895 * @param request The subprotocol to request
896 * @param ec A reference to an error code that will be filled in the case of
897 * errors
898 */
899 void add_subprotocol(std::string const & request, lib::error_code & ec);
900
901 /// Adds the given subprotocol string to the request list
902 /**
903 * Adds a subprotocol to the list to send with the opening handshake. This
904 * may be called multiple times to request more than one. If the server
905 * supports one of these, it may choose one. If so, it will return it
906 * in it's handshake reponse and the value will be available via
907 * get_subprotocol(). Subprotocol requests should be added in order of
908 * preference.
909 *
910 * @param request The subprotocol to request
911 */
912 void add_subprotocol(std::string const & request);
913
914 /// Select a subprotocol to use (exception free)
915 /**
916 * Indicates which subprotocol should be used for this connection. Valid
917 * only during the validate handler callback. Subprotocol selected must have
918 * been requested by the client. Consult get_requested_subprotocols() for a
919 * list of valid subprotocols.
920 *
921 * This member function is valid on server endpoints/connections only
922 *
923 * @param value The subprotocol to select
924 * @param ec A reference to an error code that will be filled in the case of
925 * errors
926 */
927 void select_subprotocol(std::string const & value, lib::error_code & ec);
928
929 /// Select a subprotocol to use
930 /**
931 * Indicates which subprotocol should be used for this connection. Valid
932 * only during the validate handler callback. Subprotocol selected must have
933 * been requested by the client. Consult get_requested_subprotocols() for a
934 * list of valid subprotocols.
935 *
936 * This member function is valid on server endpoints/connections only
937 *
938 * @param value The subprotocol to select
939 */
940 void select_subprotocol(std::string const & value);
941
942 /////////////////////////////////////////////////////////////
943 // Pass-through access to the request and response objects //
944 /////////////////////////////////////////////////////////////
945
946 /// Retrieve a request header
947 /**
948 * Retrieve the value of a header from the handshake HTTP request.
949 *
950 * @param key Name of the header to get
951 * @return The value of the header
952 */
953 std::string const & get_request_header(std::string const & key) const;
954
955 /// Retrieve a request body
956 /**
957 * Retrieve the value of the request body. This value is typically used with
958 * PUT and POST requests to upload files or other data. Only HTTP
959 * connections will ever have bodies. WebSocket connection's will always
960 * have blank bodies.
961 *
962 * @return The value of the request body.
963 */
964 std::string const & get_request_body() const;
965
966 /// Retrieve a response header
967 /**
968 * Retrieve the value of a header from the handshake HTTP request.
969 *
970 * @param key Name of the header to get
971 * @return The value of the header
972 */
973 std::string const & get_response_header(std::string const & key) const;
974
975 /// Get response HTTP status code
976 /**
977 * Gets the response status code
978 *
979 * @since 0.7.0
980 *
981 * @return The response status code sent
982 */
983 http::status_code::value get_response_code() const {
984 return m_response.get_status_code();
985 }
986
987 /// Get response HTTP status message
988 /**
989 * Gets the response status message
990 *
991 * @since 0.7.0
992 *
993 * @return The response status message sent
994 */
995 std::string const & get_response_msg() const {
996 return m_response.get_status_msg();
997 }
998
999 /// Set response status code and message
1000 /**
1001 * Sets the response status code to `code` and looks up the corresponding
1002 * message for standard codes. Non-standard codes will be entered as Unknown
1003 * use set_status(status_code::value,std::string) overload to set both
1004 * values explicitly.
1005 *
1006 * This member function is valid only from the http() and validate() handler
1007 * callbacks.
1008 *
1009 * @param code Code to set
1010 * @param msg Message to set
1011 * @see websocketpp::http::response::set_status
1012 */
1013 void set_status(http::status_code::value code);
1014
1015 /// Set response status code and message
1016 /**
1017 * Sets the response status code and message to independent custom values.
1018 * use set_status(status_code::value) to set the code and have the standard
1019 * message be automatically set.
1020 *
1021 * This member function is valid only from the http() and validate() handler
1022 * callbacks.
1023 *
1024 * @param code Code to set
1025 * @param msg Message to set
1026 * @see websocketpp::http::response::set_status
1027 */
1028 void set_status(http::status_code::value code, std::string const & msg);
1029
1030 /// Set response body content
1031 /**
1032 * Set the body content of the HTTP response to the parameter string. Note
1033 * set_body will also set the Content-Length HTTP header to the appropriate
1034 * value. If you want the Content-Length header to be something else set it
1035 * to something else after calling set_body
1036 *
1037 * This member function is valid only from the http() and validate() handler
1038 * callbacks.
1039 *
1040 * @param value String data to include as the body content.
1041 * @see websocketpp::http::response::set_body
1042 */
1043 void set_body(std::string const & value);
1044
1045 /// Append a header
1046 /**
1047 * If a header with this name already exists the value will be appended to
1048 * the existing header to form a comma separated list of values. Use
1049 * `connection::replace_header` to overwrite existing values.
1050 *
1051 * This member function is valid only from the http() and validate() handler
1052 * callbacks, or to a client connection before connect has been called.
1053 *
1054 * @param key Name of the header to set
1055 * @param val Value to add
1056 * @see replace_header
1057 * @see websocketpp::http::parser::append_header
1058 */
1059 void append_header(std::string const & key, std::string const & val);
1060
1061 /// Replace a header
1062 /**
1063 * If a header with this name already exists the old value will be replaced
1064 * Use `connection::append_header` to append to a list of existing values.
1065 *
1066 * This member function is valid only from the http() and validate() handler
1067 * callbacks, or to a client connection before connect has been called.
1068 *
1069 * @param key Name of the header to set
1070 * @param val Value to set
1071 * @see append_header
1072 * @see websocketpp::http::parser::replace_header
1073 */
1074 void replace_header(std::string const & key, std::string const & val);
1075
1076 /// Remove a header
1077 /**
1078 * Removes a header from the response.
1079 *
1080 * This member function is valid only from the http() and validate() handler
1081 * callbacks, or to a client connection before connect has been called.
1082 *
1083 * @param key The name of the header to remove
1084 * @see websocketpp::http::parser::remove_header
1085 */
1086 void remove_header(std::string const & key);
1087
1088 /// Get request object
1089 /**
1090 * Direct access to request object. This can be used to call methods of the
1091 * request object that are not part of the standard request API that
1092 * connection wraps.
1093 *
1094 * Note use of this method involves using behavior specific to the
1095 * configured HTTP policy. Such behavior may not work with alternate HTTP
1096 * policies.
1097 *
1098 * @since 0.3.0-alpha3
1099 *
1100 * @return A const reference to the raw request object
1101 */
1102 request_type const & get_request() const {
1103 return m_request;
1104 }
1105
1106 /// Get response object
1107 /**
1108 * Direct access to the HTTP response sent or received as a part of the
1109 * opening handshake. This can be used to call methods of the response
1110 * object that are not part of the standard request API that connection
1111 * wraps.
1112 *
1113 * Note use of this method involves using behavior specific to the
1114 * configured HTTP policy. Such behavior may not work with alternate HTTP
1115 * policies.
1116 *
1117 * @since 0.7.0
1118 *
1119 * @return A const reference to the raw response object
1120 */
1121 response_type const & get_response() const {
1122 return m_response;
1123 }
1124
1125 /// Defer HTTP Response until later (Exception free)
1126 /**
1127 * Used in the http handler to defer the HTTP response for this connection
1128 * until later. Handshake timers will be canceled and the connection will be
1129 * left open until `send_http_response` or an equivalent is called.
1130 *
1131 * Warning: deferred connections won't time out and as a result can tie up
1132 * resources.
1133 *
1134 * @since 0.6.0
1135 *
1136 * @return A status code, zero on success, non-zero otherwise
1137 */
1139
1140 /// Send deferred HTTP Response (exception free)
1141 /**
1142 * Sends an http response to an HTTP connection that was deferred. This will
1143 * send a complete response including all headers, status line, and body
1144 * text. The connection will be closed afterwards.
1145 *
1146 * @since 0.6.0
1147 *
1148 * @param ec A status code, zero on success, non-zero otherwise
1149 */
1150 void send_http_response(lib::error_code & ec);
1151
1152 /// Send deferred HTTP Response
1153 void send_http_response();
1154
1155 // TODO HTTPNBIO: write_headers
1156 // function that processes headers + status so far and writes it to the wire
1157 // beginning the HTTP response body state. This method will ignore anything
1158 // in the response body.
1159
1160 // TODO HTTPNBIO: write_body_message
1161 // queues the specified message_buffer for async writing
1162
1163 // TODO HTTPNBIO: finish connection
1164 //
1165
1166 // TODO HTTPNBIO: write_response
1167 // Writes the whole response, headers + body and closes the connection
1168
1169
1170
1171 /////////////////////////////////////////////////////////////
1172 // Pass-through access to the other connection information //
1173 /////////////////////////////////////////////////////////////
1174
1175 /// Get Connection Handle
1176 /**
1177 * The connection handle is a token that can be shared outside the
1178 * WebSocket++ core for the purposes of identifying a connection and
1179 * sending it messages.
1180 *
1181 * @return A handle to the connection
1182 */
1183 connection_hdl get_handle() const {
1184 return m_connection_hdl;
1185 }
1186
1187 /// Get whether or not this connection is part of a server or client
1188 /**
1189 * @return whether or not the connection is attached to a server endpoint
1190 */
1191 bool is_server() const {
1192 return m_is_server;
1193 }
1194
1195 /// Return the same origin policy origin value from the opening request.
1196 /**
1197 * This value is available after the HTTP request has been fully read and
1198 * may be called from any thread.
1199 *
1200 * @return The connection's origin value from the opening handshake.
1201 */
1202 std::string const & get_origin() const;
1203
1204 /// Return the connection state.
1205 /**
1206 * Values can be connecting, open, closing, and closed
1207 *
1208 * @return The connection's current state.
1209 */
1210 session::state::value get_state() const;
1211
1212
1213 /// Get the WebSocket close code sent by this endpoint.
1214 /**
1215 * @return The WebSocket close code sent by this endpoint.
1216 */
1218 return m_local_close_code;
1219 }
1220
1221 /// Get the WebSocket close reason sent by this endpoint.
1222 /**
1223 * @return The WebSocket close reason sent by this endpoint.
1224 */
1225 std::string const & get_local_close_reason() const {
1226 return m_local_close_reason;
1227 }
1228
1229 /// Get the WebSocket close code sent by the remote endpoint.
1230 /**
1231 * @return The WebSocket close code sent by the remote endpoint.
1232 */
1234 return m_remote_close_code;
1235 }
1236
1237 /// Get the WebSocket close reason sent by the remote endpoint.
1238 /**
1239 * @return The WebSocket close reason sent by the remote endpoint.
1240 */
1241 std::string const & get_remote_close_reason() const {
1242 return m_remote_close_reason;
1243 }
1244
1245 /// Get the internal error code for a closed/failed connection
1246 /**
1247 * Retrieves a machine readable detailed error code indicating the reason
1248 * that the connection was closed or failed. Valid only after the close or
1249 * fail handler is called.
1250 *
1251 * @return Error code indicating the reason the connection was closed or
1252 * failed
1253 */
1254 lib::error_code get_ec() const {
1255 return m_ec;
1256 }
1257
1258 /// Get a message buffer
1259 /**
1260 * Warning: The API related to directly sending message buffers may change
1261 * before the 1.0 release. If you plan to use it, please keep an eye on any
1262 * breaking changes notifications in future release notes. Also if you have
1263 * any feedback about usage and capabilities now is a great time to provide
1264 * it.
1265 *
1266 * Message buffers are used to store message payloads and other message
1267 * metadata.
1268 *
1269 * The size parameter is a hint only. Your final payload does not need to
1270 * match it. There may be some performance benefits if the initial size
1271 * guess is equal to or slightly higher than the final payload size.
1272 *
1273 * @param op The opcode for the new message
1274 * @param size A hint to optimize the initial allocation of payload space.
1275 * @return A new message buffer
1276 */
1277 message_ptr get_message(websocketpp::frame::opcode::value op, size_t size)
1278 const
1279 {
1280 return m_msg_manager->get_message(op, size);
1281 }
1282
1283 ////////////////////////////////////////////////////////////////////////
1284 // The remaining public member functions are for internal/policy use //
1285 // only. Do not call from application code unless you understand what //
1286 // you are doing. //
1287 ////////////////////////////////////////////////////////////////////////
1288
1289
1290
1291 void read_handshake(size_t num_bytes);
1292
1293 void handle_read_handshake(lib::error_code const & ec,
1294 size_t bytes_transferred);
1295 void handle_read_http_response(lib::error_code const & ec,
1296 size_t bytes_transferred);
1297
1298
1299 void handle_write_http_response(lib::error_code const & ec);
1300 void handle_send_http_request(lib::error_code const & ec);
1301
1302 void handle_open_handshake_timeout(lib::error_code const & ec);
1303 void handle_close_handshake_timeout(lib::error_code const & ec);
1304
1305 void handle_read_frame(lib::error_code const & ec, size_t bytes_transferred);
1306 void read_frame();
1307
1308 /// Get array of WebSocket protocol versions that this connection supports.
1309 std::vector<int> const & get_supported_versions() const;
1310
1311 /// Sets the handler for a terminating connection. Should only be used
1312 /// internally by the endpoint class.
1313 void set_termination_handler(termination_handler new_handler);
1314
1315 void terminate(lib::error_code const & ec);
1316 void handle_terminate(terminate_status tstat, lib::error_code const & ec);
1317
1318 /// Checks if there are frames in the send queue and if there are sends one
1319 /**
1320 * \todo unit tests
1321 *
1322 * This method locks the m_write_lock mutex
1323 */
1324 void write_frame();
1325
1326 /// Process the results of a frame write operation and start the next write
1327 /**
1328 * \todo unit tests
1329 *
1330 * This method locks the m_write_lock mutex
1331 *
1332 * @param terminate Whether or not to terminate the connection upon
1333 * completion of this write.
1334 *
1335 * @param ec A status code from the transport layer, zero on success,
1336 * non-zero otherwise.
1337 */
1338 void handle_write_frame(lib::error_code const & ec);
1339// protected:
1340 // This set of methods would really like to be protected, but doing so
1341 // requires that the endpoint be able to friend the connection. This is
1342 // allowed with C++11, but not prior versions
1343
1344 /// Start the connection state machine
1345 void start();
1346
1347 /// Set Connection Handle
1348 /**
1349 * The connection handle is a token that can be shared outside the
1350 * WebSocket++ core for the purposes of identifying a connection and
1351 * sending it messages.
1352 *
1353 * @param hdl A connection_hdl that the connection will use to refer
1354 * to itself.
1355 */
1356 void set_handle(connection_hdl hdl) {
1357 m_connection_hdl = hdl;
1358 transport_con_type::set_handle(hdl);
1359 }
1360protected:
1361 void handle_transport_init(lib::error_code const & ec);
1362
1363 /// Set m_processor based on information in m_request. Set m_response
1364 /// status and return an error code indicating status.
1366
1367 /// Perform WebSocket handshake validation of m_request using m_processor.
1368 /// set m_response and return an error code indicating status.
1370private:
1371
1372
1373 /// Completes m_response, serializes it, and sends it out on the wire.
1374 void write_http_response(lib::error_code const & ec);
1375
1376 /// Sends an opening WebSocket connect request
1377 void send_http_request();
1378
1379 /// Alternate path for write_http_response in error conditions
1380 void write_http_response_error(lib::error_code const & ec);
1381
1382 /// Process control message
1383 /**
1384 *
1385 */
1386 void process_control_frame(message_ptr msg);
1387
1388 /// Send close acknowledgement
1389 /**
1390 * If no arguments are present no close code/reason will be specified.
1391 *
1392 * Note: the close code/reason values provided here may be overrided by
1393 * other settings (such as silent close).
1394 *
1395 * @param code The close code to send
1396 * @param reason The close reason to send
1397 * @return A status code, zero on success, non-zero otherwise
1398 */
1399 lib::error_code send_close_ack(close::status::value code =
1400 close::status::blank, std::string const & reason = std::string());
1401
1402 /// Send close frame
1403 /**
1404 * If no arguments are present no close code/reason will be specified.
1405 *
1406 * Note: the close code/reason values provided here may be overrided by
1407 * other settings (such as silent close).
1408 *
1409 * The ack flag determines what to do in the case of a blank status and
1410 * whether or not to terminate the TCP connection after sending it.
1411 *
1412 * @param code The close code to send
1413 * @param reason The close reason to send
1414 * @param ack Whether or not this is an acknowledgement close frame
1415 * @return A status code, zero on success, non-zero otherwise
1416 */
1417 lib::error_code send_close_frame(close::status::value code =
1418 close::status::blank, std::string const & reason = std::string(), bool ack = false,
1419 bool terminal = false);
1420
1421 /// Get a pointer to a new WebSocket protocol processor for a given version
1422 /**
1423 * @param version Version number of the WebSocket protocol to get a
1424 * processor for. Negative values indicate invalid/unknown versions and will
1425 * always return a null ptr
1426 *
1427 * @return A shared_ptr to a new instance of the appropriate processor or a
1428 * null ptr if there is no installed processor that matches the version
1429 * number.
1430 */
1431 processor_ptr get_processor(int version) const;
1432
1433 /// Add a message to the write queue
1434 /**
1435 * Adds a message to the write queue and updates any associated shared state
1436 *
1437 * Must be called while holding m_write_lock
1438 *
1439 * @todo unit tests
1440 *
1441 * @param msg The message to push
1442 */
1443 void write_push(message_ptr msg);
1444
1445 /// Pop a message from the write queue
1446 /**
1447 * Removes and returns a message from the write queue and updates any
1448 * associated shared state.
1449 *
1450 * Must be called while holding m_write_lock
1451 *
1452 * @todo unit tests
1453 *
1454 * @return the message_ptr at the front of the queue
1455 */
1456 message_ptr write_pop();
1457
1458 /// Prints information about the incoming connection to the access log
1459 /**
1460 * Prints information about the incoming connection to the access log.
1461 * Includes: connection type, websocket version, remote endpoint, user agent
1462 * path, status code.
1463 */
1464 void log_open_result();
1465
1466 /// Prints information about a connection being closed to the access log
1467 /**
1468 * Includes: local and remote close codes and reasons
1469 */
1470 void log_close_result();
1471
1472 /// Prints information about a connection being failed to the access log
1473 /**
1474 * Includes: error code and message for why it was failed
1475 */
1476 void log_fail_result();
1477
1478 /// Prints information about HTTP connections
1479 /**
1480 * Includes: TODO
1481 */
1482 void log_http_result();
1483
1484 /// Prints information about an arbitrary error code on the specified channel
1485 template <typename error_type>
1486 void log_err(log::level l, char const * msg, error_type const & ec) {
1487 std::stringstream s;
1488 s << msg << " error: " << ec << " (" << ec.message() << ")";
1489 m_elog->write(l, s.str());
1490 }
1491
1492 // internal handler functions
1493 read_handler m_handle_read_frame;
1494 write_frame_handler m_write_frame_handler;
1495
1496 // static settings
1497 std::string const m_user_agent;
1498
1499 /// Pointer to the connection handle
1500 connection_hdl m_connection_hdl;
1501
1502 /// Handler objects
1503 open_handler m_open_handler;
1504 close_handler m_close_handler;
1505 fail_handler m_fail_handler;
1506 ping_handler m_ping_handler;
1507 pong_handler m_pong_handler;
1508 pong_timeout_handler m_pong_timeout_handler;
1509 interrupt_handler m_interrupt_handler;
1510 http_handler m_http_handler;
1511 validate_handler m_validate_handler;
1512 message_handler m_message_handler;
1513
1514 /// constant values
1515 long m_open_handshake_timeout_dur;
1516 long m_close_handshake_timeout_dur;
1517 long m_pong_timeout_dur;
1518 size_t m_max_message_size;
1519
1520 /// External connection state
1521 /**
1522 * Lock: m_connection_state_lock
1523 */
1524 session::state::value m_state;
1525
1526 /// Internal connection state
1527 /**
1528 * Lock: m_connection_state_lock
1529 */
1530 istate_type m_internal_state;
1531
1532 mutable mutex_type m_connection_state_lock;
1533
1534 /// The lock used to protect the message queue
1535 /**
1536 * Serializes access to the write queue as well as shared state within the
1537 * processor.
1538 */
1539 mutex_type m_write_lock;
1540
1541 // connection resources
1542 char m_buf[config::connection_read_buffer_size];
1543 size_t m_buf_cursor;
1544 termination_handler m_termination_handler;
1545 con_msg_manager_ptr m_msg_manager;
1546 timer_ptr m_handshake_timer;
1547 timer_ptr m_ping_timer;
1548
1549 /// @todo this is not memory efficient. this value is not used after the
1550 /// handshake.
1551 std::string m_handshake_buffer;
1552
1553 /// Pointer to the processor object for this connection
1554 /**
1555 * The processor provides functionality that is specific to the WebSocket
1556 * protocol version that the client has negotiated. It also contains all of
1557 * the state necessary to encode and decode the incoming and outgoing
1558 * WebSocket byte streams
1559 *
1560 * Use of the prepare_data_frame method requires lock: m_write_lock
1561 */
1562 processor_ptr m_processor;
1563
1564 /// Queue of unsent outgoing messages
1565 /**
1566 * Lock: m_write_lock
1567 */
1568 std::queue<message_ptr> m_send_queue;
1569
1570 /// Size in bytes of the outstanding payloads in the write queue
1571 /**
1572 * Lock: m_write_lock
1573 */
1574 size_t m_send_buffer_size;
1575
1576 /// buffer holding the various parts of the current message being writen
1577 /**
1578 * Lock m_write_lock
1579 */
1580 std::vector<transport::buffer> m_send_buffer;
1581
1582 /// a list of pointers to hold on to the messages being written to keep them
1583 /// from going out of scope before the write is complete.
1584 std::vector<message_ptr> m_current_msgs;
1585
1586 /// True if there is currently an outstanding transport write
1587 /**
1588 * Lock m_write_lock
1589 */
1590 bool m_write_flag;
1591
1592 /// True if this connection is presently reading new data
1593 bool m_read_flag;
1594
1595 // connection data
1596 request_type m_request;
1597 response_type m_response;
1598 uri_ptr m_uri;
1599 std::string m_subprotocol;
1600
1601 // connection data that might not be necessary to keep around for the life
1602 // of the whole connection.
1603 std::vector<std::string> m_requested_subprotocols;
1604
1605 bool const m_is_server;
1606 const lib::shared_ptr<alog_type> m_alog;
1607 const lib::shared_ptr<elog_type> m_elog;
1608
1609 rng_type & m_rng;
1610
1611 // Close state
1612 /// Close code that was sent on the wire by this endpoint
1613 close::status::value m_local_close_code;
1614
1615 /// Close reason that was sent on the wire by this endpoint
1616 std::string m_local_close_reason;
1617
1618 /// Close code that was received on the wire from the remote endpoint
1619 close::status::value m_remote_close_code;
1620
1621 /// Close reason that was received on the wire from the remote endpoint
1622 std::string m_remote_close_reason;
1623
1624 /// Detailed internal error code
1625 lib::error_code m_ec;
1626
1627 /// A flag that gets set once it is determined that the connection is an
1628 /// HTTP connection and not a WebSocket one.
1629 bool m_is_http;
1630
1631 /// A flag that gets set when the completion of an http connection is
1632 /// deferred until later.
1633 session::http_state::value m_http_state;
1634
1635 bool m_was_clean;
1636};
1637
1638} // namespace websocketpp
1639
1640#include <websocketpp/impl/connection_impl.hpp>
1641
1642#endif // WEBSOCKETPP_CONNECTION_HPP
#define _WEBSOCKETPP_CPP11_FUNCTIONAL_
#define _WEBSOCKETPP_CPP11_THREAD_
#define _WEBSOCKETPP_CPP11_MEMORY_
#define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
#define _WEBSOCKETPP_INITIALIZER_LISTS_
Concurrency policy that uses std::mutex / boost::mutex.
Definition: basic.hpp:37
Stub for user supplied base class.
Represents an individual WebSocket connection.
Definition: connection.hpp:238
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:336
void handle_interrupt()
Transport inturrupt callback.
void set_message_handler(message_handler h)
Set message handler.
Definition: connection.hpp:473
lib::error_code interrupt()
Asyncronously invoke handler::on_inturrupt.
void start()
Start the connection state machine.
std::string const & get_request_body() const
Retrieve a request body.
config::transport_type::transport_con_type transport_con_type
Type of the transport component of this connection.
Definition: connection.hpp:256
void ping(std::string const &payload)
Send a ping.
void set_close_handler(close_handler h)
Set close handler.
Definition: connection.hpp:361
void set_pong_handler(pong_handler h)
Set pong handler.
Definition: connection.hpp:398
lib::error_code send(message_ptr msg)
Add a message to the outgoing send queue.
config::alog_type alog_type
Type of the access logging policy.
Definition: connection.hpp:250
http::status_code::value get_response_code() const
Get response HTTP status code.
Definition: connection.hpp:983
lib::error_code defer_http_response()
Defer HTTP Response until later (Exception free)
lib::error_code resume_reading()
Resume reading of new data.
void add_subprotocol(std::string const &request, lib::error_code &ec)
Adds the given subprotocol string to the request list (exception free)
void add_subprotocol(std::string const &request)
Adds the given subprotocol string to the request list.
bool get_secure() const
Returns the secure flag from the connection URI.
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition: connection.hpp:525
void set_body(std::string const &value)
Set response body content.
size_t get_buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
std::string const & get_origin() const
Return the same origin policy origin value from the opening request.
void close(close::status::value const code, std::string const &reason, lib::error_code &ec)
exception free variant of close
std::string const & get_host() const
Returns the host component of the connection URI.
response_type const & get_response() const
Get response object.
void set_max_message_size(size_t new_value)
Set maximum message size.
Definition: connection.hpp:575
std::string const & get_resource() const
Returns the resource component of the connection URI.
void select_subprotocol(std::string const &value, lib::error_code &ec)
Select a subprotocol to use (exception free)
std::string const & get_request_header(std::string const &key) const
Retrieve a request header.
lib::error_code process_handshake_request()
void handle_pause_reading()
Pause reading callback.
std::vector< int > const & get_supported_versions() const
Get array of WebSocket protocol versions that this connection supports.
lib::error_code send(void const *payload, size_t len, frame::opcode::value op=frame::opcode::binary)
Send a message (raw array overload)
void remove_header(std::string const &key)
Remove a header.
uri_ptr get_uri() const
Gets the connection URI.
void ping(std::string const &payload, lib::error_code &ec)
exception free variant of ping
connection_hdl get_handle() const
Get Connection Handle.
void set_pong_timeout_handler(pong_timeout_handler h)
Set pong timeout handler.
Definition: connection.hpp:421
void send_http_response(lib::error_code &ec)
Send deferred HTTP Response (exception free)
connection< config > type
Type of this connection.
Definition: connection.hpp:241
void set_ping_handler(ping_handler h)
Set ping handler.
Definition: connection.hpp:387
std::string const & get_response_header(std::string const &key) const
Retrieve a response header.
void set_http_handler(http_handler h)
Set http handler.
Definition: connection.hpp:447
std::string const & get_response_msg() const
Get response HTTP status message.
Definition: connection.hpp:995
config::elog_type elog_type
Type of the error logging policy.
Definition: connection.hpp:252
void pong(std::string const &payload, lib::error_code &ec)
exception free variant of pong
message_ptr get_message(websocketpp::frame::opcode::value op, size_t size) const
Get a message buffer.
void handle_write_frame(lib::error_code const &ec)
Process the results of a frame write operation and start the next write.
close::status::value get_local_close_code() const
Get the WebSocket close code sent by this endpoint.
lib::error_code get_ec() const
Get the internal error code for a closed/failed connection.
void set_fail_handler(fail_handler h)
Set fail handler.
Definition: connection.hpp:372
void write_frame()
Checks if there are frames in the send queue and if there are sends one.
session::state::value get_state() const
Return the connection state.
void select_subprotocol(std::string const &value)
Select a subprotocol to use.
void set_status(http::status_code::value code)
Set response status code and message.
void replace_header(std::string const &key, std::string const &val)
Replace a header.
void set_status(http::status_code::value code, std::string const &msg)
Set response status code and message.
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition: connection.hpp:594
config::concurrency_type concurrency_type
Type of the concurrency component of this connection.
Definition: connection.hpp:248
transport_con_type::timer_ptr timer_ptr
Type of a pointer to a transport timer handle.
Definition: connection.hpp:284
void set_validate_handler(validate_handler h)
Set validate handler.
Definition: connection.hpp:463
void pong(std::string const &payload)
Send a pong.
void set_interrupt_handler(interrupt_handler h)
Set interrupt handler.
Definition: connection.hpp:432
size_t buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
Definition: connection.hpp:635
void send_http_response()
Send deferred HTTP Response.
close::status::value get_remote_close_code() const
Get the WebSocket close code sent by the remote endpoint.
void set_open_handler(open_handler h)
Set open handler.
Definition: connection.hpp:351
bool is_server() const
Get whether or not this connection is part of a server or client.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection.
Definition: connection.hpp:243
std::string const & get_remote_close_reason() const
Get the WebSocket close reason sent by the remote endpoint.
void set_pong_timeout(long dur)
Set pong timeout.
Definition: connection.hpp:546
lib::error_code initialize_processor()
void set_uri(uri_ptr uri)
Sets the connection URI.
void set_termination_handler(termination_handler new_handler)
request_type const & get_request() const
Get request object.
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition: connection.hpp:610
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the transport component of this connection.
Definition: connection.hpp:258
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition: connection.hpp:501
lib::error_code pause_reading()
Pause reading of new data.
void handle_resume_reading()
Resume reading callback.
std::vector< std::string > const & get_requested_subprotocols() const
Gets all of the subprotocols requested by the client.
void close(close::status::value const code, std::string const &reason)
Close the connection.
std::string const & get_subprotocol() const
Gets the negotated subprotocol.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void handle_pong_timeout(std::string payload, lib::error_code const &ec)
Utility method that gets called back when the ping timer expires.
lib::error_code send(std::string const &payload, frame::opcode::value op=frame::opcode::text)
Create a message and then add it to the outgoing send queue.
void read_frame()
Issue a new transport read unless reading is paused.
uint16_t get_port() const
Returns the port component of the connection URI.
std::string const & get_local_close_reason() const
Get the WebSocket close reason sent by this endpoint.
size_t get_max_message_size() const
Get maximum message size.
Definition: connection.hpp:559
void append_header(std::string const &key, std::string const &val)
Append a header.
config::rng_type rng_type
Type of RNG.
Definition: connection.hpp:275
Stub for user supplied base class.
Creates and manages connections associated with a WebSocket endpoint.
Definition: endpoint.hpp:42
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition: endpoint.hpp:466
void set_user_agent(std::string const &ua)
Sets the user agent string that this endpoint will use.
Definition: endpoint.hpp:196
connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code &ec)
Retrieves a connection_ptr from a connection_hdl (exception free)
Definition: endpoint.hpp:643
config::concurrency_type concurrency_type
Type of the concurrency component of this endpoint.
Definition: endpoint.hpp:51
config::alog_type alog_type
Type of access logger.
Definition: endpoint.hpp:75
void ping(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a ping to a specific connection.
alog_type & get_alog()
Get reference to access logger.
Definition: endpoint.hpp:261
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:65
std::string get_user_agent() const
Returns the user agent string that this endpoint will use.
Definition: endpoint.hpp:169
void ping(connection_hdl hdl, std::string const &payload)
Send a ping to a specific connection.
void clear_access_channels(log::level channels)
Clear Access logging channels.
Definition: endpoint.hpp:231
void resume_reading(connection_hdl hdl)
Resume reading of new data.
config::elog_type elog_type
Type of error logger.
Definition: endpoint.hpp:73
elog_type & get_elog()
Get reference to error logger.
Definition: endpoint.hpp:269
bool is_server() const
Returns whether or not this endpoint is a server.
Definition: endpoint.hpp:205
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op, lib::error_code &ec)
Create a message and add it to the outgoing send queue (exception free)
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition: endpoint.hpp:377
connection_type::message_ptr message_ptr
Type of message pointers that this endpoint uses.
Definition: endpoint.hpp:70
void pong(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a pong to a specific connection.
void set_access_channels(log::level channels)
Set Access logging channel.
Definition: endpoint.hpp:220
void set_max_message_size(size_t new_value)
Set default maximum message size.
Definition: endpoint.hpp:432
size_t get_max_message_size() const
Get default maximum message size.
Definition: endpoint.hpp:415
connection_ptr get_con_from_hdl(connection_hdl hdl)
Retrieves a connection_ptr from a connection_hdl (exception version)
Definition: endpoint.hpp:653
connection connection_type
Type of the connections that this endpoint creates.
Definition: endpoint.hpp:54
void set_error_channels(log::level channels)
Set Error logging channel.
Definition: endpoint.hpp:242
config::transport_type transport_type
Type of the transport component of this endpoint.
Definition: endpoint.hpp:49
void clear_error_channels(log::level channels)
Clear Error logging channels.
Definition: endpoint.hpp:253
void resume_reading(connection_hdl hdl, lib::error_code &ec)
Resume reading of new data (exception free)
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op)
Create a message and add it to the outgoing send queue.
connection_type::ptr connection_ptr
Shared pointer to connection_type.
Definition: endpoint.hpp:56
transport_type::transport_con_type transport_con_type
Definition: endpoint.hpp:62
concurrency_type::mutex_type mutex_type
Type of our concurrency policy's mutex object.
Definition: endpoint.hpp:80
void pong(connection_hdl hdl, std::string const &payload)
Send a pong to a specific connection.
void interrupt(connection_hdl hdl, lib::error_code &ec)
void set_pong_timeout(long dur)
Set pong timeout.
Definition: endpoint.hpp:399
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition: endpoint.hpp:449
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition: endpoint.hpp:352
config::rng_type rng_type
Type of RNG.
Definition: endpoint.hpp:83
concurrency_type::scoped_lock_type scoped_lock_type
Type of our concurrency policy's scoped lock object.
Definition: endpoint.hpp:78
void send_http_response(connection_hdl hdl, lib::error_code &ec)
Send deferred HTTP Response.
void pause_reading(connection_hdl hdl, lib::error_code &ec)
Pause reading of new data (exception free)
void send_http_response(connection_hdl hdl)
Send deferred HTTP Response (exception free)
void pause_reading(connection_hdl hdl)
Pause reading of new data.
connection_type::message_handler message_handler
Type of message_handler.
Definition: endpoint.hpp:68
connection_type::weak_ptr connection_weak_ptr
Weak pointer to connection type.
Definition: endpoint.hpp:58
Stub class for use when disabling permessage_deflate extension.
Definition: disabled.hpp:53
err_str_pair negotiate(http::attribute_list const &)
Negotiate extension.
Definition: disabled.hpp:65
lib::error_code compress(std::string const &, std::string &)
Compress bytes.
Definition: disabled.hpp:109
std::string generate_offer() const
Generate extension offer.
Definition: disabled.hpp:99
lib::error_code decompress(uint8_t const *, size_t, std::string &)
Decompress bytes.
Definition: disabled.hpp:120
lib::error_code init(bool)
Initialize state.
Definition: disabled.hpp:76
header_list const & get_headers() const
Return a list of all HTTP headers.
Definition: parser.hpp:179
size_t process_body(char const *buf, size_t len)
Process body data.
Definition: parser.hpp:145
std::string const & get_body() const
Get HTTP body.
Definition: parser.hpp:505
bool get_header_as_plist(std::string const &key, parameter_list &out) const
Extract an HTTP parameter list from a parser header.
Definition: parser.hpp:55
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition: parser.hpp:161
void set_version(std::string const &version)
Set HTTP parser Version.
Definition: parser.hpp:41
void remove_header(std::string const &key)
Remove a header from the parser.
Definition: parser.hpp:87
void set_body(std::string const &value)
Set body content.
Definition: parser.hpp:91
bool body_ready() const
Check if the parser is done parsing the body.
Definition: parser.hpp:599
bool prepare_body()
Prepare the parser to begin parsing body data.
Definition: parser.hpp:119
void set_max_body_size(size_t value)
Set body size limit.
Definition: parser.hpp:542
void replace_header(std::string const &key, std::string const &val)
Set a value for an HTTP header, replacing an existing value.
Definition: parser.hpp:81
void append_header(std::string const &key, std::string const &val)
Append a value to an existing HTTP header.
Definition: parser.hpp:67
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition: parser.hpp:183
std::string const & get_header(std::string const &key) const
Get the value of an HTTP header.
Definition: parser.hpp:45
std::string const & get_version() const
Get the HTTP version string.
Definition: parser.hpp:410
bool parse_parameter_list(std::string const &in, parameter_list &out) const
Extract an HTTP parameter list from a string.
Definition: parser.hpp:107
size_t get_max_body_size() const
Get body size limit.
Definition: parser.hpp:529
Stores, parses, and manipulates HTTP requests.
Definition: request.hpp:50
std::string raw() const
Returns the full raw request (including the body)
Definition: request.hpp:131
std::string const & get_uri() const
Return the requested URI.
Definition: request.hpp:104
std::string const & get_method() const
Return the request method.
Definition: request.hpp:96
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition: request.hpp:41
void set_uri(std::string const &uri)
Set the HTTP uri. Must be a valid HTTP uri.
Definition: request.hpp:159
bool ready() const
Returns whether or not the request is ready for reading.
Definition: request.hpp:82
void set_method(std::string const &method)
Set the HTTP method. Must be a valid HTTP token.
Definition: request.hpp:151
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request)
Definition: request.hpp:141
Stores, parses, and manipulates HTTP responses.
Definition: response.hpp:57
void set_status(status_code::value code)
Set response status code and message.
Definition: response.hpp:191
std::string raw() const
Returns the full raw response.
Definition: response.hpp:178
size_t consume(std::istream &s)
Process bytes in the input buffer (istream version)
Definition: response.hpp:139
bool headers_ready() const
Returns true if the response headers are fully parsed.
Definition: response.hpp:121
bool ready() const
Returns true if the response is ready.
Definition: response.hpp:116
void set_status(status_code::value code, std::string const &msg)
Set response status code and message.
Definition: response.hpp:197
const std::string & get_status_msg() const
Return the response status message.
Definition: response.hpp:157
status_code::value get_status_code() const
Return the response status code.
Definition: response.hpp:152
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition: response.hpp:42
Basic logger that outputs to an ostream.
Definition: basic.hpp:59
void write(level channel, char const *msg)
Write a cstring message to the given channel.
Definition: basic.hpp:151
void write(level channel, std::string const &msg)
Write a string message to the given channel.
Definition: basic.hpp:137
bool recycle(message *)
Recycle a message.
Definition: alloc.hpp:80
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
Definition: alloc.hpp:66
message_ptr get_message()
Get an empty message buffer.
Definition: alloc.hpp:55
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Definition: alloc.hpp:96
Represents a buffer for a single WebSocket message.
Definition: message.hpp:84
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
Definition: message.hpp:107
std::string & get_raw_payload()
Get a non-const reference to the payload string.
Definition: message.hpp:254
void set_header(std::string const &header)
Set prepared frame header.
Definition: message.hpp:234
bool recycle()
Recycle the message.
Definition: message.hpp:316
bool get_compressed() const
Return whether or not the message is flagged as compressed.
Definition: message.hpp:143
void set_payload(std::string const &payload)
Set payload data.
Definition: message.hpp:264
bool get_terminal() const
Get whether or not the message is terminal.
Definition: message.hpp:169
std::string const & get_header() const
Return the prepared frame header.
Definition: message.hpp:224
void set_payload(void const *payload, size_t len)
Set payload data.
Definition: message.hpp:275
bool get_fin() const
Read the fin bit.
Definition: message.hpp:195
void append_payload(void const *payload, size_t len)
Append payload data.
Definition: message.hpp:298
void set_opcode(frame::opcode::value op)
Set the opcode.
Definition: message.hpp:215
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
Definition: message.hpp:135
frame::opcode::value get_opcode() const
Return the message opcode.
Definition: message.hpp:210
void set_terminal(bool value)
Set the terminal flag.
Definition: message.hpp:181
bool get_prepared() const
Return whether or not the message has been prepared for sending.
Definition: message.hpp:125
void append_payload(std::string const &payload)
Append payload data.
Definition: message.hpp:287
void set_compressed(bool value)
Set or clear the compression flag.
Definition: message.hpp:156
message(const con_msg_man_ptr manager)
Construct an empty message.
Definition: message.hpp:96
void set_fin(bool value)
Set the fin bit.
Definition: message.hpp:205
std::string const & get_payload() const
Get a reference to the payload string.
Definition: message.hpp:246
WebSocket protocol processor abstract base class.
Definition: processor.hpp:160
Thread safe stub "random" integer generator.
Definition: none.hpp:46
int_type operator()()
advances the engine's state and returns the generated value
Definition: none.hpp:51
Server endpoint role based on the given config.
void start_accept(lib::error_code &ec)
Starts the server's async connection acceptance loop (exception free)
transport_type::transport_con_type transport_con_type
Type of the connection transport component.
connection_type::ptr connection_ptr
Type of a shared pointer to the connections this server will create.
server< config > type
Type of this endpoint.
endpoint< connection_type, config > endpoint_type
Type of the endpoint component of this server.
config::transport_type transport_type
Type of the endpoint transport component.
connection< config > connection_type
Type of the connections this server will create.
connection_ptr get_connection()
Create and initialize a new connection.
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
void start_accept()
Starts the server's async connection acceptance loop.
config::concurrency_type concurrency_type
Type of the endpoint concurrency component.
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the connection transport component.
Basic Asio connection socket component.
Definition: none.hpp:58
lib::asio::ip::tcp::socket & get_raw_socket()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:124
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection socket component.
Definition: none.hpp:63
void set_socket_init_handler(socket_init_handler h)
Set the socket initialization handler.
Definition: none.hpp:100
connection type
Type of this connection socket component.
Definition: none.hpp:61
lib::asio::ip::tcp::socket & get_socket()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:108
bool is_secure() const
Check whether or not this connection is secure.
Definition: none.hpp:88
lib::shared_ptr< socket_type > socket_ptr
Type of a shared pointer to the socket being used.
Definition: none.hpp:72
static lib::error_code translate_ec(lib::error_code ec)
Definition: none.hpp:292
static lib::error_code translate_ec(ErrorCodeType)
Translate any security policy specific information about an error code.
Definition: none.hpp:284
void set_handle(connection_hdl hdl)
Sets the connection handle.
Definition: none.hpp:234
lib::asio::error_code cancel_socket()
Cancel all async operations on this socket.
Definition: none.hpp:247
void pre_init(init_handler callback)
Pre-initialize security policy.
Definition: none.hpp:204
std::string get_remote_endpoint(lib::error_code &ec) const
Get the remote endpoint address.
Definition: none.hpp:138
void post_init(init_handler callback)
Post-initialize security policy.
Definition: none.hpp:223
lib::error_code init_asio(io_service_ptr service, strand_ptr, bool)
Perform one time initializations.
Definition: none.hpp:165
lib::asio::ip::tcp::socket socket_type
Type of the ASIO socket being used.
Definition: none.hpp:70
ptr get_shared()
Get a shared pointer to this component.
Definition: none.hpp:80
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service strand being used.
Definition: none.hpp:68
lib::asio::ip::tcp::socket & get_next_layer()
Retrieve a pointer to the underlying socket.
Definition: none.hpp:116
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
Definition: none.hpp:66
Basic ASIO endpoint socket component.
Definition: none.hpp:317
void set_socket_init_handler(socket_init_handler h)
Set socket init handler.
Definition: none.hpp:346
lib::error_code init(socket_con_ptr scon)
Initialize a connection.
Definition: none.hpp:359
endpoint type
The type of this endpoint socket component.
Definition: none.hpp:320
bool is_secure() const
Checks whether the endpoint creates secure connections.
Definition: none.hpp:334
connection socket_con_type
The type of the corresponding connection socket component.
Definition: none.hpp:323
Asio based connection transport component.
Definition: connection.hpp:67
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception)
Definition: connection.hpp:261
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition: connection.hpp:173
void set_proxy_basic_auth(std::string const &username, std::string const &password)
Set the basic auth credentials to use (exception)
Definition: connection.hpp:232
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free)
Definition: connection.hpp:250
config::elog_type elog_type
Type of this transport's error logging policy.
Definition: connection.hpp:81
strand_ptr get_strand()
Get a pointer to this connection's strand.
Definition: connection.hpp:366
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
read at least num_bytes bytes into buf and then call handler.
Definition: connection.hpp:820
lib::error_code proxy_init(std::string const &authority)
initialize the proxy buffers and http parsers
Definition: connection.hpp:437
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition: connection.hpp:77
lib::error_code interrupt(interrupt_handler handler)
Trigger the on_interrupt handler.
config::alog_type alog_type
Type of this transport's access logging policy.
Definition: connection.hpp:79
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
Definition: connection.hpp:980
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
Definition: connection.hpp:350
lib::error_code init_asio(io_service_ptr io_service)
Finish constructing the transport.
Definition: connection.hpp:461
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition: connection.hpp:572
void async_shutdown(shutdown_handler callback)
close and clean up the underlying socket
lib::asio::error_code get_transport_ec() const
Get the internal transport error code for a closed/failed connection.
Definition: connection.hpp:389
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition: connection.hpp:75
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
Definition: connection.hpp:89
void set_proxy(std::string const &uri)
Set the proxy to connect through (exception)
Definition: connection.hpp:198
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
Definition: connection.hpp:536
connection< config > type
Type of this connection transport component.
Definition: connection.hpp:70
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
void set_proxy(std::string const &uri, lib::error_code &ec)
Set the proxy to connect through (exception free)
Definition: connection.hpp:189
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
Definition: connection.hpp:93
void set_proxy_basic_auth(std::string const &username, std::string const &password, lib::error_code &ec)
Set the basic auth credentials to use (exception free)
Definition: connection.hpp:217
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
Definition: connection.hpp:906
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
Definition: connection.hpp:939
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition: connection.hpp:72
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition: connection.hpp:313
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition: connection.hpp:158
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
Definition: connection.hpp:742
void set_uri(uri_ptr u)
Set uri hook.
Definition: connection.hpp:130
std::string get_remote_endpoint() const
Get the remote endpoint address.
Definition: connection.hpp:281
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:110
void cancel_socket_checked()
Cancel the underlying socket and log any errors.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition: connection.hpp:144
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service::strand being used.
Definition: connection.hpp:91
void init(init_handler callback)
Initialize transport for reading.
Definition: connection.hpp:411
connection_hdl get_handle() const
Get the connection handle.
Definition: connection.hpp:295
Asio based endpoint transport component.
Definition: endpoint.hpp:54
std::size_t run_one()
wraps the run_one method of the internal io_service object
Definition: endpoint.hpp:648
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition: endpoint.hpp:69
void stop_listening(lib::error_code &ec)
Stop listening (exception free)
Definition: endpoint.hpp:604
config::socket_type socket_type
Type of the socket policy.
Definition: endpoint.hpp:62
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition: endpoint.hpp:87
void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb)
Initiate a new connection.
Definition: endpoint.hpp:849
void init_asio()
Initialize asio transport with internal io_service.
Definition: endpoint.hpp:249
config::elog_type elog_type
Type of the error logging policy.
Definition: endpoint.hpp:64
void init_logging(const lib::shared_ptr< alog_type > &a, const lib::shared_ptr< elog_type > &e)
Initialize logging.
Definition: endpoint.hpp:823
bool is_secure() const
Return whether or not the endpoint produces secure connections.
Definition: endpoint.hpp:172
void init_asio(io_service_ptr ptr)
initialize asio transport with external io_service
Definition: endpoint.hpp:212
lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code &ec)
Get local TCP endpoint.
Definition: endpoint.hpp:395
void set_reuse_addr(bool value)
Sets whether to use the SO_REUSEADDR flag when opening listening sockets.
Definition: endpoint.hpp:363
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition: endpoint.hpp:302
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer handler.
Definition: endpoint.hpp:745
void start_perpetual()
Marks the endpoint as perpetual, stopping it from exiting when empty.
Definition: endpoint.hpp:689
void stop()
wraps the stop method of the internal io_service object
Definition: endpoint.hpp:653
std::size_t run()
wraps the run method of the internal io_service object
Definition: endpoint.hpp:640
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition: endpoint.hpp:317
void set_listen_backlog(int backlog)
Sets the maximum length of the queue of pending connections.
Definition: endpoint.hpp:342
bool stopped() const
wraps the stopped method of the internal io_service object
Definition: endpoint.hpp:673
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition: endpoint.hpp:717
void init_asio(io_service_ptr ptr, lib::error_code &ec)
initialize asio transport with external io_service (exception free)
Definition: endpoint.hpp:185
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition: endpoint.hpp:71
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition: endpoint.hpp:1113
asio::connection< config > transport_con_type
Definition: endpoint.hpp:75
void init_asio(lib::error_code &ec)
Initialize asio transport with internal io_service (exception free)
Definition: endpoint.hpp:227
void async_accept(transport_con_ptr tcon, accept_handler callback)
Accept the next connection attempt and assign it to con.
Definition: endpoint.hpp:807
void listen(uint16_t port)
Set up endpoint for listening on a port.
Definition: endpoint.hpp:536
void listen(std::string const &host, std::string const &service, lib::error_code &ec)
Set up endpoint for listening on a host and service (exception free)
Definition: endpoint.hpp:556
endpoint< config > type
Type of this endpoint transport component.
Definition: endpoint.hpp:57
lib::asio::io_service & get_io_service()
Retrieve a reference to the endpoint's io_service.
Definition: endpoint.hpp:378
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition: endpoint.hpp:60
std::size_t poll()
wraps the poll method of the internal io_service object
Definition: endpoint.hpp:658
void stop_perpetual()
Clears the endpoint's perpetual flag, allowing it to exit when empty.
Definition: endpoint.hpp:701
lib::shared_ptr< lib::asio::ip::tcp::acceptor > acceptor_ptr
Type of a shared pointer to the acceptor being used.
Definition: endpoint.hpp:83
void listen(lib::asio::ip::tcp::endpoint const &ep)
Set up endpoint for listening manually.
Definition: endpoint.hpp:460
void handle_resolve_timeout(timer_ptr, connect_handler callback, lib::error_code const &ec)
DNS resolution timeout handler.
Definition: endpoint.hpp:944
void listen(lib::asio::ip::tcp::endpoint const &ep, lib::error_code &ec)
Set up endpoint for listening manually (exception free)
Definition: endpoint.hpp:412
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:78
lib::shared_ptr< lib::asio::io_service::work > work_ptr
Type of a shared pointer to an io_service work object.
Definition: endpoint.hpp:89
void reset()
wraps the reset method of the internal io_service object
Definition: endpoint.hpp:668
void set_tcp_pre_bind_handler(tcp_pre_bind_handler h)
Sets the tcp pre bind handler.
Definition: endpoint.hpp:274
config::alog_type alog_type
Type of the access logging policy.
Definition: endpoint.hpp:66
lib::asio::io_service * io_service_ptr
Type of a pointer to the ASIO io_service being used.
Definition: endpoint.hpp:81
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition: endpoint.hpp:502
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition: endpoint.hpp:288
void listen(std::string const &host, std::string const &service)
Set up endpoint for listening on a host and service.
Definition: endpoint.hpp:589
void handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
Definition: endpoint.hpp:1053
void async_accept(transport_con_ptr tcon, accept_handler callback, lib::error_code &ec)
Accept the next connection attempt and assign it to con (exception free)
Definition: endpoint.hpp:768
std::size_t poll_one()
wraps the poll_one method of the internal io_service object
Definition: endpoint.hpp:663
void listen(InternetProtocol const &internet_protocol, uint16_t port, lib::error_code &ec)
Set up endpoint for listening with protocol and port (exception free)
Definition: endpoint.hpp:481
void listen(uint16_t port, lib::error_code &ec)
Set up endpoint for listening on a port (exception free)
Definition: endpoint.hpp:520
bool is_listening() const
Check if the endpoint is listening.
Definition: endpoint.hpp:635
void stop_listening()
Stop listening.
Definition: endpoint.hpp:625
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition: endpoint.hpp:85
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition: endpoint.hpp:92
Asio transport error category.
Definition: base.hpp:184
Error category related to asio transport socket policies.
Definition: base.hpp:110
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
Definition: connection.hpp:65
connection_hdl get_handle() const
Get the connection handle.
Definition: connection.hpp:313
config::alog_type alog_type
Type of this transport's access logging policy.
Definition: connection.hpp:70
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
Definition: connection.hpp:580
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
Definition: connection.hpp:593
void set_write_handler(write_handler h)
Sets the write handler.
Definition: connection.hpp:350
void set_secure(bool value)
Set whether or not this connection is secure.
Definition: connection.hpp:257
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition: connection.hpp:400
connection< config > type
Type of this connection transport component.
Definition: connection.hpp:63
config::elog_type elog_type
Type of this transport's error logging policy.
Definition: connection.hpp:72
void fatal_error()
Signal transport error.
Definition: connection.hpp:235
size_t read_some(char const *buf, size_t len)
Manual input supply (read some)
Definition: connection.hpp:165
size_t read_all(char const *buf, size_t len)
Manual input supply (read all)
Definition: connection.hpp:188
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
Definition: connection.hpp:487
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED)
Definition: connection.hpp:208
config::concurrency_type concurrency_type
transport concurrency policy
Definition: connection.hpp:68
void init(init_handler handler)
Initialize the connection transport.
Definition: connection.hpp:410
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
Definition: connection.hpp:327
void set_remote_endpoint(std::string value)
Set human readable remote endpoint address.
Definition: connection.hpp:289
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
Definition: connection.hpp:142
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
Definition: connection.hpp:380
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition: connection.hpp:271
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
Definition: connection.hpp:305
void set_handle(connection_hdl hdl)
Set Connection Handle.
Definition: connection.hpp:565
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
Definition: connection.hpp:104
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
Initiate an async_read for at least num_bytes bytes into buf.
Definition: connection.hpp:439
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather)
Definition: connection.hpp:527
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:93
iostream::connection< config > transport_con_type
Definition: endpoint.hpp:62
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition: endpoint.hpp:56
void set_write_handler(write_handler h)
Sets the write handler.
Definition: endpoint.hpp:134
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition: endpoint.hpp:154
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition: endpoint.hpp:116
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition: endpoint.hpp:51
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:65
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition: endpoint.hpp:183
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition: endpoint.hpp:197
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
Definition: endpoint.hpp:171
endpoint type
Type of this endpoint transport component.
Definition: endpoint.hpp:49
void register_ostream(std::ostream *o)
Register a default output stream.
Definition: endpoint.hpp:80
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition: endpoint.hpp:54
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition: endpoint.hpp:102
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition: endpoint.hpp:58
iostream transport error category
Definition: base.hpp:85
std::string get_query() const
Return the query portion.
Definition: uri.hpp:294
#define _WEBSOCKETPP_CONSTEXPR_TOKEN_
Definition: cpp11.hpp:132
#define _WEBSOCKETPP_NOEXCEPT_TOKEN_
Definition: cpp11.hpp:113
#define __has_extension
Definition: cpp11.hpp:40
#define __has_feature(x)
Definition: cpp11.hpp:37
A package of types and methods for manipulating WebSocket close status'.
Definition: close.hpp:47
static value const blank
A blank value for internal use.
Definition: close.hpp:52
static value const abnormal_close
A dummy value to indicate that the connection was closed abnormally.
Definition: close.hpp:104
uint16_t value
The type of a close code value.
Definition: close.hpp:49
A package of types and methods for manipulating WebSocket close codes.
Definition: close.hpp:45
Concurrency handling support.
Definition: basic.hpp:34
Library level error codes.
Definition: error.hpp:44
@ general
Catch-all library error.
Definition: error.hpp:47
@ unrequested_subprotocol
Selected subprotocol was not requested by the client.
Definition: error.hpp:102
@ invalid_port
Invalid port in URI.
Definition: error.hpp:120
@ client_only
Attempted to use a client specific feature on a server endpoint.
Definition: error.hpp:105
@ http_connection_ended
HTTP connection ended.
Definition: error.hpp:111
@ async_accept_not_listening
Definition: error.hpp:124
@ operation_canceled
The requested operation was canceled.
Definition: error.hpp:127
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
Definition: error.hpp:68
@ http_parse_error
HTTP parse error.
Definition: error.hpp:143
@ reserved_close_code
Close code is in a reserved range.
Definition: error.hpp:80
@ con_creation_failed
Connection creation attempted failed.
Definition: error.hpp:99
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
Definition: error.hpp:71
@ invalid_state
The connection was in the wrong state for this operation.
Definition: error.hpp:74
@ extension_neg_failed
Extension negotiation failed.
Definition: error.hpp:146
@ rejected
Connection rejected.
Definition: error.hpp:130
@ unsupported_version
Unsupported WebSocket protocol version.
Definition: error.hpp:140
@ invalid_utf8
Invalid UTF-8.
Definition: error.hpp:86
@ invalid_close_code
Close code is invalid.
Definition: error.hpp:83
@ server_only
Attempted to use a server specific feature on a client endpoint.
Definition: error.hpp:108
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
Definition: error.hpp:57
@ close_handshake_timeout
WebSocket close handshake timed out.
Definition: error.hpp:117
@ invalid_subprotocol
Invalid subprotocol.
Definition: error.hpp:89
@ bad_close_code
Unable to parse close code.
Definition: error.hpp:77
@ open_handshake_timeout
WebSocket opening handshake timed out.
Definition: error.hpp:114
@ invalid_version
Invalid WebSocket protocol version.
Definition: error.hpp:137
@ send_queue_full
send attempted when endpoint write queue was full
Definition: error.hpp:50
@ test
Unit testing utility error code.
Definition: error.hpp:96
@ invalid_uri
An invalid uri was supplied.
Definition: error.hpp:65
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition: disabled.hpp:44
Constants related to frame and payload limits.
Definition: frame.hpp:145
static uint8_t const close_reason_size
Maximum size of close frame reason.
Definition: frame.hpp:169
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127)
Definition: frame.hpp:162
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
Definition: frame.hpp:153
static unsigned int const max_header_length
Maximum length of a WebSocket header.
Definition: frame.hpp:150
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
Definition: frame.hpp:159
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
Definition: frame.hpp:156
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Definition: frame.hpp:147
Constants and utility functions related to WebSocket opcodes.
Definition: frame.hpp:76
bool invalid(value v)
Check if an opcode is invalid.
Definition: frame.hpp:130
bool reserved(value v)
Check if an opcode is reserved.
Definition: frame.hpp:118
bool is_control(value v)
Check if an opcode is for a control frame.
Definition: frame.hpp:139
Data structures and utility functions for manipulating WebSocket frames.
Definition: frame.hpp:45
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
Definition: frame.hpp:469
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
Definition: frame.hpp:366
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
Definition: frame.hpp:50
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition: frame.hpp:393
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
Definition: frame.hpp:384
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
Definition: frame.hpp:573
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Definition: frame.hpp:431
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Definition: frame.hpp:830
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
Definition: frame.hpp:645
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Definition: frame.hpp:52
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
Definition: frame.hpp:375
bool get_masked(basic_header const &h)
check whether the frame is masked
Definition: frame.hpp:402
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
Definition: frame.hpp:357
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place)
Definition: frame.hpp:675
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
Definition: frame.hpp:540
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place)
Definition: frame.hpp:857
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition: frame.hpp:321
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
Definition: frame.hpp:612
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition: frame.hpp:339
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
Definition: frame.hpp:411
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
Definition: frame.hpp:768
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place)
Definition: frame.hpp:731
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
Definition: frame.hpp:348
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition: frame.hpp:445
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
Definition: frame.hpp:330
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
Definition: frame.hpp:555
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
Definition: frame.hpp:702
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
Definition: frame.hpp:489
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
Definition: frame.hpp:516
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
Definition: frame.hpp:48
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place)
Definition: frame.hpp:805
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
Definition: frame.hpp:595
HTTP handling support.
Definition: request.hpp:37
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
Definition: constants.hpp:68
static char const header_separator[]
Literal value of the HTTP header separator.
Definition: constants.hpp:59
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition: constants.hpp:53
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
Definition: constants.hpp:71
bool is_not_token_char(unsigned char c)
Is the character a non-token.
Definition: constants.hpp:103
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
Definition: constants.hpp:65
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
Definition: constants.hpp:56
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
Definition: constants.hpp:111
static char const header_token[]
invalid HTTP token characters
Definition: constants.hpp:78
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
Definition: constants.hpp:116
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
Definition: constants.hpp:45
bool is_token_char(unsigned char c)
Is the character a token.
Definition: constants.hpp:98
static std::string const empty_header
Literal value of an empty header.
Definition: constants.hpp:62
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition: processor.hpp:59
Stub RNG policy that always returns 0.
Definition: none.hpp:35
Random number generation policies.
lib::function< void(connection_hdl, lib::asio::ip::tcp::socket &)> socket_init_handler
The signature of the socket init handler for this socket policy.
Definition: none.hpp:51
Asio transport errors.
Definition: base.hpp:161
lib::error_category const & get_category()
Get a reference to a static copy of the asio transport error category.
Definition: base.hpp:211
lib::error_code make_error_code(error::value e)
Create an error code with the given value and the asio transport category.
Definition: base.hpp:217
@ proxy_invalid
Invalid Proxy URI.
Definition: base.hpp:177
@ pass_through
there was an error in the underlying transport library
Definition: base.hpp:171
@ proxy_failed
The connection to the requested proxy server failed.
Definition: base.hpp:174
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: base.hpp:168
@ invalid_host_service
Invalid host or service.
Definition: base.hpp:180
Errors related to asio transport sockets.
Definition: base.hpp:75
@ missing_tls_init_handler
Required tls_init handler not present.
Definition: base.hpp:99
@ invalid_state
A function was called in a state that it was illegal to do so.
Definition: base.hpp:86
@ tls_failed_sni_hostname
Failed to set TLS SNI hostname.
Definition: base.hpp:105
@ tls_handshake_failed
TLS Handshake Failed.
Definition: base.hpp:102
@ tls_handshake_timeout
TLS Handshake Timeout.
Definition: base.hpp:93
@ pass_through
pass_through from underlying library
Definition: base.hpp:96
Transport policy that uses asio.
Definition: endpoint.hpp:46
Generic transport related errors.
Definition: connection.hpp:146
@ pass_through
underlying transport pass through
Definition: connection.hpp:153
@ operation_not_supported
Operation not supported.
Definition: connection.hpp:165
@ operation_aborted
Operation aborted.
Definition: connection.hpp:162
@ tls_error
Other TLS error.
Definition: connection.hpp:180
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: connection.hpp:156
@ action_after_shutdown
read or write after shutdown
Definition: connection.hpp:177
@ tls_short_read
TLS short read.
Definition: connection.hpp:171
@ double_read
async_read called while another async_read was in progress
Definition: connection.hpp:159
iostream transport errors
Definition: base.hpp:64
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition: base.hpp:71
@ double_read
async_read called while another async_read was in progress
Definition: base.hpp:74
lib::error_code make_error_code(error::value e)
Get an error code with the given value and the iostream transport category.
Definition: base.hpp:118
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Definition: base.hpp:112
Transport policy that uses STL iostream for I/O and does not support timers.
Definition: endpoint.hpp:43
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
Definition: base.hpp:57
lib::function< lib::error_code(connection_hdl)> shutdown_handler
Definition: base.hpp:61
lib::function< lib::error_code(connection_hdl, char const *, size_t)> write_handler
The type and signature of the callback used by iostream transport to write.
Definition: base.hpp:48
Transport policies provide network connectivity and timers.
Definition: endpoint.hpp:45
lib::function< void(lib::error_code const &, size_t)> read_handler
The type and signature of the callback passed to the read method.
Definition: connection.hpp:120
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
Definition: connection.hpp:135
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
Definition: connection.hpp:132
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
Definition: endpoint.hpp:69
lib::function< void(lib::error_code const &)> timer_handler
The type and signature of the callback passed to the read method.
Definition: connection.hpp:126
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
Definition: endpoint.hpp:72
lib::function< void(lib::error_code const &)> write_handler
The type and signature of the callback passed to the write method.
Definition: connection.hpp:123
lib::function< void(lib::error_code const &)> init_handler
The type and signature of the callback passed to the init hook.
Definition: connection.hpp:117
lib::function< void(lib::error_code const &)> shutdown_handler
The type and signature of the callback passed to the shutdown method.
Definition: connection.hpp:129
Generic non-websocket specific utility functions and data structures.
Definition: utilities.hpp:39
std::string to_hex(std::string const &input)
Convert std::string to ascii printed string of hex digits.
std::string to_hex(uint8_t const *input, size_t length)
Convert byte array (uint8_t) to ascii printed string of hex digits.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
Definition: utilities.hpp:101
std::string string_replace_all(std::string subject, std::string const &search, std::string const &replace)
Replace all occurrances of a substring with another.
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive)
Definition: utilities.hpp:123
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
std::string to_lower(std::string const &in)
Convert a string to lowercase.
Namespace for the WebSocket++ project.
std::string base64_decode(std::string const &input)
Decode a base64 encoded string into a string of raw bytes.
Definition: base64.hpp:131
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
Definition: connection.hpp:109
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
Definition: connection.hpp:69
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
Definition: connection.hpp:116
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
Definition: connection.hpp:151
std::string base64_encode(std::string const &input)
Encode a string into a base64 string.
Definition: base64.hpp:119
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
Definition: connection.hpp:59
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
Definition: connection.hpp:91
static uint16_t const uri_default_secure_port
Default port for wss://.
Definition: uri.hpp:47
lib::function< void(connection_hdl)> fail_handler
The type and function signature of a fail handler.
Definition: connection.hpp:79
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
static uint16_t const uri_default_port
Default port for ws://.
Definition: uri.hpp:45
lib::function< bool(connection_hdl, std::string)> ping_handler
The type and function signature of a ping handler.
Definition: connection.hpp:101
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition: uri.hpp:352
std::pair< lib::error_code, std::string > err_str_pair
Combination error code / string type for returning two values.
Definition: error.hpp:41
lib::function< bool(connection_hdl)> validate_handler
The type and function signature of a validate handler.
Definition: connection.hpp:129
static bool is_base64(unsigned char c)
Test whether a character is a valid base64 character.
Definition: base64.hpp:53
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
Definition: base64.hpp:66
#define TYP_BIGE
Definition: network.hpp:53
#define TYP_SMLE
Definition: network.hpp:52
#define TYP_INIT
Definition: network.hpp:51
Server config with asio transport and TLS disabled.
Definition: asio_no_tls.hpp:38
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
Definition: core.hpp:137
static const long timeout_connect
Length of time to wait for TCP connect.
Definition: core.hpp:134
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
Definition: core.hpp:131
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
Definition: core.hpp:121
static const long timeout_socket_pre_init
Default timer values (in ms)
Definition: core.hpp:118
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Definition: core.hpp:128
Server config with iostream transport.
Definition: core.hpp:68
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
Definition: core.hpp:93
static const websocketpp::log::level elog_level
Default static error logging channels.
Definition: core.hpp:176
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
Definition: core.hpp:142
static const size_t max_http_body_size
Default maximum http body size.
Definition: core.hpp:252
static const long timeout_open_handshake
Default timer values (in ms)
Definition: core.hpp:152
static const size_t max_message_size
Default maximum message size.
Definition: core.hpp:240
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
Definition: core.hpp:213
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
Definition: core.hpp:154
static const websocketpp::log::level alog_level
Default static access logging channels.
Definition: core.hpp:189
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition: core.hpp:88
static const long timeout_pong
Length of time to wait for a pong after a ping.
Definition: core.hpp:156
static const bool silent_close
Suppresses the return of detailed connection close information.
Definition: core.hpp:228
static bool const enable_multithreading
Definition: core.hpp:98
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
Definition: core.hpp:204
static const bool enable_extensions
Global flag for enabling/disabling extensions.
Definition: core.hpp:255
static const int client_version
WebSocket Protocol version to use as a client.
Definition: core.hpp:164
The constant size component of a WebSocket frame header.
Definition: frame.hpp:189
The variable size component of a WebSocket frame header.
Definition: frame.hpp:235
Package of log levels for logging access events.
Definition: levels.hpp:112
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition: levels.hpp:164
static level const fail
One line for each failed WebSocket connection with details.
Definition: levels.hpp:147
static level const none
Special aggregate value representing "no levels".
Definition: levels.hpp:114
static level const debug_handshake
Extra information about opening handshakes.
Definition: levels.hpp:137
static level const devel
Development messages (warning: very chatty)
Definition: levels.hpp:141
static level const all
Special aggregate value representing "all levels".
Definition: levels.hpp:152
static level const debug_close
Extra information about closing handshakes.
Definition: levels.hpp:139
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty)
Definition: levels.hpp:129
static level const connect
Information about new connections.
Definition: levels.hpp:121
static level const app
Special channel for application specific logs. Not used by the library.
Definition: levels.hpp:143
static level const frame_header
One line per frame, includes the full frame header.
Definition: levels.hpp:127
static level const message_payload
Reserved.
Definition: levels.hpp:133
static level const endpoint
Reserved.
Definition: levels.hpp:135
static level const message_header
Reserved.
Definition: levels.hpp:131
static level const control
One line per control frame.
Definition: levels.hpp:125
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
Definition: levels.hpp:123
static level const access_core
Definition: levels.hpp:150
static level const http
Access related to HTTP requests.
Definition: levels.hpp:145
Package of values for hinting at the nature of a given logger.
Definition: levels.hpp:46
static value const none
No information.
Definition: levels.hpp:51
static value const access
Access log.
Definition: levels.hpp:53
static value const error
Error log.
Definition: levels.hpp:55
uint32_t value
Type of a channel type hint value.
Definition: levels.hpp:48
Package of log levels for logging errors.
Definition: levels.hpp:59
static level const devel
Low level debugging information (warning: very chatty)
Definition: levels.hpp:63
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition: levels.hpp:91
static level const library
Definition: levels.hpp:66
static level const info
Definition: levels.hpp:69
static level const all
Special aggregate value representing "all levels".
Definition: levels.hpp:80
static level const fatal
Definition: levels.hpp:78
static level const none
Special aggregate value representing "no levels".
Definition: levels.hpp:61
static level const rerror
Definition: levels.hpp:75
static level const warn
Definition: levels.hpp:72
A simple utility buffer class.
Definition: connection.hpp:138
Helper less than functor for case insensitive find.
Definition: utilities.hpp:75
Helper functor for case insensitive find.
Definition: utilities.hpp:49
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
Definition: utilities.hpp:63
my_equal(std::locale const &loc)
Construct the functor with the given locale.
Definition: utilities.hpp:54
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Two byte conversion union.
Definition: frame.hpp:55
Four byte conversion union.
Definition: frame.hpp:61
Eight byte conversion union.
Definition: frame.hpp:67