Conexión asíncrona y desconexión con epoll (Linux)

Question

Necesito una conexión asincrónica y una desconexión para el cliente tcp que utiliza epoll para Linux. Hay ext. funciones en Windows, como ConnectEx, DisconnectEx, AcceptEx, etc ... En tcp la función de aceptación estándar del servidor está funcionando, pero en tcp el cliente no funciona, conéctese y desconecte ... Todos los enchufes no bloquean.

¿Cómo puedo hacer esto?

Gracias!

Answer 1

podido hacer sin bloqueo connect(), asumiendo que el socket ya se ha hecho sin bloqueo:

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 
} 

Para el segundo caso, en connect() fallado con EINPROGRESS (y sólo en este caso), debe esperar a que el zócalo sea escribible, por ej. para epoll especifica que estás esperando EPOLLOUT en este socket. Una vez que se le notifica que es escribible (con epoll, también esperar para obtener una EPOLLERR o evento EPOLLHUP), comprobar el resultado del intento de conexión:

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() 

En mi experiencia, en Linux, connect() Nunca de inmediato tiene éxito y siempre tienes que esperar por la escritura. Sin embargo, por ejemplo, en FreeBSD, he visto no-blocking connect() a localhost tener éxito de inmediato.

Answer 2

que tienen un "completo" responder aquí en caso de cualquier otra persona está buscando esto:

#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

Por experiencia, cuando se detecta una conexión sin bloqueo, epoll es un poco diferente de seleccionar y sondeo.

con epoll:

Después de que se hizo la llamada connect(), compruebe el código de retorno.

Si la conexión no se puede completar inmediatamente, registre el evento EPOLLOUT con epoll.

Llamada epoll_wait().

si la conexión falló, sus eventos se llenarán con EPOLLERR o EPOLLHUP, de lo contrario se activará EPOLLOUT.

Answer 4

He intentado la solución de Sonny y el epoll_ctl devolverá un argumento no válido. Así que creo que tal vez la forma correcta de hacerlo es la siguiente:

socketfd 1.Create y epollfd

epoll_ctl 2.use asociar el socketfd y epollfd con el evento epoll.

3.do conectar (socketfd, ...)

4.Compruebe el valor de retorno o errno

5.if errno == EINPROGRESS, hacer epoll_wait