Wie kann ich wake wählen Sie() auf eine Steckdose in der Nähe?

In der Regel ich nur daneben die Buchse für das schließen in dem anderen thread, und dann, wenn select() kehrt aus der Aktivität oder timeout, führe ich ein cleanup-pass und schließen Sie alle Toten verbindungen und aktualisieren Sie die fd_set. Tun es auf eine andere Weise öffnet Sie bis zu Wettlaufsituationen, in denen Sie gab, bis auf die Verbindung, einfach als select() erkannte schließlich einige Daten für Sie, dann schließen Sie es, aber der andere thread versucht, die Daten zu verarbeiten, wurde entdeckt und verärgert zu finden, die Verbindung geschlossen.

Oh, und poll() ist in der Regel besser als select() in Bezug auf die nicht mit zu kopieren so viele Daten um.

Umgang mit EBADF auf select():

int fopts = 0;
for (int i = 0; i < num_clients; ++i) {
    if (fcntl(client[i].fd, F_GETFL, &fopts) < 0) {
        //call close(), FD_CLR(), and remove i'th element from client list
    }
}

Dieser code setzt Voraus, Sie haben ein array von client-Strukturen, die "fd" - Mitglieder für den socket-Deskriptor. Die fcntl () - Aufruf wird überprüft, ob der socket noch "am Leben", und wenn nicht, tun wir, was wir haben, um zu entfernen die abgestorbenen Buchse und Ihre zugehörigen client-info.

Wenn Sie mit poll(2) wie bereits in anderen Antworten, die Sie verwenden können, die POLLNVAL status, die im wesentlichen EBADF, aber auf einer pro-Datei-Deskriptor-basis, nicht auf das ganze system nennen, da es für select(2).

Führen Sie einfach einen "test auswählen" auf jede einzelne Steckdose, die möglicherweise geschlossen haben mit einer null-timeout und überprüfen Sie die select-Ergebnis und errno, bis Sie einen gefunden, der hat geschlossen.

Folgende Stück der demo-code beginnt mit zwei server-sockets in separaten threads und erstellt zwei client-sockets eine Verbindung zum server-socket. Dann beginnt es einen anderen thread, der zufällig töten, einer der client-sockets, die nach 10 Sekunden (es wird nur schließen). Schließen Sie entweder client-socket-Ursachen, wählen Sie Fehler in der main-thread und den folgenden code wird nun testen, welche der beiden buchsen hat tatsächlich geschlossen.

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <pthread.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>


static void * serverThread ( void * threadArg )
{
    int res;
    int connSo;
    int servSo;
    socklen_t addrLen;
    struct sockaddr_in soAddr;
    uint16_t * port = threadArg;

    servSo = socket(PF_INET, SOCK_STREAM, 0);
    assert(servSo >= 0);

    memset(&soAddr, 0, sizeof(soAddr));
    soAddr.sin_family = AF_INET;
    soAddr.sin_port = htons(*port);

    //Uncommend line below if your system offers this field in the struct
    //and also needs this field to be initialized correctly.
// soAddr.sin_len = sizeof(soAddr);

    res = bind(servSo, (struct sockaddr *)&soAddr, sizeof(soAddr));
    assert(res == 0);

    res = listen(servSo, 10);
    assert(res == 0);

    addrLen = 0;
    connSo = accept(servSo, NULL, &addrLen);
    assert(connSo >= 0);

    for (;;) {
        char buffer[2048];
        ssize_t bytesRead;

        bytesRead = recv(connSo, buffer, sizeof(buffer), 0);
        if (bytesRead <= 0) break;

        printf("Received %zu bytes on port %d.\n", bytesRead, (int)*port);
    }
    free(port);
    close(connSo);
    close(servSo);
    return NULL;
}

static void * killSocketIn10Seconds ( void * threadArg )
{
    int * so = threadArg;

    sleep(10);
    printf("Killing socket %d.\n", *so);
    close(*so);
    free(so);
    return NULL;
}


int main ( int argc, const char * const * argv )
{
    int res;
    int clientSo1;
    int clientSo2;
    int * socketArg;
    uint16_t * portArg;
    pthread_t killThread;
    pthread_t serverThread1;
    pthread_t serverThread2;
    struct sockaddr_in soAddr;

    //Create a server socket at port 19500
    portArg = malloc(sizeof(*portArg));
    assert(portArg != NULL);
    *portArg = 19500;
    res = pthread_create(&serverThread1, NULL, &serverThread, portArg);
    assert(res == 0);

    //Create another server socket at port 19501
    portArg = malloc(sizeof(*portArg));
    assert(portArg != NULL);

    *portArg = 19501;
    res = pthread_create(&serverThread1, NULL, &serverThread, portArg);
    assert(res == 0);

    //Create two client sockets, one for 19500 and one for 19501
    //and connect both to the server sockets we created above.

    clientSo1 = socket(PF_INET, SOCK_STREAM, 0);
    assert(clientSo1 >= 0);

    clientSo2 = socket(PF_INET, SOCK_STREAM, 0);
    assert(clientSo2 >= 0);

    memset(&soAddr, 0, sizeof(soAddr));
    soAddr.sin_family = AF_INET;
    soAddr.sin_port = htons(19500);
    res = inet_pton(AF_INET, "127.0.0.1", &soAddr.sin_addr);
    assert(res == 1);

    //Uncommend line below if your system offers this field in the struct
    //and also needs this field to be initialized correctly.
// soAddr.sin_len = sizeof(soAddr);

    res = connect(clientSo1, (struct sockaddr *)&soAddr, sizeof(soAddr));
    assert(res == 0);

    soAddr.sin_port = htons(19501);
    res = connect(clientSo2, (struct sockaddr *)&soAddr, sizeof(soAddr));
    assert(res == 0);

    //We want either client socket to be closed locally after 10 seconds.
    //Which one is random, so try running test app multiple times.
    socketArg = malloc(sizeof(*socketArg));
    srandomdev();
    *socketArg = (random() % 2 == 0 ? clientSo1 : clientSo2);
    res = pthread_create(&killThread, NULL, &killSocketIn10Seconds, socketArg);
    assert(res == 0);

    for (;;) {
        int ndfs;
        int count;
        fd_set readSet;

        //ndfs must be the highest socket number + 1
        ndfs = (clientSo2 > clientSo1 ? clientSo2 : clientSo1);
        ndfs++;

        FD_ZERO(&readSet);
        FD_SET(clientSo1, &readSet);
        FD_SET(clientSo2, &readSet);

        //No timeout, that means select may block forever here.
        count = select(ndfs, &readSet, NULL, NULL, NULL);

        //Without a timeout count should never be zero.
        //Zero is only returned if select ran into the timeout.
        assert(count != 0);

        if (count < 0) {
            int error = errno;

            printf("Select terminated with error: %s\n", strerror(error));

            if (error == EBADF) {
                fd_set closeSet;
                struct timeval atonce;

                FD_ZERO(&closeSet);
                FD_SET(clientSo1, &closeSet);
                memset(&atonce, 0, sizeof(atonce));
                count = select(clientSo1 + 1, &closeSet, NULL, NULL, &atonce);
                if (count == -1 && errno == EBADF) {
                    printf("Socket 1 (%d) closed.\n", clientSo1);
                    break; //Terminate test app
                }

                FD_ZERO(&closeSet);
                FD_SET(clientSo2, &closeSet);
                //Note: Standard requires you to re-init timeout for every
                //select call, you must never rely that select has not changed
                //its value in any way, not even if its all zero.
                memset(&atonce, 0, sizeof(atonce));
                count = select(clientSo2 + 1, &closeSet, NULL, NULL, &atonce);
                if (count == -1 && errno == EBADF) {
                    printf("Socket 2 (%d) closed.\n", clientSo2);
                    break; //Terminate test app
                }
            }
        }
    }
    //Be a good citizen, close all sockets, join all threads
    close(clientSo1);
    close(clientSo2);
    pthread_join(killThread, NULL);
    pthread_join(serverThread1, NULL);
    pthread_join(serverThread2, NULL);

    return EXIT_SUCCESS;
}

Beispiel-Ausgabe für die Durchführung dieses test-code doppelt:

$ ./sockclose 
Killing socket 3.
Select terminated with error: Bad file descriptor
Socket 1 (3) closed.

$  ./sockclose 
Killing socket 4.
Select terminated with error: Bad file descriptor
Socket 1 (4) closed.

Jedoch, wenn Ihr system unterstützt poll() würde ich raten Ihnen dringend zu prüfen, die diese API nutzen, statt select(). Wählen ist ein ziemlich hässlich, legacy-API aus der Vergangenheit, nur bleibt es für die Abwärtskompatibilität mit vorhandenen code. Poll hat eine viel bessere Oberfläche für diese Aufgabe und es hat ein extra-flag direkt zu signalisieren, dass Sie ein socket geschlossen lokal: POLLNVAL nach revents wenn das socket geschlossen wurde, unabhängig davon, welche flags du gebeten, auf Veranstaltungen, da POLLNVAL ist ein Ausgang nur die Flaggen, das heißt, es wird ignoriert, wenn festgelegt wird, auf events. Wenn der socket nicht geschlossen wurde lokal, sondern remote-server hat nur die Verbindung geschlossen, die fahne POLLHUP wird im revents (auch eine output-only-flag). Ein weiterer Vorteil der Befragung ist, dass das timeout einfach einen int-Wert (Millisekunden, feinkörnigen genug für echte Netzwerk-sockets) und dass es keine Beschränkungen für die Anzahl der sockets, die überwacht werden können oder deren numerischen Wertebereich.