resolve_endpoint_op.hpp 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. //
  2. // detail/resolve_endpoint_op.hpp
  3. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. //
  5. // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
  6. //
  7. // Distributed under the Boost Software License, Version 1.0. (See accompanying
  8. // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  9. //
  10. #ifndef BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
  11. #define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
  12. #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  13. # pragma once
  14. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  15. #include <boost/asio/detail/config.hpp>
  16. #include <boost/asio/detail/bind_handler.hpp>
  17. #include <boost/asio/detail/fenced_block.hpp>
  18. #include <boost/asio/detail/handler_alloc_helpers.hpp>
  19. #include <boost/asio/detail/handler_invoke_helpers.hpp>
  20. #include <boost/asio/detail/handler_work.hpp>
  21. #include <boost/asio/detail/memory.hpp>
  22. #include <boost/asio/detail/resolve_op.hpp>
  23. #include <boost/asio/detail/socket_ops.hpp>
  24. #include <boost/asio/error.hpp>
  25. #include <boost/asio/ip/basic_resolver_results.hpp>
  26. #if defined(BOOST_ASIO_HAS_IOCP)
  27. # include <boost/asio/detail/win_iocp_io_context.hpp>
  28. #else // defined(BOOST_ASIO_HAS_IOCP)
  29. # include <boost/asio/detail/scheduler.hpp>
  30. #endif // defined(BOOST_ASIO_HAS_IOCP)
  31. #include <boost/asio/detail/push_options.hpp>
  32. namespace boost {
  33. namespace asio {
  34. namespace detail {
  35. template <typename Protocol, typename Handler, typename IoExecutor>
  36. class resolve_endpoint_op : public resolve_op
  37. {
  38. public:
  39. BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_endpoint_op);
  40. typedef typename Protocol::endpoint endpoint_type;
  41. typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
  42. #if defined(BOOST_ASIO_HAS_IOCP)
  43. typedef class win_iocp_io_context scheduler_impl;
  44. #else
  45. typedef class scheduler scheduler_impl;
  46. #endif
  47. resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
  48. const endpoint_type& endpoint, scheduler_impl& sched,
  49. Handler& handler, const IoExecutor& io_ex)
  50. : resolve_op(&resolve_endpoint_op::do_complete),
  51. cancel_token_(cancel_token),
  52. endpoint_(endpoint),
  53. scheduler_(sched),
  54. handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
  55. work_(handler_, io_ex)
  56. {
  57. }
  58. static void do_complete(void* owner, operation* base,
  59. const boost::system::error_code& /*ec*/,
  60. std::size_t /*bytes_transferred*/)
  61. {
  62. // Take ownership of the operation object.
  63. resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
  64. ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
  65. if (owner && owner != &o->scheduler_)
  66. {
  67. // The operation is being run on the worker io_context. Time to perform
  68. // the resolver operation.
  69. // Perform the blocking endpoint resolution operation.
  70. char host_name[NI_MAXHOST];
  71. char service_name[NI_MAXSERV];
  72. socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
  73. o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
  74. o->endpoint_.protocol().type(), o->ec_);
  75. o->results_ = results_type::create(o->endpoint_, host_name, service_name);
  76. // Pass operation back to main io_context for completion.
  77. o->scheduler_.post_deferred_completion(o);
  78. p.v = p.p = 0;
  79. }
  80. else
  81. {
  82. // The operation has been returned to the main io_context. The completion
  83. // handler is ready to be delivered.
  84. BOOST_ASIO_HANDLER_COMPLETION((*o));
  85. // Take ownership of the operation's outstanding work.
  86. handler_work<Handler, IoExecutor> w(
  87. BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
  88. o->work_));
  89. // Make a copy of the handler so that the memory can be deallocated
  90. // before the upcall is made. Even if we're not about to make an upcall,
  91. // a sub-object of the handler may be the true owner of the memory
  92. // associated with the handler. Consequently, a local copy of the handler
  93. // is required to ensure that any owning sub-object remains valid until
  94. // after we have deallocated the memory here.
  95. detail::binder2<Handler, boost::system::error_code, results_type>
  96. handler(o->handler_, o->ec_, o->results_);
  97. p.h = boost::asio::detail::addressof(handler.handler_);
  98. p.reset();
  99. if (owner)
  100. {
  101. fenced_block b(fenced_block::half);
  102. BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
  103. w.complete(handler, handler.handler_);
  104. BOOST_ASIO_HANDLER_INVOCATION_END;
  105. }
  106. }
  107. }
  108. private:
  109. socket_ops::weak_cancel_token_type cancel_token_;
  110. endpoint_type endpoint_;
  111. scheduler_impl& scheduler_;
  112. Handler handler_;
  113. handler_work<Handler, IoExecutor> work_;
  114. results_type results_;
  115. };
  116. } // namespace detail
  117. } // namespace asio
  118. } // namespace boost
  119. #include <boost/asio/detail/pop_options.hpp>
  120. #endif // BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP