套接字没有async_read

Question

I'm new to async functions in boost::asio, and I've already had my first problem right here:

class tcp_connection
    : public boost::enable_shared_from_this<tcp_connection>
{
public:
    typedef boost::shared_ptr<tcp_connection> pointer;

    static pointer create(boost::asio::io_context& io_context)
    {
        return pointer(new tcp_connection(io_context));
    }

    tcp::socket& socket()
    {
        return socket_;
    }

    // Called when connection is made
    void start()
    {
        // New connection, read data
        boost::array<unsigned char, 128> buf;
        boost::asio::async_read(socket_, boost::asio::buffer(buf),
            boost::bind(&tcp_connection::handle_readConnection, shared_from_this(), boost::asio::placeholders::error, boost::ref(buf)));
    }

private:
    tcp_connection(boost::asio::io_context& io_context)
        : socket_(io_context)
    {
    }

    void handle_write(const boost::system::error_code& error,
        size_t bytes_transferred)
    {
    }

    void handle_readConnection(const boost::system::error_code& error, boost::array<unsigned char, 128> buf)
    {
        std::cerr << error.message() << std::endl;
        std::cout << "New connection!" << std::endl;
    }

    tcp::socket socket_;
    std::string message_;
};

class tcp_server
{
public:
    tcp_server(boost::asio::io_context& io_context)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
    {
        start_accept();
    }

private:
    // Creates a socket and initializes an async accept operation to wait for a new connection
    void start_accept()
    {
        tcp_connection::pointer new_connection =
            tcp_connection::create(acceptor_.get_executor().context());

        acceptor_.async_accept(new_connection->socket(),
            boost::bind(&tcp_server::handle_accept, this, new_connection,
                boost::asio::placeholders::error));
    }

    // Called by start_accept. Creates a new connection and runs start_accept again to search for new clients
    void handle_accept(tcp_connection::pointer new_connection,
        const boost::system::error_code& error)
    {
        if (!error)
        {
            new_connection->start();
        }

        start_accept();
    }

    tcp::acceptor acceptor_;
};

int main()
{
    try {
        boost::asio::io_context io_context;
        tcp_server server(io_context);

        io_context.run();
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
}

This piece of code is called at the main() function, and its purpose is to read some data from the socket that has just connected to it, and print "New connection" along with any error messages (See tcp_connection::handle_readConnection ). Now, the problem is, although clients can connect to it and the boost::asio::async_read line in tcp_connection is called, handle_readConnection never is. Is there something I'm missing here? Thanks in advance.

Answer 1

Do you actually connect to a remote socket? Eg via socket::async_connect() ? If not, where should it read the data from?

One other problem is here:

boost::array<unsigned char, 128> buf;
        boost::asio::async_read(socket_, boost::asio::buffer(buf),
            boost::bind(&tcp_connection::handle_readConnection, shared_from_this(), boost::asio::placeholders::error, boost::ref(buf)));

You ask asio to read asynchronously into a buffer which is on the stack. As soon as the function returns the address (which asio still stores) is invalid, and the read attempt could overwrite any kind of memory on the stack. Starting from there on you are more or less at undefined behavior, which might be the reason why the callback is never called. The buffer must always outlive the duration of the read attempt.

Another thing where the lifetime must be valid is for io_ref .It must not be destroyed as long as any tcp_connection::pointer instance is active. Since we don't see this code, it's hard to tell. If it's a global variable or part of the main function it's probably ok.