28 #ifndef WEBSOCKETPP_TRANSPORT_ASIO_HPP
29 #define WEBSOCKETPP_TRANSPORT_ASIO_HPP
31 #include <websocketpp/transport/base/endpoint.hpp>
32 #include <websocketpp/transport/asio/connection.hpp>
33 #include <websocketpp/transport/asio/security/none.hpp>
35 #include <websocketpp/uri.hpp>
36 #include <websocketpp/logger/levels.hpp>
38 #include <websocketpp/common/asio.hpp>
39 #include <websocketpp/common/functional.hpp>
53 template <
typename config>
54 class endpoint :
public config::socket_type {
57 typedef endpoint<config>
type;
78 typedef typename transport_con_type::ptr transport_con_ptr;
97 , m_external_io_service(
false)
98 , m_listen_backlog(lib::asio::socket_base::max_connections)
100 , m_state(UNINITIALIZED)
112 if (m_state != UNINITIALIZED && !m_external_io_service) {
120 #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
121 endpoint(
const endpoint & src) =
delete;
122 endpoint& operator= (
const endpoint & rhs) =
delete;
125 endpoint(
const endpoint & src);
126 endpoint & operator= (
const endpoint & rhs);
130 #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
131 endpoint (endpoint && src)
132 : config::socket_type(std::move(src))
133 , m_tcp_pre_init_handler(src.m_tcp_pre_init_handler)
134 , m_tcp_post_init_handler(src.m_tcp_post_init_handler)
135 , m_io_service(src.m_io_service)
136 , m_external_io_service(src.m_external_io_service)
137 , m_acceptor(src.m_acceptor)
138 , m_listen_backlog(lib::asio::socket_base::max_connections)
139 , m_reuse_addr(src.m_reuse_addr)
142 , m_state(src.m_state)
144 src.m_io_service = NULL;
145 src.m_external_io_service =
false;
146 src.m_acceptor = NULL;
147 src.m_state = UNINITIALIZED;
186 if (m_state != UNINITIALIZED) {
187 m_elog->write(log::elevel::library,
188 "asio::init_asio called from the wrong state");
189 using websocketpp::error::make_error_code;
190 ec = make_error_code(websocketpp::error::invalid_state);
194 m_alog->write(log::alevel::devel,
"asio::init_asio");
197 m_external_io_service =
true;
198 m_acceptor.reset(
new lib::asio::ip::tcp::acceptor(*m_io_service));
201 ec = lib::error_code();
215 if (ec) {
throw exception(ec); }
232 #ifdef _WEBSOCKETPP_CPP11_MEMORY_
233 lib::unique_ptr<lib::asio::io_service> service(
new lib::asio::io_service());
235 lib::auto_ptr<lib::asio::io_service> service(
new lib::asio::io_service());
237 init_asio(service.get(), ec);
238 if( !ec ) service.release();
239 m_external_io_service =
false;
254 #ifdef _WEBSOCKETPP_CPP11_MEMORY_
255 lib::unique_ptr<lib::asio::io_service> service(
new lib::asio::io_service());
257 lib::auto_ptr<lib::asio::io_service> service(
new lib::asio::io_service());
259 init_asio( service.get() );
262 m_external_io_service =
false;
275 m_tcp_pre_bind_handler = h;
289 m_tcp_pre_init_handler = h;
303 set_tcp_pre_init_handler(h);
318 m_tcp_post_init_handler = h;
343 m_listen_backlog = backlog;
364 m_reuse_addr = value;
379 return *m_io_service;
397 return m_acceptor->local_endpoint(ec);
399 ec = lib::asio::error::make_error_code(lib::asio::error::bad_descriptor);
400 return lib::asio::ip::tcp::endpoint();
412 void listen(lib::asio::ip::tcp::endpoint
const & ep, lib::error_code & ec)
414 if (m_state != READY) {
415 m_elog->write(log::elevel::library,
416 "asio::listen called from the wrong state");
417 using websocketpp::error::make_error_code;
418 ec = make_error_code(websocketpp::error::invalid_state);
422 m_alog->write(log::alevel::devel,
"asio::listen");
424 lib::asio::error_code bec;
426 m_acceptor->open(ep.protocol(),bec);
427 if (bec) {ec = clean_up_listen_after_error(bec);
return;}
429 m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
430 if (bec) {ec = clean_up_listen_after_error(bec);
return;}
433 if (m_tcp_pre_bind_handler) {
434 ec = m_tcp_pre_bind_handler(m_acceptor);
436 ec = clean_up_listen_after_error(ec);
441 m_acceptor->bind(ep,bec);
442 if (bec) {ec = clean_up_listen_after_error(bec);
return;}
444 m_acceptor->listen(m_listen_backlog,bec);
445 if (bec) {ec = clean_up_listen_after_error(bec);
return;}
449 ec = lib::error_code();
460 void listen(lib::asio::ip::tcp::endpoint
const & ep) {
463 if (ec) {
throw exception(ec); }
480 template <
typename InternetProtocol>
481 void listen(InternetProtocol
const & internet_protocol, uint16_t port,
482 lib::error_code & ec)
484 lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
501 template <
typename InternetProtocol>
502 void listen(InternetProtocol
const & internet_protocol, uint16_t port)
504 lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
520 void listen(uint16_t port, lib::error_code & ec) {
521 listen(lib::asio::ip::tcp::v6(), port, ec);
537 listen(lib::asio::ip::tcp::v6(), port);
556 void listen(std::string
const & host, std::string
const & service,
557 lib::error_code & ec)
559 using lib::asio::ip::tcp;
560 tcp::resolver r(*m_io_service);
561 tcp::resolver::query query(host, service);
562 tcp::resolver::iterator endpoint_iterator = r.resolve(query);
563 tcp::resolver::iterator end;
564 if (endpoint_iterator == end) {
565 m_elog->write(log::elevel::library,
566 "asio::listen could not resolve the supplied host or service");
567 ec = make_error_code(error::invalid_host_service);
570 listen(*endpoint_iterator,ec);
589 void listen(std::string
const & host, std::string
const & service)
592 listen(host,service,ec);
593 if (ec) {
throw exception(ec); }
605 if (m_state != LISTENING) {
606 m_elog->write(log::elevel::library,
607 "asio::listen called from the wrong state");
608 using websocketpp::error::make_error_code;
609 ec = make_error_code(websocketpp::error::invalid_state);
615 ec = lib::error_code();
628 if (ec) {
throw exception(ec); }
636 return (m_state == LISTENING);
641 return m_io_service->run();
649 return m_io_service->run_one();
654 m_io_service->stop();
659 return m_io_service->poll();
664 return m_io_service->poll_one();
669 m_io_service->reset();
674 return m_io_service->stopped();
690 m_work.reset(
new lib::asio::io_service::work(*m_io_service));
718 timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
720 lib::asio::milliseconds(duration)
723 new_timer->async_wait(
729 lib::placeholders::_1
746 lib::asio::error_code
const & ec)
749 if (ec == lib::asio::error::operation_aborted) {
750 callback(make_error_code(transport::error::operation_aborted));
752 m_elog->write(log::elevel::info,
753 "asio handle_timer error: "+ec.message());
754 log_err(log::elevel::info,
"asio handle_timer",ec);
755 callback(socket_con_type::translate_ec(ec));
758 callback(lib::error_code());
769 lib::error_code & ec)
771 if (m_state != LISTENING || !m_acceptor) {
772 using websocketpp::error::make_error_code;
773 ec = make_error_code(websocketpp::error::async_accept_not_listening);
777 m_alog->write(log::alevel::devel,
"asio::async_accept");
779 if (config::enable_multithreading) {
780 m_acceptor->async_accept(
781 tcon->get_raw_socket(),
782 tcon->get_strand()->wrap(lib::bind(
783 &type::handle_accept,
786 lib::placeholders::_1
790 m_acceptor->async_accept(
791 tcon->get_raw_socket(),
793 &type::handle_accept,
796 lib::placeholders::_1
809 async_accept(tcon,callback,ec);
810 if (ec) {
throw exception(ec); }
828 void handle_accept(accept_handler callback, lib::asio::error_code
const &
831 lib::error_code ret_ec;
833 m_alog->write(log::alevel::devel,
"asio::handle_accept");
836 if (asio_ec == lib::asio::errc::operation_canceled) {
837 ret_ec = make_error_code(websocketpp::error::operation_canceled);
839 log_err(log::elevel::info,
"asio handle_accept",asio_ec);
840 ret_ec = socket_con_type::translate_ec(asio_ec);
850 using namespace lib::asio::ip;
854 m_resolver.reset(
new lib::asio::ip::tcp::resolver(*m_io_service));
859 std::string proxy = tcon->get_proxy();
864 host = u->get_host();
865 port = u->get_port_str();
869 uri_ptr pu = lib::make_shared<uri>(proxy);
871 if (!pu->get_valid()) {
872 cb(make_error_code(error::proxy_invalid));
876 ec = tcon->proxy_init(u->get_authority());
882 host = pu->get_host();
883 port = pu->get_port_str();
886 tcp::resolver::query query(host,port);
888 if (m_alog->static_test(log::alevel::devel)) {
889 m_alog->write(log::alevel::devel,
890 "starting async DNS resolve for "+host+
":"+port);
895 dns_timer = tcon->set_timer(
896 config::timeout_dns_resolve,
898 &type::handle_resolve_timeout,
902 lib::placeholders::_1
906 if (config::enable_multithreading) {
907 m_resolver->async_resolve(
909 tcon->get_strand()->wrap(lib::bind(
910 &type::handle_resolve,
915 lib::placeholders::_1,
916 lib::placeholders::_2
920 m_resolver->async_resolve(
923 &type::handle_resolve,
928 lib::placeholders::_1,
929 lib::placeholders::_2
945 lib::error_code
const & ec)
947 lib::error_code ret_ec;
950 if (ec == transport::error::operation_aborted) {
951 m_alog->write(log::alevel::devel,
952 "asio handle_resolve_timeout timer cancelled");
956 log_err(log::elevel::devel,
"asio handle_resolve_timeout",ec);
959 ret_ec = make_error_code(transport::error::timeout);
962 m_alog->write(log::alevel::devel,
"DNS resolution timed out");
963 m_resolver->cancel();
967 void handle_resolve(transport_con_ptr tcon,
timer_ptr dns_timer,
968 connect_handler callback, lib::asio::error_code
const & ec,
969 lib::asio::ip::tcp::resolver::iterator iterator)
971 if (ec == lib::asio::error::operation_aborted ||
972 lib::asio::is_neg(dns_timer->expires_from_now()))
974 m_alog->write(log::alevel::devel,
"async_resolve cancelled");
981 log_err(log::elevel::info,
"asio async_resolve",ec);
982 callback(socket_con_type::translate_ec(ec));
986 if (m_alog->static_test(log::alevel::devel)) {
988 s <<
"Async DNS resolve successful. Results: ";
990 lib::asio::ip::tcp::resolver::iterator it, end;
991 for (it = iterator; it != end; ++it) {
992 s << (*it).endpoint() <<
" ";
995 m_alog->write(log::alevel::devel,s.str());
998 m_alog->write(log::alevel::devel,
"Starting async connect");
1002 con_timer = tcon->set_timer(
1003 config::timeout_connect,
1005 &type::handle_connect_timeout,
1010 lib::placeholders::_1
1014 if (config::enable_multithreading) {
1015 lib::asio::async_connect(
1016 tcon->get_raw_socket(),
1018 tcon->get_strand()->wrap(lib::bind(
1019 &type::handle_connect,
1024 lib::placeholders::_1
1028 lib::asio::async_connect(
1029 tcon->get_raw_socket(),
1032 &type::handle_connect,
1037 lib::placeholders::_1
1054 connect_handler callback, lib::error_code
const & ec)
1056 lib::error_code ret_ec;
1059 if (ec == transport::error::operation_aborted) {
1060 m_alog->write(log::alevel::devel,
1061 "asio handle_connect_timeout timer cancelled");
1065 log_err(log::elevel::devel,
"asio handle_connect_timeout",ec);
1068 ret_ec = make_error_code(transport::error::timeout);
1071 m_alog->write(log::alevel::devel,
"TCP connect timed out");
1072 tcon->cancel_socket_checked();
1076 void handle_connect(transport_con_ptr tcon,
timer_ptr con_timer,
1077 connect_handler callback, lib::asio::error_code
const & ec)
1079 if (ec == lib::asio::error::operation_aborted ||
1080 lib::asio::is_neg(con_timer->expires_from_now()))
1082 m_alog->write(log::alevel::devel,
"async_connect cancelled");
1086 con_timer->cancel();
1089 log_err(log::elevel::info,
"asio async_connect",ec);
1090 callback(socket_con_type::translate_ec(ec));
1094 if (m_alog->static_test(log::alevel::devel)) {
1095 m_alog->write(log::alevel::devel,
1096 "Async connect to "+tcon->get_remote_endpoint()+
" successful.");
1099 callback(lib::error_code());
1114 m_alog->write(log::alevel::devel,
"transport::asio::init");
1117 socket_type::init(lib::static_pointer_cast<socket_con_type,
1118 transport_con_type>(tcon));
1122 ec = tcon->init_asio(m_io_service);
1123 if (ec) {
return ec;}
1125 tcon->set_tcp_pre_init_handler(m_tcp_pre_init_handler);
1126 tcon->set_tcp_post_init_handler(m_tcp_post_init_handler);
1128 return lib::error_code();
1132 template <
typename error_type>
1133 void log_err(log::level l,
char const * msg, error_type
const & ec) {
1134 std::stringstream s;
1135 s << msg <<
" error: " << ec <<
" (" << ec.message() <<
")";
1136 m_elog->write(l,s.str());
1140 template <
typename error_type>
1141 lib::error_code clean_up_listen_after_error(error_type
const & ec) {
1142 if (m_acceptor->is_open()) {
1143 m_acceptor->close();
1145 log_err(log::elevel::info,
"asio listen",ec);
1157 tcp_init_handler m_tcp_pre_init_handler;
1158 tcp_init_handler m_tcp_post_init_handler;
1162 bool m_external_io_service;
1168 int m_listen_backlog;
1171 lib::shared_ptr<elog_type> m_elog;
1172 lib::shared_ptr<alog_type> m_alog;