2 * Copyright (c) 2014, Peter Thorson. All rights reserved.
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.
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.
28 #ifndef WEBSOCKETPP_CONNECTION_IMPL_HPP
29 #define WEBSOCKETPP_CONNECTION_IMPL_HPP
31 #include <websocketpp/processors/hybi00.hpp>
32 #include <websocketpp/processors/hybi07.hpp>
33 #include <websocketpp/processors/hybi08.hpp>
34 #include <websocketpp/processors/hybi13.hpp>
36 #include <websocketpp/processors/processor.hpp>
38 #include <websocketpp/common/platforms.hpp>
39 #include <websocketpp/common/system_error.hpp>
48 namespace websocketpp {
50 namespace istate = session::internal_state;
52 template <typename config>
53 void connection<config>::set_termination_handler(
54 termination_handler new_handler)
56 m_alog.write(log::alevel::devel,
57 "connection set_termination_handler");
59 //scoped_lock_type lock(m_connection_state_lock);
61 m_termination_handler = new_handler;
64 template <typename config>
65 std::string const & connection<config>::get_origin() const {
66 //scoped_lock_type lock(m_connection_state_lock);
67 return m_processor->get_origin(m_request);
70 template <typename config>
71 size_t connection<config>::get_buffered_amount() const {
72 //scoped_lock_type lock(m_connection_state_lock);
73 return m_send_buffer_size;
76 template <typename config>
77 session::state::value connection<config>::get_state() const {
78 //scoped_lock_type lock(m_connection_state_lock);
82 template <typename config>
83 lib::error_code connection<config>::send(std::string const & payload,
84 frame::opcode::value op)
86 message_ptr msg = m_msg_manager->get_message(op,payload.size());
87 msg->append_payload(payload);
88 msg->set_compressed(true);
93 template <typename config>
94 lib::error_code connection<config>::send(void const * payload, size_t len,
95 frame::opcode::value op)
97 message_ptr msg = m_msg_manager->get_message(op,len);
98 msg->append_payload(payload,len);
103 template <typename config>
104 lib::error_code connection<config>::send(typename config::message_type::ptr msg)
106 if (m_alog.static_test(log::alevel::devel)) {
107 m_alog.write(log::alevel::devel,"connection send");
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);
117 message_ptr outgoing_msg;
118 bool needs_writing = false;
120 if (msg->get_prepared()) {
123 scoped_lock_type lock(m_write_lock);
124 write_push(outgoing_msg);
125 needs_writing = !m_write_flag && !m_send_queue.empty();
127 outgoing_msg = m_msg_manager->get_message();
130 return error::make_error_code(error::no_outgoing_buffers);
133 scoped_lock_type lock(m_write_lock);
134 lib::error_code ec = m_processor->prepare_data_frame(msg,outgoing_msg);
140 write_push(outgoing_msg);
141 needs_writing = !m_write_flag && !m_send_queue.empty();
145 transport_con_type::dispatch(lib::bind(
151 return lib::error_code();
154 template <typename config>
155 void 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");
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);
171 message_ptr msg = m_msg_manager->get_message();
173 ec = error::make_error_code(error::no_outgoing_buffers);
177 ec = m_processor->prepare_ping(payload,msg);
180 // set ping timer if we are listening for one
181 if (m_pong_timeout_handler) {
182 // Cancel any existing timers
184 m_ping_timer->cancel();
187 if (m_pong_timeout_dur > 0) {
188 m_ping_timer = transport_con_type::set_timer(
191 &type::handle_pong_timeout,
194 lib::placeholders::_1
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.");
206 bool needs_writing = false;
208 scoped_lock_type lock(m_write_lock);
210 needs_writing = !m_write_flag && !m_send_queue.empty();
214 transport_con_type::dispatch(lib::bind(
220 ec = lib::error_code();
223 template<typename config>
224 void connection<config>::ping(std::string const & payload) {
232 template<typename config>
233 void connection<config>::handle_pong_timeout(std::string payload,
234 lib::error_code const & ec)
237 if (ec == transport::error::operation_aborted) {
238 // ignore, this is expected
242 m_elog.write(log::elevel::devel,"pong_timeout error: "+ec.message());
246 if (m_pong_timeout_handler) {
247 m_pong_timeout_handler(m_connection_hdl,payload);
251 template <typename config>
252 void 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");
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);
268 message_ptr msg = m_msg_manager->get_message();
270 ec = error::make_error_code(error::no_outgoing_buffers);
274 ec = m_processor->prepare_pong(payload,msg);
277 bool needs_writing = false;
279 scoped_lock_type lock(m_write_lock);
281 needs_writing = !m_write_flag && !m_send_queue.empty();
285 transport_con_type::dispatch(lib::bind(
291 ec = lib::error_code();
294 template<typename config>
295 void connection<config>::pong(std::string const & payload) {
303 template <typename config>
304 void connection<config>::close(close::status::value const code,
305 std::string const & reason, lib::error_code & ec)
307 if (m_alog.static_test(log::alevel::devel)) {
308 m_alog.write(log::alevel::devel,"connection close");
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));
315 scoped_lock_type lock(m_connection_state_lock);
317 if (m_state != session::state::open) {
318 ec = error::make_error_code(error::invalid_state);
322 ec = this->send_close_frame(code,tr,false,close::status::terminal(code));
325 template<typename config>
326 void connection<config>::close(close::status::value const code,
327 std::string const & reason)
330 close(code,reason,ec);
336 /// Trigger the on_interrupt handler
338 * This is thread safe if the transport is thread safe
340 template <typename config>
341 lib::error_code connection<config>::interrupt() {
342 m_alog.write(log::alevel::devel,"connection connection::interrupt");
343 return transport_con_type::interrupt(
345 &type::handle_interrupt,
352 template <typename config>
353 void connection<config>::handle_interrupt() {
354 if (m_interrupt_handler) {
355 m_interrupt_handler(m_connection_hdl);
359 template <typename config>
360 lib::error_code connection<config>::pause_reading() {
361 m_alog.write(log::alevel::devel,"connection connection::pause_reading");
362 return transport_con_type::dispatch(
364 &type::handle_pause_reading,
370 /// Pause reading handler. Not safe to call directly
371 template <typename config>
372 void connection<config>::handle_pause_reading() {
373 m_alog.write(log::alevel::devel,"connection connection::handle_pause_reading");
377 template <typename config>
378 lib::error_code connection<config>::resume_reading() {
379 m_alog.write(log::alevel::devel,"connection connection::resume_reading");
380 return transport_con_type::dispatch(
382 &type::handle_resume_reading,
388 /// Resume reading helper method. Not safe to call directly
389 template <typename config>
390 void connection<config>::handle_resume_reading() {
405 template <typename config>
406 bool connection<config>::get_secure() const {
407 //scoped_lock_type lock(m_connection_state_lock);
408 return m_uri->get_secure();
411 template <typename config>
412 std::string const & connection<config>::get_host() const {
413 //scoped_lock_type lock(m_connection_state_lock);
414 return m_uri->get_host();
417 template <typename config>
418 std::string const & connection<config>::get_resource() const {
419 //scoped_lock_type lock(m_connection_state_lock);
420 return m_uri->get_resource();
423 template <typename config>
424 uint16_t connection<config>::get_port() const {
425 //scoped_lock_type lock(m_connection_state_lock);
426 return m_uri->get_port();
429 template <typename config>
430 uri_ptr connection<config>::get_uri() const {
431 //scoped_lock_type lock(m_connection_state_lock);
435 template <typename config>
436 void connection<config>::set_uri(uri_ptr uri) {
437 //scoped_lock_type lock(m_connection_state_lock);
446 template <typename config>
447 std::string const & connection<config>::get_subprotocol() const {
448 return m_subprotocol;
451 template <typename config>
452 std::vector<std::string> const &
453 connection<config>::get_requested_subprotocols() const {
454 return m_requested_subprotocols;
457 template <typename config>
458 void connection<config>::add_subprotocol(std::string const & value,
459 lib::error_code & ec)
462 ec = error::make_error_code(error::client_only);
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())
470 ec = error::make_error_code(error::invalid_subprotocol);
474 m_requested_subprotocols.push_back(value);
477 template <typename config>
478 void connection<config>::add_subprotocol(std::string const & value) {
480 this->add_subprotocol(value,ec);
487 template <typename config>
488 void connection<config>::select_subprotocol(std::string const & value,
489 lib::error_code & ec)
492 ec = error::make_error_code(error::server_only);
497 ec = lib::error_code();
501 std::vector<std::string>::iterator it;
503 it = std::find(m_requested_subprotocols.begin(),
504 m_requested_subprotocols.end(),
507 if (it == m_requested_subprotocols.end()) {
508 ec = error::make_error_code(error::unrequested_subprotocol);
512 m_subprotocol = value;
515 template <typename config>
516 void connection<config>::select_subprotocol(std::string const & value) {
518 this->select_subprotocol(value,ec);
525 template <typename config>
527 connection<config>::get_request_header(std::string const & key) const {
528 return m_request.get_header(key);
531 template <typename config>
533 connection<config>::get_request_body() const {
534 return m_request.get_body();
537 template <typename config>
539 connection<config>::get_response_header(std::string const & key) const {
540 return m_response.get_header(key);
543 // TODO: EXCEPTION_FREE
544 template <typename config>
545 void connection<config>::set_status(http::status_code::value code)
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));
551 m_response.set_status(code);
554 // TODO: EXCEPTION_FREE
555 template <typename config>
556 void connection<config>::set_status(http::status_code::value code,
557 std::string const & msg)
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));
564 m_response.set_status(code,msg);
567 // TODO: EXCEPTION_FREE
568 template <typename config>
569 void 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));
575 m_response.set_body(value);
578 // TODO: EXCEPTION_FREE
579 template <typename config>
580 void connection<config>::append_header(std::string const & key,
581 std::string const & val)
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);
588 throw exception("Call to append_header from invalid state",
589 error::make_error_code(error::invalid_state));
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);
596 throw exception("Call to append_header from invalid state",
597 error::make_error_code(error::invalid_state));
602 // TODO: EXCEPTION_FREE
603 template <typename config>
604 void connection<config>::replace_header(std::string const & key,
605 std::string const & val)
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);
612 throw exception("Call to replace_header from invalid state",
613 error::make_error_code(error::invalid_state));
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);
620 throw exception("Call to replace_header from invalid state",
621 error::make_error_code(error::invalid_state));
626 // TODO: EXCEPTION_FREE
627 template <typename config>
628 void connection<config>::remove_header(std::string const & key)
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);
635 throw exception("Call to remove_header from invalid state",
636 error::make_error_code(error::invalid_state));
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);
643 throw exception("Call to remove_header from invalid state",
644 error::make_error_code(error::invalid_state));
649 /// Defer HTTP Response until later
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.
655 * Warning: deferred connections won't time out and as a result can tie up
658 * @return A status code, zero on success, non-zero otherwise
660 template <typename config>
661 lib::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();
669 // Do something to signal deferral
670 m_http_state = session::http_state::deferred;
672 return lib::error_code();
675 /// Send deferred HTTP Response (exception free)
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.
683 * @param ec A status code, zero on success, non-zero otherwise
685 template <typename config>
686 void connection<config>::send_http_response(lib::error_code & ec) {
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);
694 m_http_state = session::http_state::body_written;
697 this->write_http_response(lib::error_code());
698 ec = lib::error_code();
701 template <typename config>
702 void connection<config>::send_http_response() {
704 this->send_http_response(ec);
713 /******** logic thread ********/
715 template <typename config>
716 void connection<config>::start() {
717 m_alog.write(log::alevel::devel,"connection start");
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));
725 m_internal_state = istate::TRANSPORT_INIT;
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(
732 &type::handle_transport_init,
734 lib::placeholders::_1
739 template <typename config>
740 void connection<config>::handle_transport_init(lib::error_code const & ec) {
741 m_alog.write(log::alevel::devel,"connection handle_transport_init");
743 lib::error_code ecm = ec;
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);
753 s << "handle_transport_init received error: "<< ecm.message();
754 m_elog.write(log::elevel::rerror,s.str());
756 this->terminate(ecm);
760 // At this point the transport is ready to read and write bytes.
762 m_internal_state = istate::READ_HTTP_REQUEST;
763 this->read_handshake(1);
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();
773 template <typename config>
774 void connection<config>::read_handshake(size_t num_bytes) {
775 m_alog.write(log::alevel::devel,"connection read_handshake");
777 if (m_open_handshake_timeout_dur > 0) {
778 m_handshake_timer = transport_con_type::set_timer(
779 m_open_handshake_timeout_dur,
781 &type::handle_open_handshake_timeout,
783 lib::placeholders::_1
788 transport_con_type::async_read_at_least(
791 config::connection_read_buffer_size,
793 &type::handle_read_handshake,
795 lib::placeholders::_1,
796 lib::placeholders::_2
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.
803 template <typename config>
804 void connection<config>::handle_read_handshake(lib::error_code const & ec,
805 size_t bytes_transferred)
807 m_alog.write(log::alevel::devel,"connection handle_read_handshake");
809 lib::error_code ecm = ec;
812 scoped_lock_type lock(m_connection_state_lock);
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);
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");
826 ecm = error::make_error_code(error::invalid_state);
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");
838 log_err(log::elevel::rerror,"handle_read_handshake",ecm);
839 this->terminate(ecm);
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));
850 size_t bytes_processed = 0;
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));
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));
869 if (m_alog.static_test(log::alevel::devel)) {
871 s << "bytes_transferred: " << bytes_transferred
872 << " bytes, bytes processed: " << bytes_processed << " bytes";
873 m_alog.write(log::alevel::devel,s.str());
876 if (m_request.ready()) {
877 lib::error_code processor_ec = this->initialize_processor();
879 this->write_http_response_error(processor_ec);
883 if (m_processor && m_processor->get_version() == 0) {
884 // Version 00 has an extra requirement to read some bytes after the
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)
891 bytes_processed += 8;
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);
896 this->write_http_response_error(processor::error::make_error_code(processor::error::short_key3));
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")));
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;
916 m_internal_state = istate::PROCESS_HTTP_REQUEST;
918 // We have the complete request. Process it.
919 lib::error_code handshake_ec = this->process_handshake_request();
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);
928 // read at least 1 more byte
929 transport_con_type::async_read_at_least(
932 config::connection_read_buffer_size,
934 &type::handle_read_handshake,
936 lib::placeholders::_1,
937 lib::placeholders::_2
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
948 template <typename config>
949 void 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));
957 m_internal_state = istate::PROCESS_HTTP_REQUEST;
959 this->write_http_response(ec);
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.
964 template <typename config>
965 void connection<config>::handle_read_frame(lib::error_code const & ec,
966 size_t bytes_transferred)
968 //m_alog.write(log::alevel::devel,"connection handle_read_frame");
970 lib::error_code ecm = ec;
972 if (!ecm && m_internal_state != istate::PROCESS_CONNECTION) {
973 ecm = error::make_error_code(error::invalid_state);
977 log::level echannel = log::elevel::rerror;
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
983 m_alog.write(log::alevel::devel,"got eof from closed con");
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());
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");
1002 } else if (ecm == transport::error::tls_short_read) {
1003 if (m_state == session::state::closed) {
1004 // We expect to get a TLS short read if we try to read after the
1005 // connection is closed. If this happens ignore and exit the
1007 terminate(lib::error_code());
1010 echannel = log::elevel::rerror;
1011 } else if (ecm == transport::error::action_after_shutdown) {
1012 echannel = log::elevel::info;
1015 log_err(echannel, "handle_read_frame", ecm);
1016 this->terminate(ecm);
1020 // Boundaries checking. TODO: How much of this should be done?
1021 /*if (bytes_transferred > config::connection_read_buffer_size) {
1022 m_elog.write(log::elevel::fatal,"Fatal boundaries checking error");
1023 this->terminate(make_error_code(error::general));
1029 if (m_alog.static_test(log::alevel::devel)) {
1030 std::stringstream s;
1031 s << "p = " << p << " bytes transferred = " << bytes_transferred;
1032 m_alog.write(log::alevel::devel,s.str());
1035 while (p < bytes_transferred) {
1036 if (m_alog.static_test(log::alevel::devel)) {
1037 std::stringstream s;
1038 s << "calling consume with " << bytes_transferred-p << " bytes";
1039 m_alog.write(log::alevel::devel,s.str());
1042 lib::error_code consume_ec;
1044 if (m_alog.static_test(log::alevel::devel)) {
1045 std::stringstream s;
1046 s << "Processing Bytes: " << utility::to_hex(reinterpret_cast<uint8_t*>(m_buf)+p,bytes_transferred-p);
1047 m_alog.write(log::alevel::devel,s.str());
1050 p += m_processor->consume(
1051 reinterpret_cast<uint8_t*>(m_buf)+p,
1052 bytes_transferred-p,
1056 if (m_alog.static_test(log::alevel::devel)) {
1057 std::stringstream s;
1058 s << "bytes left after consume: " << bytes_transferred-p;
1059 m_alog.write(log::alevel::devel,s.str());
1062 log_err(log::elevel::rerror, "consume", consume_ec);
1064 if (config::drop_on_protocol_error) {
1065 this->terminate(consume_ec);
1068 lib::error_code close_ec;
1070 processor::error::to_ws(consume_ec),
1071 consume_ec.message(),
1076 log_err(log::elevel::fatal, "Protocol error close frame ", close_ec);
1077 this->terminate(close_ec);
1084 if (m_processor->ready()) {
1085 if (m_alog.static_test(log::alevel::devel)) {
1086 std::stringstream s;
1087 s << "Complete message received. Dispatching";
1088 m_alog.write(log::alevel::devel,s.str());
1091 message_ptr msg = m_processor->get_message();
1094 m_alog.write(log::alevel::devel, "null message from m_processor");
1095 } else if (!is_control(msg->get_opcode())) {
1096 // data message, dispatch to user
1097 if (m_state != session::state::open) {
1098 m_elog.write(log::elevel::warn, "got non-close frame while closing");
1099 } else if (m_message_handler) {
1100 m_message_handler(m_connection_hdl, msg);
1103 process_control_frame(msg);
1111 /// Issue a new transport read unless reading is paused.
1112 template <typename config>
1113 void connection<config>::read_frame() {
1118 transport_con_type::async_read_at_least(
1119 // std::min wont work with undefined static const values.
1120 // TODO: is there a more elegant way to do this?
1121 // Need to determine if requesting 1 byte or the exact number of bytes
1122 // is better here. 1 byte lets us be a bit more responsive at a
1123 // potential expense of additional runs through handle_read_frame
1124 /*(m_processor->get_bytes_needed() > config::connection_read_buffer_size ?
1125 config::connection_read_buffer_size : m_processor->get_bytes_needed())*/
1128 config::connection_read_buffer_size,
1133 template <typename config>
1134 lib::error_code connection<config>::initialize_processor() {
1135 m_alog.write(log::alevel::devel,"initialize_processor");
1137 // if it isn't a websocket handshake nothing to do.
1138 if (!processor::is_websocket_handshake(m_request)) {
1139 return lib::error_code();
1142 int version = processor::get_websocket_version(m_request);
1145 m_alog.write(log::alevel::devel, "BAD REQUEST: can't determine version");
1146 m_response.set_status(http::status_code::bad_request);
1147 return error::make_error_code(error::invalid_version);
1150 m_processor = get_processor(version);
1152 // if the processor is not null we are done
1154 return lib::error_code();
1157 // We don't have a processor for this version. Return bad request
1158 // with Sec-WebSocket-Version header filled with values we do accept
1159 m_alog.write(log::alevel::devel, "BAD REQUEST: no processor for version");
1160 m_response.set_status(http::status_code::bad_request);
1162 std::stringstream ss;
1164 std::vector<int>::const_iterator it;
1165 for (it = versions_supported.begin(); it != versions_supported.end(); it++)
1171 m_response.replace_header("Sec-WebSocket-Version",ss.str());
1172 return error::make_error_code(error::unsupported_version);
1175 template <typename config>
1176 lib::error_code connection<config>::process_handshake_request() {
1177 m_alog.write(log::alevel::devel,"process handshake request");
1179 if (!processor::is_websocket_handshake(m_request)) {
1180 // this is not a websocket handshake. Process as plain HTTP
1181 m_alog.write(log::alevel::devel,"HTTP REQUEST");
1183 // extract URI from request
1184 m_uri = processor::get_uri_from_host(
1186 (transport_con_type::is_secure() ? "https" : "http")
1189 if (!m_uri->get_valid()) {
1190 m_alog.write(log::alevel::devel, "Bad request: failed to parse uri");
1191 m_response.set_status(http::status_code::bad_request);
1192 return error::make_error_code(error::invalid_uri);
1195 if (m_http_handler) {
1197 m_http_handler(m_connection_hdl);
1199 if (m_state == session::state::closed) {
1200 return error::make_error_code(error::http_connection_ended);
1203 set_status(http::status_code::upgrade_required);
1204 return error::make_error_code(error::upgrade_required);
1207 return lib::error_code();
1210 lib::error_code ec = m_processor->validate_handshake(m_request);
1212 // Validate: make sure all required elements are present.
1214 // Not a valid handshake request
1215 m_alog.write(log::alevel::devel, "Bad request " + ec.message());
1216 m_response.set_status(http::status_code::bad_request);
1220 // Read extension parameters and set up values necessary for the end user
1221 // to complete extension negotiation.
1222 std::pair<lib::error_code,std::string> neg_results;
1223 neg_results = m_processor->negotiate_extensions(m_request);
1225 if (neg_results.first) {
1226 // There was a fatal error in extension parsing that should result in
1227 // a failed connection attempt.
1228 m_alog.write(log::alevel::devel, "Bad request: " + neg_results.first.message());
1229 m_response.set_status(http::status_code::bad_request);
1230 return neg_results.first;
1232 // extension negotiation succeeded, set response header accordingly
1233 // we don't send an empty extensions header because it breaks many
1235 if (neg_results.second.size() > 0) {
1236 m_response.replace_header("Sec-WebSocket-Extensions",
1237 neg_results.second);
1241 // extract URI from request
1242 m_uri = m_processor->get_uri(m_request);
1245 if (!m_uri->get_valid()) {
1246 m_alog.write(log::alevel::devel, "Bad request: failed to parse uri");
1247 m_response.set_status(http::status_code::bad_request);
1248 return error::make_error_code(error::invalid_uri);
1251 // extract subprotocols
1252 lib::error_code subp_ec = m_processor->extract_subprotocols(m_request,
1253 m_requested_subprotocols);
1256 // should we do anything?
1259 // Ask application to validate the connection
1260 if (!m_validate_handler || m_validate_handler(m_connection_hdl)) {
1261 m_response.set_status(http::status_code::switching_protocols);
1263 // Write the appropriate response headers based on request and
1264 // processor version
1265 ec = m_processor->process_handshake(m_request,m_subprotocol,m_response);
1268 std::stringstream s;
1269 s << "Processing error: " << ec << "(" << ec.message() << ")";
1270 m_alog.write(log::alevel::devel, s.str());
1272 m_response.set_status(http::status_code::internal_server_error);
1276 // User application has rejected the handshake
1277 m_alog.write(log::alevel::devel, "USER REJECT");
1279 // Use Bad Request if the user handler did not provide a more
1280 // specific http response error code.
1281 // TODO: is there a better default?
1282 if (m_response.get_status_code() == http::status_code::uninitialized) {
1283 m_response.set_status(http::status_code::bad_request);
1286 return error::make_error_code(error::rejected);
1289 return lib::error_code();
1292 template <typename config>
1293 void connection<config>::write_http_response(lib::error_code const & ec) {
1294 m_alog.write(log::alevel::devel,"connection write_http_response");
1296 if (ec == error::make_error_code(error::http_connection_ended)) {
1297 m_alog.write(log::alevel::http,"An HTTP handler took over the connection.");
1301 if (m_response.get_status_code() == http::status_code::uninitialized) {
1302 m_response.set_status(http::status_code::internal_server_error);
1303 m_ec = error::make_error_code(error::general);
1308 m_response.set_version("HTTP/1.1");
1310 // Set server header based on the user agent settings
1311 if (m_response.get_header("Server").empty()) {
1312 if (!m_user_agent.empty()) {
1313 m_response.replace_header("Server",m_user_agent);
1315 m_response.remove_header("Server");
1319 // have the processor generate the raw bytes for the wire (if it exists)
1321 m_handshake_buffer = m_processor->get_raw(m_response);
1323 // a processor wont exist for raw HTTP responses.
1324 m_handshake_buffer = m_response.raw();
1327 if (m_alog.static_test(log::alevel::devel)) {
1328 m_alog.write(log::alevel::devel,"Raw Handshake response:\n"+m_handshake_buffer);
1329 if (!m_response.get_header("Sec-WebSocket-Key3").empty()) {
1330 m_alog.write(log::alevel::devel,
1331 utility::to_hex(m_response.get_header("Sec-WebSocket-Key3")));
1336 transport_con_type::async_write(
1337 m_handshake_buffer.data(),
1338 m_handshake_buffer.size(),
1340 &type::handle_write_http_response,
1342 lib::placeholders::_1
1347 template <typename config>
1348 void connection<config>::handle_write_http_response(lib::error_code const & ec) {
1349 m_alog.write(log::alevel::devel,"handle_write_http_response");
1351 lib::error_code ecm = ec;
1354 scoped_lock_type lock(m_connection_state_lock);
1356 if (m_state == session::state::connecting) {
1357 if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
1358 ecm = error::make_error_code(error::invalid_state);
1360 } else if (m_state == session::state::closed) {
1361 // The connection was canceled while the response was being sent,
1362 // usually by the handshake timer. This is basically expected
1363 // (though hopefully rare) and there is nothing we can do so ignore.
1364 m_alog.write(log::alevel::devel,
1365 "handle_write_http_response invoked after connection was closed");
1368 ecm = error::make_error_code(error::invalid_state);
1373 if (ecm == transport::error::eof && m_state == session::state::closed) {
1374 // we expect to get eof if the connection is closed already
1375 m_alog.write(log::alevel::devel,
1376 "got (expected) eof/state error from closed con");
1380 log_err(log::elevel::rerror,"handle_write_http_response",ecm);
1381 this->terminate(ecm);
1385 if (m_handshake_timer) {
1386 m_handshake_timer->cancel();
1387 m_handshake_timer.reset();
1390 if (m_response.get_status_code() != http::status_code::switching_protocols)
1392 /*if (m_processor || m_ec == error::http_parse_error ||
1393 m_ec == error::invalid_version || m_ec == error::unsupported_version
1394 || m_ec == error::upgrade_required)
1397 std::stringstream s;
1398 s << "Handshake ended with HTTP error: "
1399 << m_response.get_status_code();
1400 m_elog.write(log::elevel::rerror,s.str());
1402 // if this was not a websocket connection, we have written
1403 // the expected response and the connection can be closed.
1405 this->log_http_result();
1408 m_alog.write(log::alevel::devel,
1409 "got to writing HTTP results with m_ec set: "+m_ec.message());
1411 m_ec = make_error_code(error::http_connection_ended);
1414 this->terminate(m_ec);
1418 this->log_open_result();
1420 m_internal_state = istate::PROCESS_CONNECTION;
1421 m_state = session::state::open;
1423 if (m_open_handler) {
1424 m_open_handler(m_connection_hdl);
1427 this->handle_read_frame(lib::error_code(), m_buf_cursor);
1430 template <typename config>
1431 void connection<config>::send_http_request() {
1432 m_alog.write(log::alevel::devel,"connection send_http_request");
1434 // TODO: origin header?
1436 // Have the protocol processor fill in the appropriate fields based on the
1437 // selected client version
1440 ec = m_processor->client_handshake_request(m_request,m_uri,
1441 m_requested_subprotocols);
1444 log_err(log::elevel::fatal,"Internal library error: Processor",ec);
1448 m_elog.write(log::elevel::fatal,"Internal library error: missing processor");
1452 // Unless the user has overridden the user agent, send generic WS++ UA.
1453 if (m_request.get_header("User-Agent").empty()) {
1454 if (!m_user_agent.empty()) {
1455 m_request.replace_header("User-Agent",m_user_agent);
1457 m_request.remove_header("User-Agent");
1461 m_handshake_buffer = m_request.raw();
1463 if (m_alog.static_test(log::alevel::devel)) {
1464 m_alog.write(log::alevel::devel,"Raw Handshake request:\n"+m_handshake_buffer);
1467 if (m_open_handshake_timeout_dur > 0) {
1468 m_handshake_timer = transport_con_type::set_timer(
1469 m_open_handshake_timeout_dur,
1471 &type::handle_open_handshake_timeout,
1473 lib::placeholders::_1
1478 transport_con_type::async_write(
1479 m_handshake_buffer.data(),
1480 m_handshake_buffer.size(),
1482 &type::handle_send_http_request,
1484 lib::placeholders::_1
1489 template <typename config>
1490 void connection<config>::handle_send_http_request(lib::error_code const & ec) {
1491 m_alog.write(log::alevel::devel,"handle_send_http_request");
1493 lib::error_code ecm = ec;
1496 scoped_lock_type lock(m_connection_state_lock);
1498 if (m_state == session::state::connecting) {
1499 if (m_internal_state != istate::WRITE_HTTP_REQUEST) {
1500 ecm = error::make_error_code(error::invalid_state);
1502 m_internal_state = istate::READ_HTTP_RESPONSE;
1504 } else if (m_state == session::state::closed) {
1505 // The connection was canceled while the response was being sent,
1506 // usually by the handshake timer. This is basically expected
1507 // (though hopefully rare) and there is nothing we can do so ignore.
1508 m_alog.write(log::alevel::devel,
1509 "handle_send_http_request invoked after connection was closed");
1512 ecm = error::make_error_code(error::invalid_state);
1517 if (ecm == transport::error::eof && m_state == session::state::closed) {
1518 // we expect to get eof if the connection is closed already
1519 m_alog.write(log::alevel::devel,
1520 "got (expected) eof/state error from closed con");
1524 log_err(log::elevel::rerror,"handle_send_http_request",ecm);
1525 this->terminate(ecm);
1529 transport_con_type::async_read_at_least(
1532 config::connection_read_buffer_size,
1534 &type::handle_read_http_response,
1536 lib::placeholders::_1,
1537 lib::placeholders::_2
1542 template <typename config>
1543 void connection<config>::handle_read_http_response(lib::error_code const & ec,
1544 size_t bytes_transferred)
1546 m_alog.write(log::alevel::devel,"handle_read_http_response");
1548 lib::error_code ecm = ec;
1551 scoped_lock_type lock(m_connection_state_lock);
1553 if (m_state == session::state::connecting) {
1554 if (m_internal_state != istate::READ_HTTP_RESPONSE) {
1555 ecm = error::make_error_code(error::invalid_state);
1557 } else if (m_state == session::state::closed) {
1558 // The connection was canceled while the response was being sent,
1559 // usually by the handshake timer. This is basically expected
1560 // (though hopefully rare) and there is nothing we can do so ignore.
1561 m_alog.write(log::alevel::devel,
1562 "handle_read_http_response invoked after connection was closed");
1565 ecm = error::make_error_code(error::invalid_state);
1570 if (ecm == transport::error::eof && m_state == session::state::closed) {
1571 // we expect to get eof if the connection is closed already
1572 m_alog.write(log::alevel::devel,
1573 "got (expected) eof/state error from closed con");
1577 log_err(log::elevel::rerror,"handle_read_http_response",ecm);
1578 this->terminate(ecm);
1582 size_t bytes_processed = 0;
1583 // TODO: refactor this to use error codes rather than exceptions
1585 bytes_processed = m_response.consume(m_buf,bytes_transferred);
1586 } catch (http::exception & e) {
1587 m_elog.write(log::elevel::rerror,
1588 std::string("error in handle_read_http_response: ")+e.what());
1589 this->terminate(make_error_code(error::general));
1593 m_alog.write(log::alevel::devel,std::string("Raw response: ")+m_response.raw());
1595 if (m_response.headers_ready()) {
1596 if (m_handshake_timer) {
1597 m_handshake_timer->cancel();
1598 m_handshake_timer.reset();
1601 lib::error_code validate_ec = m_processor->validate_server_handshake_response(
1606 log_err(log::elevel::rerror,"Server handshake response",validate_ec);
1607 this->terminate(validate_ec);
1611 // Read extension parameters and set up values necessary for the end
1612 // user to complete extension negotiation.
1613 std::pair<lib::error_code,std::string> neg_results;
1614 neg_results = m_processor->negotiate_extensions(m_response);
1616 if (neg_results.first) {
1617 // There was a fatal error in extension negotiation. For the moment
1618 // kill all connections that fail extension negotiation.
1620 // TODO: deal with cases where the response is well formed but
1621 // doesn't match the options requested by the client. Its possible
1622 // that the best behavior in this cases is to log and continue with
1623 // an unextended connection.
1624 m_alog.write(log::alevel::devel, "Extension negotiation failed: "
1625 + neg_results.first.message());
1626 this->terminate(make_error_code(error::extension_neg_failed));
1627 // TODO: close connection with reason 1010 (and list extensions)
1630 // response is valid, connection can now be assumed to be open
1631 m_internal_state = istate::PROCESS_CONNECTION;
1632 m_state = session::state::open;
1634 this->log_open_result();
1636 if (m_open_handler) {
1637 m_open_handler(m_connection_hdl);
1640 // The remaining bytes in m_buf are frame data. Copy them to the
1641 // beginning of the buffer and note the length. They will be read after
1642 // the handshake completes and before more bytes are read.
1643 std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
1644 m_buf_cursor = bytes_transferred-bytes_processed;
1646 this->handle_read_frame(lib::error_code(), m_buf_cursor);
1648 transport_con_type::async_read_at_least(
1651 config::connection_read_buffer_size,
1653 &type::handle_read_http_response,
1655 lib::placeholders::_1,
1656 lib::placeholders::_2
1662 template <typename config>
1663 void connection<config>::handle_open_handshake_timeout(
1664 lib::error_code const & ec)
1666 if (ec == transport::error::operation_aborted) {
1667 m_alog.write(log::alevel::devel,"open handshake timer cancelled");
1669 m_alog.write(log::alevel::devel,
1670 "open handle_open_handshake_timeout error: "+ec.message());
1671 // TODO: ignore or fail here?
1673 m_alog.write(log::alevel::devel,"open handshake timer expired");
1674 terminate(make_error_code(error::open_handshake_timeout));
1678 template <typename config>
1679 void connection<config>::handle_close_handshake_timeout(
1680 lib::error_code const & ec)
1682 if (ec == transport::error::operation_aborted) {
1683 m_alog.write(log::alevel::devel,"asio close handshake timer cancelled");
1685 m_alog.write(log::alevel::devel,
1686 "asio open handle_close_handshake_timeout error: "+ec.message());
1687 // TODO: ignore or fail here?
1689 m_alog.write(log::alevel::devel, "asio close handshake timer expired");
1690 terminate(make_error_code(error::close_handshake_timeout));
1694 template <typename config>
1695 void connection<config>::terminate(lib::error_code const & ec) {
1696 if (m_alog.static_test(log::alevel::devel)) {
1697 m_alog.write(log::alevel::devel,"connection terminate");
1700 // Cancel close handshake timer
1701 if (m_handshake_timer) {
1702 m_handshake_timer->cancel();
1703 m_handshake_timer.reset();
1706 terminate_status tstat = unknown;
1709 m_local_close_code = close::status::abnormal_close;
1710 m_local_close_reason = ec.message();
1713 // TODO: does any of this need a mutex?
1715 m_http_state = session::http_state::closed;
1717 if (m_state == session::state::connecting) {
1718 m_state = session::state::closed;
1721 // Log fail result here before socket is shut down and we can't get
1722 // the remote address, etc anymore
1723 if (m_ec != error::http_connection_ended) {
1726 } else if (m_state != session::state::closed) {
1727 m_state = session::state::closed;
1730 m_alog.write(log::alevel::devel,
1731 "terminate called on connection that was already terminated");
1735 // TODO: choose between shutdown and close based on error code sent
1737 transport_con_type::async_shutdown(
1739 &type::handle_terminate,
1742 lib::placeholders::_1
1747 template <typename config>
1748 void connection<config>::handle_terminate(terminate_status tstat,
1749 lib::error_code const & ec)
1751 if (m_alog.static_test(log::alevel::devel)) {
1752 m_alog.write(log::alevel::devel,"connection handle_terminate");
1756 // there was an error actually shutting down the connection
1757 log_err(log::elevel::devel,"handle_terminate",ec);
1761 if (tstat == failed) {
1762 if (m_ec != error::http_connection_ended) {
1763 if (m_fail_handler) {
1764 m_fail_handler(m_connection_hdl);
1767 } else if (tstat == closed) {
1768 if (m_close_handler) {
1769 m_close_handler(m_connection_hdl);
1773 m_elog.write(log::elevel::rerror,"Unknown terminate_status");
1776 // call the termination handler if it exists
1777 // if it exists it might (but shouldn't) refer to a bad memory location.
1778 // If it does, we don't care and should catch and ignore it.
1779 if (m_termination_handler) {
1781 m_termination_handler(type::get_shared());
1782 } catch (std::exception const & e) {
1783 m_elog.write(log::elevel::warn,
1784 std::string("termination_handler call failed. Reason was: ")+e.what());
1789 template <typename config>
1790 void connection<config>::write_frame() {
1791 //m_alog.write(log::alevel::devel,"connection write_frame");
1794 scoped_lock_type lock(m_write_lock);
1796 // Check the write flag. If true, there is an outstanding transport
1797 // write already. In this case we just return. The write handler will
1798 // start a new write if the write queue isn't empty. If false, we set
1799 // the write flag and proceed to initiate a transport write.
1804 // pull off all the messages that are ready to write.
1805 // stop if we get a message marked terminal
1806 message_ptr next_message = write_pop();
1807 while (next_message) {
1808 m_current_msgs.push_back(next_message);
1809 if (!next_message->get_terminal()) {
1810 next_message = write_pop();
1812 next_message = message_ptr();
1816 if (m_current_msgs.empty()) {
1817 // there was nothing to send
1820 // At this point we own the next messages to be sent and are
1821 // responsible for holding the write flag until they are
1822 // successfully sent or there is some error
1823 m_write_flag = true;
1827 typename std::vector<message_ptr>::iterator it;
1828 for (it = m_current_msgs.begin(); it != m_current_msgs.end(); ++it) {
1829 std::string const & header = (*it)->get_header();
1830 std::string const & payload = (*it)->get_payload();
1832 m_send_buffer.push_back(transport::buffer(header.c_str(),header.size()));
1833 m_send_buffer.push_back(transport::buffer(payload.c_str(),payload.size()));
1836 // Print detailed send stats if those log levels are enabled
1837 if (m_alog.static_test(log::alevel::frame_header)) {
1838 if (m_alog.dynamic_test(log::alevel::frame_header)) {
1839 std::stringstream general,header,payload;
1841 general << "Dispatching write containing " << m_current_msgs.size()
1842 <<" message(s) containing ";
1843 header << "Header Bytes: \n";
1844 payload << "Payload Bytes: \n";
1849 for (size_t i = 0; i < m_current_msgs.size(); i++) {
1850 hbytes += m_current_msgs[i]->get_header().size();
1851 pbytes += m_current_msgs[i]->get_payload().size();
1854 header << "[" << i << "] ("
1855 << m_current_msgs[i]->get_header().size() << ") "
1856 << utility::to_hex(m_current_msgs[i]->get_header()) << "\n";
1858 if (m_alog.static_test(log::alevel::frame_payload)) {
1859 if (m_alog.dynamic_test(log::alevel::frame_payload)) {
1860 payload << "[" << i << "] ("
1861 << m_current_msgs[i]->get_payload().size() << ") ["<<m_current_msgs[i]->get_opcode()<<"] "
1862 << (m_current_msgs[i]->get_opcode() == frame::opcode::text ?
1863 m_current_msgs[i]->get_payload() :
1864 utility::to_hex(m_current_msgs[i]->get_payload())
1871 general << hbytes << " header bytes and " << pbytes << " payload bytes";
1873 m_alog.write(log::alevel::frame_header,general.str());
1874 m_alog.write(log::alevel::frame_header,header.str());
1875 m_alog.write(log::alevel::frame_payload,payload.str());
1879 transport_con_type::async_write(
1881 m_write_frame_handler
1885 template <typename config>
1886 void connection<config>::handle_write_frame(lib::error_code const & ec)
1888 if (m_alog.static_test(log::alevel::devel)) {
1889 m_alog.write(log::alevel::devel,"connection handle_write_frame");
1892 bool terminal = m_current_msgs.back()->get_terminal();
1894 m_send_buffer.clear();
1895 m_current_msgs.clear();
1896 // TODO: recycle instead of deleting
1899 log_err(log::elevel::fatal,"handle_write_frame",ec);
1900 this->terminate(ec);
1905 this->terminate(lib::error_code());
1909 bool needs_writing = false;
1911 scoped_lock_type lock(m_write_lock);
1913 // release write flag
1914 m_write_flag = false;
1916 needs_writing = !m_send_queue.empty();
1919 if (needs_writing) {
1920 transport_con_type::dispatch(lib::bind(
1927 template <typename config>
1928 std::vector<int> const & connection<config>::get_supported_versions() const
1930 return versions_supported;
1933 template <typename config>
1934 void connection<config>::process_control_frame(typename config::message_type::ptr msg)
1936 m_alog.write(log::alevel::devel,"process_control_frame");
1938 frame::opcode::value op = msg->get_opcode();
1941 std::stringstream s;
1942 s << "Control frame received with opcode " << op;
1943 m_alog.write(log::alevel::control,s.str());
1945 if (m_state == session::state::closed) {
1946 m_elog.write(log::elevel::warn,"got frame in state closed");
1949 if (op != frame::opcode::CLOSE && m_state != session::state::open) {
1950 m_elog.write(log::elevel::warn,"got non-close frame in state closing");
1954 if (op == frame::opcode::PING) {
1955 bool should_reply = true;
1957 if (m_ping_handler) {
1958 should_reply = m_ping_handler(m_connection_hdl, msg->get_payload());
1962 this->pong(msg->get_payload(),ec);
1964 log_err(log::elevel::devel,"Failed to send response pong",ec);
1967 } else if (op == frame::opcode::PONG) {
1968 if (m_pong_handler) {
1969 m_pong_handler(m_connection_hdl, msg->get_payload());
1972 m_ping_timer->cancel();
1974 } else if (op == frame::opcode::CLOSE) {
1975 m_alog.write(log::alevel::devel,"got close frame");
1976 // record close code and reason somewhere
1978 m_remote_close_code = close::extract_code(msg->get_payload(),ec);
1981 if (config::drop_on_protocol_error) {
1982 s << "Received invalid close code " << m_remote_close_code
1983 << " dropping connection per config.";
1984 m_elog.write(log::elevel::devel,s.str());
1985 this->terminate(ec);
1987 s << "Received invalid close code " << m_remote_close_code
1988 << " sending acknowledgement and closing";
1989 m_elog.write(log::elevel::devel,s.str());
1990 ec = send_close_ack(close::status::protocol_error,
1991 "Invalid close code");
1993 log_err(log::elevel::devel,"send_close_ack",ec);
1999 m_remote_close_reason = close::extract_reason(msg->get_payload(),ec);
2001 if (config::drop_on_protocol_error) {
2002 m_elog.write(log::elevel::devel,
2003 "Received invalid close reason. Dropping connection per config");
2004 this->terminate(ec);
2006 m_elog.write(log::elevel::devel,
2007 "Received invalid close reason. Sending acknowledgement and closing");
2008 ec = send_close_ack(close::status::protocol_error,
2009 "Invalid close reason");
2011 log_err(log::elevel::devel,"send_close_ack",ec);
2017 if (m_state == session::state::open) {
2019 s << "Received close frame with code " << m_remote_close_code
2020 << " and reason " << m_remote_close_reason;
2021 m_alog.write(log::alevel::devel,s.str());
2023 ec = send_close_ack();
2025 log_err(log::elevel::devel,"send_close_ack",ec);
2027 } else if (m_state == session::state::closing && !m_was_clean) {
2029 m_alog.write(log::alevel::devel, "Got acknowledgement of close");
2033 // If we are a server terminate the connection now. Clients should
2034 // leave the connection open to give the server an opportunity to
2035 // initiate the TCP close. The client's timer will handle closing
2036 // its side of the connection if the server misbehaves.
2038 // TODO: different behavior if the underlying transport doesn't
2041 terminate(lib::error_code());
2045 m_elog.write(log::elevel::devel, "Got close frame in wrong state");
2048 // got an invalid control opcode
2049 m_elog.write(log::elevel::devel, "Got control frame with invalid opcode");
2050 // initiate protocol error shutdown
2054 template <typename config>
2055 lib::error_code connection<config>::send_close_ack(close::status::value code,
2056 std::string const & reason)
2058 return send_close_frame(code,reason,true,m_is_server);
2061 template <typename config>
2062 lib::error_code connection<config>::send_close_frame(close::status::value code,
2063 std::string const & reason, bool ack, bool terminal)
2065 m_alog.write(log::alevel::devel,"send_close_frame");
2067 // check for special codes
2069 // If silent close is set, respect it and blank out close information
2070 // Otherwise use whatever has been specified in the parameters. If
2071 // parameters specifies close::status::blank then determine what to do
2072 // based on whether or not this is an ack. If it is not an ack just
2073 // send blank info. If it is an ack then echo the close information from
2074 // the remote endpoint.
2075 if (config::silent_close) {
2076 m_alog.write(log::alevel::devel,"closing silently");
2077 m_local_close_code = close::status::no_status;
2078 m_local_close_reason.clear();
2079 } else if (code != close::status::blank) {
2080 m_alog.write(log::alevel::devel,"closing with specified codes");
2081 m_local_close_code = code;
2082 m_local_close_reason = reason;
2084 m_alog.write(log::alevel::devel,"closing with no status code");
2085 m_local_close_code = close::status::no_status;
2086 m_local_close_reason.clear();
2087 } else if (m_remote_close_code == close::status::no_status) {
2088 m_alog.write(log::alevel::devel,
2089 "acknowledging a no-status close with normal code");
2090 m_local_close_code = close::status::normal;
2091 m_local_close_reason.clear();
2093 m_alog.write(log::alevel::devel,"acknowledging with remote codes");
2094 m_local_close_code = m_remote_close_code;
2095 m_local_close_reason = m_remote_close_reason;
2098 std::stringstream s;
2099 s << "Closing with code: " << m_local_close_code << ", and reason: "
2100 << m_local_close_reason;
2101 m_alog.write(log::alevel::devel,s.str());
2103 message_ptr msg = m_msg_manager->get_message();
2105 return error::make_error_code(error::no_outgoing_buffers);
2108 lib::error_code ec = m_processor->prepare_close(m_local_close_code,
2109 m_local_close_reason,msg);
2114 // Messages flagged terminal will result in the TCP connection being dropped
2115 // after the message has been written. This is typically used when servers
2116 // send an ack and when any endpoint encounters a protocol error
2118 msg->set_terminal(true);
2121 m_state = session::state::closing;
2127 // Start a timer so we don't wait forever for the acknowledgement close
2129 if (m_close_handshake_timeout_dur > 0) {
2130 m_handshake_timer = transport_con_type::set_timer(
2131 m_close_handshake_timeout_dur,
2133 &type::handle_close_handshake_timeout,
2135 lib::placeholders::_1
2140 bool needs_writing = false;
2142 scoped_lock_type lock(m_write_lock);
2144 needs_writing = !m_write_flag && !m_send_queue.empty();
2147 if (needs_writing) {
2148 transport_con_type::dispatch(lib::bind(
2154 return lib::error_code();
2157 template <typename config>
2158 typename connection<config>::processor_ptr
2159 connection<config>::get_processor(int version) const {
2160 // TODO: allow disabling certain versions
2166 p = lib::make_shared<processor::hybi00<config> >(
2167 transport_con_type::is_secure(),
2173 p = lib::make_shared<processor::hybi07<config> >(
2174 transport_con_type::is_secure(),
2181 p = lib::make_shared<processor::hybi08<config> >(
2182 transport_con_type::is_secure(),
2189 p = lib::make_shared<processor::hybi13<config> >(
2190 transport_con_type::is_secure(),
2200 // Settings not configured by the constructor
2201 p->set_max_message_size(m_max_message_size);
2206 template <typename config>
2207 void connection<config>::write_push(typename config::message_type::ptr msg)
2213 m_send_buffer_size += msg->get_payload().size();
2214 m_send_queue.push(msg);
2216 if (m_alog.static_test(log::alevel::devel)) {
2217 std::stringstream s;
2218 s << "write_push: message count: " << m_send_queue.size()
2219 << " buffer size: " << m_send_buffer_size;
2220 m_alog.write(log::alevel::devel,s.str());
2224 template <typename config>
2225 typename config::message_type::ptr connection<config>::write_pop()
2229 if (m_send_queue.empty()) {
2233 msg = m_send_queue.front();
2235 m_send_buffer_size -= msg->get_payload().size();
2238 if (m_alog.static_test(log::alevel::devel)) {
2239 std::stringstream s;
2240 s << "write_pop: message count: " << m_send_queue.size()
2241 << " buffer size: " << m_send_buffer_size;
2242 m_alog.write(log::alevel::devel,s.str());
2247 template <typename config>
2248 void connection<config>::log_open_result()
2250 std::stringstream s;
2253 if (!processor::is_websocket_handshake(m_request)) {
2256 version = processor::get_websocket_version(m_request);
2260 s << (version == -1 ? "HTTP" : "WebSocket") << " Connection ";
2262 // Remote endpoint address
2263 s << transport_con_type::get_remote_endpoint() << " ";
2265 // Version string if WebSocket
2266 if (version != -1) {
2267 s << "v" << version << " ";
2271 std::string ua = m_request.get_header("User-Agent");
2275 // check if there are any quotes in the user agent
2276 s << "\"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2280 s << (m_uri ? m_uri->get_resource() : "NULL") << " ";
2283 s << m_response.get_status_code();
2285 m_alog.write(log::alevel::connect,s.str());
2288 template <typename config>
2289 void connection<config>::log_close_result()
2291 std::stringstream s;
2294 << "close local:[" << m_local_close_code
2295 << (m_local_close_reason.empty() ? "" : ","+m_local_close_reason)
2296 << "] remote:[" << m_remote_close_code
2297 << (m_remote_close_reason.empty() ? "" : ","+m_remote_close_reason) << "]";
2299 m_alog.write(log::alevel::disconnect,s.str());
2302 template <typename config>
2303 void connection<config>::log_fail_result()
2305 std::stringstream s;
2307 int version = processor::get_websocket_version(m_request);
2310 s << "WebSocket Connection ";
2312 // Remote endpoint address & WebSocket version
2313 s << transport_con_type::get_remote_endpoint();
2317 s << " v" << version;
2321 std::string ua = m_request.get_header("User-Agent");
2325 // check if there are any quotes in the user agent
2326 s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2330 s << (m_uri ? m_uri->get_resource() : "-");
2333 s << " " << m_response.get_status_code();
2335 // WebSocket++ error code & reason
2336 s << " " << m_ec << " " << m_ec.message();
2338 m_alog.write(log::alevel::fail,s.str());
2341 template <typename config>
2342 void connection<config>::log_http_result() {
2343 std::stringstream s;
2345 if (processor::is_websocket_handshake(m_request)) {
2346 m_alog.write(log::alevel::devel,"Call to log_http_result for WebSocket");
2351 s << (m_request.get_header("host").empty() ? "-" : m_request.get_header("host"))
2352 << " " << transport_con_type::get_remote_endpoint()
2353 << " \"" << m_request.get_method()
2354 << " " << (m_uri ? m_uri->get_resource() : "-")
2355 << " " << m_request.get_version() << "\" " << m_response.get_status_code()
2356 << " " << m_response.get_body().size();
2359 std::string ua = m_request.get_header("User-Agent");
2363 // check if there are any quotes in the user agent
2364 s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
2367 m_alog.write(log::alevel::http,s.str());
2370 } // namespace websocketpp
2372 #endif // WEBSOCKETPP_CONNECTION_IMPL_HPP