boost :: asio :: async_write, zapisywanie danych większych niż 65536 bajtów

Question

Próbuję napisać ramki jpeg przez gniazdo do klienta za pomocą async_write(). Jako punkt wyjścia posłużyłem się przykładem zwiększenia wartości asynchronous TCP daytime server.

#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; 
} 

mam zmodyfikowane metody, które wykonuje się w następujący sposób: async_write()

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)); 
    } 

Podczas czytania dużego pliku z serwera przy użyciu klienta, serwer będzie tylko zapis maksymalnie 65536 bajtów. Jeśli zastąpię połączenie boost::asio::async_write() za pomocą połączenia synchronicznego boost::asio::write(), poprawna ilość bajtów zostanie przesłana do klienta.

Więc przypuszczam, że moje pytanie brzmi: jak mogę wysłać więcej niż 65536 bajtów używając boost::asio::async_write()? Każda pomoc będzie bardzo ceniona.

Answer 1

Problem jest to, że przy użyciu danych funkcja async_write będzie nie wysyłać bezpośrednio przez funkcję, ale w pewnym momencie po metoda start jest zakończona i zmienna lokalna message_ zostaną zniszczone i boost::asio::buffer nie kopiuje zawartość message_. Przechowuje tylko odniesienie do niego. Rezultat jest nieprzewidywalny. Może być wynikiem transmisji 65536 bajtów.