select

SELECT(2)               Manual del Programador de Linux              SELECT(2)



NOMBRE
       select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - multiplexación de
       E/S sÃncrona

SINOPSIS
       /* Según POSIX 1003.1-2001 */
       #include <sys/select.h>

       /* Según estándares anteriores */
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
       struct timeval *timeout);

       int pselect(int n, fd_set *readfds, fd_set *writefds, fd_set
       *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);

       FD_CLR(int fd, fd_set *set);
       FD_ISSET(int fd, fd_set *set);
       FD_SET(int fd, fd_set *set);
       FD_ZERO(fd_set *set);

DESCRIPCIÃN
       Las funciones select y pselect esperan a que un número de descriptores
       de fichero cambien de estado.

       Su función es idéntica, con tres diferencias:

       (i)    La función select usa un plazo de espera (timeout)  que es de
              tipo struct timeval (con segundos y microsegundos), mientras
              pselect usa el tipo struct timespec (con segundos y
              nanosegundos).

       (ii)   La función select puede actualizar el parámetro timeout para
              indicar el tiempo sobrante. La función pselect no modifica este
              parámetro.

       (iii)  La función select no tiene parámetro sigmask , y se comporta
              como pselect llamada con el argumento sigmask a NULL.

       Se miran tres conjuntos independientes de descriptores. Aquéllos
       listados en readfds serán observados para ver si hay caracteres que
       llegan a estar disponibles para lectura (más concretamente,  para ver
       si una operación de lectura no se bloqueará - en particular, un
       descriptor de fichero está también preparado en fin-de-fichero),
       aquéllos en writefds serán observados para ver si una operación de
       escritura no se bloqueará, y aquéllos en exceptfds serán observados
       para ver si ocurren excepciones. En caso de éxito, los conjuntos se
       modifican en marcha para indicar qué descriptores cambiaron realmente
       su estado.

       Se proporcionan cuatro macros para manipular los conjuntos.  FD_ZERO
       limpiará un conjunto.  FD_SET y FD_CLR añaden o borran un descriptor
       dado a o de un conjunto.  FD_ISSET mira a ver si un descriptor es parte
       del conjunto; esto es útil después de que select regrese.

       n es el descriptor con el número más alto en cualquiera de los tres
       conjuntos, más 1.

       timeout es un lÃmite superior de la cantidad de tiempo transcurrida
       antes de que select regrese. Puede ser cero, causando que select
       regrese inmediatamente. Si timeout es NULL (no hay tiempo de espera),
       select puede bloquear indefinidamente.

       sigmask es un puntero a una máscara de señales (vea sigprocmask(2));
       si es distinto de NULL, pselect reemplaza en primer lugar la máscara
       de señales actual por aquella a la que apunta sigmask, luego hace la
       funcion `select',  y por último restablece la máscara de señales
       original de nuevo.

       La idea de pselect es que si alguien quiere esperar un evento, bien una
       señal o cualquier otra cosa sobre un descriptor de fichero, se
       necesita una comprobación atómica para evitar condiciones de carrera.
       (Suponga que el manejador de señales fija una opción global y
       regresa. Después una comprobación de esta opción seguida de una
       llamada a select() podrÃa colgarse indefinidamente si la señal llegó
       justo después de la comprobación pero justo antes de la llamada. Por
       otra parte, pselect le permite bloquear señales en primer lugar,
       manejar las señales que hayan llegado,  y después llamar a pselect()
       con la máscara sigmask deseada, evitando la condición de carrera.)
       Puesto que en la actualidad Linux no cuenta con una llamada al sistema
       pselect() , la rutina actual de glibc2 todavÃa tiene este defecto.

   El plazo de espera o timeout
       Las estructuras de tiempo involucradas están definidas en <sys/time.h>
       y tienen el siguiente aspecto

              struct timeval {
                  long    tv_sec;         /* segundos */
                  long    tv_usec;        /* microsegundos */
              };

       and

              struct timespec {
                  long    tv_sec;         /* segundo */
                  long    tv_nsec;        /* nanosegundos */
              };

       (Sin embargo,  lea más abajo sobre las versiones de POSIX
       1003.1-2001.)

       Hay algún código por ahà que llama a select con los tres conjuntos
       vacÃos, n cero, y un timeout distinto de cero como una forma
       transportable y curiosa de dormir con una precisión por debajo del
       segundo.

       En Linux, timeout se modifica para reflejar la cantidad de tiempo no
       dormido; la mayorÃa de otras implementaciones no hacen esto. Esto
       produce problemas cuando el código de Linux que lee timeout se
       transporta a otros sistemas operativos, y cuando se transporta a Linux
       código que reutiliza una struct timeval para varias selects en un
       bucle sin reinicializarla. Considere que timeout está indefinido
       después de que select regrese.

VALOR DEVUELTO
       En caso de éxito, select y pselect devuelven el número de
       descriptores contenidos en los conjuntos de descriptores, que puede ser
       cero si el tiempo de espera expira antes de que ocurra algo
       interesante.  En caso de error, se devuelve -1, y se pone un valor
       apropiado en errno; los conjuntos y timeout estarán indefinidos, asÃ
       que no confÃe en sus contenidos tras un error.

ERRORES
       EBADF  Se ha dado un descriptor de fichero inválido en uno de los
              conjuntos.

       EINTR  Se ha capturado una señal no bloqueante.

       EINVAL n es negativo o el valor contenido en timeout no es válido.

       ENOMEM select no ha sido capaz de reservar memoria para las tablas
              internas.

EJEMPLO
       #include <stdio.h>
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int
       main(void) {
           fd_set rfds;
           struct timeval tv;
           int valret;

           /* Mirar stdin (df 0) para ver si tiene entrada */
           FD_ZERO(&rfds);
           FD_SET(0, &rfds);
           /* Esperar hasta 5 s */
           tv.tv_sec = 5;
           tv.tv_usec = 0;

           valret = select(1, &rfds, NULL, NULL, &tv);
           /* ¡No confiar ahora en el valor de tv! */

           if (valret)
               printf("Los datos ya están disponibles.\n");
               /* FD_ISSET(0, &rfds) será verdadero */
           else
               printf("Ningún dato en 5 segundos.\n");

           return 0;
       }

CONFORME A
       4.4BSD (la función select apareció por primera vez en 4.2BSD).
       Generalmente es transportable a o desde sistemas no-BSD que admitan
       clones de la capa de zócalos de BSD (incluyendo variantes System V).
       Sin embargo, observe que la variante System V normalmente pone la
       variable de espera antes de salir, pero la variante BSD no.

       La función pselect está definida en IEEE Std 1003.1g-2000 (POSIX.1g),
       y parte de POSIX 1003.1-2001.  Se encuentra en glibc2.1 y posteriores.
       Glibc2.0 posee una función con este nombre, que sin embargo no acepta
       un parámetro sigmask.

OBSERVACIONES
       fd_set es un buffer de tamaño fijo. Ejecutar FD_CLR o FD_SET con un
       valor de fd que sea negativo o igual o mayor que FD_SETSIZE tendrá un
       comportamiento indefinido.  Además, POSIX requiere que fd sea un
       descriptor de fichero válido.

       En lo que se refiere a los tipos involucrados, lo habitual es que los
       dos campos de una estructura timeval sean de tipo long (como se muestra
       abajo), y la estructura esté definida en <sys/time.h>.  La postura de
       POSIX 1003.1-2001 es

              struct timeval {
                  time_t         tv_sec;     /* segundos */
                  suseconds_t    tv_usec;    /* microsegundos */
              };

       donde la estructura está definida en <sys/select.h> y los tipos de
       datos time_t y suseconds_t están definidos en <sys/types.h>.

       En lo que se refiere a prototipos, lo habitual es incluir el fichero de
       cabecera <time.h> para select.  La postura de POSIX 1003.1-2001 es
       incluir el fichero <sys/select.h> para select y pselect.  Libc4 y libc5
       no poseen una cabecera <sys/select.h> ; bajo glibc 2.0 y posteriores
       esta cabecera sà existe.  Bajo glibc 2.0, proporciona
       incondicionalemente el prototipo incorrecto para pselect, bajo glibc
       2.1-2.2.1 proporciona pselect cuando _GNU_SOURCE está definido, bajo
       glibc 2.2.2-2.2.4 lo proporciona cuando _XOPEN_SOURCE está definido y
       tiene un valor de 600 o mayor.  Sin duda, desde POSIX 1003.1-2001,
       deberÃa dar el prototipo por defecto.

VÃASE TAMBIÃN
       Para un tutorial detallado con ejemplos, vea select_tut(2).

       Para una mera descripción, vea accept(2), connect(2), poll(2),
       read(2), recv(2), send(2), sigprocmask(2), write(2)



Linux 2.4                       9 febrero 2001                       SELECT(2)