Avec accept() et select() en même temps?

Question

J'ai un programme de serveur de réseau axé sur les événements. Ce programme accepte les connexions d'autres processus sur d'autres hôtes. Il peut y avoir de nombreuses connexions de courte durée provenant de différents ports sur la même adresse IP distante.

Actuellement, j'ai une boucle while(1) qui appelle accept(), puis engendre un thread pour traiter la nouvelle connexion. Chaque connexion est fermée après la lecture du message. À l'extrémité distante, la connexion est fermée après l'envoi d'un message.

Je veux éliminer le surcoût lié à l'établissement et à l'arrêt des connexions en mettant en cache les FD ouverts de socket. Du côté de l'expéditeur, c'est facile - je ne ferme pas les connexions et les garde. Du côté du récepteur, c'est un peu plus difficile. Je sais que je peux stocker le FD retourné par accept() dans une structure et écouter les messages à travers toutes les sockets en utilisant poll() ou select(), mais je veux simultanément à la fois écouter les nouvelles connexions via accept()et écouter sur toutes les connexions en cache.

Si j'utilise deux fils, l'un sur poll() et un sur accept(), puis quand l'appel retourne accept() (est ouvert une nouvelle connexion), je dois réveiller l'autre thread en attente sur l'ancien ensemble de connexions. Je sais que je peux le faire avec un signal et pselect(), mais tout ce gâchis semble beaucoup trop de travail pour quelque chose d'aussi simple.

Existe-t-il un appel ou une méthodologie supérieure qui me permettra de gérer simultanément les nouvelles connexions ouvertes et les données envoyées sur les anciennes connexions?

Answer 1

La dernière fois que j'ai vérifié, vous pouvez simplement listen sur une prise de courant puis select ou poll pour voir si une connexion est venu dans ce cas, il accept. il ne bloque pas (mais vous peut vouloir devrait vraiment ensemble O_NONBLOCK juste pour être sûr)

Answer 2

je mettrais un écouteur dans le processus séparé (fil) de ne pas gâcher les choses. Et exécutez un processus de travail sur un autre pour gérer les sockets existantes. Il n'y a pas vraiment besoin d'un auditeur non bloquant. Et pas de frais généraux de thread exécutant 2 threads. Cela devrait fonctionner comme ça: vous acceptez sur votre thread d'écoute jusqu'à ce qu'il vous renvoie un descripteur de socket client et le transmette à worker qui fait tout sale travail de lecture/écriture dessus.

Si vous voulez écouter plusieurs ports et ne veulent pas tenir un processus par auditeur je vous suggère de mettre votre prise en O_NONBLOCK et faire Someth comme:

// loop through listeners here and poll'em for read, when read is successful call accept, get descriptor, pass it to worker and continue listen 
    while(1){ 
     foreach(serverSocket in ServerSockets){ 
      if(serverSocket.Poll(10, SelectRead)){ 
        clientSocket = serverSocket.Accept(); 
        // pass to worker here and release 
      } 

     } 
    } 

Answer 3

vous pouvez utiliser utiliser, puis sélectionnez écouter ou poll accepte alors

if (listen (socket_fd, Number_connection) <0) 
{ 
    perror("listen"); 
    return 1; 
} 
fd_set set; 
struct timeval timeout; 
int rv; 
FD_ZERO(&set); /* clear the set */ 
FD_SET(socket_fd, &set); /* add our file descriptor to the set */ 

timeout.tv_sec = 20; 
timeout.tv_usec = 0; 

rv = select(socket_fd + 1, &set, NULL, NULL, &timeout); 
if(rv == -1) 
{ 
    perror("select"); /* an error accured */ 
    return 1; 
} 
else if(rv == 0) 
{ 
    printf("timeout occurred (20 second) \n"); /* a timeout occured */ 
    return 1; 
} 
else 
    client_socket_fd = accept (socket_fd,(struct sockaddr *) &client_name, &client_name_len);