¿Usar accept() y select() al mismo tiempo?

Question

Tengo un programa de servidor de red dirigido por eventos. Este programa acepta conexiones de otros procesos en otros hosts. Puede haber muchas conexiones efímeras desde diferentes puertos en la misma IP remota.

Actualmente, tengo un bucle while(1) que llama al accept() y luego genera un hilo para procesar la nueva conexión. Cada conexión se cierra después de que se lee el mensaje. En el extremo remoto, la conexión se cierra después de enviar un mensaje.

quiero eliminar la sobrecarga de la creación y derribar las conexiones al almacenar en caché el FDS socket abierto. En el lado del remitente, esto es fácil; simplemente no cierro las conexiones y las mantengo cerca.

En el lado receptor, que es un poco más difícil. Sé que puedo almacenar el FD devuelto por accept() en una estructura y escuchar los mensajes a través de todas esas tomas utilizando poll() o select(), pero quiero escuchar simultáneamente tanto para las nuevas conexiones a través de accept()y escuchar en todas las conexiones almacenadas en caché.

Si utilizo dos hilos, uno de poll() y uno en accept(), a continuación, cuando los accept() devuelve la llamada (se abre una nueva conexión), tengo que despertar el otro hilo en espera en el antiguo conjunto de conexiones. Sé que puedo hacer esto con una señal y pselect(), pero todo este lío parece como demasiado trabajo para algo tan simple.

¿Hay una llamada o metodología superior que me permita al mismo tiempo manejar las nuevas conexiones que se abren y datos que son enviados en las conexiones de edad?

Answer 1

Que yo sepa, sólo podría listen en un socket y luego select o poll para ver si hay una conexión entró Si es así, que accept.; no bloqueará (pero puede querer realmente debería conjunto O_NONBLOCK sólo para estar seguro)

Answer 2

me gustaría poner un oyente en el proceso separado (rosca) para no ensuciar las cosas. Y ejecute un proceso de trabajo en otro para manejar sockets existentes. No hay necesidad de un oyente que no bloquee realmente. Y sin sobrecarga de hilos con 2 hilos.

Se debe trabajar de esa manera: se acepta en su hebra de escucha hasta que se devuelve un descriptor de socket del cliente y pasarlo al trabajador que está haciendo todo el trabajo de lectura/escritura sucia en él.

Si desea escuchar varios puertos y no desea mantener un proceso por oyente le sugiero que fija su toma en O_NONBLOCK y hacer someth como:

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

podría utilizar escuche a continuación, utilizar o seleccione Encuesta, entonces acepta

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