boost :: asio :: async_write, escribiendo datos mayores a 65536 bytes

Question

Estoy intentando escribir marcos jpeg a través de un socket a un cliente usando async_write(). Usé el ejemplo de impulso asynchronous TCP daytime server como punto de partida.

#include <ctime> 
#include <iostream> 
#include <string> 
#include <boost/bind.hpp> 
#include <boost/shared_ptr.hpp> 
#include <boost/enable_shared_from_this.hpp> 
#include <boost/asio.hpp> 

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

std::string make_daytime_string() 
{ 
    using namespace std; // For time_t, time and ctime; 
    time_t now = time(0); 
    return ctime(&now); 
} 

class tcp_connection 
    : public boost::enable_shared_from_this<tcp_connection> 
{ 
public: 
    typedef boost::shared_ptr<tcp_connection> pointer; 

    static pointer create(boost::asio::io_service& io_service) 
    { 
    return pointer(new tcp_connection(io_service)); 
    } 

    tcp::socket& socket() 
    { 
    return socket_; 
    } 

    void start() 
    { 
    message_ = make_daytime_string(); 

    boost::asio::async_write(socket_, boost::asio::buffer(message_), 
     boost::bind(&tcp_connection::handle_write, shared_from_this(), 
      boost::asio::placeholders::error, 
      boost::asio::placeholders::bytes_transferred)); 
    } 

private: 
    tcp_connection(boost::asio::io_service& io_service) 
    : socket_(io_service) 
    { 
    } 

    void handle_write(const boost::system::error_code& /*error*/, 
     size_t /*bytes_transferred*/) 
    { 
    } 

    tcp::socket socket_; 
    std::string message_; 
}; 

class tcp_server 
{ 
public: 
    tcp_server(boost::asio::io_service& io_service) 
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 13)) 
    { 
    start_accept(); 
    } 

private: 
    void start_accept() 
    { 
    tcp_connection::pointer new_connection = 
     tcp_connection::create(acceptor_.io_service()); 

    acceptor_.async_accept(new_connection->socket(), 
     boost::bind(&tcp_server::handle_accept, this, new_connection, 
      boost::asio::placeholders::error)); 
    } 

    void handle_accept(tcp_connection::pointer new_connection, 
     const boost::system::error_code& error) 
    { 
    if (!error) 
    { 
     new_connection->start(); 
     start_accept(); 
    } 
    } 

    tcp::acceptor acceptor_; 
}; 

int main() 
{ 
    try 
    { 
    boost::asio::io_service io_service; 
    tcp_server server(io_service); 
    io_service.run(); 
    } 
    catch (std::exception& e) 
    { 
    std::cerr << e.what() << std::endl; 
    } 

    return 0; 
} 

He modificado el método que realiza la async_write() de la siguiente manera:

void start() 
    { 
    // fileToVector method reads contents of file to vector; 
    std::vector<unsigned char> message_ = fileToVector("/tmp/test"); 

    boost::asio::async_write(socket_, boost::asio::buffer(message_), 
     boost::bind(&tcp_connection::handle_write, shared_from_this(), 
      boost::asio::placeholders::error, 
      boost::asio::placeholders::bytes_transferred)); 
    } 

Al leer un archivo grande desde el servidor mediante un cliente, el servidor sólo escribirá un máximo de 65536 bytes. Si reemplazo la llamada boost::asio::async_write() con una llamada síncrona boost::asio::write(), la cantidad correcta de bytes se transfiere al cliente.

Supongo que mi pregunta es, ¿cómo puedo enviar más de 65536 bytes usando boost::asio::async_write()? Cualquier ayuda sería muy apreciada.

Answer 1

Un problema es que el uso de los datos de la función async_write será enviado no inmediatamente por la función pero en algún momento después de que se terminó el método start y se destruyó el message_ variable local y la boost::asio::buffer no copia el contenido de message_. Almacena solo una referencia al mismo. El resultado es impredecible. Puede ser la transmisión de 65536 bytes es el resultado de este comportamiento.