1. Definir el alcance y las garantías
El servidor ejecuta un eco binario: devuelve exactamente cada cuerpo válido que recibe, conservando el orden dentro de la conexión. No interpreta texto ni modifica archivos. La operación permite comprobar el transporte sin mezclarlo con efectos de negocio.
Una sesión correcta conserva identidad, límites, contenido y orden desde la recepción hasta el envío. El bucle administra progreso parcial; epoll solo informa oportunidades de E/S.
| Requisito | Decisión del proyecto |
|---|---|
| Plataforma. | Linux, sockets Unix de flujo, epoll y signalfd. |
| Concurrencia. | Hasta 32 sesiones activas en un proceso y un hilo. |
| Cuerpo. | De cero a 4096 bytes, incluidos NUL y valores no imprimibles. |
| Memoria de aplicación. | Buffers estáticos de entrada y salida por ranura, sin crecer por lo que envíe el cliente. |
| Vida de sesión. | Diez segundos absolutos desde accept; no se renuevan por cada byte. |
| Parada. | Dejar de admitir, intentar vaciar respuestas ya formadas y terminar con gracia de tres segundos. |
El programa no crea procesos trabajadores. El trabajo por trama es pequeño y acotado; un cálculo pesado bloquearía el mismo hilo que debe atender al resto. Si se incorpora una tarea costosa, necesitará otro presupuesto o una arquitectura de trabajadores.
El límite de vida es deliberadamente simple: una conexión activa también termina al cumplir diez segundos. Es distinto de un timeout por inactividad. Sirve para mantener comprobable el proyecto; un servicio de larga duración puede separar plazos de cabecera, cuerpo, salida e inactividad.
2. Protocolo binario y criterio de admisión
+--------------------------+-------------------------+
| longitud uint32 big endian| cuerpo de longitud bytes|
| 4 bytes | 0..4096 |
+--------------------------+-------------------------+
conexion: trama A, trama B, ... → respuestas A, B, ...
shutdown de escritura del cliente → EOF de entrada
servidor vacia las respuestas pendientes → cierre de la conexionLas conexiones son persistentes y admiten varias tramas seguidas, incluso enviadas juntas. Cada respuesta repite la longitud y los bytes originales. Una longitud cero es una trama válida; no se confunde con EOF ni se llama recv con capacidad cero para detectarlo.
El punto de admisión de una operación es la recepción de una trama completa y su incorporación al buffer de salida. Una conexión aceptada no significa que todas sus peticiones futuras estén admitidas. Tampoco los bytes que todavía están en el núcleo constituyen una respuesta ya prometida por este protocolo.
Longitud excesiva, EOF en mitad de una cabecera o cuerpo y errores de transporte abortan esa sesión. Se descartan sus respuestas pendientes; no se agrega una trama de error que el cliente pudiera confundir con un eco. Una sesión inválida no derriba la escucha ni las demás conexiones.
Un EOF entre tramas es normal. Se retira el interés de lectura, se conservan los ecos ya encolados y se cierra cuando terminan de enviarse. El cliente puede seguir recibiendo después de shutdown(SHUT_WR).
3. Estado independiente por conexión
| Campo conceptual | Función | Invariante |
|---|---|---|
| fd y generación. | Relacionar el recurso y el uso actual de la ranura. | Solo se atienden eventos que coinciden con ambos estados. |
| Cabecera y desplazamiento. | Acumular los cuatro bytes de longitud. | De cero a cuatro bytes recibidos. |
| Cuerpo y desplazamiento. | Acumular el cuerpo validado. | Recibidos ≤ longitud ≤ 4096. |
| Salida usada y enviada. | Conservar el sufijo pendiente tras send parcial. | 0 ≤ enviada ≤ usada ≤ capacidad. |
| EOF y vencimiento. | Separar entrada terminada y vida restante. | EOF no elimina una salida todavía pendiente. |
Compartir una única variable de cabecera entre clientes mezclaría fragmentos de conversaciones diferentes. Tampoco sirve conservar solo el último cuerpo: puede haber varias respuestas ya producidas que un cliente lento todavía no recibió.
El array de salida conserva el orden en que se admitieron las tramas. Compactarlo mueve únicamente el sufijo todavía no enviado. Los bytes que ya se entregaron al socket no se vuelven a enviar después de la compactación.
Las ranuras y sus buffers se reservan estáticamente. Hay capacidad para cuatro tramas de tamaño máximo por buffer de salida; eso es un límite de bytes, no un límite de cuatro respuestas de cualquier tamaño. Muchas tramas pequeñas pueden ocupar el mismo espacio.
4. Elegir modo por nivel y presupuestos de trabajo
El proyecto usa notificación por nivel, sin EPOLLET. Si queda una condición de disponibilidad, puede volver a notificarse. Esto permite detener una visita después de un número acotado de llamadas sin depender de consumir toda la entrada hasta EAGAIN.
La distinción entre nivel y flanco se describe en epoll(7). Con flanco se necesitaría una política diferente para el trabajo pendiente que no se agotó durante una visita; agregar EPOLLET al código no sería una optimización equivalente.
| Visita | Presupuesto | Motivo |
|---|---|---|
| Escucha. | Hasta 16 intentos de accept. | Una ráfaga de conexiones no monopoliza el lote. |
| Lectura de sesión. | Hasta 32 llamadas recv. | Un cliente con mucho tráfico deja turnos a otros. |
| Escritura de sesión. | Hasta 32 llamadas send entre los dos puntos de envío de la visita. | La salida también tiene una cuota. |
| Espera principal. | epoll_wait con hasta 100 ms. | Permite revisar vencimientos sin un hilo de temporizadores. |
Los presupuestos incluyen intentos interrumpidos. Acotan el trabajo de una visita, pero no son un planificador de tiempo real ni prometen una latencia exacta. Cada llamada puede procesar un fragmento y el sistema operativo decide cuándo vuelve a ejecutar el proceso.
La escucha y todos los conectados son no bloqueantes. accept4 solicita SOCK_NONBLOCK y SOCK_CLOEXEC para cada conectado, según accept(2). Un despertar no garantiza que la operación siguiente vaya a producir progreso.
5. Relacionar eventos con ranuras y generaciones
Un descriptor cerrado puede reutilizarse rápidamente. Además, un lote devuelto por epoll_wait puede contener eventos que se copiaron antes de cerrar o modificar un recurso. Buscar solo por número de descriptor permite atribuir un evento viejo a una conexión nueva.
El campo data.u64 transporta un token: 32 bits de generación y 32 bits de índice de ranura. Al admitir una conexión se incrementa la generación; al atender un evento se comprueban índice, fd activo y generación. El token no es un puntero a memoria liberada.
evento guardado: ranura 5, generacion 12
cerrar conexion de ranura 5
aceptar otra conexion: ranura 5, generacion 13
evento antiguo llega al despacho → 12 != 13 → descartar
tokens especiales separados: escucha y signalfdUna ranura cuya generación alcance UINT32_MAX se retira de futuras admisiones al quedar libre. Así no se vuelve a usar una generación antigua por desbordamiento. Es una política sencilla para un caso extremadamente distante, y conserva el invariante sin suponer que el contador nunca se agotará.
epoll_ctl permite asociar y recuperar los datos de aplicación y modificar intereses; sus reglas están en epoll_ctl(2). El token no evita cerrar el descriptor correcto ni mantener un inventario coherente: complementa esas obligaciones.
6. Reconstruir cabeceras, cuerpos y EOF
leer49 solicita solo los bytes que faltan de la fase actual. Primero reúne cuatro de cabecera; después valida la longitud y recibe el cuerpo. Al completar una trama, encola la respuesta y reinicia los desplazamientos de entrada para la siguiente.
Una lectura positiva corta es progreso. EINTR permite volver a intentar dentro del presupuesto; EAGAIN o EWOULDBLOCK devuelve el control al bucle. Retorno cero con capacidad positiva confirma EOF: solo es normal si no quedó una trama incompleta.
EPOLLRDHUP indica que el interlocutor cerró o hizo shutdown de su escritura; el programa utiliza ese aviso para intentar leer. No lo toma como prueba de que ya consumió todos los bytes anteriores al cierre. El estado EOF se establece con recv igual a cero.
EPOLLERR o un cierre completo indicado por EPOLLHUP se tratan como aborto de esa sesión. Un HUP no significa que nunca hubiera datos pendientes: esta política renuncia a la conversación al observar ese cierre, mientras que la media desconexión normal sigue el camino de lectura y vaciado.
7. Salida pendiente y contrapresión
La salida tiene 4×(4096+4)=16400 bytes por cliente. Antes de seguir recibiendo se exige espacio para una trama máxima completa. Es una reserva conservadora: evita admitir un cuerpo para el que luego no haya sitio donde guardar el eco.
Si el sufijo pendiente supera 12300 bytes, queda menos de 4100 libres y se pausa la lectura. Se conserva EPOLLOUT mientras haya salida. Al enviar suficientes bytes, vuelve a ser posible leer y se restablecen EPOLLIN y EPOLLRDHUP.
EPOLLOUT no se registra permanentemente. Un socket suele estar listo para escritura cuando no hay nada que enviar; suscribirse sin trabajo pendiente puede mantener al servidor girando sin hacer trabajo útil.
Cuando se pausa lectura también se retira EPOLLRDHUP. Así una media desconexión persistente no provoca visitas repetidas que no puedan leer por falta de espacio. La información de cierre se recuperará al reactivar lectura o mediante el estado de transporte correspondiente.
La contrapresión limita memoria de aplicación, no hace desaparecer los buffers del núcleo ni establece por sí sola un límite para todo el host. El número de clientes también está acotado y cada sesión tiene duración máxima.
8. Plazos, señales y drenaje
Este proyecto no crea hijos. El proceso bloquea SIGINT y SIGTERM, crea un signalfd y lo registra en el mismo epoll. Los eventos de control se atienden antes que el resto del lote.
- En servicio, aceptar mientras haya turnos; rechazar conectados si no existe una ranura reutilizable.
- Revisar el plazo absoluto de diez segundos de cada sesión.
- Al solicitar parada, retirar escucha y nombre publicado.
- Dejar de leer nuevas tramas, descartar entradas incompletas y conservar solo las respuestas ya formadas.
- Vaciar esa salida y cerrar cada sesión; si vence la gracia de tres segundos con pendientes, abandonar y retornar fallo.
Este drenaje no promete completar una petición que solo llegó parcialmente. Su punto de admisión es la respuesta formada. Si necesitas terminar una trama ya empezada, hay que conservar esa fase y su presupuesto, y prohibir únicamente el comienzo de la siguiente.
La vida máxima de una sesión sigue aplicándose durante el drenaje. Las revisiones ocurren en el bucle; planificación y trabajo acotado pueden retrasar la observación de un vencimiento. El timeout no es una promesa de cierre a un milisegundo exacto.
Una parada normal devuelve cero. Un fallo interno o una gracia agotada con conexiones pendientes devuelve error. La salida inesperada por SIGKILL no ejecuta limpieza de nombres; el directorio privado puede quedar como evidencia de esa ejecución.
9. Servidor completo en C
Guarda epoll49.c. El programa es autónomo y crea un directorio privado nuevo dentro de /tmp. El socket usa modo 0600; las conexiones se admiten solo si SO_PEERCRED informa el mismo UID efectivo que el servidor. Esto es una política local de laboratorio, no autorización completa de una aplicación.
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/epoll.h>
#include <sys/signalfd.h>
#include <sys/stat.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define CLIENTES49 32u
#define CUERPO49 4096u
#define TRAMA49 (4u + CUERPO49)
#define SALIDA49 (4u * TRAMA49)
#define ESCUCHA49 UINT64_MAX
#define CONTROL49 (UINT64_MAX - 1u)
struct cliente49 {
int fd, eof;
uint32_t generacion, longitud;
int64_t vence;
size_t cab_usada, cuerpo_usado, salida_usada, salida_enviada;
unsigned char cab[4], cuerpo[CUERPO49], salida[SALIDA49];
};
struct servidor49 {
int ep, escucha, control, propio, directorio, drenando;
int64_t gracia;
char dir[32], ruta[108];
struct stat identidad;
struct cliente49 clientes[CLIENTES49];
};
static int cerrar49(int *fd)
{
if (*fd < 0) return 0;
int n = *fd; *fd = -1;
if (close(n) == -1) { perror("close"); return -1; }
return 0;
}
static int quitar49(int ep, int *fd)
{
if (*fd < 0) return 0;
int fallo = 0;
if (ep >= 0 && epoll_ctl(ep, EPOLL_CTL_DEL, *fd, NULL) == -1 && errno != ENOENT) {
perror("epoll DEL"); fallo = 1;
}
if (cerrar49(fd) == -1) fallo = 1;
return fallo ? -1 : 0;
}
static int64_t ahora49(void)
{
struct timespec t;
if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
static uint32_t longitud49(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | p[3];
}
static size_t pendiente49(const struct cliente49 *c)
{
return c->salida_usada - c->salida_enviada;
}
static int puede_leer49(const struct cliente49 *c)
{
return !c->eof && SALIDA49 - pendiente49(c) >= TRAMA49;
}
static uint64_t clave49(unsigned i, uint32_t generacion)
{
return ((uint64_t)generacion << 32) | i;
}
static int registrar49(int ep, int fd, uint32_t intereses, uint64_t clave)
{
struct epoll_event e = { .events = intereses, .data.u64 = clave };
return epoll_ctl(ep, EPOLL_CTL_ADD, fd, &e);
}
static int modificar49(struct servidor49 *s, unsigned i)
{
struct cliente49 *c = &s->clientes[i];
uint32_t intereses = 0;
if (!s->drenando && puede_leer49(c)) intereses |= EPOLLIN | EPOLLRDHUP;
if (pendiente49(c)) intereses |= EPOLLOUT;
struct epoll_event e = { .events = intereses,
.data.u64 = clave49(i, c->generacion) };
return epoll_ctl(s->ep, EPOLL_CTL_MOD, c->fd, &e);
}
static void compactar49(struct cliente49 *c)
{
if (c->salida_enviada) {
size_t n = pendiente49(c);
memmove(c->salida, c->salida + c->salida_enviada, n);
c->salida_usada = n; c->salida_enviada = 0;
}
}
/* 0 conservar; 1 abortar sesion. No ejecuta operaciones bloqueantes. */
static int leer49(struct cliente49 *c)
{
int presupuesto = 32;
compactar49(c);
while (presupuesto > 0 && puede_leer49(c)) {
if (c->cab_usada < sizeof c->cab) {
--presupuesto;
ssize_t n = recv(c->fd, c->cab + c->cab_usada,
sizeof c->cab - c->cab_usada, 0);
if (n > 0) c->cab_usada += (size_t)n;
else if (n == 0) {
if (c->cab_usada != 0) return 1;
c->eof = 1; return 0;
} else {
if (errno == EINTR) continue;
return errno == EAGAIN || errno == EWOULDBLOCK ? 0 : 1;
}
if (c->cab_usada < sizeof c->cab) continue;
c->longitud = longitud49(c->cab);
if (c->longitud > CUERPO49) return 1;
}
if (c->cuerpo_usado < c->longitud) {
if (presupuesto == 0) break;
--presupuesto;
ssize_t n = recv(c->fd, c->cuerpo + c->cuerpo_usado,
c->longitud - c->cuerpo_usado, 0);
if (n > 0) c->cuerpo_usado += (size_t)n;
else if (n == 0) return 1;
else {
if (errno == EINTR) continue;
return errno == EAGAIN || errno == EWOULDBLOCK ? 0 : 1;
}
if (c->cuerpo_usado < c->longitud) continue;
}
/* Al entrar se reservo espacio para una trama maxima. */
memcpy(c->salida + c->salida_usada, c->cab, sizeof c->cab);
c->salida_usada += sizeof c->cab;
memcpy(c->salida + c->salida_usada, c->cuerpo, c->longitud);
c->salida_usada += c->longitud;
c->cab_usada = 0; c->cuerpo_usado = 0; c->longitud = 0;
}
return 0;
}
static int escribir49(struct cliente49 *c, int *presupuesto)
{
while (*presupuesto > 0 && pendiente49(c)) {
--*presupuesto;
ssize_t n = send(c->fd, c->salida + c->salida_enviada,
pendiente49(c), MSG_NOSIGNAL);
if (n > 0) c->salida_enviada += (size_t)n;
else if (n == 0) return 1;
else {
if (errno == EINTR) continue;
return errno == EAGAIN || errno == EWOULDBLOCK ? 0 : 1;
}
}
if (!pendiente49(c)) c->salida_usada = c->salida_enviada = 0;
return 0;
}
static int atender49(struct servidor49 *s, unsigned i, uint32_t eventos)
{
struct cliente49 *c = &s->clientes[i];
if (eventos & (EPOLLERR | EPOLLHUP)) return quitar49(s->ep, &c->fd);
int presupuesto = 32;
if (pendiente49(c) && escribir49(c, &presupuesto)) return quitar49(s->ep, &c->fd);
if (!s->drenando && puede_leer49(c) && (eventos & (EPOLLIN | EPOLLRDHUP)))
if (leer49(c)) return quitar49(s->ep, &c->fd);
if (pendiente49(c) && escribir49(c, &presupuesto)) return quitar49(s->ep, &c->fd);
if (c->eof && !pendiente49(c)) return quitar49(s->ep, &c->fd);
return modificar49(s, i);
}
static int despachar49(struct servidor49 *s, uint64_t clave, uint32_t eventos)
{
unsigned i = (unsigned)(clave & UINT32_MAX);
uint32_t generacion = (uint32_t)(clave >> 32);
if (i >= CLIENTES49 || s->clientes[i].fd < 0 ||
s->clientes[i].generacion != generacion) return 0;
return atender49(s, i, eventos);
}
static int aceptar49(struct servidor49 *s)
{
for (unsigned turno = 0; turno < 16; ++turno) {
int fd = accept4(s->escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (fd == -1) {
if (errno == EINTR || errno == ECONNABORTED) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) return 0;
return -1; /* Incluye agotamiento de descriptores: fallo del servicio. */
}
struct ucred cred;
socklen_t tam = sizeof cred;
if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cred, &tam) == -1 ||
tam != sizeof cred || cred.uid != geteuid()) {
if (cerrar49(&fd) == -1) return -1;
continue;
}
unsigned i;
for (i = 0; i < CLIENTES49; ++i)
if (s->clientes[i].fd < 0 && s->clientes[i].generacion < UINT32_MAX) break;
if (i == CLIENTES49) {
if (cerrar49(&fd) == -1) return -1;
continue;
}
int64_t ahora = ahora49();
if (ahora < 0) { cerrar49(&fd); return -1; }
struct cliente49 *c = &s->clientes[i];
uint32_t nueva = c->generacion + 1u;
memset(c, 0, sizeof *c);
c->fd = fd; c->generacion = nueva; c->vence = ahora + 10000;
if (registrar49(s->ep, fd, EPOLLIN | EPOLLRDHUP, clave49(i, nueva)) == -1) {
quitar49(s->ep, &c->fd); return -1;
}
}
return 0;
}
static int activos49(const struct servidor49 *s)
{
int n = 0;
for (unsigned i = 0; i < CLIENTES49; ++i) if (s->clientes[i].fd >= 0) ++n;
return n;
}
static int retirar49(struct servidor49 *s)
{
if (!s->propio) return 0;
struct stat actual;
if (lstat(s->ruta, &actual) == -1) {
if (errno == ENOENT) { s->propio = 0; return 0; }
return -1;
}
if (!S_ISSOCK(actual.st_mode) || actual.st_dev != s->identidad.st_dev ||
actual.st_ino != s->identidad.st_ino) { errno = ESTALE; return -1; }
if (unlink(s->ruta) == -1) return -1;
s->propio = 0; return 0;
}
static int drenar49(struct servidor49 *s)
{
if (s->drenando) return 0;
int64_t ahora = ahora49();
if (ahora < 0) return -1;
s->drenando = 1; s->gracia = ahora + 3000;
if (quitar49(s->ep, &s->escucha) == -1 || retirar49(s) == -1) return -1;
for (unsigned i = 0; i < CLIENTES49; ++i) {
struct cliente49 *c = &s->clientes[i];
if (c->fd < 0) continue;
c->eof = 1; c->cab_usada = c->cuerpo_usado = 0;
if (!pendiente49(c)) {
if (quitar49(s->ep, &c->fd) == -1) return -1;
} else if (modificar49(s, i) == -1) return -1;
}
fprintf(stderr, "E49 drenando\n");
return 0;
}
static int senales49(int fd, int *parar)
{
for (;;) {
struct signalfd_siginfo s;
ssize_t n = read(fd, &s, sizeof s);
if (n == (ssize_t)sizeof s) {
if (s.ssi_signo == SIGINT || s.ssi_signo == SIGTERM) *parar = 1;
} else if (n == -1 && errno == EINTR) continue;
else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
else { errno = EIO; return -1; }
}
}
int main(void)
{
static struct servidor49 s;
s.ep = s.escucha = s.control = -1;
for (unsigned i = 0; i < CLIENTES49; ++i) s.clientes[i].fd = -1;
memcpy(s.dir, "/tmp/epoll49.XXXXXX", sizeof "/tmp/epoll49.XXXXXX");
int salida = EXIT_FAILURE;
sigset_t mascara;
sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
signal(SIGPIPE, SIG_IGN) == SIG_ERR ||
sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) { perror("senales"); goto fin; }
s.ep = epoll_create1(EPOLL_CLOEXEC);
s.control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
if (s.ep == -1 || s.control == -1 || mkdtemp(s.dir) == NULL) { perror("preparar"); goto fin; }
s.directorio = 1;
int largo = snprintf(s.ruta, sizeof s.ruta, "%s/servicio.sock", s.dir);
if (largo < 0 || (size_t)largo >= sizeof s.ruta) goto fin;
struct sockaddr_un direccion = { .sun_family = AF_UNIX };
memcpy(direccion.sun_path, s.ruta, (size_t)largo + 1);
s.escucha = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (s.escucha == -1 || bind(s.escucha, (struct sockaddr *)&direccion, sizeof direccion) == -1) {
perror("socket/bind"); goto fin;
}
if (lstat(s.ruta, &s.identidad) == -1) { perror("lstat"); goto fin; }
s.propio = 1;
if (chmod(s.ruta, 0600) == -1 || listen(s.escucha, 32) == -1 ||
registrar49(s.ep, s.escucha, EPOLLIN, ESCUCHA49) == -1 ||
registrar49(s.ep, s.control, EPOLLIN, CONTROL49) == -1) { perror("publicar"); goto fin; }
printf("E49 listo pid=%jd socket=%s max=%u\n", (intmax_t)getpid(), s.ruta, CLIENTES49);
if (fflush(stdout) == EOF) goto fin;
salida = EXIT_SUCCESS;
for (;;) {
int64_t ahora = ahora49();
if (ahora < 0) goto error;
if (s.drenando && ahora >= s.gracia) {
if (activos49(&s)) {
fprintf(stderr, "E49 gracia agotada; pendientes abandonados\n");
salida = EXIT_FAILURE;
}
break;
}
for (unsigned i = 0; i < CLIENTES49; ++i)
if (s.clientes[i].fd >= 0 && ahora >= s.clientes[i].vence)
if (quitar49(s.ep, &s.clientes[i].fd) == -1) goto error;
if (s.drenando && !activos49(&s)) break;
struct epoll_event eventos[64];
int n = epoll_wait(s.ep, eventos, 64, 100);
if (n == -1) { if (errno == EINTR) continue; goto error; }
/* Control primero: una parada no acepta mas sesiones del mismo lote. */
for (int j = 0; j < n; ++j) if (eventos[j].data.u64 == CONTROL49) {
if (eventos[j].events & (EPOLLERR | EPOLLHUP)) { errno = EIO; goto error; }
int parar = 0;
if (senales49(s.control, ¶r) == -1 || (parar && drenar49(&s) == -1)) goto error;
}
for (int j = 0; j < n; ++j) {
uint64_t clave = eventos[j].data.u64;
if (clave == CONTROL49) continue;
if (clave == ESCUCHA49) {
if (s.escucha >= 0 && !s.drenando) {
if (eventos[j].events & (EPOLLERR | EPOLLHUP)) { errno = EIO; goto error; }
if (aceptar49(&s) == -1) goto error;
}
continue;
}
if (despachar49(&s, clave, eventos[j].events) == -1) goto error;
}
}
goto fin;
error:
perror("servidor"); salida = EXIT_FAILURE;
fin:
for (unsigned i = 0; i < CLIENTES49; ++i)
if (quitar49(s.ep, &s.clientes[i].fd) == -1) salida = EXIT_FAILURE;
if (quitar49(s.ep, &s.escucha) == -1) salida = EXIT_FAILURE;
if (quitar49(s.ep, &s.control) == -1) salida = EXIT_FAILURE;
if (cerrar49(&s.ep) == -1) salida = EXIT_FAILURE;
if (retirar49(&s) == -1) { perror("retirar"); salida = EXIT_FAILURE; }
if (s.directorio && rmdir(s.dir) == -1) { perror("rmdir propio"); salida = EXIT_FAILURE; }
return salida;
}10. Leer el bucle y sus caminos de error
registrar49 agrega escucha, control o conectado. modificar49 calcula los intereses a partir de trabajo real: lectura solo si se admite entrada y hay reserva de salida; escritura solo si hay bytes pendientes. El modo sigue siendo por nivel.
atender49 intenta primero avanzar la salida existente, recibe si corresponde y vuelve a intentar enviar con el presupuesto que quedó. No reinicia la cuota entre ambos envíos. Si una lectura o escritura detecta un error de sesión, se retira y cierra ese conectado.
| Situación | Ámbito de fallo | Acción |
|---|---|---|
| EAGAIN o EWOULDBLOCK. | Disponibilidad momentánea. | Conservar desplazamientos y volver al bucle. |
| EINTR. | Intento interrumpido. | Reintentar si queda presupuesto; no inventar progreso. |
| Trama inválida, truncamiento o error de socket. | Una sesión. | Eliminar su interés y cerrar; otras sesiones siguen. |
| No queda ranura. | Admisión. | Cerrar el conectado recién aceptado sin prometer respuesta. |
| Fallo de epoll_ctl, reloj o control. | Estado interno del servicio. | Terminar con error y limpiar recursos propios. |
| EMFILE o ENFILE en accept. | Recursos del servicio o sistema. | Fallar explícitamente; no girar sobre una escucha que sigue lista. |
quitar49 retira el interés antes de cerrar, invalida el fd y conserva la generación para la próxima admisión. No se reintenta close sobre el mismo entero. La comprobación del token se realiza antes de volver a tocar la ranura desde un evento.
El ejemplo no implementa recuperación especial de agotamiento de descriptores mediante un descriptor de reserva. Su política es terminar con error y cerrar lo que ya posee. Una extensión debe evitar convertir ese estado en un bucle de accept fallidos.
Retirar el socket exige comprobar que sigue siendo el recurso creado en el directorio privado. El contraste de inodo y dispositivo no basta contra cambios hostiles concurrentes en un directorio compartido; el ejemplo presupone que otros procesos del mismo usuario no manipulan su directorio privado.
11. Cliente y pruebas de integración en Python
Guarda cliente49.py. La función intercambiar usa un único plazo monotónico y permite leer mientras todavía quedan bytes por enviar. Así una tanda de peticiones mayor que los buffers disponibles no obliga a ambos extremos a esperar por el otro en direcciones opuestas.
import argparse
from concurrent.futures import ThreadPoolExecutor
import json
import os
from pathlib import Path
import re
import selectors
import signal
import socket
import struct
import subprocess
import time
MAXIMO = 4096
def restante(fin):
r = fin - time.monotonic()
if r <= 0:
raise TimeoutError("plazo de cliente agotado")
return r
def tramas(cuerpos):
if len(cuerpos) > 128 or any(len(b) > MAXIMO for b in cuerpos):
raise ValueError("tanda fuera de limites")
return b"".join(struct.pack("!I", len(b)) + b for b in cuerpos)
def intercambiar(ruta, cuerpos, fragmentado=False, segundos=7):
esperado = tramas(cuerpos)
fin = time.monotonic() + segundos
enviados = recibidos = 0
cerrado = False
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.settimeout(restante(fin))
s.connect(ruta)
s.setblocking(False)
with selectors.DefaultSelector() as sel:
sel.register(s, selectors.EVENT_READ | selectors.EVENT_WRITE)
while True:
if enviados == len(esperado) and not cerrado:
s.shutdown(socket.SHUT_WR)
cerrado = True
intereses = selectors.EVENT_READ
if not cerrado:
intereses |= selectors.EVENT_WRITE
sel.modify(s, intereses)
eventos = sel.select(restante(fin))
if not eventos:
raise TimeoutError("cliente sin progreso dentro del plazo")
for key, mask in eventos:
if mask & selectors.EVENT_WRITE and not cerrado:
tope = min(len(esperado), enviados + (3 if fragmentado else 65536))
try:
n = s.send(memoryview(esperado)[enviados:tope])
except (BlockingIOError, InterruptedError):
n = None
if n == 0:
raise EOFError("envio sin progreso")
if n is not None:
enviados += n
if mask & selectors.EVENT_READ:
try:
bloque = s.recv(65536)
except (BlockingIOError, InterruptedError):
continue
if not bloque:
if enviados != len(esperado) or recibidos != len(esperado):
raise EOFError("respuesta truncada")
return len(cuerpos)
if bloque != esperado[recibidos:recibidos + len(bloque)]:
raise ValueError("cabecera, cuerpo, orden o longitud incorrectos")
recibidos += len(bloque)
def leer_exacto(s, n, fin):
datos = bytearray()
while len(datos) < n:
s.settimeout(restante(fin))
b = s.recv(n - len(datos))
if not b:
raise EOFError("sesion termino antes del punto de prueba")
datos.extend(b)
return bytes(datos)
def anuncio(proceso):
fin = time.monotonic() + 7
datos = bytearray()
with selectors.DefaultSelector() as sel:
sel.register(proceso.stdout, selectors.EVENT_READ)
while b"\n" not in datos:
r = fin - time.monotonic()
if r <= 0 or not sel.select(r):
raise TimeoutError("servidor no anuncio preparacion")
bloque = os.read(proceso.stdout.fileno(), 256)
if not bloque:
raise ValueError("servidor termino antes del anuncio")
datos.extend(bloque)
if len(datos) > 1024:
raise ValueError("anuncio excesivo")
m = re.fullmatch(rb"E49 listo pid=([0-9]+) socket=(\S+) max=32\n", bytes(datos))
if m is None or int(m[1]) != proceso.pid:
raise ValueError("anuncio incompatible")
return os.fsdecode(m[2])
def invalida(ruta, datos):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.settimeout(2)
s.connect(ruta)
s.sendall(datos)
s.shutdown(socket.SHUT_WR)
try:
if s.recv(1):
raise ValueError("se respondio a una entrada invalida")
except ConnectionResetError:
pass
def probar(exe):
proceso = subprocess.Popen([str(exe.resolve(strict=True))],
stdout=subprocess.PIPE, start_new_session=True)
try:
ruta = anuncio(proceso)
def sesion(i):
cuerpos = [b"", struct.pack("!I", i) + b"\x00ID",
bytes((i + j) % 251 for j in range(MAXIMO))]
return intercambiar(ruta, cuerpos, fragmentado=(i % 3 == 0))
with ThreadPoolExecutor(max_workers=8) as grupo:
resultados = list(grupo.map(sesion, range(24)))
if resultados != [3] * 24:
raise ValueError("faltan sesiones o tramas verificadas")
# El eco previo confirma que esta conexion ya fue aceptada.
fin = time.monotonic() + 7
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as incompleto:
incompleto.settimeout(restante(fin))
incompleto.connect(ruta)
ping = tramas([b"ping"])
incompleto.settimeout(restante(fin))
incompleto.sendall(ping)
if leer_exacto(incompleto, len(ping), fin) != ping:
raise ValueError("punto de sincronizacion incorrecto")
incompleto.settimeout(restante(fin))
incompleto.sendall(b"\x00\x00")
intercambiar(ruta, [b"otro cliente progresa"])
for datos in [struct.pack("!I", 4097), struct.pack("!I", 4294967295),
b"\x00\x00", struct.pack("!I", 8) + b"abc"]:
invalida(ruta, datos)
intercambiar(ruta, [b"servicio sigue disponible"])
proceso.terminate()
if proceso.wait(timeout=5) != 0:
raise ValueError("parada no exitosa")
if Path(ruta).exists() or Path(ruta).parent.exists():
raise ValueError("socket o directorio sin retirar")
print("24 sesiones concurrentes, 72 tramas binarias y fragmentacion verificadas")
print("Entrada incompleta aislada, invalidas rechazadas y recursos retirados")
finally:
if proceso.poll() is None:
proceso.terminate()
try:
proceso.wait(timeout=5)
except subprocess.TimeoutExpired:
try:
os.killpg(proceso.pid, signal.SIGKILL)
except ProcessLookupError:
pass
proceso.wait()
proceso.stdout.close()
def main():
p = argparse.ArgumentParser()
sub = p.add_subparsers(dest="accion", required=True)
q = sub.add_parser("consulta")
q.add_argument("ruta")
q.add_argument("texto")
t = sub.add_parser("prueba")
t.add_argument("ejecutable", type=Path)
a = p.parse_args()
if a.accion == "prueba":
probar(a.ejecutable)
else:
cuerpo = a.texto.encode("utf-8")
n = intercambiar(a.ruta, [cuerpo])
print(json.dumps({"tramas_verificadas": n, "bytes_cuerpo": len(cuerpo)}))
if __name__ == "__main__":
main()El cliente conoce las tramas que envió y compara incrementalmente todos los bytes de respuesta con ese formato esperado. No acepta un cuerpo correcto bajo una cabecera alterada, ni bytes extra después del conjunto previsto. El EOF final debe llegar después de completar envío y recepción.
El modo fragmentado limita cada send a tres bytes, lo que obliga a dividir una cabecera en el emisor. El núcleo puede reagrupar escrituras; la prueba no supone un recv por send. La inyección de lecturas y escrituras reales de un byte permite comprobar desplazamientos de forma determinista.
La prueba integrada realiza 24 sesiones con hasta ocho clientes a la vez. Cada una lleva una trama vacía, un identificador binario propio y un cuerpo máximo con patrón diferente. Además, mantiene una sesión aceptada con una cabecera siguiente incompleta y comprueba que otro cliente sigue progresando.
El controlador espera el anuncio de preparación, conserva el PID que lanzó y lo recoge al detener. Los errores del servidor no se capturan en una tubería sin drenar. Un SIGKILL de emergencia puede dejar el directorio privado, porque no ejecuta su limpieza.
12. Compilar, ejecutar y comprobar recursos
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 epoll49.c -o epoll49
python3 cliente49.py prueba ./epoll49Una prueba exitosa confirma integridad de las sesiones, aislamiento frente a entrada incompleta, rechazo de longitud excesiva y retirada de recursos tras parada normal. No depende de copiar un PID ni de una pausa fija para adivinar el arranque.
./epoll49
# E49 listo pid=... socket=/tmp/epoll49.XXXXXX/servicio.sock max=32ruta=/tmp/epoll49.ABC123/servicio.sock # reemplazar
python3 cliente49.py consulta "$ruta" "Hola epoll"
python3 cliente49.py consulta "$ruta" ""
# Para terminar, enviar SIGTERM al PID real anunciado por epoll49.Las consultas imprimen el número de tramas verificadas y bytes de cuerpo. El modo prueba crea su propio servidor; para consultar uno ya iniciado se usa consulta. Un nombre ilustrativo de otra corrida no identifica el endpoint actual.
El directorio se crea nuevo y privado. Tras la parada normal no deben quedar ni el socket ni su directorio. Si hubo una terminación forzada, identifica primero qué ejecución era dueña de una ruta residual y comprueba que ya no hay participantes que la utilicen.
13. Pruebas de límites y fallos
| Ensayo | Resultado esperado | Propiedad |
|---|---|---|
| Trama vacía, binaria y de 4096 bytes. | Eco exacto, incluido prefijo de longitud. | No depender de terminadores de texto. |
| Cabecera y cuerpo fragmentados. | Completar sin duplicar ni saltar bytes. | Estado parcial de entrada. |
| Varias tramas en una escritura. | Respuestas completas y ordenadas. | No confundir escritura con mensaje. |
| send y recv reales de un byte con EINTR. | Los mismos intercambios se verifican. | Progreso parcial y cuotas de visita. |
| Longitud 4097 o UINT32_MAX. | Cerrar solo esa sesión sin reservar ese cuerpo. | Validación anterior a consumo de memoria. |
| EOF en mitad de cabecera o cuerpo. | Abortar la sesión. | No interpretar truncamiento como petición válida. |
| EOF entre tramas con respuestas pendientes. | Vaciar ecos admitidos y cerrar. | Media desconexión separada de salida. |
| Cliente que no completa su siguiente cabecera. | Otros clientes siguen progresando. | Ausencia de bloqueo por conexión. |
| Más de 32 sesiones aceptadas. | Rechazo acotado de nuevas; las existentes conservan su estado. | Límite de admisión. |
| Eventos de un uso anterior de ranura. | Descartar por generación. | Identidad independiente del entero de fd. |
| Cliente lento hasta vencer vida. | Retirar la sesión sin derribar el servicio. | Límite absoluto no renovado por fragmentos. |
| SIGTERM y salida bloqueada. | Vaciar dentro de gracia o abandonar con retorno de fallo. | Drenaje acotado y resultado observable. |
Después de cada caso inválido, abre otra sesión válida y comprueba un eco. Eso detecta errores que cierran la escucha o corrompen otra ranura. Prueba también aperturas y cierres rápidos para ejercitar reutilización de descriptores.
La prueba de token antiguo debe ser controlada: una copia instrumentada puede conservar un token, cerrar esa ranura, reutilizarla e intentar despacharlo. No hace falta esperar que el núcleo reproduzca una secuencia de eventos particularmente rara para comprobar la condición de rechazo.
Para probar límites de tiempo sin esperar diez segundos por caso, reduce el plazo en una copia de prueba. Conserva la política y los caminos de limpieza; no elimines la espera ni inventes retornos positivos que no transfirieron bytes.
Para saturación de clientes, confirma que las 32 primeras fueron aceptadas con una consulta breve en cada una antes de abrir la siguiente. Tener 32 connect exitosos no demuestra por sí solo que las 32 ocupan ranuras de aplicación.
14. Provocar contrapresión real
Un cliente lento de lectura debe enviar suficientes tramas válidas para llenar tanto salida de aplicación como capacidad de envío del socket. Si solo envías una trama pequeña, el núcleo probablemente la acepte completa aunque el cliente todavía no haya llamado recv.
- Usar una conexión propia y cuerpos máximos con un patrón o secuencia reconocible.
- Enviar sin leer, con el socket del cliente no bloqueante y un límite total de prueba.
- En una copia instrumentada, confirmar que una sesión conserva EPOLLOUT y ha retirado EPOLLIN por salida pendiente.
- Comprobar que otro cliente recibe respuesta mientras el primero está presionado.
- Volver a leer el primero y verificar el orden completo, usando envío y recepción concurrentes si todavía queda entrada por enviar.
Los tamaños de buffers del núcleo dependen del entorno. En una copia de prueba se puede reducir SO_SNDBUF del conectado del servidor para alcanzar la condición con menos datos. No se sustituye un send real por EAGAIN mientras el socket permanece siempre listo: eso podría crear un escenario artificial de giro que no representa la presión real.
Una herramienta útil es /proc/PID/fdinfo del descriptor epoll, que permite contrastar intereses registrados. Relaciona token y fd de la sesión correcta. La prueba necesita observar una condición, no asumir que ocurrió después de dormir una cantidad fija de tiempo.
Durante un drenaje, se conservan solo las respuestas que ya se formaron. Si el emisor había escrito cien peticiones en el núcleo, no se promete responder las cien al dejar de leer. Para comprobar el drenaje se valida un prefijo completo y ordenado de operaciones admitidas, junto con la política de gracia.
Si el cliente no lee durante toda la gracia, el servidor puede abandonar salida y devolver error. Si el cliente lee a tiempo, la salida puede completarse. Ambos son resultados distintos del mismo contrato; no se debe declarar éxito de entrega por el solo hecho de haber solicitado parada.
15. Simular recepción, salida y pausa
El simulador usa límites reducidos para mostrar la reserva conservadora. Cada trama admite hasta ocho bytes y necesita cuatro de cabecera; la salida dispone de 48 bytes. Puedes completar tramas, simular envíos parciales, observar pausa de lectura y drenar respuestas formadas.
Recepción—
Salida pendiente / capacidad—
Intereses del cliente—
Estado—
Tramas formadas / bytes enviados—
Reserva disponible—
—
Enviar cinco bytes no equivale a completar una respuesta: puede avanzar solo parte de la cabecera o cuerpo. El contador de salida representa un sufijo ordenado. El modelo no representa sockets reales, eventos antiguos ni planificación; sirve para comprobar transiciones de una sesión.
EOF en mitad del cuerpo aborta y descarta la salida del modelo, igual que la política de sesión inválida. Solicitar drenaje descarta entrada incompleta y conserva respuestas ya formadas. Se pueden comparar ambas decisiones sin confundirlas.
16. Diagnosticar con herramientas del sistema
pid=12345 # reemplazar por el PID E49 real
lsof -nP -a -p "$pid" -U
ss -xlnp
ls -l "/proc/$pid/fd"
# Identificar el descriptor anon_inode:[eventpoll] y consultar su fdinfo.
cat "/proc/$pid/fdinfo/$epfd"La escucha, cada conectado, el epoll y el signalfd son recursos diferentes. En fdinfo, los datos guardados de cada interés ayudan a relacionar índice y generación con el token del programa. No interpretes el número del descriptor como identidad permanente de la sesión.
ensayo=$(mktemp -d)
strace -ff -tt -T -yy -s 32 -o "$ensayo/traza" -e trace=socket,bind,listen,accept4,getsockopt,epoll_create1,epoll_ctl,epoll_wait,signalfd4,read,recvfrom,sendto,close,unlink,rmdir ./epoll49Usa consulta sobre la ruta que anuncie esa ejecución. El modo prueba inicia otro servidor propio y, por tanto, no consultaría automáticamente la instancia trazada. Busca ADD de conectados, MOD al cambiar presión y DEL antes del cierre.
Una secuencia de EPOLLOUT sin bytes pendientes indicaría un error de intereses. Un cliente con salida pendiente y EPOLLOUT ausente podría quedar detenido. Un RDHUP atendido sin leer por falta de espacio puede provocar giro si se conserva indefinidamente el interés correspondiente.
El tema 44 explica las limitaciones de estas capturas. Los filtros pueden omitir datos y el trazador modifica la ejecución. Las comprobaciones funcionales y los tiempos sin instrumentación deben conservar alcances separados.
17. Extender sin perder invariantes
Plazos por fase
Para conexiones de larga vida, separa inactividad entre tramas, recepción de una trama y salida bloqueada. No renueves indefinidamente un plazo de cuerpo al llegar cada byte. Un timerfd puede despertar el bucle, pero la estructura de vencimientos sigue siendo la autoridad del tiempo.
Más clientes
Una tabla dinámica o un pool mayor necesita presupuestar memoria global y mantener identidad estable. Si se liberan objetos apuntados por data.ptr, pueden quedar eventos del lote con punteros caducados. El esquema de índice y generación evita esa clase de uso, siempre que su tabla tenga vida adecuada.
Trabajo costoso
Un conjunto de trabajadores puede procesar tareas y devolver resultados al bucle mediante un canal o cola con notificación. Debe definirse quién posee cada petición y cómo se reconoce una respuesta de una conexión que ya terminó. El siguiente proyecto introduce trabajadores y memoria compartida.
Operaciones con efectos
El eco no necesita deduplicación ni diario. Si lo reemplazas por una operación con efectos, una desconexión puede dejar desconocido el resultado. Identidad de operación y durabilidad requieren otro contrato; epoll no aporta esas garantías.
Otro modo de notificación
Para EPOLLET o EPOLLONESHOT hay que revisar agotamiento, rearme y trabajo pendiente. El presupuesto por visita del modo por nivel no se traslada mecánicamente. Primero conserva un camino correcto y una batería de pruebas que detecte pérdida de progreso.
18. Revisar el proyecto antes de medir
| Revisión | Evidencia necesaria |
|---|---|
| Framing. | Vacíos, binarios, fragmentos, varias tramas y rechazo de longitudes inválidas. |
| Memoria. | Límites por cliente y número máximo de clientes; ningún crecimiento por longitudes ajenas. |
| Progreso. | EAGAIN conserva sufijos; LT y cuotas permiten continuar. |
| Intereses. | EPOLLOUT solo con pendientes; lectura y RDHUP retirados al pausar. |
| Identidad. | Tokens de índice y generación; eventos antiguos descartados. |
| Cierre. | EOF limpio drena; truncamiento aborta; DEL y close en todos los caminos. |
| Control. | Señales atendidas primero, gracia y vida de sesiones comprobadas. |
| Propiedad. | Solo se retiran nombre y directorio de la ejecución propia. |
Para rendimiento, separa establecimiento, intercambio y cierre. Conserva la validación de contenido y mide varias corridas con la misma carga. Un servidor que acepta conexiones y descarta cuerpos no realiza el mismo trabajo que uno que conserva ecos completos y ordenados.
Cuenta también errores, rechazos y vencimientos. Un throughput alto acompañado de muchas sesiones abandonadas no describe la misma calidad de servicio. Los percentiles de latencia requieren duraciones individuales o una distribución adecuada; no se derivan de un único total.
El tema 48 aporta la ficha de decisión y el alcance de los contadores. Este proyecto concreta una de esas elecciones: socket Unix de flujo y epoll en Linux, con límites e invariantes que pueden revisarse.
19. Resumen, repaso y práctica
El servidor integra framing binario, progreso parcial, buffers acotados y contrapresión por sesión. epoll por nivel permite repartir trabajo con cuotas; índice y generación separan eventos de usos anteriores. EOF, aborto y drenaje tienen políticas distintas y observables.
- Entrada: recibir solo lo que falta de la fase validada.
- Salida: conservar el sufijo pendiente y registrar escritura únicamente cuando existe.
- Capacidad: reservar una trama máxima antes de admitir más entrada.
- Identidad: comprobar ranura activa y generación antes de despachar.
- Ciclo: plazos, retirada de escucha y limpieza bajo propiedad explícita.
Preguntas de repaso
1. ¿Qué garantiza epoll sobre una llamada siguiente?
Informa disponibilidad observada; la operación todavía puede no progresar. Se usan descriptores no bloqueantes y se trata EAGAIN.
2. ¿Por qué se usa notificación por nivel?
Permite acotar una visita y volver a recibir disponibilidad si queda trabajo. El modo por flanco necesita otra política de agotamiento y reanudación.
3. ¿Una trama vacía representa EOF?
No. Lleva cabecera de longitud cero y produce una respuesta con esa cabecera. EOF se confirma con recv de capacidad positiva que devuelve cero.
4. ¿Qué ocurre si llega solo parte de una cabecera?
Se conserva su desplazamiento en la sesión y se continúa después. Otra conexión mantiene su propio estado.
5. ¿Por qué se reserva una trama máxima en salida?
Evita admitir una trama que no pueda guardarse como respuesta. Es una política conservadora y acotada.
6. ¿Cuándo se pausa lectura?
Cuando hay menos de 4100 bytes libres en el buffer de salida. Se reanuda al recuperar esa reserva.
7. ¿Por qué se retira también EPOLLRDHUP al pausar?
Para evitar visitas repetidas por una media desconexión que no se puede consumir mientras falta espacio.
8. ¿Cuándo se conserva EPOLLOUT?
Solo mientras exista un sufijo de salida pendiente. Mantenerlo sin trabajo puede provocar giro.
9. ¿EOF limpio elimina las respuestas pendientes?
No. Se deja de leer y se intenta vaciar lo ya formado. El truncamiento usa otra política y aborta la sesión.
10. ¿Por qué el fd no identifica toda la vida de una conexión?
El entero puede reutilizarse. Índice y generación permiten rechazar eventos asociados a un uso anterior.
11. ¿Qué hace una ranura al agotar su generación?
Queda retirada de nuevas admisiones cuando se libera. El contador no vuelve a una identidad antigua por desbordamiento.
12. ¿La vida de diez segundos es un timeout de inactividad?
No. Es un límite absoluto desde accept, incluso si el cliente sigue enviando. El proyecto lo define como una simplificación explícita.
13. ¿Qué conserva el drenaje?
Las respuestas ya formadas. Descarta entrada incompleta y deja de admitir nuevas tramas; tiene gracia de tres segundos.
14. ¿Por qué el cliente lee mientras envía?
Evita que ambos extremos queden esperando por capacidad en direcciones opuestas cuando hay muchas tramas en vuelo.
15. ¿Qué garantía falta para reemplazar eco por una operación persistente?
Hay que definir identidad de operación, reintentos, resultado desconocido y durabilidad. epoll solo organiza disponibilidad de E/S.
Para practicar y ampliar
- Dibuja el estado de dos sesiones que reciben fragmentos intercalados.
- Verifica tramas vacías, cuerpos binarios y máximos.
- Fuerza send y recv reales de un byte con EINTR.
- Genera truncamiento de cabecera y de cuerpo y consulta después con otro cliente.
- Confirma 32 sesiones admitidas y comprueba el rechazo de la siguiente.
- Observa la retirada y restauración de EPOLLIN bajo presión real.
- Inyecta un token antiguo después de reutilizar una ranura.
- Reduce plazos en una copia y prueba vida máxima y gracia.
- Comprueba drenaje con un lector que se reactiva a tiempo y otro que no lee.
- Diseña plazos independientes para cabecera, cuerpo y salida.
- Propón cómo devolver un resultado de trabajador a una sesión con generación válida.
- Mide sesiones completadas y latencias conservando todas las validaciones.
El tema 50 desarrolla trabajadores con memoria compartida: distribuir tareas por una cola POSIX y compartir resultados con semáforos. Se añadirá ejecución fuera del bucle conservando propiedad, identidad y recogida.