Async verbinden und trennen mit Epoll (Linux)

Question

Ich brauche async verbinden und trennen für TCP-Client mit Epoll für Linux. Es gibt ext. Funktionen in Windows, wie ConnectEx, DisconnectEx, AcceptEx, etc ... In TCP-Server-Standard-Funktion akzeptieren funktioniert, aber im TCP-Client funktioniert nicht verbinden und trennen ... Alle Sockets sind nonblocking.

Wie kann ich das tun?

Danke!

Answer 1

ein blockierungs connect() zu tun, die Buchse ist unter der Annahme, bereits nicht blockierend vorgenommen:

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 
} 

Für den zweiten Fall, wo connect() mit EINPROGRESS fehlgeschlagen (und nur in diesem Fall), müssen Sie warten, bis der Socket beschreibbar ist, z Für epoll geben Sie an, dass Sie auf diesen Socket auf EPOLLOUT warten. Sobald Sie benachrichtigen, dass es beschreibbar ist (mit epoll, auch erwarten ein EPOLLERR oder EPOLLHUP Ereignis zu erhalten), das Ergebnis des Verbindungsversuches überprüfen:

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

Nach meiner Erfahrung auf Linux, connect() nie ist sofort erfolgreich und Sie müssen immer auf Schreibbarkeit warten. Unter FreeBSD habe ich jedoch festgestellt, dass non-blocking connect() zu localhost sofort erfolgreich ist.

Answer 2

ich eine „vollständige“ Antwort hier falls jemand anderes für diese sucht:

#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

Aus Erfahrung, wenn Blockierung nicht-Verbindung erkennen, ist epoll ein wenig anders wählen und Umfrage.

mit epoll:

Nach connect() Anruf getätigt wird, Return-Code überprüfen.

Wenn die Verbindung nicht sofort hergestellt werden kann, registrieren Sie das Ereignis EPOLLOUT mit epoll.

Aufruf epoll_wait().

Wenn die Verbindung fehlgeschlagen ist, werden Ihre Ereignisse mit EPOLLERR oder EPOLLHUP gefüllt, andernfalls wird EPOLLOUT ausgelöst.

Answer 4

Ich habe versucht, die Sonny-Lösung und die epoll_ctl wird ungültiges Argument zurückgeben. Deshalb denke ich, vielleicht der richtige Weg, dies wie folgt zu tun:

1.Erstellen socketfd und epollfd

2.use epoll_ctl die socketfd und epollfd mit epoll Ereignis zuzuordnen.

3.do verbinden (socketfd, ...)

4.Check Rückgabewert oder errno

5.if errno == EINPROGRESS, tun epoll_wait