ich versuche mich gerade an einem Server der sich zu seines Gleichen verbindet um dann ein Paket hin und her zu senden.

Meine boost-Version ist 1.46.1.

Anbei habe ich einen ersten Entwurf der sich stark an http://www.boost.org/doc/libs/1_46_1/doc/html/boost_asio/example/http/client/async_client.cpp orientiert.

Der Client macht nichts 'dolles, er zieht genau eine Nachricht von einem Server, der in meinem Fall http://www.boost.org/doc/libs/1_46_1/doc/html/boost_asio/tutorial/tutdaytime3/src.html ist. Dieser Server ist nur ein Behelf bis mein Client selbst ein Server geworden ist und sich selbst Pakete zuschicken kann.

Meine erste Frage: Wie verändere ich meinen Client so das dieser ständig Nachricht nach Nachricht zieht?

Meine erste Frage: Wie verändere ich meinen Client so das dieser ständig Nachricht nach Nachricht zieht?

Indem du
a) das "Nachrichtenziehen" in eine Schleife packst, oder
b) nach ASIO-Manier den passenden Completion-Handler so implementierst, dass nach dem Empfang einer Nachricht gleich nach der nächsten gefragt wird.

Ich nehme mal an, dass das Ganze asynchron läuft (hab jetzt nicht die Zeit, das Tutorial anzuschauen), daher fällt a) wohl aus

#include <iostream>
#include <istream>
#include <ostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

using boost::asio::ip::tcp;

class client
{
public:
  client(boost::asio::io_service& io_service,
      const std::string& server, const std::string& port)
    : resolver_(io_service),
      socket_(io_service)
  {
    // Start an asynchronous resolve to translate the server and service names
    // into a list of endpoints.
    tcp::resolver::query query(server, port);
    resolver_.async_resolve(query,
        boost::bind(&client::handle_resolve, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::iterator));
  }

private:
  void handle_resolve(const boost::system::error_code& err,
      tcp::resolver::iterator endpoint_iterator)
  {
    if (!err)
    {
      // Attempt a connection to each endpoint in the list until we
      // successfully establish a connection.
      tcp::endpoint endpoint = *endpoint_iterator;
      socket_.async_connect(endpoint,
          boost::bind(&client::handle_connect, this,
            boost::asio::placeholders::error));
    }
    else
    {
      std::cout << "Error: " << err.message() << "\n";
    }
  }

  void handle_connect(const boost::system::error_code& err)
  {
    if (!err)
    {
      // The connection was successful. Read the response.
      boost::asio::async_read(socket_, response_,
          boost::bind(&client::handle_response, this));
    }
    else if (err != boost::asio::error::eof)
    {
      std::cout << "Error: " << err.message() << "\n";
    }
  }

  void handle_response()
  {
    if (response_.size() > 0)
      std::cout << "Response: " << &response_;
    else
      std::cout << "Response is empty." << std::endl;
  }

  tcp::resolver resolver_;
  tcp::socket socket_;
  boost::asio::streambuf request_;
  boost::asio::streambuf response_;
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 3)
    {
      std::cout << "Usage: async_client <server> <port>\n";
      std::cout << "Example:\n";
      std::cout << "  async_client localhost 2020\n";
      return 1;
    }

    boost::asio::io_service io_service;
    client c(io_service, argv[1], argv[2]);
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cout << "Exception: " << e.what() << "\n";
  }

  return 0;
}

b) nach ASIO-Manier den passenden Completion-Handler so implementierst, dass nach dem Empfang einer Nachricht gleich nach der nächsten gefragt wird.

Geht das gut, beliebig viele Handler hintereinander aufzurufen?

void handle_connect(const boost::system::error_code& err)
  {
    if (!err)
    {
      // The connection was successful. Read the response.
      boost::asio::async_read(socket_, response_,
          boost::bind(&client::handle_response, this));
      boost::asio::async_read(socket_, response_,
          boost::bind(&client::handle_response, this));
    }
    else if (err != boost::asio::error::eof)
    {
      std::cout << "Error: " << err.message() << "\n";
    }
  }

Die Ausgabe (mittels handle_response()) ist dann:

Response: Thu Sep  6 10:11:59 2012
Response is empty.

Das zweite Lesen ging daneben. Was habe ich falsch gemacht?

Entschuldigung, ich hatte meinen Code vergessen zu posten

Ändert nichts an der Antwort
Der Completion-Handler den du ändern willst, ist dann wohl handle_response.

PS: Wenn du einen C++11-fähigen Compiler hast, bieten sich an Stelle von boost::bind Lambdas an:

using namespace boost::system;
using namespace boost::asio;

class client
{
public:
  client(io_service& io_service,
      const std::string& server, const std::string& port)
    : resolver_(io_service),
      socket_(io_service)
  {
    // Start an asynchronous resolve to translate the server and service names
    // into a list of endpoints.
    tcp::resolver::query query(server, port);
    resolver_.async_resolve(query, 
      [this](const boost::system::error_code& err, tcp::resolver::iterator endpoint_iterator)
      {
         //... Inhalt von handle_connect...
      });
  }

Response: Thu Sep  6 10:41:21 2012
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.
Response is empty.

Irgendwo ist der Wurm drin.

void handle_response()
  {
    if (response_.size() > 0)
      std::cout << "Response: " << &response_;
    else
      std::cout << "Response is empty." << std::endl;

    boost::asio::async_read(socket_, response_,
          boost::bind(&client::handle_response, this));
  }

Führ dir nochmal vor Augen, wie das mit den Completion-Handles in ASIO funktioniert...

Dann sendet der Server nur beim Connect des Clients ein Datum, danach aber nichts mehr. Laut Titel wolltest du ja aber eh einen Ping/Pong-Server schreiben, in dem Fall müsste dein Client auch jedesmal erst "etwas" (ein PING) senden, bevor der Server was antwortet.

Ja, ich weiß, aber ich muss mich ran tasten. Aktuell wäre ein Ping-Pong-Server meinerseits so buggy das ich nicht wüsste wo anzufangen.