Provided by: manpages-es_1.55-10_all bug

NOMBRE

       select,  pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - multiplexacion de
       E/S sincrona

SINOPSIS

       /* Segun POSIX 1003.1-2001 */
       #include <sys/select.h>

       /* Segun estandares 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'ON

       Las funciones select y pselect esperan a que un numero de  descriptores
       de fichero cambien de estado.

       Su funcion es identica, con tres diferencias:

       (i)    La  funcion  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 funcion select puede actualizar  el  parametro  timeout  para
              indicar  el tiempo sobrante. La funcion pselect no modifica este
              parametro.

       (iii)  La funcion select no tiene parametro sigmask  ,  y  se  comporta
              como pselect llamada con el argumento sigmask a NULL.

       Se  miran  tres  conjuntos  independientes  de  descriptores.  Aquellos
       listados en readfds seran observados para ver  si  hay  caracteres  que
       llegan  a  estar disponibles para lectura (mas concretamente,  para ver
       si una operacion de  lectura  no  se  bloqueara  -  en  particular,  un
       descriptor  de  fichero  esta  tambien  preparado  en  fin-de-fichero),
       aquellos en writefds seran observados para  ver  si  una  operacion  de
       escritura  no  se  bloqueara,  y aquellos en exceptfds seran observados
       para ver si ocurren excepciones. En caso de  exito,  los  conjuntos  se
       modifican  en  marcha para indicar que descriptores cambiaron realmente
       su estado.

       Se proporcionan cuatro macros para manipular  los  conjuntos.   FD_ZERO
       limpiara  un  conjunto.   FD_SET y FD_CLR anaden o borran un descriptor
       dado a o de un conjunto.  FD_ISSET mira a ver si un descriptor es parte
       del conjunto; esto es util despues de que select regrese.

       n  es  el  descriptor  con el numero mas alto en cualquiera de los tres
       conjuntos, mas 1.

       timeout es un limite 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 mascara de senales (vea sigprocmask(2)); si
       es distinto de NULL, pselect reemplaza en primer lugar  la  mascara  de
       senales  actual  por  aquella  a  la  que apunta sigmask, luego hace la
       funcion `select',  y  por  ultimo  restablece  la  mascara  de  senales
       original de nuevo.

       La idea de pselect es que si alguien quiere esperar un evento, bien una
       senal o cualquier otra cosa sobre un descriptor de fichero, se necesita
       una  comprobacion atomica para evitar condiciones de carrera.  (Suponga
       que el manejador de senales fija una opcion global y  regresa.  Despues
       una  comprobacion  de  esta  opcion  seguida  de una llamada a select()
       podria colgarse indefinidamente si la senal llego justo despues  de  la
       comprobacion pero justo antes de la llamada. Por otra parte, pselect le
       permite bloquear senales en primer lugar, manejar las senales que hayan
       llegado,   y despues llamar a pselect() con la mascara sigmask deseada,
       evitando la condicion de carrera.)  Puesto que en la  actualidad  Linux
       no  cuenta  con  una llamada al sistema pselect() , la rutina actual de
       glibc2 todavia tiene este defecto.

   El plazo de espera o timeout
       Las estructuras de tiempo involucradas estan 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 mas abajo sobre las versiones de POSIX 1003.1-2001.)

       Hay  algun  codigo  por  ahi  que llama a select con los tres conjuntos
       vacios,  n  cero,  y  un  timeout  distinto  de  cero  como  una  forma
       transportable  y  curiosa  de  dormir  con una precision por debajo del
       segundo.

       En Linux, timeout se modifica para reflejar la cantidad  de  tiempo  no
       dormido;  la  mayoria  de  otras  implementaciones  no hacen esto. Esto
       produce problemas  cuando  el  codigo  de  Linux  que  lee  timeout  se
       transporta  a otros sistemas operativos, y cuando se transporta a Linux
       codigo que reutiliza una struct timeval para varias selects en un bucle
       sin  reinicializarla.  Considere que timeout esta indefinido despues de
       que select regrese.

VALOR DEVUELTO

       En caso de exito, select y pselect devuelven el numero 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 estaran indefinidos,  asi  que  no  confie  en  sus
       contenidos tras un error.

ERRORES

       EBADF  Se  ha  dado  un  descriptor  de  fichero invalido en uno de los
              conjuntos.

       EINTR  Se ha capturado una senal no bloqueante.

       EINVAL n es negativo o el valor contenido en timeout no es valido.

       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);
           /* iNo confiar ahora en el valor de tv! */

           if (valret)
               printf("Los datos ya estan disponibles.\n");
               /* FD_ISSET(0, &rfds) sera verdadero */
           else
               printf("Ningun dato en 5 segundos.\n");

           return 0;
       }

CONFORME A

       4.4BSD  (la  funcion  select  aparecio  por  primera  vez  en  4.2BSD).
       Generalmente es transportable a o desde  sistemas  no-BSD  que  admitan
       clones  de  la  capa de zocalos 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 funcion pselect esta 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 funcion con este nombre, que sin embargo no acepta
       un parametro sigmask.

OBSERVACIONES

       fd_set es un buffer de tamano fijo. Ejecutar FD_CLR  o  FD_SET  con  un
       valor  de  fd que sea negativo o igual o mayor que FD_SETSIZE tendra un
       comportamiento indefinido.   Ademas,  POSIX  requiere  que  fd  sea  un
       descriptor de fichero valido.

       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 este 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 esta definida en  <sys/select.h>  y  los  tipos  de
       datos time_t y suseconds_t estan 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    si    existe.     Bajo   glibc   2.0,   proporciona
       incondicionalemente el prototipo incorrecto para  pselect,  bajo  glibc
       2.1-2.2.1  proporciona  pselect  cuando _GNU_SOURCE esta definido, bajo
       glibc 2.2.2-2.2.4 lo proporciona cuando _XOPEN_SOURCE esta  definido  y
       tiene  un  valor  de  600  o mayor.  Sin duda, desde POSIX 1003.1-2001,
       deberia dar el prototipo por defecto.

V'EASE TAMBI'EN

       Para un tutorial detallado con ejemplos, vea select_tut(2).

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