asio tcp

acceptor Sınıfı
acceptor Sınıfı yazısına taşıdım.

endpoint Sınıfı

Constructor - Port
Sınıf şöyle kurulur. Endpoint bir ip adresi ve bir de port numarasından oluşur.

asio::ip::tcp::endpoint end(asio::ip::tcp::v4(), 1234);

Constructor - IP + Port
string ve port numarasından şöyle kurarız.

std::string HostName = "...";const int Port = ...;
asio::ip::tcp::endpoint e(asio::ip::address::from_string(HostName), Port);

Constructor - Resolver
Şöyle yaparız.

tcp::resolver resolver = ...;
tcp::resolver::query query (host, port);
tcp::resolver::iterator it = resolver.resolve(query);
tcp::endpoint endpoint = *it;

address metodu - getter
address değerini verir.  Şöyle yaparız.

std::string s = socket.remote_endpoint().address().to_string();

address metodu - setter
Şöyle yaparız.

tcp::endpoint endpoint;endpoint.address(boost::asio::ip::address_v4::from_string("127.0.0.1"));

port metod - setter
Şöyle yaparız.

tcp::endpoint endpoint;
endpoint.port(90);

iostream Sınıfı

Constructor
Şöyle yaparız. Bağlanmak için connect metodu çağrılır.

boost::asio::ip::tcp::iostream stream;

Constructor - hostname + port
Şöyle yaparız.

string hostname = ...;
boost::asio::ip::tcp::iostream stream (hostname, "http");

connect metodu

Şöyle yaparız.

stream.connect ("localhost", "12345");

good metodu

Şöyle yaparız.

if(!stream.good()){
  throw runtime_error("...");
}

opertor << Şöyle yaparız.

stream << "Test" <<std::endl;

Şöyle yaparız.

stream << "GET " << path << " HTTP/1.0\r\n" << "Host: " << hostname << "\r\n";
stream << "Accept: */*\r\n" << "Connection: close\r\n\r\n";
stream << flush;

Stream aynı zamanda STL algoritmaları ile de kullanılabilir. 

string lineContent;
while(getline(stream, lineContent)){
  ...
}

rdbuf metodu
Sokette okumaya hazır veriyi öğrenmek için şöyle yaparız.

// Block until 6 bytes are available.
while (stream.rdbuf()->available() < 6)
{
  std::this_thread::sleep_for(std::chrono::seconds(1));
}

read metodu
Şöyle yaparız.

/// @brief Read up to `n` characters from `stream` and store them
///        into `buffer` without blocking.  This may not read all
///        of the requested amount of bytes.
template <typename... Args>
std::streamsize readsome(
  boost::asio::basic_socket_iostream<Args...>& stream,
  char* buffer,
  std::streamsize n)
{
  std::streamsize available =
    stream.rdbuf()->in_avail()     // available on input sequence
    + stream.rdbuf()->available(); // available on socket
  n = std::min(n, available);
  if (n == 0) return 0;

  stream.read(buffer, n);
  return n;
}

read_some metodu

Şöyle yaparız.

char inp[6]={0,0,0,0,0,0};
size_t r = stream.read_some (inp,5);

socket Sınıfı
tcp socket Sınıfı yazısına taşıdım.

query Sınıfı

Constructor
Sınıf şöyle kurulur.

asio::tcp::resolver::query query(tcp::v4(),"10.0.0.16",80); 

Kendi bilgisayar ismimiz için şöyle kurulur.

asio::ip::tcp::resolver::query query(boost::asio::ip::host_name(),"");

resolver Sınıfı

Bu sınıfın kardeşi udp isim alanı altında mevcuttur.
Constructor
Verilen query nesnesini endpoint'e çevirir. Sınıf şöyle kurulur.

asio::ip::tcp::resolver (io_svc)

resolve metodu
resolve metodu şöyle kullanılır.

ip::tcp::resolver resolver(my_io_service);
ip::tcp::resolver::query query("www.boost.org", "http");
ip::tcp::resolver::iterator iter = resolver.resolve(query);
ip::tcp::resolver::iterator end; // End marker.
while (iter != end)
{
    ip::tcp::endpoint endpoint = *iter++;
    std::cout << endpoint << std::endl;
}

async_resolve metodu
Şöyle sorgulanır.

resolver.async_resolve(
          query,
          boost::bind(
              &MyClass::handle_resolve,
              this,
              boost::asio::placeholders::error,
              boost::asio::placeholders::iterator));

resolve callback completion şuna benzer.

void MyClass::handle_resolve(
        const boost::system::error_code & error,
        boost::asio::ip::tcp::resolver::iterator endpoint_itr)
    {
      if (!error)
      {
        boost::asio::ip::tcp::endpoint endpoint = *endpoint_itr;
        socket_.async_connect(
            endpoint,
            boost::bind(
              &Session::handle_connect,
              this,
              boost::asio::placeholders::error,
              ++endpoint_itr));
      }
      else
      {
        std::cerr << "Failed to resolve\n";
        std::cerr << "Error: " << error.message() << std::endl;
      }
    }

Bir başka örnek

#include <boost/asio/io_service.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <array>
#include <string>
#include <iostream>

using namespace boost::asio;
using namespace boost::asio::ip;
using namespace std;

void resolve_handler(const boost::system::error_code &ec,
                     tcp::resolver::iterator it)
{
  tcp::resolver::iterator end;
  for (; it != end; ++it) {
    cout << it->host_name() << endl;
  }
}

int main()
{
  io_service ioservice;
  tcp::resolver resolv{ioservice};
  tcp::endpoint endpoint{address::from_string("74.125.239.48"), 80};
  resolv.async_resolve(endpoint, resolve_handler);
  ioservice.run();
  return 0;
}