Ip::udp::socket.async_receive_from. Как передать дополнительные аргументы в callback

#include <cstdlib>
#include <iostream>
#include <list>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
 
using namespace boost::asio;
 
class UdpSimpleServer{
private:
    ip::udp::socket socket1;
    std::array<char, 1024> buff;
    int port;
 
    void receive_callback(const boost::system::error_code &err, std::size_t bytes_transfered)
    {
        buff[bytes_transfered] = '\0';
        std::cout<< "got: " << buff.data() << std::endl;
        socket1.send_to(buffer(buff, bytes_transfered), client_endpoint_);
        socket1.async_receive_from(buffer(buff), client_endpoint_, boost::bind(&UdpSimpleServer::receive_callback, this,
            boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
    }
 
public:
    UdpSimpleServer(io_service &service,int port) :socket1(service){
        UdpSimpleServer::port = port;
    }
    void Start()
    {
        try{
            socket1.open(ip::udp::v4());
            socket1.bind(ip::udp::endpoint(ip::address_v4::from_string("0.0.0.0"), port));
            
            socket1.async_receive_from(buffer(buff), client_endpoint_, boost::bind(&UdpSimpleServer::receive_callback, this,
                boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }
        catch (std::exception ex)
        {
            std::cout << "Error: " << ex.what() << std::endl;
        }
    }
 
    ip::udp::endpoint client_endpoint_;
};
 
int main()
{
    io_service service;
    UdpSimpleServer server(service, 9050);
    server.Start();
    service.run();
 
    std::cin.get();
    return 0;
}

#include <cstdlib>
#include <iostream>
#include <list>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/thread.hpp>
 
using namespace boost::asio;
 
io_service ios;
 
class Client
{
public:
   Client(int port) : socket_(ios)
   {
      receiver_ = ip::udp::endpoint(ip::address_v4::from_string("127.0.0.1"), port);
 
      socket_.open(ip::udp::v4());
      socket_.async_receive_from(buffer(buffer_), receiver_, boost::bind(&Client::on_receive, this, placeholders::error, placeholders::bytes_transferred));
   }
   void send(const std::string& msg)
   {
      std::copy(msg.begin(), msg.end(), buffer_.begin());
      socket_.async_send_to(buffer(buffer_, msg.size()), receiver_, boost::bind(&Client::on_send, this, placeholders::error, placeholders::bytes_transferred));
   }
private:
 
   void on_send(const boost::system::error_code& ec, const size_t bytes)
   {
      std::cout << "sended " << bytes << " bytes with " << ec.message() << std::endl;
   }
 
   void on_receive(const boost::system::error_code& ec, const size_t bytes)
   {
      std::cout << "received " << bytes << " bytes with " << ec.message() << std::endl;
      buffer_[bytes] = '\0';
      std::cout << buffer_.data() << std::endl;
   }
 
   ip::udp::socket socket_;
   std::array<char, 1024> buffer_;
   ip::udp::endpoint receiver_;
};
 
int main()
{
   Client client(9050);
   client.send("hello");
   ios.run();
}

#include <cstdlib>
#include <iostream>
#include <list>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/asio/spawn.hpp>
 
using namespace boost::asio;
 
class UdpSimpleServer{
private:
  ip::udp::socket socket1;
  int port;
 
  void receiver(boost::asio::yield_context yield)
  {
     for (;;)
     {
        std::array<char, 1024> buff;
        ip::udp::endpoint endpoint;
        boost::system::error_code ec;
        std::size_t bytes_transfered = socket1.async_receive_from(buffer(buff), endpoint, yield[ec]);
        std::cout << "We got " << bytes_transfered << " bytes " << ec.message() << " from port: " << endpoint.port() << std::endl;
        const std::string received(buff.begin(), buff.begin() + bytes_transfered);
        if (bytes_transfered > 0)
        {
           std::cout << "received: " << received << " send it to client" << std::endl;
           bytes_transfered = socket1.async_send_to(buffer(received), endpoint, yield[ec]);
           std::cout << "Sended " << bytes_transfered << " bytes " << ec.message() << std::endl;
        }
     }
  }
 
public:
  UdpSimpleServer(io_service &service, int port) :socket1(service){
      UdpSimpleServer::port = port;
  }
 
  void Start()
  {
      try{
          socket1.open(ip::udp::v4());
          socket1.bind(ip::udp::endpoint(ip::address_v4::from_string("0.0.0.0"), port));
          boost::asio::spawn(socket1.get_io_service(), boost::bind(&UdpSimpleServer::receiver, this, _1));
      }
      catch (std::exception ex)
      {
          std::cout << "Error: " << ex.what() << std::endl;
      }
  }
};
 
int main()
{
  io_service service;
  UdpSimpleServer server(service, 9050);
  server.Start();
  service.run();
 
  std::cin.get();
  return 0;
}

#include <cstdlib>
#include <iostream>
#include <queue>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/asio/spawn.hpp>
 
using namespace boost::asio;
 
io_service ios;
 
class Client
{
public:
    Client(int port) : socket_(ios)
    {
        receiver_ = ip::udp::endpoint(ip::address_v4::from_string("127.0.0.1"), port);
        socket_.open(ip::udp::v4());
    }
 
    void spawn_task()
    {
       spawn(ios, boost::bind(&Client::sender, this, _1));
    }
 
    void send(const std::string& message)
    {
       queue.push(message);
    }
 
private:
    void sender(boost::asio::yield_context yield)
    {
       for (;;)
       {
         while (!queue.empty())
         {
            const std::string message = queue.front();
            queue.pop();
            boost::system::error_code ec;
            size_t bytes = socket_.async_send_to(buffer(message), receiver_, yield[ec]);
            std::cout << "sended " << bytes << " " << ec.message() << std::endl;
            std::array<char, 1024> buff;
            bytes = socket_.async_receive_from(buffer(buff), receiver_, yield);
            std::cout << "received " << bytes << " " << ec.message() << " " << std::string(buff.begin(), buff.begin() + bytes) << std::endl;
         }
       }
    }
    ip::udp::socket socket_;
    ip::udp::endpoint receiver_;
    std::queue<std::string> queue;
};
 
int main()
{
    Client client(9050);
    client.spawn_task();
    client.send("message");
    client.send("message2");
    ios.run();
}