Question

this is my boost::asio server

class Server: public boost::enable_shared_from_this<Server>, private boost::noncopyable{
  private:
    boost::asio::ip::tcp::acceptor _acceptor;
    boost::asio::ip::tcp::socket   _socket;
  public:
    explicit Server(boost::asio::io_service& ios, boost::asio::ip::tcp::endpoint& endpoint):_acceptor(ios, endpoint), _socket(ios){

    }
    void start(){
       accept();
    }
    void accept(){
       std::cout << "accepting " << std::endl;;
      _acceptor.async_accept(_socket, boost::bind(&Server::handler, this, boost::asio::placeholders::error));
    }
    void handler(const boost::system::error_code &ec){
       const std::string message = "HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, world!";
       if(!ec){
         boost::asio::async_write(_socket, boost::asio::buffer(message), boost::bind(&Server::write_handler, this));
       }else{
         std::cout << ec << std::endl;
       }
       accept();
    }
    void write_handler(){

    }
    boost::asio::ip::tcp::socket& socket(){
      return _socket;
    }
};


int main(){
  boost::asio::io_service ios;
  const unsigned int port = 5050;
  boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);

  Server server(ios, endpoint);
  server.start();

  ios.run();
  return 0;
}

for the first time it responds with an ‘Hallo World’;
Then it just keeps looping in accept <–> handler loop and doesn’t write the welcome message. ec prints

asio.misc:1
accepting 
asio.misc:1
accepting 
asio.misc:1
accepting 
asio.misc:1
accepting 
asio.misc:1
accepting 
asio.misc:1
accepting 
......

and never stops

Answer 1

The infinite loop is the result of _socket being in use. The first async_accept() works because _socket is not in use. However, the _socket is never closed, so additional calls to async_accept() with _socket are going to fail. The async_accept()‘s peer argument expects that the socket is not in use, as it is going to use the socket for a new connection. This can be resolved by either:

• Allocating a new socket per connection. Consider managing the sockets via boost::shared_ptr. This allows the server to handle multiple concurrent connections.
• Closing the _socket in the write_handler, then invoke accept(). This limits the server to one connection at a time.

Also, be careful with async_write(). Ownership of the underlying buffer memory is retained by the caller, who must guarantee that it remains valid until the handler is called. In this case, message will pop off of the stack before write_handler() is invoked. With message being const, consider making it static to guarantee its duration.

Use shared_from_this() instead of this when passing in the object to the instance to the bind call. Otherwise, the instance pointed to by this may be deleted, as referencing counting only properly takes place when using shared_from_this().

Finally, when printing boost::system::error_code, use the error_code.message() method to get a more meaningful message. In the case of the infinite loop, it would print “Already open”.

Here is the modified handler() and write_handler() code that supports one connection at a time:

void accept(){
   std::cout << "accepting " << std::endl;;
  _acceptor.async_accept(_socket, boost::bind(&Server::handler, shared_from_this(), boost::asio::placeholders::error));
}
void handler(const boost::system::error_code &ec){
   // Guarantee message will remain valid throughout the duration of async_write.
   static const std::string message = "HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, world!";
   if(!ec){
     // write_handler will accept the next connection once it is done with the socket.
     boost::asio::async_write(_socket, boost::asio::buffer(message), boost::bind(&Server::write_handler, shared_from_this()));
   }else{
     std::cout << ec.message() << std::endl;
     // Try accepting on error.
     accept();
   }
}
void write_handler(){
   _socket.close();
   // Now that the socket is closed, new connectiosn can be accepted.
   accept();
}