Boost.Asio：socket :: close不取消aysnc_read_some

Question

I have a boost socket doing an async_read_some :

socket_.async_read_some(boost::asio::buffer(data_, max_length),
    boost::bind(&Session::handle_read, this,
    boost::asio::placeholders::error,
    boost::asio::placeholders::bytes_transferred));

When my Session class is deleted socket_.close() is called. I thought this would cancel the async_read_some and call Session::handle_read with an error.

However this is not the case and looking at basic_socket.hpp

/// Close the socket.
/**
* This function is used to close the socket. Any asynchronous send, receive
* or connect operations will be cancelled immediately, and will complete
* with the boost::asio::error::operation_aborted error.
*
* @throws boost::system::system_error Thrown on failure. Note that, even if
* the function indicates an error, the underlying descriptor is closed.
*
* @note For portable behaviour with respect to graceful closure of a
* connected socket, call shutdown() before closing the socket.
*/
void close()

there is no mention of reads being cancelled. So my question is, how do I cancel the read so I can close the socket cleanly?

Answer 1

First, it should cause the handle to be called when the next run , run_one , poll , or poll_one is called, assuming the io_service is still in a valid state. Canceling/closing does not suddenly change the behavior of how handlers are invoked in ASIO.

Because of this, if you're triggering this on deletion of your Session , you will have UB, since the handler will be invoked on the destroyed object, since you passed it the raw pointer, which has subsequently been deleted.

My usual technique for this is to use shared_ptr combined with a variant of the pimpl pattern. I usually have the implementation in a shared pointer, and pass that to the various ASIO calls. When the exterior interface is destroyed, I call a shutdown method on the pimpl which causes ASIO to cancel its operations, and then the interface resets its copy of the shared pointer.

Once ASIO calls of the stored handlers, it will no longer have a copy of the shared pointer, and the destruction will complete.

Answer 2

In my case, calling acceptor->close() only sends operation_aborted error to queued accept_async and send_async tasks. My read_some_async does not receive error. I found that calling socket->shutdown(socket_base::shutdown_type::shutdown_both); and socket->close(); will trigger the error completion callback.