asio aync_send memory leak

Question

I have next snippet:

void TcpConnection::Send(const std::vector<uint8_t>& buffer) {
std::shared_ptr<std::vector<uint8_t>> bufferCopy = std::make_shared<std::vector<uint8_t>>(buffer);

auto socket = m_socket;

m_socket->async_send(asio::buffer(bufferCopy->data(), bufferCopy->size()), [socket, bufferCopy](const boost::system::error_code& err, size_t bytesSent)
{
    if (err)
    {
        logwarning << "clientcomms_t::sendNext encountered error: " << err.message();

        // Assume that the communications path is no longer
        // valid.
        socket->close();
        }
    });
}

This code leads to memory leak. if m_socket->async_send call is commented then there is not memeory leak. I can not understand why bufferCopy is not freed after callback is dispatched. What I am doing wrong? Windows is used.

Answer 1

Since you don't show any relevant code, and the code shown does not contain a strict problem, I'm going to assume from the code smells.

The smell is that you have a TcpConnection class that is not enable_shared_from_this<TcpConnection> derived. This leads me to suspect you didn't plan ahead, because there's no possible reasonable way to continue using the instance after the completion of any asynchronous operation (like the async_send).

This leads me to suspect you have a crucially simple problem, which is that your completion handler never runs. There's only one situation that could explain this, and that leads me to assume you never run() the ios_service instance

Here's the situation live:

Live On Coliru

#include <boost/asio.hpp>
namespace asio = boost::asio;
using asio::ip::tcp;

#include <iostream>
auto& logwarning = std::clog;

struct TcpConnection {
    using Buffer = std::vector<uint8_t>;
    void Send(Buffer const &);

    TcpConnection(asio::io_service& svc) : m_socket(std::make_shared<tcp::socket>(svc)) {}
    tcp::socket& socket() const { return *m_socket; }
  private:
    std::shared_ptr<tcp::socket> m_socket;
};

void TcpConnection::Send(Buffer const &buffer) {
    auto bufferCopy = std::make_shared<Buffer>(buffer);
    auto socket     = m_socket;

    m_socket->async_send(asio::buffer(bufferCopy->data(), bufferCopy->size()),
         [socket, bufferCopy](const boost::system::error_code &err, size_t /*bytesSent*/) {
             if (err) {
                 logwarning << "clientcomms_t::sendNext encountered error: " << err.message();

                 // Assume that the communications path is no longer
                 // valid.
                 socket->close();
             }

         });
}

int main() {
    asio::io_service svc;
    tcp::acceptor a(svc, tcp::v4());
    a.bind({{}, 6767});
    a.listen();

    boost::system::error_code ec;
    do {
        TcpConnection conn(svc);
        a.accept(conn.socket(), ec);

        char const* greeting = "whale hello there!\n";
        conn.Send({greeting, greeting+strlen(greeting)});
    } while (!ec);
}

You'll see that any client, connection e.g. with netcat localhost 6767 will receive the greeting, after which, surprisingly the connection will stay open, instead of being closed.

You'd expect the connection to be closed by the server side either way, either because

• a transmission error occurred in async_send
• or because after the completion handler is run, it is destroyed and hence the captured shared-pointers are destructed. Not only would that free the copied buffer, but also would it run the destructor of socket which would close the connection.

This clearly confirms that the completion handler never runs. The fix is "easy", find a place to run the service:

int main() {
    asio::io_service svc;
    tcp::acceptor a(svc, tcp::v4());
    a.set_option(tcp::acceptor::reuse_address());
    a.bind({{}, 6767});
    a.listen();

    std::thread th;

    {
        asio::io_service::work keep(svc); // prevent service running out of work early
        th = std::thread([&svc] { svc.run(); });

        boost::system::error_code ec;
        for (int i = 0; i < 11 && !ec; ++i) {
            TcpConnection conn(svc);
            a.accept(conn.socket(), ec);

            char const* greeting = "whale hello there!\n";
            conn.Send({greeting, greeting+strlen(greeting)});
        }
    }

    th.join();
}

This runs 11 connections and exits leak-free.

Better:

It becomes a lot cleaner when the accept loop is also async, and the TcpConnection is properly shared as hinted above:

Live On Coliru

#include <boost/asio.hpp>
namespace asio = boost::asio;
using asio::ip::tcp;

#include <memory>
#include <thread>
#include <iostream>
auto& logwarning = std::clog;

struct TcpConnection : std::enable_shared_from_this<TcpConnection> {
    using Buffer = std::vector<uint8_t>;

    TcpConnection(asio::io_service& svc) : m_socket(svc) {}

    void start() {
        char const* greeting = "whale hello there!\n";
        Send({greeting, greeting+strlen(greeting)});
    }

    void Send(Buffer);

  private:
    friend struct Server;
    Buffer m_output;
    tcp::socket m_socket;
};

struct Server {
    Server(unsigned short port) {
        _acceptor.set_option(tcp::acceptor::reuse_address());
        _acceptor.bind({{}, port});
        _acceptor.listen();

        do_accept();
    }

    ~Server() {
        keep.reset();
        _svc.post([this] { _acceptor.cancel(); });
        if (th.joinable())
            th.join();
    }

  private:
    void do_accept() {
        auto conn = std::make_shared<TcpConnection>(_svc);
        _acceptor.async_accept(conn->m_socket, [this,conn](boost::system::error_code ec) {
            if (ec)
                logwarning << "accept failed: " << ec.message() << "\n";
            else {
                conn->start();
                do_accept();
            }
        });
    }

    asio::io_service _svc;
    // prevent service running out of work early:
    std::unique_ptr<asio::io_service::work> keep{std::make_unique<asio::io_service::work>(_svc)};
    std::thread th{[this]{_svc.run();}}; // TODO handle handler exceptions

    tcp::acceptor _acceptor{_svc, tcp::v4()};
};

void TcpConnection::Send(Buffer buffer) {
    m_output  = std::move(buffer);
    auto self = shared_from_this();

    m_socket.async_send(asio::buffer(m_output),
         [self](const boost::system::error_code &err, size_t /*bytesSent*/) {
             if (err) {
                 logwarning << "clientcomms_t::sendNext encountered error: " << err.message() << "\n";
                 // not holding on to `self` means the socket gets closed
             }

             // do more with `self` which points to the TcpConnection instance...
         });
}

int main() {
    Server server(6868);
    std::this_thread::sleep_for(std::chrono::seconds(3));
}