boost :: asio :: buffer: recupero della dimensione del buffer e prevenzione dell'overflow del buffer?

Question

Ho le due seguenti funzioni per l'invio e la ricezione di pacchetti.

void send(std::string protocol) 
{ 
    char *request=new char[protocol.size()+1]; 
    request[protocol.size()] = 0; 
    memcpy(request,protocol.c_str(),protocol.size()); 

    request_length = std::strlen(request); 
    boost::asio::write(s, boost::asio::buffer(request, request_length)); 
} 
void receive() 
{ 
    char reply[max_length]; 
    size_t reply_length = boost::asio::read(s, boost::asio::buffer(reply, request_length)); 
    std::cout << "Reply is: "; 
    std::cout.write(reply, reply_length); 
    std::cout << "\n"; 
} 

Le domande riguardano questa parte boost::asio::buffer(reply, request_length) cui la lunghezza richiesta è la lunghezza di una stringa che inizialmente era configurazione quando il pacchetto è stato inviato. Come posso controllare la dimensione del buffer senza conoscere request_length? Un'altra domanda è come impedire l'overflow del buffer?

Answer 1

Per ottenere le dimensioni di un buffer, è possibile utilizzare la funzione boost::asio::buffer_size(). Tuttavia, nel tuo esempio, questo probabilmente ti sarà poco utile.

Come spiegato nel buffer overview, Boost.Asio utilizza le classi del buffer per rappresentare i buffer. Queste classi forniscono un'astrazione e proteggono le operazioni Boost.Asio contro i sovraccarichi del buffer. Sebbene il risultato di boost::asio::buffer() venga passato alle operazioni, i metadati, come la dimensione del buffer o il tipo sottostante, non vengono trasmessi. Inoltre, questi buffer non possiedono la memoria, quindi è responsabilità delle applicazioni assicurare che la memoria sottostante rimanga valida per tutta la durata della vita dell'astrazione del buffer.

La funzione boost::asio::buffer() fornisce un modo conveniente per creare le classi di buffer, in cui la dimensione del buffer viene dedotta dal tipo possibile. Quando Boost.Asio è in grado di dedurre la lunghezza del buffer, le operazioni Boost.Asio non invocheranno un overflow del buffer quando si utilizza il tipo di buffer risultante. Tuttavia, se il codice dell'applicazione specifica la dimensione del buffer su boost::asio::buffer(), è responsabilità delle applicazioni assicurarsi che la dimensione non sia maggiore della memoria sottostante.

Durante la lettura dei dati, è richiesto un buffer. La domanda fondamentale diventa come si fa a sapere quanta memoria allocare, se Boost.Asio non trasmette la dimensione. Ci sono alcune soluzioni a questo problema:

• Query la presa per la quantità di dati è disponibile tramite socket::available(), quindi allocare il buffer di conseguenza.

  std::vector<char> data(socket_.available()); 
  boost::asio::read(socket_, boost::asio::buffer(data)); 
  

• utilizzare una classe che Boost.Asio può crescere in memoria, come ad esempio boost::asio::streambuf. Alcune operazioni, ad esempio boost::asio::read() accettano gli oggetti streambuf come buffer e allocano la memoria come richiesto per l'operazione. Tuttavia, dovrebbe essere fornita una condizione di completamento; in caso contrario, l'operazione continuerà fino a quando il buffer non sarà pieno.

  boost::asio::streambuf data; 
  boost::asio::read(socket_, data, 
          boost::asio::transfer_at_least(socket_.available())); 
  

• Come suggerisce Öö Tiib, incorporare lunghezza come parte del protocollo di comunicazione. Controlla Boost.Asio examples per esempi di protocolli di comunicazione. Concentrati sul protocollo, non necessariamente sul Boost.Asio API.

  • In un protocollo di dimensioni fisse, sia il produttore di dati che il consumatore utilizzano lo stesso messaggio di dimensione. Poiché il lettore conosce la dimensione del messaggio, il lettore può allocare un buffer in anticipo.

  • In un protocollo di lunghezza variabile, i messaggi sono spesso divisi in due parti: un'intestazione e un corpo. L'intestazione è in genere di dimensioni fisse e può contenere varie meta-informazioni, come la lunghezza del corpo. Ciò consente a un lettore di leggere un'intestazione in un buffer di dimensioni fisse, estrarre la lunghezza del corpo, allocare un buffer per il corpo, quindi leggere il corpo.

    // Read fixed header. 
    std::vector<char> data(fixed_header_size); 
    boost::asio::read(socket_, boost::asio::buffer(data)); 
    
    protocol::header header(data); 
    network_to_local(header); // Handle endianess. 
    
    // Read body. 
    data.resize(header.body_length()); 
    boost::asio::read(socket_, boost::asio::buffer(data)); 
    
    protocol::body body(data); 
    network_to_local(body); // Handle endianess.  
    

Answer 2

Penso che la tua domanda è confusa, ma questo potrebbe aiutare:

void receive() { 
    enum { max_length = 1024 }; 
    char reply[max_length]; 
    size_t reply_length; 
    std::cout << "Reply is: "; 
    while ((reply_length = ba::read(s, basio::buffer(reply, max_length))) > 0) { 
    std::cout.write(reply, reply_length); 
    } 
    std::cout << "\n"; 
} 

Answer 3

Tipicamente un protocollo di comunicazione o utilizza i messaggi di lunghezza fissa o messaggi che contengono un'intestazione che racconta la lunghezza del messaggio.

Boost.Asio online documentation contiene un ampio set di esempi ed esercitazioni quindi è consigliabile iniziare da lì. Wikipedia è una buona fonte per spiegare la terminologia data transmission, aumentare la documentazione asio non lo fa.