← Comunicación entre ProcesosBloque 9 · Multiplexación y bucles de eventos · Tema 38 de 52

Tema 38

Multiplexar con poll

Vas a representar cada descriptor con sus intereses y sus eventos devueltos, sin calcular el mayor número de descriptor ni usar fd_set. Construirás un servidor local que incorpora y retira clientes, conserva las respuestas pendientes y distingue un cierre con datos por drenar de una conexión que ya puede liberarse. El estado de cada conversación seguirá siendo responsabilidad de la aplicación.

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ónRegla del ejemploConsecuencia
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

C · interfaz y una entrada por recurso vigilado
#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.

C · dos entradas y timeout en milisegundos
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 pollInterpretaciónAcció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.

C · comprobar bits sin exigir una máscara exacta
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

BitLectura práctica en este temaTratamiento
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.

secuencia · cierre completo después de enviar hola
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 entradaEfecto en pollUso
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.

Despacho de clientes antes de instalar nuevas conexionesEl bucle reconstruye pollfd desde las posiciones estables, espera y despacha eventos de clientes ya existentes. Después acepta una conexión en un hueco. Esa alta se incluye por primera vez en la siguiente espera. Reconstruir pollfdy esperarAtender clientesy retirar bajasAceptar en un huecoal final del despachoEl evento capturado pertenece a la sesión anterior a la espera.La conexión nueva participa desde la siguiente vuelta.
No se aplica un revents antiguo a un número de descriptor recién reutilizado.

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.

conversión utilizada · presupuesto pequeño y controlado
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.

servidor38.c · tabla estable, admisión limitada y cierre del socket propio
#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.

cliente38.c · longitud, contenido y EOF verificados
#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

Bash · preparar un directorio privado y arrancar en la terminal A
$ 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 s

En 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.

Bash · tres clientes, dos de ellos iniciados en paralelo
$ 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 EOF

El 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.

Bash · comprobar la retirada en la terminal A
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.

cierre38.c · drenar antes de retirar y distinguir pausa de interés cero
#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;
}
Bash en Linux · resultado del experimento
$ 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 completo

La 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

Aspectoselectpoll
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

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.

Bash · ejecutar sobre una ruta privada real preparada para el ensayo
$ strace -s 64 -e trace=poll,ppoll,accept4,sendto,recvfrom,getsockopt,close,unlink ./servidor38 "$ruta" 3

Busca 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

ErrorConsecuenciaCorrecció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

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

  1. Ejecuta servidor y clientes con texto, vacío y 256 bytes.
  2. Escribe un cliente binario que envíe NUL y verifique el resultado por longitud.
  3. Ocupa una posición con un cliente silencioso y completa otras sesiones.
  4. Ocupa las cuatro posiciones y observa cómo se reanuda la escucha al liberar una.
  5. Completa ocho sesiones y comprueba la reinicialización de posiciones reutilizadas.
  6. Provoca una sesión excesiva junto a otra válida y verifica el aislamiento del fallo.
  7. Usa cierre38 y el simulador para comparar HUP, events cero y fd negativo.
  8. Fuerza operaciones de un byte e interrupciones y conserva la verificación completa.
  9. Diseña una tabla compacta y explica cómo evitarías saltar un elemento al retirar otro.
  10. Propón plazos individuales y una política continua de admisión para consumidores lentos.
Próximo paso

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.