Wie setze ich das Socket-Timeout in C, wenn mehrere Verbindungen hergestellt werden?

Ich schreibe ein einfaches Programm, das mehrere Verbindungen zu verschiedenen Servern zur Statusprüfung herstellt. Alle diese Verbindungen werden nach Bedarf erstellt; Bis zu 10 Verbindungen können gleichzeitig erstellt werden. Ich mag die Idee von einem Thread pro Socket nicht, also habe ich alle diese Client-Sockets nicht blockierend gemacht und sie in einen select()-Pool geworfen.

Es hat großartig funktioniert, bis sich mein Client darüber beschwert hat, dass die Wartezeit zu lang ist, bevor er den Fehlerbericht erhalten kann, wenn die Zielserver nicht mehr reagieren.

Ich habe mehrere Themen im Forum überprüft. Einige hatten vorgeschlagen, dass man das alarm()-Signal verwenden oder ein Timeout im select()-Funktionsaufruf setzen kann. Aber ich habe es mit mehreren Verbindungen zu tun, anstatt mit einer. Wenn ein prozessweites Timeout-Signal auftritt, habe ich keine Möglichkeit, die Timeout-Verbindung von allen anderen Verbindungen zu unterscheiden.

Gibt es eine Möglichkeit, die systemstandardmäßige Zeitüberschreitungsdauer zu ändern?

Sie können die Socket-Optionen SO_RCVTIMEO und SO_SNDTIMEO verwenden, um Zeitüberschreitungen für alle Socket-Operationen wie folgt festzulegen:

    struct timeval timeout;      
    timeout.tv_sec = 10;
    timeout.tv_usec = 0;
    
    if (setsockopt (sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout,
                sizeof timeout) < 0)
        error("setsockopt failed\n");

    if (setsockopt (sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout,
                sizeof timeout) < 0)
        error("setsockopt failed\n");
    

Bearbeiten: von dem setsockopt Manpage:

SO_SNDTIMEO ist eine Option, um einen Timeout-Wert für Ausgabevorgänge festzulegen. Es akzeptiert einen struct timeval-Parameter mit der Anzahl von Sekunden und Mikrosekunden, die verwendet werden, um die Wartezeiten für den Abschluss von Ausgabeoperationen zu begrenzen. Wenn eine Sendeoperation so lange blockiert hat, kehrt sie mit einer Teilzählung zurück oder mit dem Fehler EWOULDBLOCK, wenn keine Daten gesendet wurden. In der aktuellen Implementierung wird dieser Zeitgeber jedes Mal neu gestartet, wenn zusätzliche Daten an das Protokoll geliefert werden, was impliziert, dass die Grenze für Ausgabeabschnitte gilt, deren Größe von der Niedrigwassermarke bis zur Hochwassermarke für die Ausgabe reicht.

SO_RCVTIMEO ist eine Option, um einen Timeout-Wert für Eingabeoperationen festzulegen. Es akzeptiert einen struct timeval-Parameter mit der Anzahl von Sekunden und Mikrosekunden, die verwendet werden, um die Wartezeiten für den Abschluss von Eingabeoperationen zu begrenzen. In der aktuellen Implementierung wird dieser Zeitgeber jedes Mal neu gestartet, wenn zusätzliche Daten durch das Protokoll empfangen werden, und somit ist die Grenze tatsächlich ein Inaktivitätszeitgeber. Wenn eine Empfangsoperation so lange blockiert wurde, ohne weitere Daten zu erhalten, kehrt sie mit einer kurzen Zählung zurück oder mit dem Fehler EWOULDBLOCK, wenn keine Daten empfangen wurden. Der Parameter struct timeval muss ein positives Zeitintervall darstellen; andernfalls kehrt setsockopt() mit dem Fehler EDOM zurück.

Ich bin mir nicht sicher, ob ich das Problem vollständig verstehe, aber ich denke, es hängt mit dem zusammen, das ich hatte. Ich verwende Qt mit TCP-Socket-Kommunikation, alle nicht blockierend, sowohl Windows als auch Linux.

wollte eine schnelle Benachrichtigung erhalten, wenn ein bereits verbundener Client ausgefallen oder vollständig verschwunden ist, und nicht die standardmäßigen 900+ Sekunden warten, bis das Trennungssignal ausgelöst wurde. Der Trick, um dies zum Laufen zu bringen, bestand darin, die TCP_USER_TIMEOUT-Socket-Option des SOL_TCP-Layers auf den erforderlichen Wert in Millisekunden zu setzen.

Dies ist eine vergleichsweise neue Option, siehe bitte https://www.rfc-editor.org/rfc/rfc5482aber anscheinend funktioniert es gut, habe es mit WinXP, Win7/x64 und Kubuntu 12.04/x64 versucht, meine Wahl von 10 s war etwas länger, aber viel besser als alles andere, was ich zuvor versucht habe 😉

Das einzige Problem, auf das ich gestoßen bin, war, die richtigen Includes zu finden, da dies anscheinend (noch) nicht zu den Standard-Socket-Includes hinzugefügt wurde, also habe ich sie schließlich selbst wie folgt definiert:

#ifdef WIN32
    #include <winsock2.h>
#else
    #include <sys/socket.h>
#endif

#ifndef SOL_TCP
    #define SOL_TCP 6  // socket options TCP level
#endif
#ifndef TCP_USER_TIMEOUT
    #define TCP_USER_TIMEOUT 18  // how long for loss retry before timeout [ms]
#endif

Das Setzen dieser Socket-Option funktioniert nur, wenn der Client bereits verbunden ist, die Codezeilen sehen so aus:

int timeout = 10000;  // user timeout in milliseconds [ms]
setsockopt (fd, SOL_TCP, TCP_USER_TIMEOUT, (char*) &timeout, sizeof (timeout));

und der Fehler einer anfänglichen Verbindung wird von einem Timer abgefangen, der beim Aufrufen von connect() gestartet wird, da dafür kein Signal von Qt vorhanden ist, wird das Verbindungssignal nicht ausgelöst, da keine Verbindung besteht, und das Trennsignal wird es tun auch nicht erhoben werden, da noch keine Verbindung bestanden hat..

Können Sie nicht Ihr eigenes Timeout-System implementieren?

Führen Sie eine sortierte Liste oder besser noch einen Prioritätsspeicher, wie Heath vorschlägt, von Timeout-Ereignissen. Verwenden Sie in Ihren Auswahl- oder Abfrageaufrufen den Zeitüberschreitungswert oben in der Zeitüberschreitungsliste. Wenn diese Zeitüberschreitung eintrifft, führen Sie die mit dieser Zeitüberschreitung verbundene Aktion aus.

Diese Aktion könnte das Schließen eines Sockets sein, der noch nicht verbunden ist.

connect Timeout muss mit einem nicht blockierenden Socket behandelt werden (GNU LibC Dokumentation an connect). Du erhältst connect sofort zurückgeben und dann verwenden select mit einer Zeitüberschreitung warten, bis die Verbindung hergestellt ist.

Dies wird auch hier erklärt: Operation läuft jetzt Fehler bei Verbindung (Funktion) Fehler.

int wait_on_sock(int sock, long timeout, int r, int w)
{
    struct timeval tv = {0,0};
    fd_set fdset;
    fd_set *rfds, *wfds;
    int n, so_error;
    unsigned so_len;

    FD_ZERO (&fdset);
    FD_SET  (sock, &fdset);
    tv.tv_sec = timeout;
    tv.tv_usec = 0;

    TRACES ("wait in progress tv={%ld,%ld} ...\n",
            tv.tv_sec, tv.tv_usec);

    if (r) rfds = &fdset; else rfds = NULL;
    if (w) wfds = &fdset; else wfds = NULL;

    TEMP_FAILURE_RETRY (n = select (sock+1, rfds, wfds, NULL, &tv));
    switch (n) {
    case 0:
        ERROR ("wait timed out\n");
        return -errno;
    case -1:
        ERROR_SYS ("error during wait\n");
        return -errno;
    default:
        // select tell us that sock is ready, test it
        so_len = sizeof(so_error);
        so_error = 0;
        getsockopt (sock, SOL_SOCKET, SO_ERROR, &so_error, &so_len);
        if (so_error == 0)
            return 0;
        errno = so_error;
        ERROR_SYS ("wait failed\n");
        return -errno;
    }
}