win_iocp_socket_recv_op.hpp 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126
  1. //
  2. // detail/win_iocp_socket_recv_op.hpp
  3. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. //
  5. // Copyright (c) 2003-2023 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 ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
  11. #define ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
  12. #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  13. # pragma once
  14. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  15. #include "asio/detail/config.hpp"
  16. #if defined(ASIO_HAS_IOCP)
  17. #include "asio/detail/bind_handler.hpp"
  18. #include "asio/detail/buffer_sequence_adapter.hpp"
  19. #include "asio/detail/fenced_block.hpp"
  20. #include "asio/detail/handler_alloc_helpers.hpp"
  21. #include "asio/detail/handler_work.hpp"
  22. #include "asio/detail/memory.hpp"
  23. #include "asio/detail/operation.hpp"
  24. #include "asio/detail/socket_ops.hpp"
  25. #include "asio/error.hpp"
  26. #include "asio/detail/push_options.hpp"
  27. namespace asio {
  28. namespace detail {
  29. template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
  30. class win_iocp_socket_recv_op : public operation
  31. {
  32. public:
  33. ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recv_op);
  34. win_iocp_socket_recv_op(socket_ops::state_type state,
  35. socket_ops::weak_cancel_token_type cancel_token,
  36. const MutableBufferSequence& buffers, Handler& handler,
  37. const IoExecutor& io_ex)
  38. : operation(&win_iocp_socket_recv_op::do_complete),
  39. state_(state),
  40. cancel_token_(cancel_token),
  41. buffers_(buffers),
  42. handler_(static_cast<Handler&&>(handler)),
  43. work_(handler_, io_ex)
  44. {
  45. }
  46. static void do_complete(void* owner, operation* base,
  47. const asio::error_code& result_ec,
  48. std::size_t bytes_transferred)
  49. {
  50. asio::error_code ec(result_ec);
  51. // Take ownership of the operation object.
  52. ASIO_ASSUME(base != 0);
  53. win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base));
  54. ptr p = { asio::detail::addressof(o->handler_), o, o };
  55. ASIO_HANDLER_COMPLETION((*o));
  56. // Take ownership of the operation's outstanding work.
  57. handler_work<Handler, IoExecutor> w(
  58. static_cast<handler_work<Handler, IoExecutor>&&>(
  59. o->work_));
  60. #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  61. // Check whether buffers are still valid.
  62. if (owner)
  63. {
  64. buffer_sequence_adapter<asio::mutable_buffer,
  65. MutableBufferSequence>::validate(o->buffers_);
  66. }
  67. #endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
  68. socket_ops::complete_iocp_recv(o->state_, o->cancel_token_,
  69. buffer_sequence_adapter<asio::mutable_buffer,
  70. MutableBufferSequence>::all_empty(o->buffers_),
  71. ec, bytes_transferred);
  72. ASIO_ERROR_LOCATION(ec);
  73. // Make a copy of the handler so that the memory can be deallocated before
  74. // the upcall is made. Even if we're not about to make an upcall, a
  75. // sub-object of the handler may be the true owner of the memory associated
  76. // with the handler. Consequently, a local copy of the handler is required
  77. // to ensure that any owning sub-object remains valid until after we have
  78. // deallocated the memory here.
  79. detail::binder2<Handler, asio::error_code, std::size_t>
  80. handler(o->handler_, ec, bytes_transferred);
  81. p.h = asio::detail::addressof(handler.handler_);
  82. p.reset();
  83. // Make the upcall if required.
  84. if (owner)
  85. {
  86. fenced_block b(fenced_block::half);
  87. ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
  88. w.complete(handler, handler.handler_);
  89. ASIO_HANDLER_INVOCATION_END;
  90. }
  91. }
  92. private:
  93. socket_ops::state_type state_;
  94. socket_ops::weak_cancel_token_type cancel_token_;
  95. MutableBufferSequence buffers_;
  96. Handler handler_;
  97. handler_work<Handler, IoExecutor> work_;
  98. };
  99. } // namespace detail
  100. } // namespace asio
  101. #include "asio/detail/pop_options.hpp"
  102. #endif // defined(ASIO_HAS_IOCP)
  103. #endif // ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP