无法将 std::function 传递到 boost::asio async_accept 处理程序

Question

I am trying to write a server which takes a custom handler from the user using boost asio. I am able to call statements from inside the async_accept handler but whenever I call the handler received by the server, It results in a segfault.

#include <boost/asio.hpp>
#include <functional>
#include <iostream>

using namespace std;
using namespace boost;
using boost::asio::ip::tcp;

class Server {
private:
  asio::io_service &io_service;
  tcp::acceptor acc;
  tcp::endpoint endpoint;

public:
  Server(asio::io_service &io) : io_service{io}, acc{io} {}

  void listen(unsigned short port);
  void accept(function<void()> handler);
};

void Server::listen(unsigned short port) {
  endpoint.port(port);

  acc.open(endpoint.protocol());
  acc.set_option(tcp::acceptor::reuse_address(true));

  acc.bind(endpoint);
  acc.listen();
}

void Server::accept(function<void()> handler) {
  tcp::socket socket(io_service);


  acc.async_accept(socket, [this, h = handler](const system::error_code &error) {
    cout << "Hello World" << endl;

    h();

    accept(h);
  });
}

int main() {
  asio::io_service io_service;
  Server s(io_service);

  s.listen(8000);

  s.accept([]() { cout << "Connection Accepted" << endl; });

  io_service.run();
}

However when I use std::bind to the lambda I pass it magically runs. I am unable to understand why and would also like to know if this approach is performant?

void Server::accept(function<void()> handler) {
  tcp::socket socket(io_service);

  auto h = std::bind(handler);

  acc.async_accept(socket, [this, h](const system::error_code &error) {
    cout << "Hello World" << endl;

    h();

    accept(h);
  });
}

Answer 1

Problem is not with a handler.

Undefined behaviour is caused by accessing dangling reference to socket as local variable.

You call async_accept which takes the socket by reference as first parameter: According to official reference , the caller (you) is responsible to prolong its lifetime until handler is called:

The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the handler is called.

You should wrap socket in some kind of smart pointer and then pass this pointer to lambda to prolong its lifetime:

  std::shared_ptr<tcp::socket> socket = std::make_shared<tcp::socket>(io_service);


  acc.async_accept(*socket, [this, h = handler, socket](const system::error_code &error) {

---

I hope, you are aware that async_XXX returns immediately, hence socket is deleted as well when the function returns.