1. Contrato del servicio
El tema 37 utilizó select para coordinar varias conversaciones. Ahora construiremos un servicio con ruta, clientes independientes y una tabla de hasta cuatro sesiones activas. poll permitirá observar la escucha y esas sesiones en una sola espera.
Cada cliente envía entre cero y 256 bytes y ejecuta SHUT_WR. El servidor acumula hasta EOF, transforma únicamente las letras ASCII de a a z y envía una respuesta de la misma longitud. Después cierra el conectado; el cliente verifica los bytes y el EOF final.
Cada entrada de pollfd separa el descriptor, los intereses solicitados en events y las condiciones devueltas en revents. El estado del protocolo y la propiedad del recurso se mantienen en otra estructura.
| Decisión | Regla del ejemplo | Consecuencia |
|---|---|---|
| Sesiones simultáneas. | Cuatro posiciones estables. | Una sesión silenciosa no impide atender las otras tres. |
| Límite de ejecución. | De una a veinte aceptaciones, tres por defecto. | Al alcanzar el límite se cierra la escucha y se terminan las sesiones activas. |
| Protocolo. | Una petición terminada por EOF y una respuesta. | No hay varias solicitudes por conexión. |
| Memoria. | 256 bytes de cuerpo por posición. | Una entrada excesiva se rechaza antes de copiar fuera del arreglo. |
| Plazo. | Sesenta segundos para el bucle completo. | No se renueva por actividad ni por EINTR. |
| Directorio. | Privado, nuevo y administrado exclusivamente. | Se reutilizan las reglas de publicación y retirada del tema 32. |
«Simultáneas» significa que las sesiones pueden permanecer abiertas y progresar de forma intercalada. Un solo hilo ejecuta sus operaciones de E/S. No se crean hilos ni procesos trabajadores por cliente.
2. El arreglo de pollfd
#include <poll.h>
struct pollfd {
int fd;
short events;
short revents;
};
int poll(struct pollfd *fds, nfds_t nfds, int timeout);nfds indica la cantidad de entradas del arreglo que se pasa a poll. A diferencia del argumento de select, no es el mayor descriptor más uno. Si hay entradas para los descriptores 4 y 1500, el arreglo tiene dos elementos y nfds vale dos.
La representación no impone el límite FD_SETSIZE de fd_set. Siguen existiendo límites del proceso, capacidad de memoria y costo de recorrer el arreglo. Un número de descriptor alto no obliga a reservar una posición por cada número anterior.
struct pollfd fds[2] = {
{ .fd = entrada, .events = POLLIN, .revents = 0 },
{ .fd = salida, .events = POLLOUT, .revents = 0 }
};
int n = poll(fds, 2, 1000);Un timeout negativo significa espera sin límite; cero hace una consulta inmediata y un valor positivo expresa milisegundos. La espera puede prolongarse por resolución y planificación. La interfaz se documenta en poll(2).
3. Intereses, resultados y retorno
events es entrada y no se transforma en la lista de resultados como sucedía con fd_set. revents es salida de la espera. Puedes conservar el arreglo, pero debes actualizar events cuando cambia el trabajo pendiente y no interpretar revents antiguos después de un error.
| Retorno de poll | Interpretación | Acción |
|---|---|---|
| Mayor que cero. | Cantidad de entradas cuyo revents es distinto de cero. | Recorrer las posiciones y examinar sus máscaras. |
| Cero. | Timeout sin condiciones devueltas. | Revisar plazos, cancelación y trabajo pendiente. |
| −1 con EINTR. | Una señal interrumpió la espera. | Aplicar política y recalcular el tiempo restante. |
| −1 con otro error. | Falló la propia llamada. | Diagnosticar sin procesar revents como resultados válidos. |
Una entrada con POLLIN y POLLHUP cuenta una vez en el retorno, aunque tenga dos bits activos. No confundas cantidad de entradas preparadas con cantidad de condiciones ni con cantidad de bytes.
Las condiciones se combinan con OR y se consultan con AND. Comparar revents por igualdad con POLLIN omite la entrada cuando también contiene otro bit. Si dos acciones son compatibles, no las conviertas accidentalmente en ramas excluyentes.
short rev = fds[i].revents;
if (rev & POLLNVAL) { /* Invariante de descriptor invalido. */ }
if (rev & POLLERR) { /* Aplicar politica de error. */ }
if (rev & (POLLIN | POLLHUP)) {
/* Si el estado espera entrada, intentar recibir lo pendiente. */
}4. POLLIN, POLLOUT y eventos de error
| Bit | Lectura práctica en este tema | Tratamiento |
|---|---|---|
| POLLIN. | Se puede intentar entrada. | recv no bloqueante; validar bytes, EOF o error real. |
| POLLOUT. | Se puede intentar salida. | Enviar desde el desplazamiento pendiente. |
| POLLHUP. | Hay cierre del interlocutor. | No descartar bytes pendientes por ese bit solamente. |
| POLLERR. | Condición de error del recurso. | Consultar el error del socket y aplicar la política de fallo. |
| POLLNVAL. | El número indicado no está abierto. | Diagnosticar propiedad o ciclo de vida y retirar la entrada. |
| POLLRDHUP. | Extensión de Linux para cierre remoto de la dirección de envío. | Puede solicitarse como aviso adicional, conservando la lectura hasta EOF. |
POLLERR, POLLHUP y POLLNVAL se pueden devolver aunque no estén incluidos en events. No necesitas agregarlos para «suscribirte». POLLRDHUP es diferente: si se desea ese aviso adicional se solicita y requiere las definiciones apropiadas de Linux.
El servidor no necesita POLLRDHUP: solicita POLLIN mientras recibe y usa recv para reconocer EOF. El medio cierre del cliente con SHUT_WR conserva la dirección en la que espera la respuesta. No se debe equiparar cualquier cierre de envío con pérdida de toda la conversación.
Para un socket, getsockopt con SO_ERROR permite recuperar un error pendiente. La consulta puede limpiar ese estado; hay que conservar el resultado para el diagnóstico. Un fallo de getsockopt también debe gestionarse. Véase socket(7).
5. POLLHUP no borra los datos pendientes
Un interlocutor puede enviar bytes y cerrar antes de que el receptor los retire. La espera puede informar POLLIN junto con POLLHUP. Todavía corresponde recibir los bytes; EOF llega después de drenar lo que quedó disponible en un cierre ordenado.
EMISOR RECEPTOR
send("hola")
close() -----------------------> poll: puede haber POLLIN | POLLHUP
recv: "ho"
recv: "la"
recv: 0, EOF
POLLHUP no significa que las recepciones anteriores deban descartarse.Con un presupuesto de una lectura por turno, POLLHUP puede volver a despertar al bucle mientras se drena esa entrada. Eso es útil si cada vuelta hace progreso. Después de EOF hay que cambiar de estado o retirar el recurso para no repetir una operación terminada.
Si hay salida pendiente y un cierre impide entregarla, el servidor no puede esperar indefinidamente una futura capacidad útil. El ejemplo intenta resolver el envío cuando aparece POLLOUT o POLLHUP; si encuentra un fallo, o EAGAIN junto con HUP, cancela esa sesión.
Un POLLERR se considera fallo fatal de sesión en esta implementación. Esa política es distinta de cerrar inmediatamente por HUP sin leer. Los errores de transporte pueden impedir recuperar datos y no se prometen respuestas después de una caída.
6. Posiciones, huecos y descriptores ignorados
El índice del arreglo no es el descriptor. Una posición puede representar al descriptor 18 hoy y al 27 después de retirar una sesión. El estado de esa posición debe reinicializarse cuando se instala una conexión nueva.
| Configuración de una entrada | Efecto en poll | Uso |
|---|---|---|
| fd válido, events=POLLIN. | Solicita lectura y permite errores o cierre. | Sesión que espera entrada. |
| fd válido, events=0. | No solicita E/S ordinaria, pero puede devolver HUP, ERR o NVAL. | No equivale a ignorar completamente el descriptor. |
| fd negativo. | Ignora esa entrada y devuelve revents cero. | Hueco o posición temporalmente fuera de la espera. |
Usa un valor como −1 para un hueco. Negar simplemente un descriptor no es una convención segura para todos los valores: el descriptor cero negado sigue siendo cero. El ejemplo usa −1 explícitamente y conserva el descriptor real de la escucha en otra variable cuando la pausa.
Una tabla con huecos evita mover elementos durante el despacho. Un arreglo compacto puede ahorrar recorrido, pero obliga a mover también el estado asociado y a no saltar la entrada que se trasladó al lugar de una baja.
7. Altas y bajas sin despachar eventos antiguos
La entrada cero observa la escucha. Las cuatro siguientes corresponden siempre a las mismas cuatro posiciones de clientes. Después de poll, primero se atienden los clientes existentes y luego se acepta, como máximo, una conexión nueva.
Si no hay huecos, se pasa fd=−1 en la entrada de escucha sin cerrar todavía su descriptor real. Las peticiones de conexión pueden permanecer en la cola del núcleo. Al liberar una posición, la siguiente vuelta vuelve a incluir la escucha.
Cuando se alcanza el máximo de aceptaciones, el servidor cierra la escucha y termina de atender lo que ya aceptó. No promete atender conexiones adicionales que hubieran quedado pendientes. Un servicio continuo necesitaría otra política de admisión.
8. Plazos y dependencias de los ejemplos
Copia apoyo32.h del tema 32 y plazo37.h del tema 37 al directorio de trabajo. No necesitas compilar los programas de esos temas. La primera cabecera aporta direcciones, validación del directorio, cierre y retirada por identidad; la segunda calcula el tiempo restante desde CLOCK_MONOTONIC.
El servidor convierte el restante a milisegundos redondeando hacia arriba y limita cada espera a 250 ms para revisar también la bandera de cancelación. El límite global de sesenta segundos se fija una sola vez y no se renueva al recibir eventos.
struct timeval tv;
int r = restante37(&limite, &tv);
/* r == -1: error; r == 0: plazo agotado. */
int ms = tv.tv_sec >= 1 ? 250 : (int)((tv.tv_usec + 999) / 1000);
if (ms > 250) ms = 250;
/* poll(..., ms): despues se vuelve a consultar el reloj. */El timeout de poll es un entero de entrada y no se modifica como el timeval de select. Aun así, repetir siempre el valor completo tras EINTR renovaría el presupuesto de aplicación. Las dos decisiones son independientes.
9. Servidor completo con cuatro posiciones
Guarda servidor38.c. Usa Linux, accept4 y sockets no bloqueantes. Un fallo de una sesión se cuenta y se retira esa posición, mientras las otras continúan. Los fallos de escucha, recursos o invariantes del registro hacen fallar el servicio.
#define _GNU_SOURCE
#include "apoyo32.h"
#include "plazo37.h"
#include <poll.h>
#define POSICIONES 4u
#define MAX_CUERPO38 256u
#define PLAZO38 60
enum fase { ENTRADA, SALIDA };
struct cliente {
int fd;
enum fase fase;
unsigned char datos[MAX_CUERPO38];
size_t usados, enviados;
};
static volatile sig_atomic_t parar;
static void solicitar(int signo) { parar = signo; }
static int temporal38(void)
{
return errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK;
}
/* 0: pendiente; 1: salida completada; -1: fallo de sesion; -2: NVAL. */
static int atender38(struct cliente *c, short rev)
{
if (rev & POLLNVAL) {
fprintf(stderr, "POLLNVAL: registro de descriptor invalido\n"); return -2;
}
if (rev & POLLERR) {
int error = 0;
socklen_t n = sizeof error;
if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &error, &n) == -1)
perror("SO_ERROR");
else fprintf(stderr, "POLLERR: %s\n", error ? strerror(error) : "sin codigo pendiente");
return -1;
}
if (c->fase == ENTRADA && (rev & (POLLIN | POLLHUP))) {
unsigned char bloque[64];
ssize_t n = recv(c->fd, bloque, sizeof bloque, 0);
if (n > 0) {
if ((size_t)n > MAX_CUERPO38 - c->usados) {
fprintf(stderr, "Peticion mayor que 256 bytes\n"); return -1;
}
memcpy(c->datos + c->usados, bloque, (size_t)n);
c->usados += (size_t)n;
} else if (n == 0) {
if (c->usados == 0) return 1;
for (size_t i = 0; i < c->usados; ++i)
if (c->datos[i] >= 'a' && c->datos[i] <= 'z')
c->datos[i] = (unsigned char)(c->datos[i] - 'a' + 'A');
c->fase = SALIDA;
} else if (!temporal38() || ((rev & POLLHUP) && errno != EINTR)) {
perror("recv sesion"); return -1;
}
return 0; /* Una operacion de datos por turno. */
}
if (c->fase == SALIDA && (rev & (POLLOUT | POLLHUP))) {
ssize_t n = send(c->fd, c->datos + c->enviados,
c->usados - c->enviados, MSG_NOSIGNAL);
if (n > 0) {
c->enviados += (size_t)n;
if (c->enviados == c->usados) return 1;
} else if (n == 0) {
fprintf(stderr, "send sin progreso\n"); return -1;
} else if (!temporal38() || ((rev & POLLHUP) && errno != EINTR)) {
perror("send sesion"); return -1;
}
}
return 0;
}
int main(int argc, char **argv)
{
unsigned maximo = 3;
if ((argc != 2 && argc != 3) ||
(argc == 3 && cantidad_clientes(argv[2], &maximo) == -1)) {
fprintf(stderr, "Uso: %s /directorio/privado/servicio.sock [sesiones(1..20)]\n", argv[0]);
return EXIT_FAILURE;
}
struct sockaddr_un direccion_local;
socklen_t longitud;
if (direccion(argv[1], &direccion_local, &longitud) == -1 ||
directorio_privado(argv[1]) == -1) {
perror("direccion o directorio privado"); return EXIT_FAILURE;
}
struct sigaction accion = {0};
accion.sa_handler = solicitar;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGINT, &accion, NULL) == -1 ||
sigaction(SIGTERM, &accion, NULL) == -1) {
perror("sigaction"); return EXIT_FAILURE;
}
struct cliente clientes[POSICIONES] = {0};
for (unsigned i = 0; i < POSICIONES; ++i) clientes[i].fd = -1;
int escucha = -1, vinculado = 0, identificado = 0;
int salida = EXIT_FAILURE;
unsigned aceptadas = 0, completadas = 0, fallos = 0;
struct stat propia;
escucha = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (escucha == -1) { perror("socket"); goto fin; }
mode_t mascara = umask(0177);
int r = bind(escucha, (struct sockaddr *)&direccion_local, longitud);
int motivo = errno;
umask(mascara); errno = motivo;
if (r == -1) { perror("bind"); goto fin; }
vinculado = 1;
if (lstat(argv[1], &propia) == -1) { perror("lstat propio"); goto fin; }
if (!S_ISSOCK(propia.st_mode) || propia.st_uid != geteuid()) {
fprintf(stderr, "No se identifico un socket propio\n"); goto fin;
}
identificado = 1;
if ((propia.st_mode & 0777) != 0600) {
fprintf(stderr, "Se requiere modo efectivo 0600\n"); goto fin;
}
if (listen(escucha, 8) == -1) { perror("listen"); goto fin; }
struct timespec limite;
if (fijar_plazo37(&limite, PLAZO38) == -1) goto fin;
printf("Poll38 listo: cuatro posiciones; limite %u; plazo %d s\n", maximo, PLAZO38);
if (fflush(stdout) == EOF) goto fin;
for (;;) {
if (parar) { salida = 128 + (int)parar; break; }
struct pollfd fds[1 + POSICIONES];
unsigned activos = 0;
int hay_hueco = 0;
for (unsigned i = 0; i < POSICIONES; ++i) {
struct cliente *c = &clientes[i];
if (c->fd == -1) hay_hueco = 1;
else ++activos;
fds[i + 1] = (struct pollfd){
.fd = c->fd,
.events = c->fase == ENTRADA ? POLLIN : POLLOUT,
.revents = 0
};
}
if (aceptadas == maximo && activos == 0) {
salida = fallos ? EXIT_FAILURE : EXIT_SUCCESS; break;
}
fds[0] = (struct pollfd){
.fd = hay_hueco ? escucha : -1, .events = POLLIN, .revents = 0
};
struct timeval tv;
int tiempo = restante37(&limite, &tv);
if (tiempo == -1) goto fin;
if (tiempo == 0) { fprintf(stderr, "Plazo global agotado\n"); goto fin; }
int ms = tv.tv_sec >= 1 ? 250 : (int)((tv.tv_usec + 999) / 1000);
if (ms > 250) ms = 250;
int n = poll(fds, 1 + POSICIONES, ms);
if (n == -1) {
if (errno == EINTR) continue;
perror("poll"); goto fin;
}
if (n == 0) continue;
/* Primero se despachan solamente las sesiones de esta instantanea. */
for (unsigned i = 0; i < POSICIONES; ++i) {
if (fds[i + 1].fd == -1 || fds[i + 1].revents == 0) continue;
int paso = atender38(&clientes[i], fds[i + 1].revents);
if (paso == -2) {
clientes[i].fd = -1; /* NVAL no autoriza cerrar un numero obsoleto. */
goto fin; /* Fallo interno de propiedad: no se oculta como sesion normal. */
}
if (paso != 0) {
if (paso == 1) ++completadas;
else ++fallos;
if (cerrar(&clientes[i].fd) == -1) goto fin;
}
}
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
if (fds[0].revents & POLLNVAL) escucha = -1;
fprintf(stderr, "Fallo de la escucha\n"); goto fin;
}
/* Las altas ocurren despues de todos los eventos de clientes. */
if (fds[0].revents & POLLIN) {
unsigned hueco = 0;
while (hueco < POSICIONES && clientes[hueco].fd != -1) ++hueco;
if (hueco < POSICIONES && aceptadas < maximo) {
int fd = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (fd == -1) {
if (temporal38() || errno == ECONNABORTED) continue;
perror("accept4"); goto fin;
}
clientes[hueco] = (struct cliente){ .fd = fd, .fase = ENTRADA };
++aceptadas;
if (aceptadas == maximo && cerrar(&escucha) == -1) goto fin;
}
}
}
fin:
for (unsigned i = 0; i < POSICIONES; ++i)
if (cerrar(&clientes[i].fd) == -1) salida = EXIT_FAILURE;
if (cerrar(&escucha) == -1) salida = EXIT_FAILURE;
if (vinculado) {
if (identificado) {
if (retirar_propia(argv[1], &propia) == -1) salida = EXIT_FAILURE;
} else {
fprintf(stderr, "No se retira una ruta sin identidad confirmada\n");
salida = EXIT_FAILURE;
}
}
printf("Aceptadas: %u; salidas completas: %u; fallos de sesion: %u\n",
aceptadas, completadas, fallos);
if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
return salida;
}salidas completas cuenta respuestas aceptadas por las operaciones locales de envío, incluida una respuesta vacía. No acredita que la aplicación remota haya procesado sus bytes; esa verificación la realiza el cliente. aceptadas incluye sesiones que luego fallen.
El servidor no ejecuta unlink antes de bind ni borra una colisión ajena. Conserva la identidad obtenida después de publicar y la compara al retirar, bajo las mismas precondiciones de directorio exclusivo del tema 32.
La llamada de entrada siempre usa un bloque auxiliar de tamaño positivo, incluso al acumular exactamente 256 bytes. Así puede distinguir EOF de un byte excesivo sin escribir fuera del búfer principal.
10. Cliente con validación de respuesta
Guarda cliente38.c. Este cliente bloqueante de prueba utiliza apoyo32.h y esperas por llamada. Envía un argumento de hasta 256 bytes, termina el envío y comprueba cada byte de la respuesta esperada. El servicio sigue siendo no bloqueante aunque el cliente de terminal sea sencillo.
#define _GNU_SOURCE
#include "apoyo32.h"
int main(int argc, char **argv)
{
if (argc != 3 || strlen(argv[2]) > 256) {
fprintf(stderr, "Uso: %s /ruta/servicio.sock texto_de_hasta_256_bytes\n", argv[0]);
return EXIT_FAILURE;
}
struct sockaddr_un a;
socklen_t longitud;
if (direccion(argv[1], &a, &longitud) == -1) {
perror("direccion"); return EXIT_FAILURE;
}
int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fd == -1) { perror("socket"); return EXIT_FAILURE; }
int salida = EXIT_FAILURE;
if (tiempo_socket(fd, SO_SNDTIMEO, 3000) == -1 ||
tiempo_socket(fd, SO_RCVTIMEO, 3000) == -1) {
perror("timeout de socket"); goto fin;
}
if (connect(fd, (struct sockaddr *)&a, longitud) == -1) {
perror("connect"); goto fin;
}
size_t total = strlen(argv[2]), enviados = 0, recibidos = 0;
while (enviados < total) {
ssize_t n = send(fd, argv[2] + enviados, total - enviados, MSG_NOSIGNAL);
if (n > 0) enviados += (size_t)n;
else if (n == -1 && errno == EINTR) continue;
else { if (n == 0) errno = EIO; perror("send"); goto fin; }
}
if (shutdown(fd, SHUT_WR) == -1) { perror("shutdown"); goto fin; }
for (;;) {
unsigned char bloque[64];
ssize_t n = recv(fd, bloque, sizeof bloque, 0);
if (n > 0) {
if ((size_t)n > total - recibidos) {
fprintf(stderr, "Respuesta excesiva\n"); goto fin;
}
for (size_t i = 0; i < (size_t)n; ++i) {
unsigned char esperado = (unsigned char)argv[2][recibidos + i];
if (esperado >= 'a' && esperado <= 'z')
esperado = (unsigned char)(esperado - 'a' + 'A');
if (bloque[i] != esperado) {
fprintf(stderr, "Respuesta incorrecta\n"); goto fin;
}
}
recibidos += (size_t)n;
} else if (n == 0) {
if (recibidos != total) {
fprintf(stderr, "Respuesta truncada\n"); goto fin;
}
break;
} else if (errno != EINTR) { perror("recv"); goto fin; }
}
printf("Respuesta verificada: %zu bytes y EOF\n", recibidos);
if (fflush(stdout) == EOF) goto fin;
salida = EXIT_SUCCESS;
fin:
if (cerrar(&fd) == -1) salida = EXIT_FAILURE;
return salida;
}El argumento de terminal no puede contener un NUL intermedio, aunque el protocolo transporta bytes binarios. La conversión no es Unicode: los bytes UTF-8 ajenos a a–z se conservan. Los tres segundos del cliente son por llamada y no constituyen un plazo total de transacción.
11. Compilar y conectar varios clientes
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 servidor38.c -o servidor38
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 cliente38.c -o cliente38
$ sesion=$(mktemp -d /tmp/poll38.XXXXXX)
$ ruta="$sesion/servicio.sock"
$ printf 'Ruta para los clientes: %s\n' "$ruta"
$ ./servidor38 "$ruta" 3
Poll38 listo: cuatro posiciones; limite 3; plazo 60 sEn la terminal B, asigna ruta al valor absoluto mostrado por la terminal A. Las variables de una terminal no se comparten automáticamente con otra. Ejecuta los clientes después del mensaje de arranque y dentro del plazo del servicio.
$ ruta=/tmp/poll38.XXXXXX/servicio.sock # Reemplazar por la ruta real.
$ ./cliente38 "$ruta" "hola" &
$ p1=$!
$ ./cliente38 "$ruta" "mundo" &
$ p2=$!
$ ./cliente38 "$ruta" ""
$ wait "$p1"
$ wait "$p2"
Respuesta verificada: 4 bytes y EOF
Respuesta verificada: 5 bytes y EOF
Respuesta verificada: 0 bytes y EOFEl orden de esas líneas puede variar. Los códigos de salida de cada cliente y del servidor deben ser cero. En A, el resumen debe indicar tres aceptadas, tres salidas completas y cero fallos de sesión.
Aceptadas: 3; salidas completas: 3; fallos de sesion: 0
$ test ! -e "$ruta" && echo "Socket propio retirado"
Socket propio retirado
$ rmdir -- "$sesion"Para observar varias sesiones realmente abiertas a la vez, un controlador puede mantener un cliente sin SHUT_WR y ejecutar otros. Esos otros deben completar su respuesta mientras haya posiciones libres; el primero conserva su posición hasta terminar o vencer el plazo global.
12. Experimento de cierre, events cero y fd negativo
Guarda cierre38.c. Es autónomo y no usa las cabeceras anteriores. Sobre un par de Linux, envía cuatro bytes y cierra completamente al emisor antes de consultar al receptor. Así el cierre y los datos pendientes ya existen cuando empieza poll.
#define _GNU_SOURCE
#include <sys/socket.h>
#include <poll.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
int par[2], fallo = 1;
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
0, par) == -1) { perror("socketpair"); return EXIT_FAILURE; }
ssize_t n;
do { n = send(par[0], "hola", 4, MSG_NOSIGNAL); }
while (n == -1 && errno == EINTR);
if (n != 4) { fprintf(stderr, "No se precargaron cuatro bytes\n"); goto fin; }
int emisor = par[0]; par[0] = -1;
if (close(emisor) == -1) { perror("close emisor"); goto fin; }
struct pollfd p = { .fd = par[1], .events = POLLIN, .revents = 0 };
char datos[4];
size_t usados = 0;
for (;;) {
int r;
do { r = poll(&p, 1, 0); } while (r == -1 && errno == EINTR);
if (r != 1 || !(p.revents & POLLHUP)) {
fprintf(stderr, "Se esperaba HUP del emisor cerrado\n"); goto fin;
}
char bloque[2];
do { n = recv(par[1], bloque, sizeof bloque, 0); }
while (n == -1 && errno == EINTR);
if (n > 0) {
if ((size_t)n > sizeof datos - usados) goto fin;
memcpy(datos + usados, bloque, (size_t)n);
usados += (size_t)n;
} else if (n == 0) break;
else { perror("recv"); goto fin; }
}
if (usados != 4 || memcmp(datos, "hola", 4) != 0) goto fin;
puts("POLLHUP: se drenaron y verificaron cuatro bytes antes de EOF");
p.events = 0;
int r;
do { r = poll(&p, 1, 0); } while (r == -1 && errno == EINTR);
if (r != 1 || !(p.revents & POLLHUP)) goto fin;
puts("events=0: el cierre sigue apareciendo");
p.fd = -1;
do { r = poll(&p, 1, 0); } while (r == -1 && errno == EINTR);
if (r != 0 || p.revents != 0) goto fin;
puts("fd=-1: la entrada se ignora por completo");
fallo = 0;
fin:
if (par[0] != -1 && close(par[0]) == -1) fallo = 1;
if (close(par[1]) == -1) fallo = 1;
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 cierre38.c -o cierre38
$ ./cierre38
POLLHUP: se drenaron y verificaron cuatro bytes antes de EOF
events=0: el cierre sigue apareciendo
fd=-1: la entrada se ignora por completoLa precarga diminuta exige que se acepten los cuatro bytes para iniciar este ensayo. No es una función general de salida pendiente. El servidor y el cliente anteriores sí conservan los desplazamientos de sus envíos normales.
13. Capacidad, errores y contrapresión
Cuatro posiciones y una cola de conexiones
La capacidad de la tabla, el backlog de listen y el máximo total de aceptaciones son límites distintos. Cuatro posiciones no significan que el quinto connect falle inmediatamente: puede quedar en la cola de conexiones pendientes, según el estado del sistema.
El servidor pausa el interés de la escucha mientras no tiene huecos. Así evita aceptar clientes sin espacio y evita despertar continuamente por una conexión pendiente que todavía no puede administrar. Al liberar una sesión vuelve a observar la escucha.
Errores de sesión y errores de servicio
Una petición excesiva o un fallo de transporte retira solo esa sesión y aumenta fallos. El servidor continúa hasta su límite o plazo y retorna fallo si hubo sesiones fallidas. Un descriptor inválido, un fallo fatal de accept o un error de la propia espera abandona el servicio y limpia sus recursos.
EMFILE o ENFILE no se resuelven repitiendo accept en un bucle que consume CPU. Este ejemplo falla y limpia; un servicio continuo necesitaría una política de recuperación de recursos, admisión y espera antes de reintentar.
Colas y clientes lentos
La salida está acotada a 256 bytes por sesión y solo se vigila POLLOUT durante la fase de respuesta. Si el diseño produjera muchas respuestas antes de que el cliente las consuma, habría que acotar también la cola de aplicación y frenar la entrada o cancelar trabajo.
El plazo de sesenta segundos es global, no un timeout independiente por cliente ni una ventana renovable de inactividad. Una sesión silenciosa ocupa un hueco; cuatro sesiones silenciosas detienen la admisión hasta que alguna termine o venza el servicio. La cancelación por señal se revisa después de EINTR y, como respaldo, mediante esperas de hasta 250 ms.
14. Qué cambia frente a select y epoll
| Aspecto | select | poll |
|---|---|---|
| Representación. | Conjuntos fd_set. | Arreglo de pollfd con events/revents. |
| Argumento de tamaño. | Mayor descriptor más uno. | Cantidad de entradas del arreglo. |
| Resultados. | Reemplazan los conjuntos. | Se escriben en revents; events conserva los intereses. |
| Límite de representación. | FD_SETSIZE limita los números admitidos. | No utiliza fd_set; sigue sujeto a límites de recursos. |
| Timeout. | timeval, tratado como consumible. | Entero en milisegundos, pasado por valor. |
| Recorrido. | Intervalo de números vigilado y conjuntos. | Entradas incluidas, también huecos si se mantienen. |
poll simplifica la representación y las máscaras por entrada, pero cada llamada sigue presentando un arreglo y la aplicación lo recorre. No equivale a registrar una colección persistente de intereses en el núcleo como hará epoll.
Las reglas del protocolo no cambian: hay EAGAIN, retornos parciales, EOF, límites y recursos que liberar. El siguiente tema estudiará epoll; ppoll y su máscara de señales se retomarán en la integración del tema 42.
15. Explorar events, revents y retirada
El modelo muestra una entrada para un receptor STREAM. Puedes entregar datos, cerrar completamente al emisor, cambiar los intereses o ignorar temporalmente la entrada. La consulta usa timeout cero; una recepción retira hasta dos bytes.
Descriptor vigilado7
events solicitadoPOLLIN
Último reventsSin consulta
Último retorno de pollSin llamada
Datos pendientes y cierreVacía; emisor abierto
Última recepciónNinguna
events expresa intereses; revents describe solo la última consulta.
Consulta con lectura y escritura mientras el emisor está abierto y hay datos. El modelo devuelve dos bits y un retorno de uno, porque solo hay una entrada. Después de cerrar y drenar, cambia events a cero: el cierre sigue apareciendo. Usa fd=−1 para quitar completamente la entrada de esa espera.
El modelo utiliza una capacidad de escritura disponible mientras el interlocutor está abierto y la retira al cierre completo. No pretende reproducir todas las combinaciones de bits de un núcleo real. POLLNVAL representa una tabla incoherente, no un cierre normal de la aplicación. Restaurar una entrada ignorada no reabre un recurso inválido.
16. Pruebas y diagnóstico
Contrato, admisión y aislamiento de fallos
- Correctos. Prueba vacío, texto, 256 bytes y un NUL interno con un cliente que opere sobre bytes.
- Exceso. Un emisor de laboratorio debe transmitir 257 bytes, porque el cliente normal los rechaza antes de conectar.
- Cliente silencioso. Conserva uno sin SHUT_WR y completa otras sesiones antes de terminar el primero.
- Cuatro posiciones ocupadas. Verifica que la escucha se pausa y que un hueco permite admitir al siguiente pendiente.
- Altas después de bajas. Completa más de cuatro sesiones, comprobando que cada alta reinicia cuerpo, fase y desplazamientos.
- Fallo aislado. Una sesión excesiva debe fallar mientras otra válida sigue respondiendo.
Fragmentos, cierres y posiciones altas
Envuelve send y recv para limitar llamadas reales a un byte e introduce EINTR o EAGAIN antes de algunas operaciones. El servidor debe conservar cada cuerpo y sufijo, y el cliente debe verificar el resultado completo. No finjas retornos positivos sin transferir datos.
Ejecuta cierre38 y comprueba datos antes de EOF, HUP con events cero y ausencia total de eventos con fd negativo. Prueba también NVAL con un descriptor cerrado bajo un controlador de una sola hebra; el servicio debe diagnosticar el registro inválido, no ocultarlo como timeout.
Reserva números de descriptor superiores a FD_SETSIZE y ejecuta el servidor con ellos heredados. poll debe poder atender sus nuevos sockets si el entorno permite abrirlos. El tamaño del arreglo seguirá siendo cinco: no aumenta hasta el mayor número de descriptor.
Para el plazo global, reduce PLAZO38 en una copia de prueba y deja clientes silenciosos. El servicio debe fallar por plazo, cerrar las sesiones y retirar su ruta. Para cancelación envía SIGTERM después del mensaje de arranque y comprueba la limpieza; un cierre con SIGKILL no puede ejecutar esa retirada.
Publicación y trazas
Antes de arrancar, prepara una colisión con un archivo propio de prueba. bind debe fallar conservando esa entrada. Repite con un directorio de permisos inadecuados y comprueba el rechazo. Estas pruebas no deben eliminar recursos de otro servicio.
$ strace -s 64 -e trace=poll,ppoll,accept4,sendto,recvfrom,getsockopt,close,unlink ./servidor38 "$ruta" 3Busca entradas con fd negativo, cambios de POLLIN a POLLOUT, recepción cero tras SHUT_WR y cierre de cada conectado. La combinación exacta de eventos y la cantidad de llamadas dependen de la ejecución; exige contenido, límites y limpieza, no una traza idéntica byte por byte.
Un controlador debe esperar «Poll38 listo», imponer un límite externo y cerrar sus clientes incluso si una aserción falla. Evita pausas aproximadas para adivinar el arranque y no dejes procesos de prueba ni sockets residuales después de un fallo.
17. Errores frecuentes
| Error | Consecuencia | Corrección |
|---|---|---|
| Usar mayor descriptor más uno como nfds. | Se accede fuera del arreglo suministrado. | Pasar cantidad real de entradas. |
| Comparar revents == POLLIN. | Se omiten combinaciones como POLLIN | POLLHUP. | Consultar bits con AND. |
| Cerrar inmediatamente por HUP sin recibir. | Se descartan datos que todavía podían drenarse. | Resolver la entrada y reconocer EOF real. |
| Usar events=0 para ignorar totalmente. | HUP o ERR pueden despertar continuamente. | Usar fd negativo si se quiere excluir la entrada. |
| Negar fd=0 como convención de pausa. | La entrada continúa usando el descriptor cero. | Usar −1 o una transformación que realmente sea negativa. |
| Procesar revents tras un retorno −1. | Se usan resultados no válidos de la espera. | Resolver el error y reconstruir la siguiente vuelta. |
| Dejar POLLOUT con salida vacía. | El bucle puede girar sin trabajo útil. | Derivar events de la fase y los bytes pendientes. |
| Aceptar en una posición y usar su revents anterior. | Un evento antiguo se aplica al recurso nuevo. | Altas después del despacho o identidad de generación. |
| Mover pollfd sin mover el estado asociado. | Los datos de un cliente se atribuyen a otro. | Posiciones estables o compactación coordinada. |
| Reintentar EMFILE continuamente. | No se recuperan recursos y se consume CPU. | Política de admisión y recuperación, o fallo explícito. |
| Reiniciar sesenta segundos tras cada evento. | El plazo deja de ser global. | Conservar un límite monotónico fijo. |
| Suponer que poll elimina los retornos parciales. | Se pierden o duplican prefijos. | Mantener contadores y buffers válidos entre turnos. |
18. Resumen
- poll recibe un arreglo de pollfd y la cantidad de entradas que contiene.
- events conserva intereses y revents contiene los resultados de la espera.
- El retorno positivo cuenta entradas con eventos, no bits ni bytes.
- Las máscaras pueden combinar POLLIN, POLLOUT y condiciones de cierre o error.
- POLLHUP no elimina los bytes que quedan por drenar antes de EOF.
- POLLERR y POLLNVAL requieren políticas diferentes de un cierre normal.
- events cero no equivale a ignorar una entrada; fd negativo sí la excluye.
- Los índices, los números de descriptor y las identidades de sesión son conceptos distintos.
- El ejemplo mantiene posiciones estables y acepta altas después de despachar clientes.
- La escucha se pausa si no hay capacidad y se retoma al liberar una posición.
- Los plazos, límites, errores parciales y la limpieza siguen siendo responsabilidad de la aplicación.
- poll evita fd_set, pero no sustituye el protocolo ni registra intereses persistentes como epoll.
19. Preguntas de repaso y práctica
Razona con entradas del arreglo, máscaras combinadas, fases de sesión y propiedad del descriptor.
1. ¿Qué representa nfds en poll?
La cantidad de entradas del arreglo suministrado, incluyendo huecos que se hayan dejado dentro de ese rango. No es el mayor descriptor más uno.
2. ¿events se convierte en el resultado como fd_set?
No. Los intereses permanecen en events y el resultado se escribe en revents. Debe actualizarse events cuando cambie el estado de la aplicación.
3. ¿Cuánto aporta al retorno una entrada con POLLIN y POLLHUP?
Una entrada preparada. El retorno no cuenta por separado cada bit de esa máscara.
4. ¿POLLHUP significa que ya no quedan bytes?
No. Puede haber datos pendientes. El receptor los retira y solo después observa EOF en el cierre ordenado.
5. ¿POLLERR y POLLNVAL deben incluirse en events?
No. Pueden devolverse sin solicitarlos. POLLNVAL indica un número no abierto; POLLERR es una condición de error del recurso.
6. ¿events cero ignora por completo el descriptor?
No. Todavía pueden aparecer condiciones como HUP, ERR y NVAL. Para excluir la entrada de esa espera se utiliza un fd negativo.
7. ¿Qué diferencia existe entre SHUT_WR del cliente y su cierre completo?
SHUT_WR termina solo su envío y permite esperar la respuesta. Un cierre completo elimina también su referencia receptora y puede impedir entregar el resultado.
8. ¿Por qué se atienden las altas al final?
Para que un número o posición reutilizados no reciban eventos capturados para una sesión anterior durante esa misma espera.
9. ¿Qué hace el servidor cuando no tiene huecos?
Excluye la escucha de poll con fd negativo, manteniendo abierto su descriptor real hasta poder reanudar o terminar la admisión.
10. ¿Cuatro posiciones equivalen a backlog cuatro?
No. Las posiciones son capacidad de sesiones administradas; backlog regula conexiones pendientes de aceptar. El máximo total es otro límite distinto.
11. ¿Por qué no se limita el socket por FD_SETSIZE?
Porque poll no representa sus intereses en fd_set. Continúan aplicándose los límites de recursos del sistema y del proceso.
12. ¿Un timeout entero elimina la necesidad de recalcular el restante?
No. El argumento no se modifica, pero repetir un presupuesto completo tras cada interrupción renovaría el plazo de aplicación.
13. ¿Qué evita el envío con MSG_NOSIGNAL?
La acción de SIGPIPE para esa llamada; el error de send sigue devolviéndose y debe tratarse.
14. ¿El resumen del servidor acredita consumo de la respuesta remota?
No. Cuenta salidas completadas localmente. El cliente comprueba contenido y EOF; una confirmación adicional exigiría otro contrato.
15. ¿poll conserva una lista de intereses registrada entre llamadas?
No como epoll. La aplicación vuelve a suministrar su arreglo y recorre las entradas de resultados en cada espera.
Para practicar y ampliar
- Ejecuta servidor y clientes con texto, vacío y 256 bytes.
- Escribe un cliente binario que envíe NUL y verifique el resultado por longitud.
- Ocupa una posición con un cliente silencioso y completa otras sesiones.
- Ocupa las cuatro posiciones y observa cómo se reanuda la escucha al liberar una.
- Completa ocho sesiones y comprueba la reinicialización de posiciones reutilizadas.
- Provoca una sesión excesiva junto a otra válida y verifica el aislamiento del fallo.
- Usa cierre38 y el simulador para comparar HUP, events cero y fd negativo.
- Fuerza operaciones de un byte e interrupciones y conserva la verificación completa.
- Diseña una tabla compacta y explica cómo evitarías saltar un elemento al retirar otro.
- Propón plazos individuales y una política continua de admisión para consumidores lentos.
El tema 39 utilizará epoll_create1, epoll_ctl y epoll_wait para mantener intereses registrados en Linux. La identidad de cada conexión y la gestión de cierres y salida pendiente seguirán siendo necesarias.