WebSocket++ 0.8.2
C++ websocket client/server library
Loading...
Searching...
No Matches
connection_impl.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_IMPL_HPP
29#define WEBSOCKETPP_CONNECTION_IMPL_HPP
30
31#include <websocketpp/processors/hybi00.hpp>
32#include <websocketpp/processors/hybi07.hpp>
33#include <websocketpp/processors/hybi08.hpp>
34#include <websocketpp/processors/hybi13.hpp>
35
36#include <websocketpp/processors/processor.hpp>
37
38#include <websocketpp/common/platforms.hpp>
39#include <websocketpp/common/system_error.hpp>
40
41#include <algorithm>
42#include <exception>
43#include <sstream>
44#include <string>
45#include <utility>
46#include <vector>
47
48namespace websocketpp {
49
50namespace istate = session::internal_state;
51
52template <typename config>
54 termination_handler new_handler)
55{
56 m_alog->write(log::alevel::devel,
57 "connection set_termination_handler");
58
59 //scoped_lock_type lock(m_connection_state_lock);
60
61 m_termination_handler = new_handler;
62}
63
64template <typename config>
65std::string const & connection<config>::get_origin() const {
66 //scoped_lock_type lock(m_connection_state_lock);
67 return m_processor->get_origin(m_request);
68}
69
70template <typename config>
71size_t connection<config>::get_buffered_amount() const {
72 //scoped_lock_type lock(m_connection_state_lock);
73 return m_send_buffer_size;
74}
75
76template <typename config>
77session::state::value connection<config>::get_state() const {
78 //scoped_lock_type lock(m_connection_state_lock);
79 return m_state;
80}
81
82template <typename config>
83lib::error_code connection<config>::send(std::string const & payload,
84 frame::opcode::value op)
85{
86 message_ptr msg = m_msg_manager->get_message(op,payload.size());
87 msg->append_payload(payload);
88 msg->set_compressed(true);
89
90 return send(msg);
91}
92
93template <typename config>
94lib::error_code connection<config>::send(void const * payload, size_t len,
95 frame::opcode::value op)
96{
97 message_ptr msg = m_msg_manager->get_message(op,len);
98 msg->append_payload(payload,len);
99
100 return send(msg);
101}
102
103template <typename config>
104lib::error_code connection<config>::send(typename config::message_type::ptr msg)
105{
106 if (m_alog->static_test(log::alevel::devel)) {
107 m_alog->write(log::alevel::devel,"connection send");
108 }
109
110 {
111 scoped_lock_type lock(m_connection_state_lock);
112 if (m_state != session::state::open) {
113 return error::make_error_code(error::invalid_state);
114 }
115 }
116
117 message_ptr outgoing_msg;
118 bool needs_writing = false;
119
120 if (msg->get_prepared()) {
121 outgoing_msg = msg;
122
123 scoped_lock_type lock(m_write_lock);
124 write_push(outgoing_msg);
125 needs_writing = !m_write_flag && !m_send_queue.empty();
126 } else {
127 outgoing_msg = m_msg_manager->get_message();
128
129 if (!outgoing_msg) {
130 return error::make_error_code(error::no_outgoing_buffers);
131 }
132
133 scoped_lock_type lock(m_write_lock);
134 lib::error_code ec = m_processor->prepare_data_frame(msg,outgoing_msg);
135
136 if (ec) {
137 return ec;
138 }
139
140 write_push(outgoing_msg);
141 needs_writing = !m_write_flag && !m_send_queue.empty();
142 }
143
144 if (needs_writing) {
145 transport_con_type::dispatch(lib::bind(
148 ));
149 }
150
151 return lib::error_code();
152}
153
154template <typename config>
155void connection<config>::ping(std::string const& payload, lib::error_code& ec) {
156 if (m_alog->static_test(log::alevel::devel)) {
157 m_alog->write(log::alevel::devel,"connection ping");
158 }
159
160 {
161 scoped_lock_type lock(m_connection_state_lock);
162 if (m_state != session::state::open) {
163 std::stringstream ss;
164 ss << "connection::ping called from invalid state " << m_state;
165 m_alog->write(log::alevel::devel,ss.str());
166 ec = error::make_error_code(error::invalid_state);
167 return;
168 }
169 }
170
171 message_ptr msg = m_msg_manager->get_message();
172 if (!msg) {
173 ec = error::make_error_code(error::no_outgoing_buffers);
174 return;
175 }
176
177 ec = m_processor->prepare_ping(payload,msg);
178 if (ec) {return;}
179
180 // set ping timer if we are listening for one
181 if (m_pong_timeout_handler) {
182 // Cancel any existing timers
183 if (m_ping_timer) {
184 m_ping_timer->cancel();
185 }
186
187 if (m_pong_timeout_dur > 0) {
188 m_ping_timer = transport_con_type::set_timer(
189 m_pong_timeout_dur,
190 lib::bind(
191 &type::handle_pong_timeout,
193 payload,
194 lib::placeholders::_1
195 )
196 );
197 }
198
199 if (!m_ping_timer) {
200 // Our transport doesn't support timers
201 m_elog->write(log::elevel::warn,"Warning: a pong_timeout_handler is \
202 set but the transport in use does not support timeouts.");
203 }
204 }
205
206 bool needs_writing = false;
207 {
208 scoped_lock_type lock(m_write_lock);
209 write_push(msg);
210 needs_writing = !m_write_flag && !m_send_queue.empty();
211 }
212
213 if (needs_writing) {
214 transport_con_type::dispatch(lib::bind(
217 ));
218 }
219
220 ec = lib::error_code();
221}
222
223template<typename config>
224void connection<config>::ping(std::string const & payload) {
225 lib::error_code ec;
226 ping(payload,ec);
227 if (ec) {
228 throw exception(ec);
229 }
230}
231
232template<typename config>
233void connection<config>::handle_pong_timeout(std::string payload,
234 lib::error_code const & ec)
235{
236 if (ec) {
238 // ignore, this is expected
239 return;
240 }
241
242 m_elog->write(log::elevel::devel,"pong_timeout error: "+ec.message());
243 return;
244 }
245
246 if (m_pong_timeout_handler) {
247 m_pong_timeout_handler(m_connection_hdl,payload);
248 }
249}
250
251template <typename config>
252void connection<config>::pong(std::string const& payload, lib::error_code& ec) {
253 if (m_alog->static_test(log::alevel::devel)) {
254 m_alog->write(log::alevel::devel,"connection pong");
255 }
256
257 {
258 scoped_lock_type lock(m_connection_state_lock);
259 if (m_state != session::state::open) {
260 std::stringstream ss;
261 ss << "connection::pong called from invalid state " << m_state;
262 m_alog->write(log::alevel::devel,ss.str());
263 ec = error::make_error_code(error::invalid_state);
264 return;
265 }
266 }
267
268 message_ptr msg = m_msg_manager->get_message();
269 if (!msg) {
270 ec = error::make_error_code(error::no_outgoing_buffers);
271 return;
272 }
273
274 ec = m_processor->prepare_pong(payload,msg);
275 if (ec) {return;}
276
277 bool needs_writing = false;
278 {
279 scoped_lock_type lock(m_write_lock);
280 write_push(msg);
281 needs_writing = !m_write_flag && !m_send_queue.empty();
282 }
283
284 if (needs_writing) {
285 transport_con_type::dispatch(lib::bind(
288 ));
289 }
290
291 ec = lib::error_code();
292}
293
294template<typename config>
295void connection<config>::pong(std::string const & payload) {
296 lib::error_code ec;
297 pong(payload,ec);
298 if (ec) {
299 throw exception(ec);
300 }
301}
302
303template <typename config>
304void connection<config>::close(close::status::value const code,
305 std::string const & reason, lib::error_code & ec)
306{
307 if (m_alog->static_test(log::alevel::devel)) {
308 m_alog->write(log::alevel::devel,"connection close");
309 }
310
311 // Truncate reason to maximum size allowable in a close frame.
312 std::string tr(reason,0,std::min<size_t>(reason.size(),
313 frame::limits::close_reason_size));
314
315 scoped_lock_type lock(m_connection_state_lock);
316
317 if (m_state != session::state::open) {
318 ec = error::make_error_code(error::invalid_state);
319 return;
320 }
321
322 ec = this->send_close_frame(code,tr,false,close::status::terminal(code));
323}
324
325template<typename config>
326void connection<config>::close(close::status::value const code,
327 std::string const & reason)
328{
329 lib::error_code ec;
330 close(code,reason,ec);
331 if (ec) {
332 throw exception(ec);
333 }
334}
335
336/// Trigger the on_interrupt handler
337/**
338 * This is thread safe if the transport is thread safe
339 */
340template <typename config>
341lib::error_code connection<config>::interrupt() {
342 m_alog->write(log::alevel::devel,"connection connection::interrupt");
343 return transport_con_type::interrupt(
344 lib::bind(
347 )
348 );
349}
350
351
352template <typename config>
353void connection<config>::handle_interrupt() {
354 if (m_interrupt_handler) {
355 m_interrupt_handler(m_connection_hdl);
356 }
357}
358
359template <typename config>
360lib::error_code connection<config>::pause_reading() {
361 m_alog->write(log::alevel::devel,"connection connection::pause_reading");
362 return transport_con_type::dispatch(
363 lib::bind(
366 )
367 );
368}
369
370/// Pause reading handler. Not safe to call directly
371template <typename config>
372void connection<config>::handle_pause_reading() {
373 m_alog->write(log::alevel::devel,"connection connection::handle_pause_reading");
374 m_read_flag = false;
375}
376
377template <typename config>
378lib::error_code connection<config>::resume_reading() {
379 m_alog->write(log::alevel::devel,"connection connection::resume_reading");
380 return transport_con_type::dispatch(
381 lib::bind(
384 )
385 );
386}
387
388/// Resume reading helper method. Not safe to call directly
389template <typename config>
390void connection<config>::handle_resume_reading() {
391 m_read_flag = true;
393}
394
395
396
397
398
399
400
401
402
403
404
405template <typename config>
406bool connection<config>::get_secure() const {
407 //scoped_lock_type lock(m_connection_state_lock);
408 return m_uri->get_secure();
409}
410
411template <typename config>
412std::string const & connection<config>::get_host() const {
413 //scoped_lock_type lock(m_connection_state_lock);
414 return m_uri->get_host();
415}
416
417template <typename config>
418std::string const & connection<config>::get_resource() const {
419 //scoped_lock_type lock(m_connection_state_lock);
420 return m_uri->get_resource();
421}
422
423template <typename config>
424uint16_t connection<config>::get_port() const {
425 //scoped_lock_type lock(m_connection_state_lock);
426 return m_uri->get_port();
427}
428
429template <typename config>
430uri_ptr connection<config>::get_uri() const {
431 //scoped_lock_type lock(m_connection_state_lock);
432 return m_uri;
433}
434
435template <typename config>
436void connection<config>::set_uri(uri_ptr uri) {
437 //scoped_lock_type lock(m_connection_state_lock);
438 m_uri = uri;
439}
440
441
442
443
444
445
446template <typename config>
447std::string const & connection<config>::get_subprotocol() const {
448 return m_subprotocol;
449}
450
451template <typename config>
452std::vector<std::string> const &
453connection<config>::get_requested_subprotocols() const {
454 return m_requested_subprotocols;
455}
456
457template <typename config>
458void connection<config>::add_subprotocol(std::string const & value,
459 lib::error_code & ec)
460{
461 if (m_is_server) {
462 ec = error::make_error_code(error::client_only);
463 return;
464 }
465
466 // If the value is empty or has a non-RFC2616 token character it is invalid.
467 if (value.empty() || std::find_if(value.begin(),value.end(),
468 http::is_not_token_char) != value.end())
469 {
470 ec = error::make_error_code(error::invalid_subprotocol);
471 return;
472 }
473
474 m_requested_subprotocols.push_back(value);
475}
476
477template <typename config>
478void connection<config>::add_subprotocol(std::string const & value) {
479 lib::error_code ec;
480 this->add_subprotocol(value,ec);
481 if (ec) {
482 throw exception(ec);
483 }
484}
485
486
487template <typename config>
488void connection<config>::select_subprotocol(std::string const & value,
489 lib::error_code & ec)
490{
491 if (!m_is_server) {
492 ec = error::make_error_code(error::server_only);
493 return;
494 }
495
496 if (value.empty()) {
497 ec = lib::error_code();
498 return;
499 }
500
501 std::vector<std::string>::iterator it;
502
503 it = std::find(m_requested_subprotocols.begin(),
504 m_requested_subprotocols.end(),
505 value);
506
507 if (it == m_requested_subprotocols.end()) {
508 ec = error::make_error_code(error::unrequested_subprotocol);
509 return;
510 }
511
512 m_subprotocol = value;
513}
514
515template <typename config>
516void connection<config>::select_subprotocol(std::string const & value) {
517 lib::error_code ec;
518 this->select_subprotocol(value,ec);
519 if (ec) {
520 throw exception(ec);
521 }
522}
523
524
525template <typename config>
526std::string const &
527connection<config>::get_request_header(std::string const & key) const {
528 return m_request.get_header(key);
529}
530
531template <typename config>
532std::string const &
533connection<config>::get_request_body() const {
534 return m_request.get_body();
535}
536
537template <typename config>
538std::string const &
539connection<config>::get_response_header(std::string const & key) const {
540 return m_response.get_header(key);
541}
542
543// TODO: EXCEPTION_FREE
544template <typename config>
545void connection<config>::set_status(http::status_code::value code)
546{
547 if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
548 throw exception("Call to set_status from invalid state",
549 error::make_error_code(error::invalid_state));
550 }
551 m_response.set_status(code);
552}
553
554// TODO: EXCEPTION_FREE
555template <typename config>
556void connection<config>::set_status(http::status_code::value code,
557 std::string const & msg)
558{
559 if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
560 throw exception("Call to set_status from invalid state",
561 error::make_error_code(error::invalid_state));
562 }
563
564 m_response.set_status(code,msg);
565}
566
567// TODO: EXCEPTION_FREE
568template <typename config>
569void connection<config>::set_body(std::string const & value) {
570 if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
571 throw exception("Call to set_status from invalid state",
572 error::make_error_code(error::invalid_state));
573 }
574
575 m_response.set_body(value);
576}
577
578// TODO: EXCEPTION_FREE
579template <typename config>
580void connection<config>::append_header(std::string const & key,
581 std::string const & val)
582{
583 if (m_is_server) {
584 if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
585 // we are setting response headers for an incoming server connection
586 m_response.append_header(key,val);
587 } else {
588 throw exception("Call to append_header from invalid state",
589 error::make_error_code(error::invalid_state));
590 }
591 } else {
592 if (m_internal_state == istate::USER_INIT) {
593 // we are setting initial headers for an outgoing client connection
594 m_request.append_header(key,val);
595 } else {
596 throw exception("Call to append_header from invalid state",
597 error::make_error_code(error::invalid_state));
598 }
599 }
600}
601
602// TODO: EXCEPTION_FREE
603template <typename config>
604void connection<config>::replace_header(std::string const & key,
605 std::string const & val)
606{
607 if (m_is_server) {
608 if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
609 // we are setting response headers for an incoming server connection
610 m_response.replace_header(key,val);
611 } else {
612 throw exception("Call to replace_header from invalid state",
613 error::make_error_code(error::invalid_state));
614 }
615 } else {
616 if (m_internal_state == istate::USER_INIT) {
617 // we are setting initial headers for an outgoing client connection
618 m_request.replace_header(key,val);
619 } else {
620 throw exception("Call to replace_header from invalid state",
621 error::make_error_code(error::invalid_state));
622 }
623 }
624}
625
626// TODO: EXCEPTION_FREE
627template <typename config>
628void connection<config>::remove_header(std::string const & key)
629{
630 if (m_is_server) {
631 if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
632 // we are setting response headers for an incoming server connection
633 m_response.remove_header(key);
634 } else {
635 throw exception("Call to remove_header from invalid state",
636 error::make_error_code(error::invalid_state));
637 }
638 } else {
639 if (m_internal_state == istate::USER_INIT) {
640 // we are setting initial headers for an outgoing client connection
641 m_request.remove_header(key);
642 } else {
643 throw exception("Call to remove_header from invalid state",
644 error::make_error_code(error::invalid_state));
645 }
646 }
647}
648
649/// Defer HTTP Response until later
650/**
651 * Used in the http handler to defer the HTTP response for this connection
652 * until later. Handshake timers will be canceled and the connection will be
653 * left open until `send_http_response` or an equivalent is called.
654 *
655 * Warning: deferred connections won't time out and as a result can tie up
656 * resources.
657 *
658 * @return A status code, zero on success, non-zero otherwise
659 */
660template <typename config>
661lib::error_code connection<config>::defer_http_response() {
662 // Cancel handshake timer, otherwise the connection will time out and we'll
663 // close the connection before the app has a chance to send a response.
664 if (m_handshake_timer) {
665 m_handshake_timer->cancel();
666 m_handshake_timer.reset();
667 }
668
669 // Do something to signal deferral
670 m_http_state = session::http_state::deferred;
671
672 return lib::error_code();
673}
674
675/// Send deferred HTTP Response (exception free)
676/**
677 * Sends an http response to an HTTP connection that was deferred. This will
678 * send a complete response including all headers, status line, and body
679 * text. The connection will be closed afterwards.
680 *
681 * @since 0.6.0
682 *
683 * @param ec A status code, zero on success, non-zero otherwise
684 */
685template <typename config>
686void connection<config>::send_http_response(lib::error_code & ec) {
687 {
688 scoped_lock_type lock(m_connection_state_lock);
689 if (m_http_state != session::http_state::deferred) {
690 ec = error::make_error_code(error::invalid_state);
691 return;
692 }
693
694 m_http_state = session::http_state::body_written;
695 }
696
697 this->write_http_response(lib::error_code());
698 ec = lib::error_code();
699}
700
701template <typename config>
702void connection<config>::send_http_response() {
703 lib::error_code ec;
704 this->send_http_response(ec);
705 if (ec) {
706 throw exception(ec);
707 }
708}
709
710
711
712
713/******** logic thread ********/
714
715template <typename config>
716void connection<config>::start() {
717 m_alog->write(log::alevel::devel,"connection start");
718
719 if (m_internal_state != istate::USER_INIT) {
720 m_alog->write(log::alevel::devel,"Start called in invalid state");
721 this->terminate(error::make_error_code(error::invalid_state));
722 return;
723 }
724
725 m_internal_state = istate::TRANSPORT_INIT;
726
727 // Depending on how the transport implements init this function may return
728 // immediately and call handle_transport_init later or call
729 // handle_transport_init from this function.
730 transport_con_type::init(
731 lib::bind(
732 &type::handle_transport_init,
734 lib::placeholders::_1
735 )
736 );
737}
738
739template <typename config>
740void connection<config>::handle_transport_init(lib::error_code const & ec) {
741 m_alog->write(log::alevel::devel,"connection handle_transport_init");
742
743 lib::error_code ecm = ec;
744
745 if (m_internal_state != istate::TRANSPORT_INIT) {
746 m_alog->write(log::alevel::devel,
747 "handle_transport_init must be called from transport init state");
748 ecm = error::make_error_code(error::invalid_state);
749 }
750
751 if (ecm) {
752 std::stringstream s;
753 s << "handle_transport_init received error: "<< ecm.message();
754 m_elog->write(log::elevel::rerror,s.str());
755
756 this->terminate(ecm);
757 return;
758 }
759
760 // At this point the transport is ready to read and write bytes.
761 if (m_is_server) {
762 m_internal_state = istate::READ_HTTP_REQUEST;
763 this->read_handshake(1);
764 } else {
765 // We are a client. Set the processor to the version specified in the
766 // config file and send a handshake request.
767 m_internal_state = istate::WRITE_HTTP_REQUEST;
768 m_processor = get_processor(config::client_version);
769 this->send_http_request();
770 }
771}
772
773template <typename config>
774void connection<config>::read_handshake(size_t num_bytes) {
775 m_alog->write(log::alevel::devel,"connection read_handshake");
776
777 if (m_open_handshake_timeout_dur > 0) {
778 m_handshake_timer = transport_con_type::set_timer(
779 m_open_handshake_timeout_dur,
780 lib::bind(
781 &type::handle_open_handshake_timeout,
783 lib::placeholders::_1
784 )
785 );
786 }
787
788 transport_con_type::async_read_at_least(
789 num_bytes,
790 m_buf,
791 config::connection_read_buffer_size,
792 lib::bind(
793 &type::handle_read_handshake,
795 lib::placeholders::_1,
796 lib::placeholders::_2
797 )
798 );
799}
800
801// All exit paths for this function need to call write_http_response() or submit
802// a new read request with this function as the handler.
803template <typename config>
804void connection<config>::handle_read_handshake(lib::error_code const & ec,
805 size_t bytes_transferred)
806{
807 m_alog->write(log::alevel::devel,"connection handle_read_handshake");
808
809 lib::error_code ecm = ec;
810
811 if (!ecm) {
812 scoped_lock_type lock(m_connection_state_lock);
813
814 if (m_state == session::state::connecting) {
815 if (m_internal_state != istate::READ_HTTP_REQUEST) {
816 ecm = error::make_error_code(error::invalid_state);
817 }
818 } else if (m_state == session::state::closed) {
819 // The connection was canceled while the response was being sent,
820 // usually by the handshake timer. This is basically expected
821 // (though hopefully rare) and there is nothing we can do so ignore.
822 m_alog->write(log::alevel::devel,
823 "handle_read_handshake invoked after connection was closed");
824 return;
825 } else {
826 ecm = error::make_error_code(error::invalid_state);
827 }
828 }
829
830 if (ecm) {
831 if (ecm == transport::error::eof && m_state == session::state::closed) {
832 // we expect to get eof if the connection is closed already
833 m_alog->write(log::alevel::devel,
834 "got (expected) eof/state error from closed con");
835 return;
836 }
837
838 log_err(log::elevel::rerror,"handle_read_handshake",ecm);
839 this->terminate(ecm);
840 return;
841 }
842
843 // Boundaries checking. TODO: How much of this should be done?
844 if (bytes_transferred > config::connection_read_buffer_size) {
845 m_elog->write(log::elevel::fatal,"Fatal boundaries checking error.");
846 this->terminate(make_error_code(error::general));
847 return;
848 }
849
850 size_t bytes_processed = 0;
851 try {
852 bytes_processed = m_request.consume(m_buf,bytes_transferred);
853 } catch (http::exception &e) {
854 // All HTTP exceptions will result in this request failing and an error
855 // response being returned. No more bytes will be read in this con.
856 m_response.set_status(e.m_error_code,e.m_error_msg);
857 this->write_http_response_error(error::make_error_code(error::http_parse_error));
858 return;
859 }
860
861 // More paranoid boundaries checking.
862 // TODO: Is this overkill?
863 if (bytes_processed > bytes_transferred) {
864 m_elog->write(log::elevel::fatal,"Fatal boundaries checking error.");
865 this->terminate(make_error_code(error::general));
866 return;
867 }
868
869 if (m_alog->static_test(log::alevel::devel)) {
870 std::stringstream s;
871 s << "bytes_transferred: " << bytes_transferred
872 << " bytes, bytes processed: " << bytes_processed << " bytes";
873 m_alog->write(log::alevel::devel,s.str());
874 }
875
876 if (m_request.ready()) {
877 lib::error_code processor_ec = this->initialize_processor();
878 if (processor_ec) {
879 this->write_http_response_error(processor_ec);
880 return;
881 }
882
883 if (m_processor && m_processor->get_version() == 0) {
884 // Version 00 has an extra requirement to read some bytes after the
885 // handshake
886 if (bytes_transferred-bytes_processed >= 8) {
887 m_request.replace_header(
888 "Sec-WebSocket-Key3",
889 std::string(m_buf+bytes_processed,m_buf+bytes_processed+8)
890 );
891 bytes_processed += 8;
892 } else {
893 // TODO: need more bytes
894 m_alog->write(log::alevel::devel,"short key3 read");
895 m_response.set_status(http::status_code::internal_server_error);
897 return;
898 }
899 }
900
901 if (m_alog->static_test(log::alevel::devel)) {
902 m_alog->write(log::alevel::devel,m_request.raw());
903 if (!m_request.get_header("Sec-WebSocket-Key3").empty()) {
904 m_alog->write(log::alevel::devel,
905 utility::to_hex(m_request.get_header("Sec-WebSocket-Key3")));
906 }
907 }
908
909 // The remaining bytes in m_buf are frame data. Copy them to the
910 // beginning of the buffer and note the length. They will be read after
911 // the handshake completes and before more bytes are read.
912 std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
913 m_buf_cursor = bytes_transferred-bytes_processed;
914
915
916 m_internal_state = istate::PROCESS_HTTP_REQUEST;
917
918 // We have the complete request. Process it.
919 lib::error_code handshake_ec = this->process_handshake_request();
920
921 // Write a response if this is a websocket connection or if it is an
922 // HTTP connection for which the response has not been deferred or
923 // started yet by a different system (i.e. still in init state).
924 if (!m_is_http || m_http_state == session::http_state::init) {
925 this->write_http_response(handshake_ec);
926 }
927 } else {
928 // read at least 1 more byte
929 transport_con_type::async_read_at_least(
930 1,
931 m_buf,
932 config::connection_read_buffer_size,
933 lib::bind(
934 &type::handle_read_handshake,
936 lib::placeholders::_1,
937 lib::placeholders::_2
938 )
939 );
940 }
941}
942
943// write_http_response requires the request to be fully read and the connection
944// to be in the PROCESS_HTTP_REQUEST state. In some cases we can detect errors
945// before the request is fully read (specifically at a point where we aren't
946// sure if the hybi00 key3 bytes need to be read). This method sets the correct
947// state and calls write_http_response
948template <typename config>
949void connection<config>::write_http_response_error(lib::error_code const & ec) {
950 if (m_internal_state != istate::READ_HTTP_REQUEST) {
951 m_alog->write(log::alevel::devel,
952 "write_http_response_error called in invalid state");
953 this->terminate(error::make_error_code(error::invalid_state));
954 return;
955 }
956
957 m_internal_state = istate::PROCESS_HTTP_REQUEST;
958
959 this->write_http_response(ec);
960}
961
962// All exit paths for this function need to call write_http_response() or submit
963// a new read request with this function as the handler.
964template <typename config>
965void connection<config>::handle_read_frame(lib::error_code const & ec,
966 size_t bytes_transferred)
967{
968 //m_alog->write(log::alevel::devel,"connection handle_read_frame");
969
970 lib::error_code ecm = ec;
971
972 if (!ecm && m_internal_state != istate::PROCESS_CONNECTION) {
973 ecm = error::make_error_code(error::invalid_state);
974 }
975
976 if (ecm) {
977 log::level echannel = log::elevel::rerror;
978
979 if (ecm == transport::error::eof) {
980 if (m_state == session::state::closed) {
981 // we expect to get eof if the connection is closed already
982 // just ignore it
983 m_alog->write(log::alevel::devel,"got eof from closed con");
984 return;
985 } else if (m_state == session::state::closing && !m_is_server) {
986 // If we are a client we expect to get eof in the closing state,
987 // this is a signal to terminate our end of the connection after
988 // the closing handshake
989 terminate(lib::error_code());
990 return;
991 }
992 } else if (ecm == error::invalid_state) {
993 // In general, invalid state errors in the closed state are the
994 // result of handlers that were in the system already when the state
995 // changed and should be ignored as they pose no problems and there
996 // is nothing useful that we can do about them.
997 if (m_state == session::state::closed) {
998 m_alog->write(log::alevel::devel,
999 "handle_read_frame: got invalid istate in closed state");
1000 return;
1001 }
1002 } else if (ecm == transport::error::action_after_shutdown) {
1003 echannel = log::elevel::info;
1004 } else {
1005 // TODO: more generally should we do something different here in the
1006 // case that m_state is cosed? Are errors after the connection is
1007 // already closed really an rerror?
1008 }
1009
1010
1011
1012 log_err(echannel, "handle_read_frame", ecm);
1013 this->terminate(ecm);
1014 return;
1015 }
1016
1017 // Boundaries checking. TODO: How much of this should be done?
1018 /*if (bytes_transferred > config::connection_read_buffer_size) {
1019 m_elog->write(log::elevel::fatal,"Fatal boundaries checking error");
1020 this->terminate(make_error_code(error::general));
1021 return;
1022 }*/
1023
1024 size_t p = 0;
1025
1026 if (m_alog->static_test(log::alevel::devel)) {
1027 std::stringstream s;
1028 s << "p = " << p << " bytes transferred = " << bytes_transferred;
1029 m_alog->write(log::alevel::devel,s.str());
1030 }
1031
1032 while (p < bytes_transferred) {
1033 if (m_alog->static_test(log::alevel::devel)) {
1034 std::stringstream s;
1035 s << "calling consume with " << bytes_transferred-p << " bytes";
1036 m_alog->write(log::alevel::devel,s.str());
1037 }
1038
1039 lib::error_code consume_ec;
1040
1041 if (m_alog->static_test(log::alevel::devel)) {
1042 std::stringstream s;
1043 s << "Processing Bytes: " << utility::to_hex(reinterpret_cast<uint8_t*>(m_buf)+p,bytes_transferred-p);
1044 m_alog->write(log::alevel::devel,s.str());
1045 }
1046
1047 p += m_processor->consume(
1048 reinterpret_cast<uint8_t*>(m_buf)+p,
1049 bytes_transferred-p,
1050 consume_ec
1051 );
1052
1053 if (m_alog->static_test(log::alevel::devel)) {
1054 std::stringstream s;
1055 s << "bytes left after consume: " << bytes_transferred-p;
1056 m_alog->write(log::alevel::devel,s.str());
1057 }
1058 if (consume_ec) {
1059 log_err(log::elevel::rerror, "consume", consume_ec);
1060
1061 if (config::drop_on_protocol_error) {
1062 this->terminate(consume_ec);
1063 return;
1064 } else {
1065 lib::error_code close_ec;
1066 this->close(
1067 processor::error::to_ws(consume_ec),
1068 consume_ec.message(),
1069 close_ec
1070 );
1071
1072 if (close_ec) {
1073 log_err(log::elevel::fatal, "Protocol error close frame ", close_ec);
1074 this->terminate(close_ec);
1075 return;
1076 }
1077 }
1078 return;
1079 }
1080
1081 if (m_processor->ready()) {
1082 if (m_alog->static_test(log::alevel::devel)) {
1083 std::stringstream s;
1084 s << "Complete message received. Dispatching";
1085 m_alog->write(log::alevel::devel,s.str());
1086 }
1087
1088 message_ptr msg = m_processor->get_message();
1089
1090 if (!msg) {
1091 m_alog->write(log::alevel::devel, "null message from m_processor");
1092 } else if (!is_control(msg->get_opcode())) {
1093 // data message, dispatch to user
1094 if (m_state != session::state::open) {
1095 m_elog->write(log::elevel::warn, "got non-close frame while closing");
1096 } else if (m_message_handler) {
1097 m_message_handler(m_connection_hdl, msg);
1098 }
1099 } else {
1100 process_control_frame(msg);
1101 }
1102 }
1103 }
1104
1106}
1107
1108/// Issue a new transport read unless reading is paused.
1109template <typename config>
1110void connection<config>::read_frame() {
1111 if (!m_read_flag) {
1112 return;
1113 }
1114
1115 transport_con_type::async_read_at_least(
1116 // std::min wont work with undefined static const values.
1117 // TODO: is there a more elegant way to do this?
1118 // Need to determine if requesting 1 byte or the exact number of bytes
1119 // is better here. 1 byte lets us be a bit more responsive at a
1120 // potential expense of additional runs through handle_read_frame
1121 /*(m_processor->get_bytes_needed() > config::connection_read_buffer_size ?
1122 config::connection_read_buffer_size : m_processor->get_bytes_needed())*/
1123 1,
1124 m_buf,
1125 config::connection_read_buffer_size,
1126 m_handle_read_frame
1127 );
1128}
1129
1130template <typename config>
1131lib::error_code connection<config>::initialize_processor() {
1132 m_alog->write(log::alevel::devel,"initialize_processor");
1133
1134 // if it isn't a websocket handshake nothing to do.
1135 if (!processor::is_websocket_handshake(m_request)) {
1136 return lib::error_code();
1137 }
1138
1139 int version = processor::get_websocket_version(m_request);
1140
1141 if (version < 0) {
1142 m_alog->write(log::alevel::devel, "BAD REQUEST: can't determine version");
1143 m_response.set_status(http::status_code::bad_request);
1144 return error::make_error_code(error::invalid_version);
1145 }
1146
1147 m_processor = get_processor(version);
1148
1149 // if the processor is not null we are done
1150 if (m_processor) {
1151 return lib::error_code();
1152 }
1153
1154 // We don't have a processor for this version. Return bad request
1155 // with Sec-WebSocket-Version header filled with values we do accept
1156 m_alog->write(log::alevel::devel, "BAD REQUEST: no processor for version");
1157 m_response.set_status(http::status_code::bad_request);
1158
1159 std::stringstream ss;
1160 std::string sep;
1161 std::vector<int>::const_iterator it;
1162 for (it = versions_supported.begin(); it != versions_supported.end(); it++)
1163 {
1164 ss << sep << *it;
1165 sep = ",";
1166 }
1167
1168 m_response.replace_header("Sec-WebSocket-Version",ss.str());
1169 return error::make_error_code(error::unsupported_version);
1170}
1171
1172template <typename config>
1173lib::error_code connection<config>::process_handshake_request() {
1174 m_alog->write(log::alevel::devel,"process handshake request");
1175
1176 if (!processor::is_websocket_handshake(m_request)) {
1177 // this is not a websocket handshake. Process as plain HTTP
1178 m_alog->write(log::alevel::devel,"HTTP REQUEST");
1179
1180 // extract URI from request
1181 m_uri = processor::get_uri_from_host(
1182 m_request,
1183 (transport_con_type::is_secure() ? "https" : "http")
1184 );
1185
1186 if (!m_uri->get_valid()) {
1187 m_alog->write(log::alevel::devel, "Bad request: failed to parse uri");
1188 m_response.set_status(http::status_code::bad_request);
1189 return error::make_error_code(error::invalid_uri);
1190 }
1191
1192 if (m_http_handler) {
1193 m_is_http = true;
1194 m_http_handler(m_connection_hdl);
1195
1196 if (m_state == session::state::closed) {
1197 return error::make_error_code(error::http_connection_ended);
1198 }
1199 } else {
1200 set_status(http::status_code::upgrade_required);
1201 return error::make_error_code(error::upgrade_required);
1202 }
1203
1204 return lib::error_code();
1205 }
1206
1207 lib::error_code ec = m_processor->validate_handshake(m_request);
1208
1209 // Validate: make sure all required elements are present.
1210 if (ec){
1211 // Not a valid handshake request
1212 m_alog->write(log::alevel::devel, "Bad request " + ec.message());
1213 m_response.set_status(http::status_code::bad_request);
1214 return ec;
1215 }
1216
1217 // Read extension parameters and set up values necessary for the end user
1218 // to complete extension negotiation.
1219 std::pair<lib::error_code,std::string> neg_results;
1220 neg_results = m_processor->negotiate_extensions(m_request);
1221
1223 // There was a fatal error in extension parsing that should result in
1224 // a failed connection attempt.
1225 m_elog->write(log::elevel::info, "Bad request: " + neg_results.first.message());
1226 m_response.set_status(http::status_code::bad_request);
1227 return neg_results.first;
1228 } else if (neg_results.first) {
1229 // There was a fatal error in extension processing that is probably our
1230 // fault. Consider extension negotiation to have failed and continue as
1231 // if extensions were not supported
1232 m_elog->write(log::elevel::info,
1233 "Extension negotiation failed: " + neg_results.first.message());
1234 } else {
1235 // extension negotiation succeeded, set response header accordingly
1236 // we don't send an empty extensions header because it breaks many
1237 // clients.
1238 if (neg_results.second.size() > 0) {
1239 m_response.replace_header("Sec-WebSocket-Extensions",
1240 neg_results.second);
1241 }
1242 }
1243
1244 // extract URI from request
1245 m_uri = m_processor->get_uri(m_request);
1246
1247
1248 if (!m_uri->get_valid()) {
1249 m_alog->write(log::alevel::devel, "Bad request: failed to parse uri");
1250 m_response.set_status(http::status_code::bad_request);
1251 return error::make_error_code(error::invalid_uri);
1252 }
1253
1254 // extract subprotocols
1255 lib::error_code subp_ec = m_processor->extract_subprotocols(m_request,
1256 m_requested_subprotocols);
1257
1258 if (subp_ec) {
1259 // should we do anything?
1260 }
1261
1262 // Ask application to validate the connection
1263 if (!m_validate_handler || m_validate_handler(m_connection_hdl)) {
1264 m_response.set_status(http::status_code::switching_protocols);
1265
1266 // Write the appropriate response headers based on request and
1267 // processor version
1268 ec = m_processor->process_handshake(m_request,m_subprotocol,m_response);
1269
1270 if (ec) {
1271 std::stringstream s;
1272 s << "Processing error: " << ec << "(" << ec.message() << ")";
1273 m_alog->write(log::alevel::devel, s.str());
1274
1275 m_response.set_status(http::status_code::internal_server_error);
1276 return ec;
1277 }
1278 } else {
1279 // User application has rejected the handshake
1280 m_alog->write(log::alevel::devel, "USER REJECT");
1281
1282 // Use Bad Request if the user handler did not provide a more
1283 // specific http response error code.
1284 // TODO: is there a better default?
1285 if (m_response.get_status_code() == http::status_code::uninitialized) {
1286 m_response.set_status(http::status_code::bad_request);
1287 }
1288
1289 return error::make_error_code(error::rejected);
1290 }
1291
1292 return lib::error_code();
1293}
1294
1295template <typename config>
1296void connection<config>::write_http_response(lib::error_code const & ec) {
1297 m_alog->write(log::alevel::devel,"connection write_http_response");
1298
1299 if (ec == error::make_error_code(error::http_connection_ended)) {
1300 m_alog->write(log::alevel::http,"An HTTP handler took over the connection.");
1301 return;
1302 }
1303
1304 if (m_response.get_status_code() == http::status_code::uninitialized) {
1305 m_response.set_status(http::status_code::internal_server_error);
1306 m_ec = error::make_error_code(error::general);
1307 } else {
1308 m_ec = ec;
1309 }
1310
1311 m_response.set_version("HTTP/1.1");
1312
1313 // Set server header based on the user agent settings
1314 if (m_response.get_header("Server").empty()) {
1315 if (!m_user_agent.empty()) {
1316 m_response.replace_header("Server",m_user_agent);
1317 } else {
1318 m_response.remove_header("Server");
1319 }
1320 }
1321
1322 // have the processor generate the raw bytes for the wire (if it exists)
1323 if (m_processor) {
1324 m_handshake_buffer = m_processor->get_raw(m_response);
1325 } else {
1326 // a processor wont exist for raw HTTP responses.
1327 m_handshake_buffer = m_response.raw();
1328 }
1329
1330 if (m_alog->static_test(log::alevel::devel)) {
1331 m_alog->write(log::alevel::devel,"Raw Handshake response:\n"+m_handshake_buffer);
1332 if (!m_response.get_header("Sec-WebSocket-Key3").empty()) {
1333 m_alog->write(log::alevel::devel,
1334 utility::to_hex(m_response.get_header("Sec-WebSocket-Key3")));
1335 }
1336 }
1337
1338 // write raw bytes
1339 transport_con_type::async_write(
1340 m_handshake_buffer.data(),
1341 m_handshake_buffer.size(),
1342 lib::bind(
1343 &type::handle_write_http_response,
1345 lib::placeholders::_1
1346 )
1347 );
1348}
1349
1350template <typename config>
1351void connection<config>::handle_write_http_response(lib::error_code const & ec) {
1352 m_alog->write(log::alevel::devel,"handle_write_http_response");
1353
1354 lib::error_code ecm = ec;
1355
1356 if (!ecm) {
1357 scoped_lock_type lock(m_connection_state_lock);
1358
1359 if (m_state == session::state::connecting) {
1360 if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
1361 ecm = error::make_error_code(error::invalid_state);
1362 }
1363 } else if (m_state == session::state::closed) {
1364 // The connection was canceled while the response was being sent,
1365 // usually by the handshake timer. This is basically expected
1366 // (though hopefully rare) and there is nothing we can do so ignore.
1367 m_alog->write(log::alevel::devel,
1368 "handle_write_http_response invoked after connection was closed");
1369 return;
1370 } else {
1371 ecm = error::make_error_code(error::invalid_state);
1372 }
1373 }
1374
1375 if (ecm) {
1376 if (ecm == transport::error::eof && m_state == session::state::closed) {
1377 // we expect to get eof if the connection is closed already
1378 m_alog->write(log::alevel::devel,
1379 "got (expected) eof/state error from closed con");
1380 return;
1381 }
1382
1383 log_err(log::elevel::rerror,"handle_write_http_response",ecm);
1384 this->terminate(ecm);
1385 return;
1386 }
1387
1388 if (m_handshake_timer) {
1389 m_handshake_timer->cancel();
1390 m_handshake_timer.reset();
1391 }
1392
1393 if (m_response.get_status_code() != http::status_code::switching_protocols)
1394 {
1395 /*if (m_processor || m_ec == error::http_parse_error ||
1396 m_ec == error::invalid_version || m_ec == error::unsupported_version
1397 || m_ec == error::upgrade_required)
1398 {*/
1399 if (!m_is_http) {
1400 std::stringstream s;
1401 s << "Handshake ended with HTTP error: "
1402 << m_response.get_status_code();
1403 m_elog->write(log::elevel::rerror,s.str());
1404 } else {
1405 // if this was not a websocket connection, we have written
1406 // the expected response and the connection can be closed.
1407
1408 this->log_http_result();
1409
1410 if (m_ec) {
1411 m_alog->write(log::alevel::devel,
1412 "got to writing HTTP results with m_ec set: "+m_ec.message());
1413 }
1414 m_ec = make_error_code(error::http_connection_ended);
1415 }
1416
1417 this->terminate(m_ec);
1418 return;
1419 }
1420
1421 this->log_open_result();
1422
1423 m_internal_state = istate::PROCESS_CONNECTION;
1424 m_state = session::state::open;
1425
1426 if (m_open_handler) {
1427 m_open_handler(m_connection_hdl);
1428 }
1429
1430 this->handle_read_frame(lib::error_code(), m_buf_cursor);
1431}
1432
1433template <typename config>
1434void connection<config>::send_http_request() {
1435 m_alog->write(log::alevel::devel,"connection send_http_request");
1436
1437 // TODO: origin header?
1438
1439 // Have the protocol processor fill in the appropriate fields based on the
1440 // selected client version
1441 if (m_processor) {
1442 lib::error_code ec;
1443 ec = m_processor->client_handshake_request(m_request,m_uri,
1444 m_requested_subprotocols);
1445
1446 if (ec) {
1447 log_err(log::elevel::fatal,"Internal library error: Processor",ec);
1448 return;
1449 }
1450 } else {
1451 m_elog->write(log::elevel::fatal,"Internal library error: missing processor");
1452 return;
1453 }
1454
1455 // Unless the user has overridden the user agent, send generic WS++ UA.
1456 if (m_request.get_header("User-Agent").empty()) {
1457 if (!m_user_agent.empty()) {
1458 m_request.replace_header("User-Agent",m_user_agent);
1459 } else {
1460 m_request.remove_header("User-Agent");
1461 }
1462 }
1463
1464 m_handshake_buffer = m_request.raw();
1465
1466 if (m_alog->static_test(log::alevel::devel)) {
1467 m_alog->write(log::alevel::devel,"Raw Handshake request:\n"+m_handshake_buffer);
1468 }
1469
1470 if (m_open_handshake_timeout_dur > 0) {
1471 m_handshake_timer = transport_con_type::set_timer(
1472 m_open_handshake_timeout_dur,
1473 lib::bind(
1474 &type::handle_open_handshake_timeout,
1476 lib::placeholders::_1
1477 )
1478 );
1479 }
1480
1481 transport_con_type::async_write(
1482 m_handshake_buffer.data(),
1483 m_handshake_buffer.size(),
1484 lib::bind(
1485 &type::handle_send_http_request,
1487 lib::placeholders::_1
1488 )
1489 );
1490}
1491
1492template <typename config>
1493void connection<config>::handle_send_http_request(lib::error_code const & ec) {
1494 m_alog->write(log::alevel::devel,"handle_send_http_request");
1495
1496 lib::error_code ecm = ec;
1497
1498 if (!ecm) {
1499 scoped_lock_type lock(m_connection_state_lock);
1500
1501 if (m_state == session::state::connecting) {
1502 if (m_internal_state != istate::WRITE_HTTP_REQUEST) {
1503 ecm = error::make_error_code(error::invalid_state);
1504 } else {
1505 m_internal_state = istate::READ_HTTP_RESPONSE;
1506 }
1507 } else if (m_state == session::state::closed) {
1508 // The connection was canceled while the response was being sent,
1509 // usually by the handshake timer. This is basically expected
1510 // (though hopefully rare) and there is nothing we can do so ignore.
1511 m_alog->write(log::alevel::devel,
1512 "handle_send_http_request invoked after connection was closed");
1513 return;
1514 } else {
1515 ecm = error::make_error_code(error::invalid_state);
1516 }
1517 }
1518
1519 if (ecm) {
1520 if (ecm == transport::error::eof && m_state == session::state::closed) {
1521 // we expect to get eof if the connection is closed already
1522 m_alog->write(log::alevel::devel,
1523 "got (expected) eof/state error from closed con");
1524 return;
1525 }
1526
1527 log_err(log::elevel::rerror,"handle_send_http_request",ecm);
1528 this->terminate(ecm);
1529 return;
1530 }
1531
1532 transport_con_type::async_read_at_least(
1533 1,
1534 m_buf,
1535 config::connection_read_buffer_size,
1536 lib::bind(
1537 &type::handle_read_http_response,
1539 lib::placeholders::_1,
1540 lib::placeholders::_2
1541 )
1542 );
1543}
1544
1545template <typename config>
1546void connection<config>::handle_read_http_response(lib::error_code const & ec,
1547 size_t bytes_transferred)
1548{
1549 m_alog->write(log::alevel::devel,"handle_read_http_response");
1550
1551 lib::error_code ecm = ec;
1552
1553 if (!ecm) {
1554 scoped_lock_type lock(m_connection_state_lock);
1555
1556 if (m_state == session::state::connecting) {
1557 if (m_internal_state != istate::READ_HTTP_RESPONSE) {
1558 ecm = error::make_error_code(error::invalid_state);
1559 }
1560 } else if (m_state == session::state::closed) {
1561 // The connection was canceled while the response was being sent,
1562 // usually by the handshake timer. This is basically expected
1563 // (though hopefully rare) and there is nothing we can do so ignore.
1564 m_alog->write(log::alevel::devel,
1565 "handle_read_http_response invoked after connection was closed");
1566 return;
1567 } else {
1568 ecm = error::make_error_code(error::invalid_state);
1569 }
1570 }
1571
1572 if (ecm) {
1573 if (ecm == transport::error::eof && m_state == session::state::closed) {
1574 // we expect to get eof if the connection is closed already
1575 m_alog->write(log::alevel::devel,
1576 "got (expected) eof/state error from closed con");
1577 return;
1578 }
1579
1580 log_err(log::elevel::rerror,"handle_read_http_response",ecm);
1581 this->terminate(ecm);
1582 return;
1583 }
1584
1585 size_t bytes_processed = 0;
1586 // TODO: refactor this to use error codes rather than exceptions
1587 try {
1588 bytes_processed = m_response.consume(m_buf,bytes_transferred);
1589 } catch (http::exception & e) {
1590 m_elog->write(log::elevel::rerror,
1591 std::string("error in handle_read_http_response: ")+e.what());
1592 this->terminate(make_error_code(error::general));
1593 return;
1594 }
1595
1596 m_alog->write(log::alevel::devel,std::string("Raw response: ")+m_response.raw());
1597
1598 if (m_response.headers_ready()) {
1599 if (m_handshake_timer) {
1600 m_handshake_timer->cancel();
1601 m_handshake_timer.reset();
1602 }
1603
1604 lib::error_code validate_ec = m_processor->validate_server_handshake_response(
1605 m_request,
1606 m_response
1607 );
1608 if (validate_ec) {
1609 log_err(log::elevel::rerror,"Server handshake response",validate_ec);
1610 this->terminate(validate_ec);
1611 return;
1612 }
1613
1614 // Read extension parameters and set up values necessary for the end
1615 // user to complete extension negotiation.
1616 std::pair<lib::error_code,std::string> neg_results;
1617 neg_results = m_processor->negotiate_extensions(m_response);
1618
1619 if (neg_results.first) {
1620 // There was a fatal error in extension negotiation. For the moment
1621 // kill all connections that fail extension negotiation.
1622
1623 // TODO: deal with cases where the response is well formed but
1624 // doesn't match the options requested by the client. Its possible
1625 // that the best behavior in this cases is to log and continue with
1626 // an unextended connection.
1627 m_alog->write(log::alevel::devel, "Extension negotiation failed: "
1628 + neg_results.first.message());
1629 this->terminate(make_error_code(error::extension_neg_failed));
1630 // TODO: close connection with reason 1010 (and list extensions)
1631 }
1632
1633 // response is valid, connection can now be assumed to be open
1634 m_internal_state = istate::PROCESS_CONNECTION;
1635 m_state = session::state::open;
1636
1637 this->log_open_result();
1638
1639 if (m_open_handler) {
1640 m_open_handler(m_connection_hdl);
1641 }
1642
1643 // The remaining bytes in m_buf are frame data. Copy them to the
1644 // beginning of the buffer and note the length. They will be read after
1645 // the handshake completes and before more bytes are read.
1646 std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
1647 m_buf_cursor = bytes_transferred-bytes_processed;
1648
1649 this->handle_read_frame(lib::error_code(), m_buf_cursor);
1650 } else {
1651 transport_con_type::async_read_at_least(
1652 1,
1653 m_buf,
1654 config::connection_read_buffer_size,
1655 lib::bind(
1656 &type::handle_read_http_response,
1658 lib::placeholders::_1,
1659 lib::placeholders::_2
1660 )
1661 );
1662 }
1663}
1664
1665template <typename config>
1666void connection<config>::handle_open_handshake_timeout(
1667 lib::error_code const & ec)
1668{
1670 m_alog->write(log::alevel::devel,"open handshake timer cancelled");
1671 } else if (ec) {
1672 m_alog->write(log::alevel::devel,
1673 "open handle_open_handshake_timeout error: "+ec.message());
1674 // TODO: ignore or fail here?
1675 } else {
1676 m_alog->write(log::alevel::devel,"open handshake timer expired");
1677 terminate(make_error_code(error::open_handshake_timeout));
1678 }
1679}
1680
1681template <typename config>
1682void connection<config>::handle_close_handshake_timeout(
1683 lib::error_code const & ec)
1684{
1686 m_alog->write(log::alevel::devel,"asio close handshake timer cancelled");
1687 } else if (ec) {
1688 m_alog->write(log::alevel::devel,
1689 "asio open handle_close_handshake_timeout error: "+ec.message());
1690 // TODO: ignore or fail here?
1691 } else {
1692 m_alog->write(log::alevel::devel, "asio close handshake timer expired");
1693 terminate(make_error_code(error::close_handshake_timeout));
1694 }
1695}
1696
1697template <typename config>
1698void connection<config>::terminate(lib::error_code const & ec) {
1699 if (m_alog->static_test(log::alevel::devel)) {
1700 m_alog->write(log::alevel::devel,"connection terminate");
1701 }
1702
1703 // Cancel close handshake timer
1704 if (m_handshake_timer) {
1705 m_handshake_timer->cancel();
1706 m_handshake_timer.reset();
1707 }
1708
1709 terminate_status tstat = unknown;
1710 if (ec) {
1711 m_ec = ec;
1712 m_local_close_code = close::status::abnormal_close;
1713 m_local_close_reason = ec.message();
1714 }
1715
1716 // TODO: does any of this need a mutex?
1717 if (m_is_http) {
1718 m_http_state = session::http_state::closed;
1719 }
1720 if (m_state == session::state::connecting) {
1721 m_state = session::state::closed;
1722 tstat = failed;
1723
1724 // Log fail result here before socket is shut down and we can't get
1725 // the remote address, etc anymore
1726 if (m_ec != error::http_connection_ended) {
1727 log_fail_result();
1728 }
1729 } else if (m_state != session::state::closed) {
1730 m_state = session::state::closed;
1731 tstat = closed;
1732 } else {
1733 m_alog->write(log::alevel::devel,
1734 "terminate called on connection that was already terminated");
1735 return;
1736 }
1737
1738 // TODO: choose between shutdown and close based on error code sent
1739
1740 transport_con_type::async_shutdown(
1741 lib::bind(
1742 &type::handle_terminate,
1744 tstat,
1745 lib::placeholders::_1
1746 )
1747 );
1748}
1749
1750template <typename config>
1751void connection<config>::handle_terminate(terminate_status tstat,
1752 lib::error_code const & ec)
1753{
1754 if (m_alog->static_test(log::alevel::devel)) {
1755 m_alog->write(log::alevel::devel,"connection handle_terminate");
1756 }
1757
1758 if (ec) {
1759 // there was an error actually shutting down the connection
1760 log_err(log::elevel::devel,"handle_terminate",ec);
1761 }
1762
1763 // clean shutdown
1764 if (tstat == failed) {
1765 if (m_ec != error::http_connection_ended) {
1766 if (m_fail_handler) {
1767 m_fail_handler(m_connection_hdl);
1768 }
1769 }
1770 } else if (tstat == closed) {
1771 if (m_close_handler) {
1772 m_close_handler(m_connection_hdl);
1773 }
1774 log_close_result();
1775 } else {
1776 m_elog->write(log::elevel::rerror,"Unknown terminate_status");
1777 }
1778
1779 // call the termination handler if it exists
1780 // if it exists it might (but shouldn't) refer to a bad memory location.
1781 // If it does, we don't care and should catch and ignore it.
1782 if (m_termination_handler) {
1783 try {
1784 m_termination_handler(type::get_shared());
1785 } catch (std::exception const & e) {
1786 m_elog->write(log::elevel::warn,
1787 std::string("termination_handler call failed. Reason was: ")+e.what());
1788 }
1789 }
1790}
1791
1792template <typename config>
1793void connection<config>::write_frame() {
1794 //m_alog->write(log::alevel::devel,"connection write_frame");
1795
1796 {
1797 scoped_lock_type lock(m_write_lock);
1798
1799 // Check the write flag. If true, there is an outstanding transport
1800 // write already. In this case we just return. The write handler will
1801 // start a new write if the write queue isn't empty. If false, we set
1802 // the write flag and proceed to initiate a transport write.
1803 if (m_write_flag) {
1804 return;
1805 }
1806
1807 // pull off all the messages that are ready to write.
1808 // stop if we get a message marked terminal
1809 message_ptr next_message = write_pop();
1810 while (next_message) {
1811 m_current_msgs.push_back(next_message);
1812 if (!next_message->get_terminal()) {
1813 next_message = write_pop();
1814 } else {
1815 next_message = message_ptr();
1816 }
1817 }
1818
1819 if (m_current_msgs.empty()) {
1820 // there was nothing to send
1821 return;
1822 } else {
1823 // At this point we own the next messages to be sent and are
1824 // responsible for holding the write flag until they are
1825 // successfully sent or there is some error
1826 m_write_flag = true;
1827 }
1828 }
1829
1830 typename std::vector<message_ptr>::iterator it;
1831 for (it = m_current_msgs.begin(); it != m_current_msgs.end(); ++it) {
1832 std::string const & header = (*it)->get_header();
1833 std::string const & payload = (*it)->get_payload();
1834
1835 m_send_buffer.push_back(transport::buffer(header.c_str(),header.size()));
1836 m_send_buffer.push_back(transport::buffer(payload.c_str(),payload.size()));
1837 }
1838
1839 // Print detailed send stats if those log levels are enabled
1840 if (m_alog->static_test(log::alevel::frame_header)) {
1841 if (m_alog->dynamic_test(log::alevel::frame_header)) {
1842 std::stringstream general,header,payload;
1843
1844 general << "Dispatching write containing " << m_current_msgs.size()
1845 <<" message(s) containing ";
1846 header << "Header Bytes: \n";
1847 payload << "Payload Bytes: \n";
1848
1849 size_t hbytes = 0;
1850 size_t pbytes = 0;
1851
1852 for (size_t i = 0; i < m_current_msgs.size(); i++) {
1853 hbytes += m_current_msgs[i]->get_header().size();
1854 pbytes += m_current_msgs[i]->get_payload().size();
1855
1856
1857 header << "[" << i << "] ("
1858 << m_current_msgs[i]->get_header().size() << ") "
1859 << utility::to_hex(m_current_msgs[i]->get_header()) << "\n";
1860
1861 if (m_alog->static_test(log::alevel::frame_payload)) {
1862 if (m_alog->dynamic_test(log::alevel::frame_payload)) {
1863 payload << "[" << i << "] ("
1864 << m_current_msgs[i]->get_payload().size() << ") ["<<m_current_msgs[i]->get_opcode()<<"] "
1865 << (m_current_msgs[i]->get_opcode() == frame::opcode::text ?
1866 m_current_msgs[i]->get_payload() :
1867 utility::to_hex(m_current_msgs[i]->get_payload())
1868 )
1869 << "\n";
1870 }
1871 }
1872 }
1873
1874 general << hbytes << " header bytes and " << pbytes << " payload bytes";
1875
1876 m_alog->write(log::alevel::frame_header,general.str());
1877 m_alog->write(log::alevel::frame_header,header.str());
1878 m_alog->write(log::alevel::frame_payload,payload.str());
1879 }
1880 }
1881
1882 transport_con_type::async_write(
1883 m_send_buffer,
1884 m_write_frame_handler
1885 );
1886}
1887
1888template <typename config>
1889void connection<config>::handle_write_frame(lib::error_code const & ec)
1890{
1891 if (m_alog->static_test(log::alevel::devel)) {
1892 m_alog->write(log::alevel::devel,"connection handle_write_frame");
1893 }
1894
1895 bool terminal = m_current_msgs.back()->get_terminal();
1896
1897 m_send_buffer.clear();
1898 m_current_msgs.clear();
1899 // TODO: recycle instead of deleting
1900
1901 if (ec) {
1902 log_err(log::elevel::fatal,"handle_write_frame",ec);
1903 this->terminate(ec);
1904 return;
1905 }
1906
1907 if (terminal) {
1908 this->terminate(lib::error_code());
1909 return;
1910 }
1911
1912 bool needs_writing = false;
1913 {
1914 scoped_lock_type lock(m_write_lock);
1915
1916 // release write flag
1917 m_write_flag = false;
1918
1919 needs_writing = !m_send_queue.empty();
1920 }
1921
1922 if (needs_writing) {
1923 transport_con_type::dispatch(lib::bind(
1926 ));
1927 }
1928}
1929
1930template <typename config>
1931std::vector<int> const & connection<config>::get_supported_versions() const
1932{
1933 return versions_supported;
1934}
1935
1936template <typename config>
1937void connection<config>::process_control_frame(typename config::message_type::ptr msg)
1938{
1939 m_alog->write(log::alevel::devel,"process_control_frame");
1940
1941 frame::opcode::value op = msg->get_opcode();
1942 lib::error_code ec;
1943
1944 std::stringstream s;
1945 s << "Control frame received with opcode " << op;
1946 m_alog->write(log::alevel::control,s.str());
1947
1948 if (m_state == session::state::closed) {
1949 m_elog->write(log::elevel::warn,"got frame in state closed");
1950 return;
1951 }
1952 if (op != frame::opcode::CLOSE && m_state != session::state::open) {
1953 m_elog->write(log::elevel::warn,"got non-close frame in state closing");
1954 return;
1955 }
1956
1957 if (op == frame::opcode::PING) {
1958 bool should_reply = true;
1959
1960 if (m_ping_handler) {
1961 should_reply = m_ping_handler(m_connection_hdl, msg->get_payload());
1962 }
1963
1964 if (should_reply) {
1965 this->pong(msg->get_payload(),ec);
1966 if (ec) {
1967 log_err(log::elevel::devel,"Failed to send response pong",ec);
1968 }
1969 }
1970 } else if (op == frame::opcode::PONG) {
1971 if (m_pong_handler) {
1972 m_pong_handler(m_connection_hdl, msg->get_payload());
1973 }
1974 if (m_ping_timer) {
1975 m_ping_timer->cancel();
1976 }
1977 } else if (op == frame::opcode::CLOSE) {
1978 m_alog->write(log::alevel::devel,"got close frame");
1979 // record close code and reason somewhere
1980
1981 m_remote_close_code = close::extract_code(msg->get_payload(),ec);
1982 if (ec) {
1983 s.str("");
1984 if (config::drop_on_protocol_error) {
1985 s << "Received invalid close code " << m_remote_close_code
1986 << " dropping connection per config.";
1987 m_elog->write(log::elevel::devel,s.str());
1988 this->terminate(ec);
1989 } else {
1990 s << "Received invalid close code " << m_remote_close_code
1991 << " sending acknowledgement and closing";
1992 m_elog->write(log::elevel::devel,s.str());
1993 ec = send_close_ack(close::status::protocol_error,
1994 "Invalid close code");
1995 if (ec) {
1996 log_err(log::elevel::devel,"send_close_ack",ec);
1997 }
1998 }
1999 return;
2000 }
2001
2002 m_remote_close_reason = close::extract_reason(msg->get_payload(),ec);
2003 if (ec) {
2004 if (config::drop_on_protocol_error) {
2005 m_elog->write(log::elevel::devel,
2006 "Received invalid close reason. Dropping connection per config");
2007 this->terminate(ec);
2008 } else {
2009 m_elog->write(log::elevel::devel,
2010 "Received invalid close reason. Sending acknowledgement and closing");
2011 ec = send_close_ack(close::status::protocol_error,
2012 "Invalid close reason");
2013 if (ec) {
2014 log_err(log::elevel::devel,"send_close_ack",ec);
2015 }
2016 }
2017 return;
2018 }
2019
2020 if (m_state == session::state::open) {
2021 s.str("");
2022 s << "Received close frame with code " << m_remote_close_code
2023 << " and reason " << m_remote_close_reason;
2024 m_alog->write(log::alevel::devel,s.str());
2025
2026 ec = send_close_ack();
2027 if (ec) {
2028 log_err(log::elevel::devel,"send_close_ack",ec);
2029 }
2030 } else if (m_state == session::state::closing && !m_was_clean) {
2031 // ack of our close
2032 m_alog->write(log::alevel::devel, "Got acknowledgement of close");
2033
2034 m_was_clean = true;
2035
2036 // If we are a server terminate the connection now. Clients should
2037 // leave the connection open to give the server an opportunity to
2038 // initiate the TCP close. The client's timer will handle closing
2039 // its side of the connection if the server misbehaves.
2040 //
2041 // TODO: different behavior if the underlying transport doesn't
2042 // support timers?
2043 if (m_is_server) {
2044 terminate(lib::error_code());
2045 }
2046 } else {
2047 // spurious, ignore
2048 m_elog->write(log::elevel::devel, "Got close frame in wrong state");
2049 }
2050 } else {
2051 // got an invalid control opcode
2052 m_elog->write(log::elevel::devel, "Got control frame with invalid opcode");
2053 // initiate protocol error shutdown
2054 }
2055}
2056
2057template <typename config>
2058lib::error_code connection<config>::send_close_ack(close::status::value code,
2059 std::string const & reason)
2060{
2061 return send_close_frame(code,reason,true,m_is_server);
2062}
2063
2064template <typename config>
2065lib::error_code connection<config>::send_close_frame(close::status::value code,
2066 std::string const & reason, bool ack, bool terminal)
2067{
2068 m_alog->write(log::alevel::devel,"send_close_frame");
2069
2070 // check for special codes
2071
2072 // If silent close is set, respect it and blank out close information
2073 // Otherwise use whatever has been specified in the parameters. If
2074 // parameters specifies close::status::blank then determine what to do
2075 // based on whether or not this is an ack. If it is not an ack just
2076 // send blank info. If it is an ack then echo the close information from
2077 // the remote endpoint.
2078 if (config::silent_close) {
2079 m_alog->write(log::alevel::devel,"closing silently");
2080 m_local_close_code = close::status::no_status;
2081 m_local_close_reason.clear();
2082 } else if (code != close::status::blank) {
2083 m_alog->write(log::alevel::devel,"closing with specified codes");
2084 m_local_close_code = code;
2085 m_local_close_reason = reason;
2086 } else if (!ack) {
2087 m_alog->write(log::alevel::devel,"closing with no status code");
2088 m_local_close_code = close::status::no_status;
2089 m_local_close_reason.clear();
2090 } else if (m_remote_close_code == close::status::no_status) {
2091 m_alog->write(log::alevel::devel,
2092 "acknowledging a no-status close with normal code");
2093 m_local_close_code = close::status::normal;
2094 m_local_close_reason.clear();
2095 } else {
2096 m_alog->write(log::alevel::devel,"acknowledging with remote codes");
2097 m_local_close_code = m_remote_close_code;
2098 m_local_close_reason = m_remote_close_reason;
2099 }
2100
2101 std::stringstream s;
2102 s << "Closing with code: " << m_local_close_code << ", and reason: "
2103 << m_local_close_reason;
2104 m_alog->write(log::alevel::devel,s.str());
2105
2106 message_ptr msg = m_msg_manager->get_message();
2107 if (!msg) {
2108 return error::make_error_code(error::no_outgoing_buffers);
2109 }
2110
2111 lib::error_code ec = m_processor->prepare_close(m_local_close_code,
2112 m_local_close_reason,msg);
2113 if (ec) {
2114 return ec;
2115 }
2116
2117 // Messages flagged terminal will result in the TCP connection being dropped
2118 // after the message has been written. This is typically used when servers
2119 // send an ack and when any endpoint encounters a protocol error
2120 if (terminal) {
2121 msg->set_terminal(true);
2122 }
2123
2124 m_state = session::state::closing;
2125
2126 if (ack) {
2127 m_was_clean = true;
2128 }
2129
2130 // Start a timer so we don't wait forever for the acknowledgement close
2131 // frame
2132 if (m_close_handshake_timeout_dur > 0) {
2133 m_handshake_timer = transport_con_type::set_timer(
2134 m_close_handshake_timeout_dur,
2135 lib::bind(
2136 &type::handle_close_handshake_timeout,
2138 lib::placeholders::_1
2139 )
2140 );
2141 }
2142
2143 bool needs_writing = false;
2144 {
2145 scoped_lock_type lock(m_write_lock);
2146 write_push(msg);
2147 needs_writing = !m_write_flag && !m_send_queue.empty();
2148 }
2149
2150 if (needs_writing) {
2151 transport_con_type::dispatch(lib::bind(
2154 ));
2155 }
2156
2157 return lib::error_code();
2158}
2159
2160template <typename config>
2161typename connection<config>::processor_ptr
2162connection<config>::get_processor(int version) const {
2163 // TODO: allow disabling certain versions
2164
2165 processor_ptr p;
2166
2167 switch (version) {
2168 case 0:
2169 p = lib::make_shared<processor::hybi00<config> >(
2170 transport_con_type::is_secure(),
2171 m_is_server,
2172 m_msg_manager
2173 );
2174 break;
2175 case 7:
2176 p = lib::make_shared<processor::hybi07<config> >(
2177 transport_con_type::is_secure(),
2178 m_is_server,
2179 m_msg_manager,
2180 lib::ref(m_rng)
2181 );
2182 break;
2183 case 8:
2184 p = lib::make_shared<processor::hybi08<config> >(
2185 transport_con_type::is_secure(),
2186 m_is_server,
2187 m_msg_manager,
2188 lib::ref(m_rng)
2189 );
2190 break;
2191 case 13:
2192 p = lib::make_shared<processor::hybi13<config> >(
2193 transport_con_type::is_secure(),
2194 m_is_server,
2195 m_msg_manager,
2196 lib::ref(m_rng)
2197 );
2198 break;
2199 default:
2200 return p;
2201 }
2202
2203 // Settings not configured by the constructor
2204 p->set_max_message_size(m_max_message_size);
2205
2206 return p;
2207}
2208
2209template <typename config>
2210void connection<config>::write_push(typename config::message_type::ptr msg)
2211{
2212 if (!msg) {
2213 return;
2214 }
2215
2216 m_send_buffer_size += msg->get_payload().size();
2217 m_send_queue.push(msg);
2218
2219 if (m_alog->static_test(log::alevel::devel)) {
2220 std::stringstream s;
2221 s << "write_push: message count: " << m_send_queue.size()
2222 << " buffer size: " << m_send_buffer_size;
2223 m_alog->write(log::alevel::devel,s.str());
2224 }
2225}
2226
2227template <typename config>
2228typename config::message_type::ptr connection<config>::write_pop()
2229{
2230 message_ptr msg;
2231
2232 if (m_send_queue.empty()) {
2233 return msg;
2234 }
2235
2236 msg = m_send_queue.front();
2237
2238 m_send_buffer_size -= msg->get_payload().size();
2239 m_send_queue.pop();
2240
2241 if (m_alog->static_test(log::alevel::devel)) {
2242 std::stringstream s;
2243 s << "write_pop: message count: " << m_send_queue.size()
2244 << " buffer size: " << m_send_buffer_size;
2245 m_alog->write(log::alevel::devel,s.str());
2246 }
2247 return msg;
2248}
2249
2250template <typename config>
2251void connection<config>::log_open_result()
2252{
2253 std::stringstream s;
2254
2255 int version;
2256 if (!processor::is_websocket_handshake(m_request)) {
2257 version = -1;
2258 } else {
2259 version = processor::get_websocket_version(m_request);
2260 }
2261
2262 // Connection Type
2263 s << (version == -1 ? "HTTP" : "WebSocket") << " Connection ";
2264
2265 // Remote endpoint address
2266 s << transport_con_type::get_remote_endpoint() << " ";
2267
2268 // Version string if WebSocket
2269 if (version != -1) {
2270 s << "v" << version << " ";
2271 }
2272
2273 // User Agent
2274 std::string ua = m_request.get_header("User-Agent");
2275 if (ua.empty()) {
2276 s << "\"\" ";
2277 } else {
2278 // check if there are any quotes in the user agent
2279 s << "\"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2280 }
2281
2282 // URI
2283 s << (m_uri ? m_uri->get_resource() : "NULL") << " ";
2284
2285 // Status code
2286 s << m_response.get_status_code();
2287
2288 m_alog->write(log::alevel::connect,s.str());
2289}
2290
2291template <typename config>
2292void connection<config>::log_close_result()
2293{
2294 std::stringstream s;
2295
2296 s << "Disconnect "
2297 << "close local:[" << m_local_close_code
2298 << (m_local_close_reason.empty() ? "" : ","+m_local_close_reason)
2299 << "] remote:[" << m_remote_close_code
2300 << (m_remote_close_reason.empty() ? "" : ","+m_remote_close_reason) << "]";
2301
2302 m_alog->write(log::alevel::disconnect,s.str());
2303}
2304
2305template <typename config>
2306void connection<config>::log_fail_result()
2307{
2308 std::stringstream s;
2309
2310 int version = processor::get_websocket_version(m_request);
2311
2312 // Connection Type
2313 s << "WebSocket Connection ";
2314
2315 // Remote endpoint address & WebSocket version
2316 s << transport_con_type::get_remote_endpoint();
2317 if (version < 0) {
2318 s << " -";
2319 } else {
2320 s << " v" << version;
2321 }
2322
2323 // User Agent
2324 std::string ua = m_request.get_header("User-Agent");
2325 if (ua.empty()) {
2326 s << " \"\" ";
2327 } else {
2328 // check if there are any quotes in the user agent
2329 s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2330 }
2331
2332 // URI
2333 s << (m_uri ? m_uri->get_resource() : "-");
2334
2335 // HTTP Status code
2336 s << " " << m_response.get_status_code();
2337
2338 // WebSocket++ error code & reason
2339 s << " " << m_ec << " " << m_ec.message();
2340
2341 m_alog->write(log::alevel::fail,s.str());
2342}
2343
2344template <typename config>
2345void connection<config>::log_http_result() {
2346 std::stringstream s;
2347
2348 if (processor::is_websocket_handshake(m_request)) {
2349 m_alog->write(log::alevel::devel,"Call to log_http_result for WebSocket");
2350 return;
2351 }
2352
2353 // Connection Type
2354 s << (m_request.get_header("host").empty() ? "-" : m_request.get_header("host"))
2355 << " " << transport_con_type::get_remote_endpoint()
2356 << " \"" << m_request.get_method()
2357 << " " << (m_uri ? m_uri->get_resource() : "-")
2358 << " " << m_request.get_version() << "\" " << m_response.get_status_code()
2359 << " " << m_response.get_body().size();
2360
2361 // User Agent
2362 std::string ua = m_request.get_header("User-Agent");
2363 if (ua.empty()) {
2364 s << " \"\" ";
2365 } else {
2366 // check if there are any quotes in the user agent
2367 s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2368 }
2369
2370 m_alog->write(log::alevel::http,s.str());
2371}
2372
2373} // namespace websocketpp
2374
2375#endif // WEBSOCKETPP_CONNECTION_IMPL_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.
ptr get_shared()
Get a shared pointer to this component.
void handle_interrupt()
Transport inturrupt callback.
void set_message_handler(message_handler h)
Set message handler.
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.
void set_close_handler(close_handler h)
Set close handler.
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.
http::status_code::value get_response_code() const
Get response HTTP status code.
lib::error_code defer_http_response()
Defer HTTP Response until later (Exception free)
lib::error_code resume_reading()
Resume reading of new data.
bool get_secure() const
Returns the secure flag from the connection URI.
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
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.
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.
std::string const & get_resource() const
Returns the resource component of the connection URI.
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)
uri_ptr get_uri() const
Gets the connection URI.
connection_hdl get_handle() const
Get Connection Handle.
void send_http_response(lib::error_code &ec)
Send deferred HTTP Response (exception free)
connection< config > type
Type of this connection.
void set_http_handler(http_handler h)
Set http handler.
std::string const & get_response_msg() const
Get response HTTP status message.
config::elog_type elog_type
Type of the error logging policy.
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.
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 set_status(http::status_code::value code)
Set response status code and message.
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
config::concurrency_type concurrency_type
Type of the concurrency component of this connection.
transport_con_type::timer_ptr timer_ptr
Type of a pointer to a transport timer handle.
void set_validate_handler(validate_handler h)
Set validate handler.
void set_interrupt_handler(interrupt_handler h)
Set interrupt handler.
size_t buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
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.
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.
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.
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.
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the transport component of this connection.
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
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.
std::string const & get_subprotocol() const
Gets the negotated subprotocol.
void set_handle(connection_hdl hdl)
Set Connection Handle.
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.
config::rng_type rng_type
Type of RNG.
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
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
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 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 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 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)
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 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
std::string generate_offer() const
Generate extension offer.
Definition disabled.hpp:99
lib::error_code init(bool)
Initialize state.
Definition disabled.hpp:76
header_list const & get_headers() const
Return a list of all HTTP headers.
Definition parser.hpp:179
size_t process_body(char const *buf, size_t len)
Process body data.
Definition parser.hpp:145
std::string const & get_body() const
Get HTTP body.
Definition parser.hpp:505
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition parser.hpp:161
bool body_ready() const
Check if the parser is done parsing the body.
Definition parser.hpp:599
bool prepare_body()
Prepare the parser to begin parsing body data.
Definition parser.hpp:119
void set_max_body_size(size_t value)
Set body size limit.
Definition parser.hpp:542
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition parser.hpp:183
std::string const & get_version() const
Get the HTTP version string.
Definition parser.hpp:410
size_t get_max_body_size() const
Get body size limit.
Definition parser.hpp:529
Stores, parses, and manipulates HTTP requests.
Definition request.hpp:50
std::string raw() const
Returns the full raw request (including the body)
Definition request.hpp:131
std::string const & get_uri() const
Return the requested URI.
Definition request.hpp:104
std::string const & get_method() const
Return the request method.
Definition request.hpp:96
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition request.hpp:41
bool ready() const
Returns whether or not the request is ready for reading.
Definition request.hpp:82
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request)
Definition request.hpp:141
Stores, parses, and manipulates HTTP responses.
Definition response.hpp:57
void set_status(status_code::value code)
Set response status code and message.
Definition response.hpp:191
std::string raw() const
Returns the full raw response.
Definition response.hpp:178
size_t consume(std::istream &s)
Process bytes in the input buffer (istream version)
Definition response.hpp:139
bool headers_ready() const
Returns true if the response headers are fully parsed.
Definition response.hpp:121
bool ready() const
Returns true if the response is ready.
Definition response.hpp:116
const std::string & get_status_msg() const
Return the response status message.
Definition response.hpp:157
status_code::value get_status_code() const
Return the response status code.
Definition response.hpp:152
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition response.hpp:42
Basic logger that outputs to an ostream.
Definition basic.hpp:59
void write(level channel, char const *msg)
Write a cstring message to the given channel.
Definition basic.hpp:151
bool recycle(message *)
Recycle a message.
Definition alloc.hpp:80
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
Definition alloc.hpp:66
message_ptr get_message()
Get an empty message buffer.
Definition alloc.hpp:55
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Definition alloc.hpp:96
Represents a buffer for a single WebSocket message.
Definition message.hpp:84
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
Definition message.hpp:107
std::string & get_raw_payload()
Get a non-const reference to the payload string.
Definition message.hpp:254
bool recycle()
Recycle the message.
Definition message.hpp:316
bool get_compressed() const
Return whether or not the message is flagged as compressed.
Definition message.hpp:143
bool get_terminal() const
Get whether or not the message is terminal.
Definition message.hpp:169
std::string const & get_header() const
Return the prepared frame header.
Definition message.hpp:224
void set_payload(void const *payload, size_t len)
Set payload data.
Definition message.hpp:275
bool get_fin() const
Read the fin bit.
Definition message.hpp:195
void append_payload(void const *payload, size_t len)
Append payload data.
Definition message.hpp:298
void set_opcode(frame::opcode::value op)
Set the opcode.
Definition message.hpp:215
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
Definition message.hpp:135
frame::opcode::value get_opcode() const
Return the message opcode.
Definition message.hpp:210
void set_terminal(bool value)
Set the terminal flag.
Definition message.hpp:181
bool get_prepared() const
Return whether or not the message has been prepared for sending.
Definition message.hpp:125
void set_compressed(bool value)
Set or clear the compression flag.
Definition message.hpp:156
message(const con_msg_man_ptr manager)
Construct an empty message.
Definition message.hpp:96
void set_fin(bool value)
Set the fin bit.
Definition message.hpp:205
std::string const & get_payload() const
Get a reference to the payload string.
Definition message.hpp:246
Category for processor errors.
Definition base.hpp:161
Processor for Hybi Draft version 00.
Definition hybi00.hpp:54
Processor for Hybi Draft version 07.
Definition hybi07.hpp:44
Processor for Hybi Draft version 08.
Definition hybi08.hpp:44
Processor for Hybi version 13 (RFC6455)
Definition hybi13.hpp:54
WebSocket protocol processor abstract base class.
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)=0
Prepare a data message for writing.
virtual size_t get_bytes_needed() const
virtual size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)=0
process new websocket connection bytes
virtual err_str_pair negotiate_extensions(response_type const &)
Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual int get_version() const =0
Get the protocol version of this processor.
virtual std::string get_raw(response_type const &request) const =0
Given a completed response, get the raw bytes to put on the wire.
virtual bool ready() const =0
Checks if there is a message ready.
virtual lib::error_code validate_handshake(request_type const &request) const =0
validate a WebSocket handshake request for this version
virtual uri_ptr get_uri(request_type const &request) const =0
Extracts client uri from a handshake request.
virtual err_str_pair negotiate_extensions(request_type const &)
Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual bool has_permessage_compress() const
Returns whether or not the permessage_compress extension is implemented.
virtual lib::error_code validate_server_handshake_response(request_type const &req, response_type &res) const =0
Validate the server's response to an outgoing handshake request.
virtual lib::error_code client_handshake_request(request_type &req, uri_ptr uri, std::vector< std::string > const &subprotocols) const =0
Fill in an HTTP request for an outgoing connection handshake.
virtual lib::error_code extract_subprotocols(const request_type &req, std::vector< std::string > &subprotocol_list)=0
Extracts requested subprotocols from a handshake request.
virtual bool get_error() const =0
Tests whether the processor is in a fatal error state.
void set_max_message_size(size_t new_value)
Set maximum message size.
virtual std::string const & get_origin(request_type const &request) const =0
Return the value of the header containing the CORS origin.
size_t get_max_message_size() const
Get maximum message size.
virtual message_ptr get_message()=0
Retrieves the most recently processed message.
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.
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception)
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free)
config::elog_type elog_type
Type of this transport's error logging policy.
strand_ptr get_strand()
Get a pointer to this connection's strand.
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
read at least num_bytes bytes into buf and then call handler.
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
lib::error_code interrupt(interrupt_handler handler)
Trigger the on_interrupt handler.
config::alog_type alog_type
Type of this transport's access logging policy.
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
lib::error_code init_asio(io_service_ptr io_service)
Finish constructing the transport.
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
void async_shutdown(shutdown_handler callback)
close and clean up the underlying socket
lib::asio::error_code get_transport_ec() const
Get the internal transport error code for a closed/failed connection.
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
connection< config > type
Type of this connection transport component.
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
void set_uri(uri_ptr u)
Set uri hook.
std::string get_remote_endpoint() const
Get the remote endpoint address.
ptr get_shared()
Get a shared pointer to this component.
void cancel_socket_checked()
Cancel the underlying socket and log any errors.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service::strand being used.
void init(init_handler callback)
Initialize transport for reading.
connection_hdl get_handle() const
Get the connection handle.
Asio based endpoint transport component.
Definition endpoint.hpp:54
std::size_t run_one()
wraps the run_one method of the internal io_service object
Definition endpoint.hpp:648
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition endpoint.hpp:69
void stop_listening(lib::error_code &ec)
Stop listening (exception free)
Definition endpoint.hpp:604
config::socket_type socket_type
Type of the socket policy.
Definition endpoint.hpp:62
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition endpoint.hpp:87
void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:849
void init_asio()
Initialize asio transport with internal io_service.
Definition endpoint.hpp:249
config::elog_type elog_type
Type of the error logging policy.
Definition endpoint.hpp:64
void init_logging(const lib::shared_ptr< alog_type > &a, const lib::shared_ptr< elog_type > &e)
Initialize logging.
Definition endpoint.hpp:823
bool is_secure() const
Return whether or not the endpoint produces secure connections.
Definition endpoint.hpp:172
void init_asio(io_service_ptr ptr)
initialize asio transport with external io_service
Definition endpoint.hpp:212
lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code &ec)
Get local TCP endpoint.
Definition endpoint.hpp:395
void set_reuse_addr(bool value)
Sets whether to use the SO_REUSEADDR flag when opening listening sockets.
Definition endpoint.hpp:363
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition endpoint.hpp:302
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer handler.
Definition endpoint.hpp:745
void start_perpetual()
Marks the endpoint as perpetual, stopping it from exiting when empty.
Definition endpoint.hpp:689
void stop()
wraps the stop method of the internal io_service object
Definition endpoint.hpp:653
std::size_t run()
wraps the run method of the internal io_service object
Definition endpoint.hpp:640
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition endpoint.hpp:317
void set_listen_backlog(int backlog)
Sets the maximum length of the queue of pending connections.
Definition endpoint.hpp:342
bool stopped() const
wraps the stopped method of the internal io_service object
Definition endpoint.hpp:673
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition endpoint.hpp:717
void init_asio(io_service_ptr ptr, lib::error_code &ec)
initialize asio transport with external io_service (exception free)
Definition endpoint.hpp:185
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition endpoint.hpp:71
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
asio::connection< config > transport_con_type
Definition endpoint.hpp:75
void init_asio(lib::error_code &ec)
Initialize asio transport with internal io_service (exception free)
Definition endpoint.hpp:227
void async_accept(transport_con_ptr tcon, accept_handler callback)
Accept the next connection attempt and assign it to con.
Definition endpoint.hpp:807
void listen(uint16_t port)
Set up endpoint for listening on a port.
Definition endpoint.hpp:536
endpoint< config > type
Type of this endpoint transport component.
Definition endpoint.hpp:57
lib::asio::io_service & get_io_service()
Retrieve a reference to the endpoint's io_service.
Definition endpoint.hpp:378
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition endpoint.hpp:60
std::size_t poll()
wraps the poll method of the internal io_service object
Definition endpoint.hpp:658
void stop_perpetual()
Clears the endpoint's perpetual flag, allowing it to exit when empty.
Definition endpoint.hpp:701
lib::shared_ptr< lib::asio::ip::tcp::acceptor > acceptor_ptr
Type of a shared pointer to the acceptor being used.
Definition endpoint.hpp:83
void listen(lib::asio::ip::tcp::endpoint const &ep)
Set up endpoint for listening manually.
Definition endpoint.hpp:460
void handle_resolve_timeout(timer_ptr, connect_handler callback, lib::error_code const &ec)
DNS resolution timeout handler.
Definition endpoint.hpp:944
void listen(lib::asio::ip::tcp::endpoint const &ep, lib::error_code &ec)
Set up endpoint for listening manually (exception free)
Definition endpoint.hpp:412
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:78
lib::shared_ptr< lib::asio::io_service::work > work_ptr
Type of a shared pointer to an io_service work object.
Definition endpoint.hpp:89
void reset()
wraps the reset method of the internal io_service object
Definition endpoint.hpp:668
void set_tcp_pre_bind_handler(tcp_pre_bind_handler h)
Sets the tcp pre bind handler.
Definition endpoint.hpp:274
config::alog_type alog_type
Type of the access logging policy.
Definition endpoint.hpp:66
lib::asio::io_service * io_service_ptr
Type of a pointer to the ASIO io_service being used.
Definition endpoint.hpp:81
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition endpoint.hpp:502
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition endpoint.hpp:288
void handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
void async_accept(transport_con_ptr tcon, accept_handler callback, lib::error_code &ec)
Accept the next connection attempt and assign it to con (exception free)
Definition endpoint.hpp:768
std::size_t poll_one()
wraps the poll_one method of the internal io_service object
Definition endpoint.hpp:663
void listen(InternetProtocol const &internet_protocol, uint16_t port, lib::error_code &ec)
Set up endpoint for listening with protocol and port (exception free)
Definition endpoint.hpp:481
void listen(uint16_t port, lib::error_code &ec)
Set up endpoint for listening on a port (exception free)
Definition endpoint.hpp:520
bool is_listening() const
Check if the endpoint is listening.
Definition endpoint.hpp:635
void stop_listening()
Stop listening.
Definition endpoint.hpp:625
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition endpoint.hpp:85
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition endpoint.hpp:92
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.
connection_hdl get_handle() const
Get the connection handle.
config::alog_type alog_type
Type of this transport's access logging policy.
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
void set_write_handler(write_handler h)
Sets the write handler.
void set_secure(bool value)
Set whether or not this connection is secure.
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
connection< config > type
Type of this connection transport component.
config::elog_type elog_type
Type of this transport's error logging policy.
void fatal_error()
Signal transport error.
size_t read_some(char const *buf, size_t len)
Manual input supply (read some)
size_t read_all(char const *buf, size_t len)
Manual input supply (read all)
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED)
config::concurrency_type concurrency_type
transport concurrency policy
void init(init_handler handler)
Initialize the connection transport.
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
bool is_secure() const
Tests whether or not the underlying transport is secure.
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
Initiate an async_read for at least num_bytes bytes into buf.
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather)
ptr get_shared()
Get a shared pointer to this component.
iostream::connection< config > transport_con_type
Definition endpoint.hpp:62
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition endpoint.hpp:56
void set_write_handler(write_handler h)
Sets the write handler.
Definition endpoint.hpp:134
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition endpoint.hpp:154
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition endpoint.hpp:116
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition endpoint.hpp:51
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:65
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:183
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition endpoint.hpp:197
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
Definition endpoint.hpp:171
endpoint type
Type of this endpoint transport component.
Definition endpoint.hpp:49
void register_ostream(std::ostream *o)
Register a default output stream.
Definition endpoint.hpp:80
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition endpoint.hpp:54
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition endpoint.hpp:102
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition endpoint.hpp:58
iostream transport error category
Definition base.hpp:85
std::string get_query() const
Return the query portion.
Definition uri.hpp:294
Provides streaming UTF8 validation functionality.
bool decode(iterator_type begin, iterator_type end)
Advance validator state with input from an iterator pair.
validator()
Construct and initialize the validator.
bool complete()
Return whether the input sequence ended on a valid utf8 codepoint.
void reset()
Reset the validator to decode another message.
bool consume(uint8_t byte)
Advance the state of the validator with the next input byte.
#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 service_restart
Definition close.hpp:138
static value const message_too_big
An endpoint received a message too large to process.
Definition close.hpp:121
static value const try_again_later
Definition close.hpp:143
static value const force_tcp_drop
Close the connection with a forced TCP drop.
Definition close.hpp:72
static value const tls_handshake
An endpoint failed to perform a TLS handshake.
Definition close.hpp:157
static value const rsv_end
Last value in range reserved for future protocol use.
Definition close.hpp:177
static value const invalid_payload
An endpoint received message data inconsistent with its type.
Definition close.hpp:110
bool terminal(value code)
Determine if the code represents an unrecoverable error.
Definition close.hpp:217
static value const protocol_error
A protocol error occurred.
Definition close.hpp:83
std::string get_string(value code)
Return a human readable interpretation of a WebSocket close code.
Definition close.hpp:232
static value const bad_gateway
Definition close.hpp:148
static value const invalid_subprotocol_data
A invalid subprotocol data.
Definition close.hpp:172
static value const invalid_high
Last value in range that is always invalid on the wire.
Definition close.hpp:192
static value const unsupported_data
Definition close.hpp:91
static value const no_status
A dummy value to indicate that no status code was received.
Definition close.hpp:97
static value const omit_handshake
Close the connection without a WebSocket close handshake.
Definition close.hpp:62
static value const normal
Definition close.hpp:76
static value const blank
A blank value for internal use.
Definition close.hpp:52
static value const invalid_low
First value in range that is always invalid on the wire.
Definition close.hpp:190
static value const abnormal_close
A dummy value to indicate that the connection was closed abnormally.
Definition close.hpp:104
static value const rsv_start
First value in range reserved for future protocol use.
Definition close.hpp:175
uint16_t value
The type of a close code value.
Definition close.hpp:49
static value const policy_violation
An endpoint received a message that violated its policy.
Definition close.hpp:118
static value const extension_required
A client expected the server to accept a required extension request.
Definition close.hpp:129
bool invalid(value code)
Test whether a close code is invalid on the wire.
Definition close.hpp:199
static value const internal_endpoint_error
Definition close.hpp:133
static value const subprotocol_error
A generic subprotocol error.
Definition close.hpp:165
bool reserved(value code)
Test whether a close code is in a reserved range.
Definition close.hpp:184
static value const going_away
Definition close.hpp:80
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
@ operation_canceled
The requested operation was canceled.
Definition error.hpp:127
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
Definition error.hpp:68
@ http_parse_error
HTTP parse error.
Definition error.hpp:143
@ reserved_close_code
Close code is in a reserved range.
Definition error.hpp:80
@ con_creation_failed
Connection creation attempted failed.
Definition error.hpp:99
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
Definition error.hpp:71
@ invalid_state
The connection was in the wrong state for this operation.
Definition error.hpp:74
@ extension_neg_failed
Extension negotiation failed.
Definition error.hpp:146
@ rejected
Connection rejected.
Definition error.hpp:130
@ unsupported_version
Unsupported WebSocket protocol version.
Definition error.hpp:140
@ invalid_utf8
Invalid UTF-8.
Definition error.hpp:86
@ invalid_close_code
Close code is invalid.
Definition error.hpp:83
@ server_only
Attempted to use a server specific feature on a client endpoint.
Definition error.hpp:108
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
Definition error.hpp:57
@ close_handshake_timeout
WebSocket close handshake timed out.
Definition error.hpp:117
@ invalid_subprotocol
Invalid subprotocol.
Definition error.hpp:89
@ bad_close_code
Unable to parse close code.
Definition error.hpp:77
@ open_handshake_timeout
WebSocket opening handshake timed out.
Definition error.hpp:114
@ invalid_version
Invalid WebSocket protocol version.
Definition error.hpp:137
@ send_queue_full
send attempted when endpoint write queue was full
Definition error.hpp:50
@ test
Unit testing utility error code.
Definition error.hpp:96
@ invalid_uri
An invalid uri was supplied.
Definition error.hpp:65
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition disabled.hpp:44
Constants related to frame and payload limits.
Definition frame.hpp:145
static uint8_t const close_reason_size
Maximum size of close frame reason.
Definition frame.hpp:169
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127)
Definition frame.hpp:162
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:153
static unsigned int const max_header_length
Maximum length of a WebSocket header.
Definition frame.hpp:150
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
Definition frame.hpp:159
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
Definition frame.hpp:156
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Definition frame.hpp:147
Constants and utility functions related to WebSocket opcodes.
Definition frame.hpp:76
bool invalid(value v)
Check if an opcode is invalid.
Definition frame.hpp:130
bool reserved(value v)
Check if an opcode is reserved.
Definition frame.hpp:118
bool is_control(value v)
Check if an opcode is for a control frame.
Definition frame.hpp:139
Data structures and utility functions for manipulating WebSocket frames.
Definition frame.hpp:45
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
Definition frame.hpp:469
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
Definition frame.hpp:366
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
Definition frame.hpp:50
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition frame.hpp:393
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
Definition frame.hpp:384
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
Definition frame.hpp:573
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Definition frame.hpp:431
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Definition frame.hpp:830
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
Definition frame.hpp:645
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:52
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
Definition frame.hpp:375
bool get_masked(basic_header const &h)
check whether the frame is masked
Definition frame.hpp:402
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
Definition frame.hpp:357
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place)
Definition frame.hpp:675
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
Definition frame.hpp:540
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place)
Definition frame.hpp:857
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition frame.hpp:321
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
Definition frame.hpp:612
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition frame.hpp:339
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
Definition frame.hpp:411
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
Definition frame.hpp:768
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place)
Definition frame.hpp:731
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
Definition frame.hpp:348
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition frame.hpp:445
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
Definition frame.hpp:330
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
Definition frame.hpp:555
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
Definition frame.hpp:702
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
Definition frame.hpp:489
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
Definition frame.hpp:516
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
Definition frame.hpp:48
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place)
Definition frame.hpp:805
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
Definition frame.hpp:595
HTTP handling support.
Definition request.hpp:37
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
Definition constants.hpp:68
static char const header_separator[]
Literal value of the HTTP header separator.
Definition constants.hpp:59
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition constants.hpp:53
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
Definition constants.hpp:71
bool is_not_token_char(unsigned char c)
Is the character a non-token.
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
Definition constants.hpp:65
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
Definition constants.hpp:56
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
static char const header_token[]
invalid HTTP token characters
Definition constants.hpp:78
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
Definition constants.hpp:45
bool is_token_char(unsigned char c)
Is the character a token.
Definition constants.hpp:98
static std::string const empty_header
Literal value of an empty header.
Definition constants.hpp:62
Constants related to processing WebSocket connections.
Definition base.hpp:44
Processor class related error codes.
Definition base.hpp:54
Error code category and codes used by all processor types.
Definition base.hpp:65
lib::error_category const & get_processor_category()
Get a reference to a static copy of the processor error category.
Definition base.hpp:238
close::status::value to_ws(lib::error_code ec)
Converts a processor error_code into a websocket close code.
Definition base.hpp:261
@ missing_required_header
Missing Required Header.
Definition base.hpp:129
@ control_too_big
Control frame too large.
Definition base.hpp:90
@ invalid_http_method
Invalid HTTP method.
Definition base.hpp:120
@ invalid_rsv_bit
Illegal use of reserved bit.
Definition base.hpp:93
@ reason_requires_code
Using a reason requires a close code.
Definition base.hpp:144
@ invalid_close_code
Invalid close code used.
Definition base.hpp:141
@ masking_required
Clients may not send unmasked frames.
Definition base.hpp:102
@ protocol_violation
Processor encountered a protocol violation in an incoming message.
Definition base.hpp:75
@ extensions_disabled
Extension related operation was ignored because extensions are disabled.
Definition base.hpp:153
@ reserved_close_code
Reserved close code used.
Definition base.hpp:138
@ extension_parse_error
Error parsing extensions.
Definition base.hpp:150
@ masking_forbidden
Servers may not send masked frames.
Definition base.hpp:105
@ not_implemented
Operation required not implemented functionality.
Definition base.hpp:117
@ invalid_opcode
Opcode was invalid for requested operation.
Definition base.hpp:87
@ sha1_library
Embedded SHA-1 library error.
Definition base.hpp:132
@ requires_64bit
Not supported on 32 bit systems.
Definition base.hpp:111
@ subprotocol_parse_error
Error parsing subprotocols.
Definition base.hpp:147
@ bad_request
Error was the result of improperly formatted user input.
Definition base.hpp:72
@ invalid_utf8
Invalid UTF-8 encoding.
Definition base.hpp:114
@ invalid_http_status
Invalid HTTP status.
Definition base.hpp:126
@ invalid_payload
Processor encountered invalid payload data.
Definition base.hpp:81
@ invalid_http_version
Invalid HTTP version.
Definition base.hpp:123
@ message_too_big
Processor encountered a message that was too large.
Definition base.hpp:78
@ no_protocol_support
No support for this feature in this protocol version.
Definition base.hpp:135
@ invalid_arguments
The processor method was called with invalid arguments.
Definition base.hpp:84
@ invalid_continuation
Continuation without message.
Definition base.hpp:99
@ non_minimal_encoding
Payload length not minimally encoded.
Definition base.hpp:108
@ fragmented_control
Fragmented control message.
Definition base.hpp:96
lib::error_code make_error_code(error::processor_errors e)
Create an error code with the given value and the processor category.
Definition base.hpp:244
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition processor.hpp:59
int get_websocket_version(request_type &r)
Extract the version from a WebSocket handshake request.
bool is_websocket_handshake(request_type &r)
Determine whether or not a generic HTTP request is a WebSocket handshake.
Definition processor.hpp:68
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
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.
@ pass_through
underlying transport pass through
@ operation_not_supported
Operation not supported.
@ operation_aborted
Operation aborted.
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
@ action_after_shutdown
read or write after shutdown
@ tls_short_read
TLS short read.
@ double_read
async_read called while another async_read was in progress
iostream transport errors
Definition base.hpp:64
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition base.hpp:71
@ double_read
async_read called while another async_read was in progress
Definition base.hpp:74
lib::error_code make_error_code(error::value e)
Get an error code with the given value and the iostream transport category.
Definition base.hpp:118
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Definition base.hpp:112
Transport policy that uses STL iostream for I/O and does not support timers.
Definition endpoint.hpp:43
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
Definition base.hpp:57
lib::function< lib::error_code(connection_hdl)> shutdown_handler
Definition base.hpp:61
lib::function< lib::error_code(connection_hdl, char const *, size_t)> write_handler
The type and signature of the callback used by iostream transport to write.
Definition base.hpp:48
Transport policies provide network connectivity and timers.
Definition endpoint.hpp:45
lib::function< void(lib::error_code const &, size_t)> read_handler
The type and signature of the callback passed to the read method.
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
Definition endpoint.hpp:69
lib::function< void(lib::error_code const &)> timer_handler
The type and signature of the callback passed to the read method.
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
Definition endpoint.hpp:72
lib::function< void(lib::error_code const &)> write_handler
The type and signature of the callback passed to the write method.
lib::function< void(lib::error_code const &)> init_handler
The type and signature of the callback passed to the init hook.
lib::function< void(lib::error_code const &)> shutdown_handler
The type and signature of the callback passed to the shutdown method.
Generic non-websocket specific utility functions and data structures.
Definition utilities.hpp:39
std::string to_hex(uint8_t const *input, size_t length)
Convert byte array (uint8_t) to ascii printed string of hex digits.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive)
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
Namespace for the WebSocket++ project.
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
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.
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.
static char const user_agent[]
Default user agent string.
Definition version.hpp:57
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.
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.
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
Definition core.hpp:137
static const long timeout_connect
Length of time to wait for TCP connect.
Definition core.hpp:134
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
Definition core.hpp:131
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
Definition core.hpp:121
static const long timeout_socket_pre_init
Default timer values (in ms)
Definition core.hpp:118
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Definition core.hpp:128
Server config with iostream transport.
Definition core.hpp:68
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
Definition core.hpp:93
static const websocketpp::log::level elog_level
Default static error logging channels.
Definition core.hpp:176
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
Definition core.hpp:142
static const size_t max_http_body_size
Default maximum http body size.
Definition core.hpp:252
static const long timeout_open_handshake
Default timer values (in ms)
Definition core.hpp:152
static const size_t max_message_size
Default maximum message size.
Definition core.hpp:240
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
Definition core.hpp:213
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
Definition core.hpp:154
static const websocketpp::log::level alog_level
Default static access logging channels.
Definition core.hpp:189
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition core.hpp:88
static const long timeout_pong
Length of time to wait for a pong after a ping.
Definition core.hpp:156
static const bool silent_close
Suppresses the return of detailed connection close information.
Definition core.hpp:228
static bool const enable_multithreading
Definition core.hpp:98
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
Definition core.hpp:204
static const bool enable_extensions
Global flag for enabling/disabling extensions.
Definition core.hpp:255
static const int client_version
WebSocket Protocol version to use as a client.
Definition core.hpp:164
The constant size component of a WebSocket frame header.
Definition frame.hpp:189
The variable size component of a WebSocket frame header.
Definition frame.hpp:235
Package of log levels for logging access events.
Definition levels.hpp:112
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:164
static level const fail
One line for each failed WebSocket connection with details.
Definition levels.hpp:147
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:114
static level const debug_handshake
Extra information about opening handshakes.
Definition levels.hpp:137
static level const devel
Development messages (warning: very chatty)
Definition levels.hpp:141
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:152
static level const debug_close
Extra information about closing handshakes.
Definition levels.hpp:139
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty)
Definition levels.hpp:129
static level const connect
Information about new connections.
Definition levels.hpp:121
static level const app
Special channel for application specific logs. Not used by the library.
Definition levels.hpp:143
static level const frame_header
One line per frame, includes the full frame header.
Definition levels.hpp:127
static level const message_payload
Reserved.
Definition levels.hpp:133
static level const endpoint
Reserved.
Definition levels.hpp:135
static level const message_header
Reserved.
Definition levels.hpp:131
static level const control
One line per control frame.
Definition levels.hpp:125
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
Definition levels.hpp:123
static level const access_core
Definition levels.hpp:150
static level const http
Access related to HTTP requests.
Definition levels.hpp:145
Package of values for hinting at the nature of a given logger.
Definition levels.hpp:46
static value const none
No information.
Definition levels.hpp:51
static value const access
Access log.
Definition levels.hpp:53
static value const error
Error log.
Definition levels.hpp:55
uint32_t value
Type of a channel type hint value.
Definition levels.hpp:48
Package of log levels for logging errors.
Definition levels.hpp:59
static level const devel
Low level debugging information (warning: very chatty)
Definition levels.hpp:63
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:91
static level const library
Definition levels.hpp:66
static level const info
Definition levels.hpp:69
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:80
static level const fatal
Definition levels.hpp:78
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:61
static level const rerror
Definition levels.hpp:75
static level const warn
Definition levels.hpp:72
A simple utility buffer class.
Helper less than functor for case insensitive find.
Definition utilities.hpp:75
Helper functor for case insensitive find.
Definition utilities.hpp:49
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
Definition utilities.hpp:63
my_equal(std::locale const &loc)
Construct the functor with the given locale.
Definition utilities.hpp:54
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Type used to convert close statuses between integer and wire representations.
Definition close.hpp:275
Two byte conversion union.
Definition frame.hpp:55
Four byte conversion union.
Definition frame.hpp:61
Eight byte conversion union.
Definition frame.hpp:67