Comment puis-je me réveille select() sur une socket?

Généralement je viens de marquer la prise de clôture dans l'autre thread, et puis quand sélectionnez() renvoie la valeur de l'activité ou de l'expiration, je lance un nettoyage de passer et de fermer toutes les connexions mortes et mise à jour de la fd_set. Faire d'une autre manière vous ouvre à des conditions de course où vous avez donné sur la connexion, tout comme select() enfin reconnu certains de données, puis de le fermer, mais de l'autre thread essaie de traiter les données qui a été détecté et qui s'énerve pour trouver la fermeture de la connexion.

Oh, et poll() est généralement supérieure à sélectionner() en termes de ne pas avoir à copier autant de données autour de.

OriginalL'auteur woolstar

Comment faire face à EBADF sur 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
    }
}

Ce code suppose que vous disposez d'un tableau de structures de clientèle qui ont "fd" les membres du descripteur de socket. La fonction fcntl() vérifie si le socket est toujours "en vie", et si non, nous faisons ce que nous avons à supprimer les morts socket et son client associé info.

OriginalL'auteur Warren Young

Si vous utilisez poll(2) comme suggéré dans d'autres réponses, vous pouvez utiliser le POLLNVAL état, qui est essentiellement EBADF, mais sur un fichier par fichier de descripteur de base, non pas sur l'ensemble du système d'appel que pour les sélectionner(2).

OriginalL'auteur camh

Il suffit de lancer un "test, sélectionnez" sur chaque support qui pourrait avoir fermé avec un zéro délai d'attente et de vérifier les résultats select et errno, jusqu'à trouver celui qui a fermé.

Le morceau suivant du code de démonstration démarre les deux sockets serveur sur des threads séparés et crée deux sockets client à se connecter à un serveur de socket. Puis il commence un autre thread, qui tuent au hasard l'un des sockets client au bout de 10 secondes (il suffit de le fermer). De clôture, soit le socket client causes sélectionnez échouer avec l'erreur dans le thread principal et le code ci-dessous va maintenant tester lequel des deux sockets a fermé.

#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;
}

Exemple de sortie pour l'exécution de ce test de code à deux reprises:

$ ./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.

Toutefois, si votre système prend en charge poll(), je vous conseille fortement d'envisager l'utilisation de cette API au lieu de select(). Select est assez moche, héritage de l'API à partir du passé, de gauche là pour assurer la compatibilité avec le code existant. Sondage a une bien meilleure interface pour cette tâche, et il a un indicateur supplémentaire pour directement vous signaler qu'une socket est fermé localement: POLLNVAL sera mis sur revents si cette prise a été fermé, peu importe qui les drapeaux que vous avez demandée sur les événements, depuis POLLNVAL est une sortie de drapeaux, ce qui signifie qu'il est ignoré lorsqu'il est installé sur events. Si le support n'a pas été fermé localement mais le serveur distant a juste fermé la connexion, le drapeau POLLHUP sera mis en revents (également une sortie de drapeau). Un autre avantage de sondage, c'est que le délai d'attente est tout simplement une valeur int (millisecondes, à grain fin assez pour de vrai réseau de prises de courant) et qu'il n'existe pas de limites pour le nombre de prises qui peuvent être suivis ou que leur valeur numérique de la gamme.

OriginalL'auteur Mecki