Question

bool Connection::Receive(){
    std::vector<uint8_t> buf(1000);
    boost::asio::async_read(socket_,boost::asio::buffer(buf,1000),
            boost::bind(&Connection::handler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));

    int rcvlen=buf.size();
    ByteBuffer b((std::shared_ptr<uint8_t>)buf.data(),rcvlen);
    if(rcvlen <= 0){
        buf.clear();
        return false;
    }
    OnReceived(b);
    buf.clear();
    return true;
}

The method works fine but only when I make a breakpoint inside it. Is there an issue with timing as it waits to receive? Without the breakpoint, nothing is received.

Answer 1

You are trying to read from the receive buffer immediately after starting the asynchronous operation, without waiting for it to complete, that is why it works when you set a breakpoint.

The code after your async_read belongs into Connection::handler, since that is the callback you told async_read to invoke after receiving some data.

What you usually want is a start_read and a handle_read_some function:

void connection::start_read()
{
    socket_->async_read_some(boost::asio::buffer(read_buffer_),
        boost::bind(&connection::handle_read_some, shared_from_this(),
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));
}

void connection::handle_read_some(const boost::system::error_code& error, size_t bytes_transferred)
{
    if (!error)
    {
        // Use the data here!

        start_read();
    }
}

Note the shared_from_this, it’s important if you want the lifetime of your connection to be automatically taken care of by the number of outstanding I/O requests. Make sure to derive your class from boost::enable_shared_from_this<connection> and to only create it with make_shared<connection>.

To enforce this, your constructor should be private and you can add a friend declaration (C++0x version; if your compiler does not support this, you will have to insert the correct number of arguments yourself):

template<typename T, typename... Arg> friend boost::shared_ptr<T> boost::make_shared(const Arg&...);

Also make sure your receive buffer is still alive by the time the callback is invoked, preferably by using a statically sized buffer member variable of your connection class.