Strano eccezione tiro - assegnare: Operation not permitted

Question

voglio fare lettura asincrono da cin quindi ho un pezzo di codice

client.h

... 
boost::asio::posix::stream_descriptor input; 
boost::asio::streambuf input_buffer 

client.cpp

Client::Client(int argc, char **argv, boost::asio::io_service &io_service) 
    : tcp_socket(io_service) 
    , udp_socket(io_service) 
    , input(io_service, ::dup(STDIN_FILENO)) 
{ 
    ... 
    read_std_input(); 
} 

void Client::read_std_input() { 
    async_read_until(input, input_buffer, '\n', 
        boost::bind(&Client::handle_std_read, this, 
           boost::asio::placeholders::error, 
           boost::asio::placeholders::bytes_transferred)); 
} 

Il problema è: quando eseguo il mio client nel modo normale [./client] e poi inserisco qualcosa via comando, funziona come un incantesimo. Tuttavia, quando l'eseguo tramite [./client < prova] getta:

Termina chiamata dopo aver lanciato un'istanza di 'boost :: :: exception_detail clone_impl

' quello che() : assegnare: Operation not permitted interrotta

hai un'idea di che cosa il problema potrebbe essere? Grazie!

Answer 1

Boost.I descrittori orientati al flusso POSIX di Asio non supportano esplicitamente i file normali. Quindi, se test è un file normale, allora ./client < test provocherà un errore nel posix::stream_descriptor::assign() quando si tenta di assegnare STDIN_FILENO allo stream_descriptor. I documentation afferma:

Boost.Asio include classi aggiunte per permettere lettura sincrona e asincrona e scrittura da eseguire su descrittori di file POSIX, come tubi, standard input e di output, e vari dispositivi (ma non file regolari).

consideri passando il contenuto del file di test-client attraverso un tubo.

$ cat test | ./client 

---

Ecco un programma di esempio completo e dimostrazione:

#include <iostream> 
#include <boost/asio.hpp> 

void handle_read(
    const boost::system::error_code& error, 
    std::size_t bytes_transferred 
) 
{ 
    std::cout << "read " << bytes_transferred << " bytes with " 
      << error.message() << std::endl; 
} 

int main() 
{ 
    boost::asio::io_service io_service; 
    boost::asio::posix::stream_descriptor input(io_service); 

    // Assign STDIN_FILENO to the stream_descriptor. It will support 
    // pipes, standard input and output, and various devices, but NOT 
    // regular files. 
    boost::system::error_code error; 
    input.assign(STDIN_FILENO, error); 
    if (error) 
    { 
    std::cerr << error.message() << std::endl; 
    return -1; 
    } 

    boost::asio::streambuf input_buffer; 
    async_read_until(input, input_buffer, '\n', &handle_read); 
    io_service.run(); 
} 

Dimostrazione

 
$ ./client 
testing standard inputenter 
read 23 bytes with Success 
$ echo "this is a test" > test 
$ ./client < test 
Operation not permitted 
$ cat test | ./client 
read 15 bytes with Success 

Answer 2

L'I/O file asincrono su Linux è ancora piuttosto primitivo. Sebbene il supporto ASIO per l'I/O asincrono dei file funzioni bene in Windows, non ho avuto molta fortuna in Windows.

This is a previous SO question that provides some background on the issue.

Answer 3

Puoi provare con questo riproduttore minimale? Funziona sulla mia Ubuntu box a 64 bit:

#include <boost/asio.hpp> 
#include <boost/asio/posix/stream_descriptor.hpp> 

#include <iostream> 

int main() 
{ 
    using namespace boost::asio; 

    io_service io; 
    posix::stream_descriptor input(io); 

    input.assign(STDIN_FILENO); 
    streambuf input_buffer; 

    std::function<void()> loop = [&] { 
     async_read_until(input, input_buffer, '\n', [&](boost::system::error_code ec, size_t) { 
      if (ec) 
       std::cerr << ec.message(); 
      else { 
       std::cout << "LOOP: '" << &input_buffer << "'\n"; 
       loop(); 
      } 
     }); 
    }; 

    loop(); 
    io.run(); 
} 

Aggiornamento penso di poter riprodurre il problema on Coliru: si può controllare l'uscita di ulimit -a?

Answer 4

Boost ASIO, su Linux, utilizza il sistema epollby default che does not support files.

Ma c'è una soluzione alternativa: se si definisce BOOST_ASIO_DISABLE_EPOLL, asio tornerà al sistema select ei file funzioneranno.