Cancelling boost::asio::async_read gracefully

I have a class that looks like this:

class MyConnector : public boost::noncopyable, public boost::enable_shared_from_this<MyConnector>
{
public:
    typedef MyConnector this_type;
    boost::asio::ip::tcp::socket _plainSocket;
    boost::shared_ptr<std::vector<uint8_t>> _readBuffer;

    // lot of obvious stuff removed....

    void readProtocol()
    {
        _readBuffer = boost::make_shared<std::vector<uint8_t>>(12, 0);
        boost::asio::async_read(_plainSocket, boost::asio::buffer(&_readBuffer->at(0), 12),
                boost::bind(&this_type::handleReadProtocol, shared_from_this(), 
                boost::asio::placeholders::bytes_transferred, boost::asio::placeholders::error));
    }

    void handleReadProtocol(size_t bytesRead,const boost::system::error_code& error)
    {
        // handling code removed
    }
};

This class instance is generally waiting to receive 12 bytes protocol, before trying to read the full message. However, when I try to cancel this read operation and destroy the object, it doesn't happen. When I call _plainSocket.cancel(ec), it doesn't call handleReadProtocol with that ec. Socket disconnects, but the handler is not called.

boost::system::error_code ec;
_plainSocket.cancel(ec);

And the shared_ptr of MyConnector object that was passed using shared_from_this() is not released. The object remains like a zombie in the heap memory. How do I cancel the async_read() in such a way that the MyConnector object reference count is decremented, allowing the object to destroy itself?

Two things: one, in handleReadProtocol, make sure that, if there is an error, that readProtocol is not called. Canceled operations still call the handler, but with an error code set.

Second, asio recommends shutting down and closing the socket if you're finished with the connection. For example:

  asio::post([this] {
     if (_plainSocket.is_open()) {
        asio::error_code ec;
        /* For portable behaviour with respect to graceful closure of a connected socket, call
         * shutdown() before closing the socket. */
        _plainSocket.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
        if (ec) {
           Log(fmt::format("Socket shutdown error {}.", ec.message()));
           ec.clear();
        }
        _plainSocket.close(ec);
        if (ec)
           Log(fmt::format("Socket close error {}.", ec.message()));
     }
  });