Question

I’m trying to make a toy asynchronous echo client using the boost asio. For some reason it gets blocked on the second request/reply cycle while waiting for sent_=true, but before receiving the echo (w/o the server crashing).

/*
UDP asynchronous clint using boost asio library
 */
#include <cstdlib>
#include <iostream>
#include <algorithm>

#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/chrono/duration.hpp>

#include "dbook/test/tools.hpp"

using boost::asio::ip::udp;

const size_t N_MESSAGES = 1024;

class udp_client {
public:
  udp_client(const std::string& host,const std::string& service)
    :io_service_(),
     socket_(io_service_),
     replied_(false),
     sent_(false)
  {
    socket_.open(boost::asio::ip::udp::v4());
    udp::resolver resolver(io_service_);
    udp::resolver::query query(udp::v4(), host,  service);
    endpoint_ = *resolver.resolve(query);

  }
  ~udp_client() {
    socket_.close();
  }

  bool sent() {
    return sent_;
  }

  void send(const int r) {
    replied_ = false;
    sent_ = false;

    memcpy(&send_buf_[0],&r,sizeof(int));
    std::cout << "prepare sending" << std::endl;

    socket_.async_send_to(boost::asio::buffer(send_buf_), endpoint_,
              boost::bind(&udp_client::handle_send, this,
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
    io_service_.run_one();

    std::cout << "after run_one" << std::endl;

  }

  bool replied() {
    return replied_;
  }

  int reply() {
    return *reinterpret_cast<int*>(&recv_buf_[0]);
  }

private:
  void handle_send(const boost::system::error_code& error,
           std::size_t size)
  {
    if (error) {
      //missing error propagation to main thread
      std::cerr << "ERROR: Client error while sending (error code = " << error << "): "  << std::endl;
      std::cerr << "ERROR: Recovering..." << std::endl;

    } else {
      sent_ = true;
      std::cout << "sent" << std::endl;
      socket_.async_receive_from(boost::asio::buffer(recv_buf_), endpoint_,
                 boost::bind(&udp_client::handle_receive, this,
                         boost::asio::placeholders::error,
                         boost::asio::placeholders::bytes_transferred));
      io_service_.run_one();


    }
  }

  void handle_receive(const boost::system::error_code& error,
              std::size_t size) {
    if (error) {
      //missing error propagation to main thread
      std::cerr << "ERROR: Client error while receiving (error code = " << error << ")" << std::endl;
      std::cerr << "ERROR: Recovering..." << std::endl;

    } else {
      std::cout << "received" << std::endl;

      replied_ = true;
    }
  }


private:
  boost::asio::io_service io_service_;
  udp::socket socket_;
  udp::endpoint endpoint_;
  volatile bool replied_;
  volatile bool sent_;
  volatile int reply_;
  boost::array<char, sizeof(int)> send_buf_;
  boost::array<char, sizeof(int)> recv_buf_;

};

int main(int argc, char* argv[]) {

  if (argc != 3) {
    std::cerr << "Usage: udp_echo_client <host> <port>" << std::endl;
    return 1;
  }

  try {
    udp_client c(argv[1],argv[2]);

    for(size_t i=0; i != N_MESSAGES; ++i) {
      int r = rand();
      c.send(r);

      //here we could put a tiemeout
      while (!c.sent()) {
    boost::this_thread::sleep(boost::posix_time::milliseconds(10)); 
      }

      //here we could put a tiemeout
      while (!c.replied()) {
    boost::this_thread::sleep(boost::posix_time::milliseconds(10)); 
      }
      int resp = c.reply();

      std::cout << "sent= " << r << ", received= " << resp << std::endl;
      assert(r == resp);
    }

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

  return 0;
}

The log I get is:

$ ./bin/udp_echo_client localhost 11111
prepare sending
sent
received
after run_one
sent= 16807, received= 16807
prepare sending
after run_one

I guess it is my lack of understanding on how to use boost asio. So, I will appreciate if someone can explain why the program behaves like that:)

Answer 1

Promoting my comment, as suggested:

Generally, you need to be continuously polling the io_service (or more approrpaitely, just call io_service::run. In this particular case, you need to call io_service::reset() after io_service::run_one() has completed.