Async connessione e disconnessione con epoll (Linux)

Question

Ho bisogno di connessione asincrona e disconnessione per client tcp che utilizza epoll per Linux. Ci sono ext. funzioni in Windows, come ConnectEx, DisconnectEx, AcceptEx, ecc ... Nel server TCP, la funzione di accettazione standard funziona, ma nel client TCP non funziona la connessione e la disconnessione ... Tutti i socket sono non bloccanti.

Come posso fare questo?

Grazie!

Answer 1

Per fare un non-bloccante connect(), assumendo la presa è già stato reso non bloccante:

int res = connect(fd, ...); 
if (res < 0 && errno != EINPROGRESS) { 
    // error, fail somehow, close socket 
    return; 
} 

if (res == 0) { 
    // connection has succeeded immediately 
} else { 
    // connection attempt is in progress 
} 

Per il secondo caso, in cui connect() non riuscita con EINPROGRESS (e solo in questo caso), devi aspettare che il socket sia scrivibile, ad es per epoll specificare che stai aspettando EPOLLOUT su questo socket. Una volta ci si notifica che è scrivibile (con epoll, anche si aspettano di ottenere un EPOLLERR o eventi EPOLLHUP), controllare il risultato del tentativo di connessione:

int result; 
socklen_t result_len = sizeof(result); 
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &result, &result_len) < 0) { 
    // error, fail somehow, close socket 
    return; 
} 

if (result != 0) { 
    // connection failed; error code is in 'result' 
    return; 
} 

// socket is ready for read()/write() 

Nella mia esperienza, su Linux, connect() mai immediatamente ha successo e devi sempre aspettare la scrittura. Tuttavia, per esempio, su FreeBSD, ho visto subito il collegamento non bloccante connect() a localhost.

Answer 2

Ho un "completo" risposta qui nel caso in cui nessun altro è alla ricerca di questo:

#include <sys/epoll.h> 
#include <errno.h> 
.... 
.... 
int retVal = -1; 
socklen_t retValLen = sizeof (retVal); 

int status = connect(socketFD, ...); 
if (status == 0) 
{ 
    // OK -- socket is ready for IO 
} 
else if (errno == EINPROGRESS) 
{ 
    struct epoll_event newPeerConnectionEvent; 
    int epollFD = -1; 
    struct epoll_event processableEvents; 
    unsigned int numEvents = -1; 

    if ((epollFD = epoll_create (1)) == -1) 
    { 
     printf ("Could not create the epoll FD list. Aborting!"); 
     exit (2); 
    }  

    newPeerConnectionEvent.data.fd = socketFD; 
    newPeerConnectionEvent.events = EPOLLOUT | EPOLLIN | EPOLLERR; 

    if (epoll_ctl (epollFD, EPOLL_CTL_ADD, socketFD, &newPeerConnectionEvent) == -1) 
    { 
     printf ("Could not add the socket FD to the epoll FD list. Aborting!"); 
     exit (2); 
    } 

    numEvents = epoll_wait (epollFD, &processableEvents, 1, -1); 

    if (numEvents < 0) 
    { 
     printf ("Serious error in epoll setup: epoll_wait() returned < 0 status!"); 
     exit (2); 
    } 

    if (getsockopt (socketFD, SOL_SOCKET, SO_ERROR, &retVal, &retValLen) < 0) 
    { 
     // ERROR, fail somehow, close socket 
    } 

    if (retVal != 0) 
    { 
     // ERROR: connect did not "go through" 
    } 
} 
else 
{ 
    // ERROR: connect did not "go through" for other non-recoverable reasons. 
    switch (errno) 
    { 
    ... 
    } 
} 

Answer 3

Per esperienza, quando rilevare non bloccante collegamento, epoll è un po 'diverso da selezionare e sondaggio.

con epoll:

Dopo chiamata connect() viene effettuata, controllare il codice di ritorno.

Se la connessione non può essere completata immediatamente, quindi registrare l'evento EPOLLOUT con epoll.

Chiama epoll_wait().

in caso di mancata connessione, gli eventi verranno riempiti con EPOLLERR o EPOLLHUP, altrimenti verrà attivato EPOLLOUT.

Answer 4

Ho provato la soluzione di Sonny e epoll_ctl restituirà un argomento non valido. Quindi penso che forse il modo giusto per fare questo è la seguente:

1.Creare socketfd e epollfd

2.use epoll_ctl ad associare il socketfd e epollfd con l'evento epoll.

3.do connect (socketfd, ...)

4.Check il valore di ritorno o errno

5.if errno == EINPROGRESS, fare epoll_wait