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

Tema 36

E/S no bloqueante y preparación

Una operación puede no tener datos para recibir ni espacio para enviar en este momento. Vas a configurar sockets para recuperar el control en esas situaciones, conservar el progreso de cada conversación y reanudar solo lo pendiente. También comprobarás por qué una notificación de disponibilidad no equivale a recibir un mensaje completo ni a entregar una respuesta a la aplicación remota.

1. Qué cambia al dejar de bloquear

En los temas anteriores, una función podía permanecer dentro de recv hasta que llegaran datos o dentro de send hasta conseguir capacidad. Eso simplifica un diálogo aislado, pero un proceso que atiende varias conexiones no puede dedicar toda su atención a un cliente silencioso.

Con O_NONBLOCK, una llamada que no puede avanzar por falta de datos o de capacidad retorna −1 con EAGAIN o EWOULDBLOCK. La aplicación conserva su estado, realiza otro trabajo o espera una notificación y vuelve a intentarlo cuando corresponde.

E/S no bloqueante significa que la operación no espera a que aparezca la condición de E/S que falta. La aplicación sigue siendo responsable del progreso pendiente, de la espera y de la finalización del protocolo.

Situación en un socket STREAMModo bloqueanteModo no bloqueante
Recepción sin datos y con envío remoto abierto.Puede esperar datos.Retorna EAGAIN/EWOULDBLOCK.
Envío sin capacidad disponible.Puede esperar espacio.Retorna EAGAIN/EWOULDBLOCK.
Solo cabe un prefijo del envío.También puede haber retornos parciales.Se registra el prefijo aceptado y se conserva el resto.
Fin ordenado de entrada, sin bytes pendientes.recv retorna cero.recv también retorna cero.

Los laboratorios usan pares AF_UNIX STREAM en un solo proceso para controlar cuándo se produce, consume y termina cada flujo. No necesitan pausas, procesos que compitan ni un servidor completo. El siguiente tema incorporará una espera de varios descriptores con select.

2. Bloqueo, disponibilidad y finalización

No bloqueante y asíncrono no son sinónimos. send y recv siguen devolviendo el resultado de la llamada que se hizo: bytes procesados, EOF o error. Configurar O_NONBLOCK no crea un hilo, un callback ni una operación que después completará por sí sola el cuerpo restante.

ConceptoPreguntaEjemplo
Operación no bloqueante.¿Qué puede hacer esta llamada ahora?recv retira tres bytes o retorna EAGAIN.
Preparación o readiness.¿Qué operación parece posible sin esperar su condición de E/S?Una espera informa que se puede intentar leer.
Finalización de una operación de aplicación.¿Se reunieron todos los datos que exige mi contrato?El parser completó cabecera y cuerpo de una respuesta.
API con notificación de finalización.¿Terminó la operación previamente presentada a esa API?Un mecanismo asíncrono entrega su resultado bajo sus propias reglas.

Una entrada de seis bytes puede llegar en tres recepciones. La preparación permite intentar una recepción, pero solo el formato del protocolo indica si esos bytes completan la petición. Del mismo modo, send completo confirma aceptación local de bytes, no su ejecución por el otro proceso.

O_NONBLOCK tampoco promete una duración máxima de CPU para cualquier llamada. En Linux no convierte las lecturas de archivos regulares o dispositivos de bloques en operaciones con latencia garantizada. La semántica de cada recurso debe consultarse; véase open(2).

3. Activar O_NONBLOCK conservando flags

C · lectura, modificación y escritura de flags de estado
#include <fcntl.h>

int anteriores = fcntl(fd, F_GETFL);
if (anteriores == -1) {
    /* Informar fallo: no usar -1 como si fuera un conjunto valido. */
} else if (fcntl(fd, F_SETFL, anteriores | O_NONBLOCK) == -1) {
    /* Informar fallo: no asumir que el cambio se aplico. */
}

F_GETFL obtiene el modo de acceso y los flags de estado. F_SETFL modifica los flags que admite esa operación. El OR agrega O_NONBLOCK sin borrar otros flags modificables que ya estuvieran presentes, como O_APPEND. Las reglas están en F_GETFL y F_SETFL.

Escribir directamente F_SETFL con O_NONBLOCK puede quitar otros flags modificables. Tampoco hay que utilizar F_GETFD/F_SETFD para este propósito: esas operaciones manejan flags del descriptor, como FD_CLOEXEC. Son grupos distintos de fcntl(2).

C · quitar solo O_NONBLOCK cuando el diseño lo permita
int actuales = fcntl(fd, F_GETFL);
if (actuales != -1) {
    if (fcntl(fd, F_SETFL, actuales & ~O_NONBLOCK) == -1) {
        /* Gestionar el error. */
    }
}

No conviene «restaurar» sin más una copia antigua de todos los flags si otro componente pudo cambiarlos entre tanto. Incluso la secuencia F_GETFL/F_SETFL necesita coordinación entre quienes modifican la misma descripción abierta. El curso usa un único propietario lógico para evitar esa carrera de configuración.

4. Alias, herencia y MSG_DONTWAIT

Como viste en el tema 35, los flags de estado pertenecen a la descripción abierta. Un alias creado con dup, heredado con fork o recibido con SCM_RIGHTS comparte O_NONBLOCK. Cambiarlo mediante una referencia puede afectar a otro proceso que utiliza la misma descripción.

Los dos extremos de socketpair son sockets distintos. Marcar par[0] no marca automáticamente par[1]. Lo que comparte el cambio es un alias de par[0], no su interlocutor.

OpciónAlcanceCuándo resulta útil
O_NONBLOCK con fcntl.Descripción abierta y sus alias.Canal que permanecerá bajo un bucle de eventos.
SOCK_NONBLOCK en la creación.Estado inicial del socket creado.Evitar una etapa inicial en modo bloqueante.
MSG_DONTWAIT en send o recv.Esa llamada sobre el socket.Comprobación puntual sin cambiar el modo compartido.
FD_CLOEXEC.Una entrada de descriptor.Controlar la herencia al completar exec.

MSG_DONTWAIT no desmarca O_NONBLOCK ni vuelve bloqueante una llamada sobre un socket que ya es no bloqueante. Sirve para solicitar el comportamiento puntual no bloqueante cuando corresponde, sin modificar los flags persistentes.

Los primeros ensayos verificarán que una llamada con MSG_DONTWAIT deja los flags como estaban y que un cambio posterior con fcntl sí aparece en un alias.

5. Interpretar retornos sin perder progreso

RetornoRecepción STREAM con capacidad positivaEnvío con longitud pendiente positiva
n > 0.Acumular exactamente n bytes.Avanzar exactamente n posiciones.
n == 0.EOF; validar si el protocolo estaba completo.No hubo progreso; tratarlo según el contrato, sin girar indefinidamente.
−1, EINTR.Conservar lo anterior y decidir reintento.Conservar lo anterior y decidir reintento.
−1, EAGAIN/EWOULDBLOCK.No hay avance en esta llamada; esperar o atender otro trabajo.Conservar el sufijo; esperar capacidad o atender otro trabajo.
−1, otro error.Aplicar la política de fallo de conexión.Aplicar la política de fallo de conexión.

Comprueba las dos constantes de ausencia temporal aunque en Linux suelen tener el mismo valor. Un retorno positivo prevalece sobre un errno antiguo: consultar errno después de recibir bytes puede hacer que se descarte progreso válido.

EAGAIN y EOF no son intercambiables. El primero indica una condición temporal para esa llamada; cero en una recepción STREAM de tamaño positivo indica final de entrada. Una solicitud de recepción de longitud cero no sirve para distinguirlos.

EINTR tampoco equivale a «el mensaje se perdió». Las llamadas anteriores pueden haber avanzado. Si hay una política de cancelación, se revisa su estado sin reiniciar el mensaje ni repetir el prefijo ya aceptado.

6. Lectura incremental y estado del parser

La función bloqueante del tema 33 podía completar toda una cabecera dentro de su bucle. En un diseño no bloqueante, esa misma cabecera puede quedar a medias cuando aparece EAGAIN. El estado debe sobrevivir al retorno de la función que atiende el evento.

estado conceptual · una conversación conserva su progreso
conexion:
    cabecera[16], bytes_de_cabecera
    longitud_validada, bytes_de_cuerpo
    cuerpo_acotado
    salida_pendiente, desplazamiento_de_salida
    entrada_terminada, cierre_de_envio_solicitado
    plazo_de_la_operacion

recv positivo: incorporar bytes y avanzar parser
EAGAIN:       conservar todo y devolver el control
EOF:          distinguir fin valido de trama truncada
error fatal:  abandonar segun la politica y liberar recursos

No declares la única copia de la cabecera parcial en una variable local que se pierda al terminar el callback. No vuelvas a interpretar el siguiente fragmento como una cabecera nueva si ya habías recibido parte de la anterior.

Si una recepción contiene varias tramas, el acumulador debe consumir las completas y conservar los sobrantes. Si usa lecturas exactas por etapa, debe guardar cuántos bytes faltan. En ambos diseños la longitud se valida antes de reservar o acumular un cuerpo externo.

Una rutina puede drenar varias recepciones hasta EAGAIN, EOF o error. En un servicio con muchas conexiones también necesita un presupuesto de trabajo para repartir turnos. El comportamiento de recv y MSG_DONTWAIT está documentado en recv(2).

7. Guardar el sufijo de un envío

El búfer de salida conserva tanto la longitud total como el desplazamiento de lo que send ya aceptó. No se libera ni se modifica la parte pendiente mientras pueda necesitarse en otra llamada.

ejemplo · una salida de diez bytes se completa en varios turnos
datos:       A B C D E F G H I J
total:       10

send -> 4    hechos = 4; quedan E F G H I J
send -> -1   errno = EAGAIN; hechos sigue en 4
... esperar capacidad ...
send -> 3    hechos = 7; quedan H I J
send -> 3    hechos = 10; salida aceptada por completo

Un error fatal después de un avance parcial no retira los bytes del flujo. El protocolo debe decidir si cierra la conversación, conserva un estado recuperable o falla la tarea. Reenviar todo desde cero en el mismo flujo duplica el prefijo.

Si send devuelve EAGAIN, llamar otra vez inmediatamente sin cambiar nada puede producir el mismo resultado indefinidamente. La rutina debe devolver «pendiente» a quien coordina el trabajo; el laboratorio de contrapresión reanudará después de que el receptor retire datos.

Los ejemplos usan MSG_NOSIGNAL para comprobar los errores de envío sin terminar por SIGPIPE. La aceptación local de bytes y los retornos parciales se describen en send(2).

8. Qué significa estar preparado

Las API select, poll y epoll permiten esperar condiciones de varios descriptores. Una indicación de lectura disponible puede significar datos, un final de entrada o una condición que debe resolverse con una operación que retorna error. La llamada de E/S determina el resultado real.

La preparación permite intentar una operación y el protocolo decide la finalización Una notificación conduce a recv o send no bloqueante. La llamada puede avanzar, indicar EAGAIN o terminar con EOF o error. Un avance vuelve al estado del protocolo; solo sus condiciones indican una operación completa. Notificaciónde preparaciónIntentar recv/sendsin bloquearActualizar estadodel protocoloEAGAIN: conservar estado y volver a esperarMensaje completo: validar y ejecutar la siguiente etapa
Una notificación no reserva bytes para un lector ni garantiza capacidad para toda una respuesta.

Entre consultar disponibilidad y llamar a recv, otro consumidor de un alias puede retirar los datos. La observación queda desactualizada. Un recv no bloqueante devuelve EAGAIN y permite recuperarse; uno bloqueante podría esperar.

Que un socket esté preparado para escribir no garantiza que quepan todos los bytes solicitados. También deben comprobarse errores. El evento no es una confirmación de entrega al proceso remoto.

En el primer laboratorio se utiliza poll con espera cero únicamente como sonda de una condición de lectura. No se implementa todavía un bucle de espera: los temas 37 y 38 desarrollarán esas interfaces y el registro de intereses. La sonda se basa en poll(2).

9. Laboratorio de recepción y disponibilidad

Guarda lectura36.c. El programa consulta un socket inicialmente vacío mediante MSG_DONTWAIT, comprueba sus flags y crea un alias del extremo receptor. Activa O_NONBLOCK con fcntl y verifica que el alias ve el cambio.

Después envía un byte y observa preparación de lectura. El alias consume ese byte antes de la recepción principal: esa segunda llamada debe retornar EAGAIN. Finalmente se transmiten cuatro bytes, se retiran con solicitudes de dos y se diferencia la cola vacía del EOF posterior a SHUT_WR.

lectura36.c · EAGAIN, alias, preparación desactualizada y EOF
#define _GNU_SOURCE
#include <sys/socket.h>
#include <poll.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int activar_no_bloqueante(int fd)
{
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl"); return -1;
    }
    return 0;
}

static int es_espera(void)
{
    return errno == EAGAIN || errno == EWOULDBLOCK;
}

static ssize_t recibir(int fd, void *p, size_t n, int flags)
{
    ssize_t r;
    do { r = recv(fd, p, n, flags); } while (r == -1 && errno == EINTR);
    return r;
}

static int enviar_prueba(int fd, const char *p, size_t total)
{
    size_t hechos = 0;
    while (hechos < total) {
        ssize_t n = send(fd, p + hechos, total - hechos,
                         MSG_DONTWAIT | MSG_NOSIGNAL);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else {
            /* Este ensayo solo envia bloques diminutos con cola vacia. */
            if (n == 0) errno = EIO;
            perror("send de prueba"); return -1;
        }
    }
    return 0;
}

int main(void)
{
    int par[2], copia = -1;
    int fallo = 1;
    char byte;
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) {
        perror("socketpair"); return EXIT_FAILURE;
    }
    ssize_t n = recibir(par[1], &byte, 1, MSG_DONTWAIT);
    if (n != -1 || !es_espera()) {
        fprintf(stderr, "Se esperaba EAGAIN en el socket vacio\n"); goto fin;
    }
    int flags = fcntl(par[1], F_GETFL);
    if (flags == -1) { perror("F_GETFL"); goto fin; }
    if (flags & O_NONBLOCK) {
        fprintf(stderr, "MSG_DONTWAIT modifico flags inesperadamente\n"); goto fin;
    }
    puts("MSG_DONTWAIT: EAGAIN sin cambiar O_NONBLOCK");

    copia = fcntl(par[1], F_DUPFD_CLOEXEC, 0);
    if (copia == -1) { perror("F_DUPFD_CLOEXEC"); goto fin; }
    if (activar_no_bloqueante(par[1]) == -1) goto fin;
    flags = fcntl(copia, F_GETFL);
    if (flags == -1) { perror("F_GETFL del alias"); goto fin; }
    if (!(flags & O_NONBLOCK)) {
        fprintf(stderr, "El alias no comparte O_NONBLOCK\n"); goto fin;
    }
    puts("fcntl: O_NONBLOCK tambien aparece en el alias");

    if (enviar_prueba(par[0], "X", 1) == -1) goto fin;
    struct pollfd sonda = { .fd = par[1], .events = POLLIN, .revents = 0 };
    int r;
    do { r = poll(&sonda, 1, 0); } while (r == -1 && errno == EINTR);
    if (r != 1 || !(sonda.revents & POLLIN)) {
        fprintf(stderr, "Se esperaba preparacion de lectura\n"); goto fin;
    }
    puts("Sonda: lectura preparada");
    if (recibir(copia, &byte, 1, 0) != 1 || byte != 'X') {
        fprintf(stderr, "El alias no retiro X\n"); goto fin;
    }
    n = recibir(par[1], &byte, 1, 0);
    if (n != -1 || !es_espera()) {
        fprintf(stderr, "Se esperaba EAGAIN despues del otro lector\n"); goto fin;
    }
    puts("Tras consumir por el alias: recv devuelve EAGAIN");

    if (enviar_prueba(par[0], "hola", 4) == -1) goto fin;
    char datos[4], bloque[2];
    size_t usados = 0;
    for (;;) {
        n = recibir(par[1], bloque, sizeof bloque, 0);
        if (n > 0) {
            if ((size_t)n > sizeof datos - usados) {
                fprintf(stderr, "Datos excesivos\n"); goto fin;
            }
            memcpy(datos + usados, bloque, (size_t)n);
            usados += (size_t)n;
        } else if (n == -1 && es_espera()) {
            break;
        } else {
            fprintf(stderr, "Recepcion inesperada antes del cierre\n"); goto fin;
        }
    }
    if (usados != 4 || memcmp(datos, "hola", 4) != 0) {
        fprintf(stderr, "Contenido incompleto o incorrecto\n"); goto fin;
    }
    puts("Recibidos y verificados 4 bytes; cola vacia: EAGAIN");
    if (shutdown(par[0], SHUT_WR) == -1) { perror("shutdown"); goto fin; }
    if (recibir(par[1], &byte, 1, 0) != 0) {
        fprintf(stderr, "Se esperaba EOF\n"); goto fin;
    }
    puts("Despues de SHUT_WR y sin datos pendientes: EOF");
    fallo = 0;
fin:
    if (copia != -1 && close(copia) == -1) { perror("close alias"); fallo = 1; }
    if (close(par[0]) == -1) { perror("close A"); fallo = 1; }
    if (close(par[1]) == -1) { perror("close B"); fallo = 1; }
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

El alias se crea con F_DUPFD_CLOEXEC para que también tenga su propio indicador de cierre en exec. Las comprobaciones principales se refieren a O_NONBLOCK, que sí se comparte. No se utilizan hilos: el orden de las operaciones hace reproducible la pérdida de actualidad de la sonda.

enviar_prueba falla si estos bloques pequeños no pueden aceptarse en el ensayo. No es una función general que programe envíos pendientes; la siguiente implementación sí conserva el estado necesario para reanudar después de EAGAIN.

10. Compilar y reconocer EAGAIN y EOF

Bash en Linux · un experimento sin pausas
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 lectura36.c -o lectura36
$ timeout 10s ./lectura36
MSG_DONTWAIT: EAGAIN sin cambiar O_NONBLOCK
fcntl: O_NONBLOCK tambien aparece en el alias
Sonda: lectura preparada
Tras consumir por el alias: recv devuelve EAGAIN
Recibidos y verificados 4 bytes; cola vacia: EAGAIN
Despues de SHUT_WR y sin datos pendientes: EOF
$ echo $?
0

La cola vacía produce dos resultados diferentes según el estado del emisor: EAGAIN cuando todavía podría enviar y cero después de terminar su envío. El modo no bloqueante no altera esa distinción.

El primer EAGAIN no prueba que O_NONBLOCK estuviera activo: se solicitó MSG_DONTWAIT para esa llamada. El segundo se obtiene sin ese flag, después de activar el modo persistente mediante fcntl.

timeout es un límite externo del ensayo. Un retorno 124 indica que esa herramienta agotó su espera; no es un código del protocolo ni un caso correcto de EAGAIN.

11. Laboratorio de contrapresión y reanudación

Guarda salida36.c. Se genera un MiB de datos binarios con patrón reproducible. El emisor intenta avanzar hasta completar el envío o encontrar EAGAIN. Entonces el mismo programa atiende al receptor, verifica los bytes retirados y vuelve al envío con el desplazamiento conservado.

Se solicita un SO_SNDBUF pequeño para provocar contrapresión pronto. El tamaño efectivo y la contabilidad interna dependen del sistema: no se espera una cantidad fija de bytes aceptados antes del primer EAGAIN. Se comprueba el contenido, no un número exacto de llamadas.

Esta alternancia es un controlador de laboratorio: puede hacer progresar directamente al interlocutor porque posee ambos extremos. Un servidor con procesos independientes debe esperar disponibilidad cuando no tiene otro trabajo listo. No debe copiar este controlador como un sondeo continuo de clientes externos.

salida36.c · salida pendiente y recepción verificadas byte a byte
#define _GNU_SOURCE
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#define TOTAL (1024u * 1024u)
#define PEDIDO 16384u

enum paso { ERROR = -1, ESPERA = 0, COMPLETO = 1 };

struct salida {
    const unsigned char *datos;
    size_t total;
    size_t hechos;
    size_t esperas;
    size_t parciales;
};

struct entrada {
    size_t recibidos;
    int eof;
};

static int es_espera(void)
{
    return errno == EAGAIN || errno == EWOULDBLOCK;
}

static unsigned char patron(size_t i)
{
    return (unsigned char)(i % 251u);
}

static enum paso avanzar_envio(int fd, struct salida *s)
{
    while (s->hechos < s->total) {
        size_t pedido = s->total - s->hechos;
        if (pedido > PEDIDO) pedido = PEDIDO;
        ssize_t n = send(fd, s->datos + s->hechos, pedido, MSG_NOSIGNAL);
        if (n > 0) {
            if ((size_t)n < pedido) ++s->parciales;
            s->hechos += (size_t)n;
        } else if (n == -1 && errno == EINTR) {
            continue;
        } else if (n == -1 && es_espera()) {
            ++s->esperas;
            return ESPERA; /* datos y hechos siguen siendo validos. */
        } else {
            if (n == 0) errno = EIO;
            perror("send"); return ERROR;
        }
    }
    return COMPLETO;
}

static int drenar_entrada(int fd, struct entrada *e, size_t total)
{
    unsigned char bloque[4096];
    for (;;) {
        ssize_t n = recv(fd, bloque, sizeof bloque, 0);
        if (n > 0) {
            if ((size_t)n > total - e->recibidos) {
                fprintf(stderr, "Se recibieron bytes excesivos\n"); return -1;
            }
            for (size_t i = 0; i < (size_t)n; ++i) {
                if (bloque[i] != patron(e->recibidos + i)) {
                    fprintf(stderr, "Contenido fuera de secuencia\n"); return -1;
                }
            }
            e->recibidos += (size_t)n;
        } else if (n == 0) {
            if (e->recibidos != total) {
                fprintf(stderr, "EOF antes de completar los datos\n"); return -1;
            }
            e->eof = 1;
            return 0;
        } else if (errno == EINTR) {
            continue;
        } else if (es_espera()) {
            return 0;
        } else {
            perror("recv"); return -1;
        }
    }
}

int main(void)
{
    unsigned char *datos = malloc(TOTAL);
    if (datos == NULL) { perror("malloc"); return EXIT_FAILURE; }
    for (size_t i = 0; i < TOTAL; ++i) datos[i] = patron(i);
    int par[2];
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
                   0, par) == -1) {
        perror("socketpair"); free(datos); return EXIT_FAILURE;
    }
    int fallo = 1;
    int capacidad = 4096;
    if (setsockopt(par[0], SOL_SOCKET, SO_SNDBUF,
                   &capacidad, sizeof capacidad) == -1) {
        perror("SO_SNDBUF"); goto fin;
    }
    struct salida s = { .datos = datos, .total = TOTAL };
    struct entrada e = {0};
    int envio_terminado = 0;
    while (!e.eof) {
        size_t antes_s = s.hechos;
        size_t antes_e = e.recibidos;
        enum paso r = avanzar_envio(par[0], &s);
        if (r == ERROR) goto fin;
        if (r == COMPLETO && !envio_terminado) {
            if (shutdown(par[0], SHUT_WR) == -1) { perror("shutdown"); goto fin; }
            envio_terminado = 1;
        }
        if (drenar_entrada(par[1], &e, s.total) == -1) goto fin;
        if (!e.eof && s.hechos == antes_s && e.recibidos == antes_e) {
            /* Con ambos extremos bajo nuestro control, no deberia ocurrir. */
            fprintf(stderr, "El controlador de laboratorio no pudo progresar\n");
            goto fin;
        }
    }
    if (s.hechos != s.total || e.recibidos != s.total || !envio_terminado) {
        fprintf(stderr, "Transferencia incompleta\n"); goto fin;
    }
    printf("Transferencia verificada: %zu bytes y EOF\n", e.recibidos);
    printf("EAGAIN de envio: %zu; envios parciales: %zu\n", s.esperas, s.parciales);
    if (fflush(stdout) == EOF) { perror("salida"); goto fin; }
    fallo = 0;
fin:
    if (close(par[0]) == -1) { perror("close A"); fallo = 1; }
    if (close(par[1]) == -1) { perror("close B"); fallo = 1; }
    free(datos);
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}

El búfer original permanece vivo hasta el final del programa. avanzar_envio no copia ni descarta el sufijo al retornar ESPERA. drenar_entrada comprueba cada byte contra su posición esperada, detectando duplicaciones, omisiones que desplacen la secuencia y bytes excesivos.

La rutina de envío no interpreta COMPLETO como «recibido por el otro extremo». El controlador marca SHUT_WR al completar la aceptación local y exige después recepción de toda la cantidad esperada y EOF. Solo entonces anuncia la transferencia verificada.

12. Comprobar todos los bytes transferidos

Bash · una cantidad fija de datos y contadores dependientes del sistema
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 salida36.c -o salida36
$ timeout 10s ./salida36
Transferencia verificada: 1048576 bytes y EOF
EAGAIN de envio: N; envios parciales: M
$ echo $?
0

N y M representan los contadores numéricos que imprimirá tu sistema; no son letras impresas por el programa. Con el búfer pequeño solicitado se espera observar contrapresión y habitualmente envíos positivos parciales. Sus valores concretos no son un requisito del protocolo.

El patrón incluye ceros y otros bytes que no son texto. No se usa strlen para interpretar la transferencia. La cantidad fija de un MiB pertenece al contrato del laboratorio; un protocolo general necesitaría declarar longitudes y validarlas.

Observa el orden: intentar enviar, retirar datos del interlocutor, reanudar el sufijo. Cada EAGAIN entrega el control y el siguiente turno cambia la condición que impedía avanzar. No se hace un bucle vacío que espere que el núcleo «se arregle» solo.

La memoria de aplicación está acotada al bloque de un MiB y al búfer de recepción. Cambiar SO_SNDBUF modifica cuándo aparece la presión, pero no debería alterar el contenido ni el resultado final.

13. Esperar, limitar colas y repartir turnos

No girar sobre EAGAIN

En una aplicación con interlocutores externos, después de agotar el trabajo disponible se espera con select, poll o epoll. Repetir recv sin datos puede consumir un núcleo de CPU sin acercarse al fin de la petición. Agregar sleep a cada vuelta reduce ese consumo a costa de introducir latencia y sondeo periódico.

La espera puede ser bloqueante aunque las operaciones de E/S sean no bloqueantes. Es una combinación útil: el proceso duerme cuando no hay trabajo listo y, al despertar, intenta operaciones que no quedan retenidas por un cliente particular.

Interés de escritura solo cuando hay trabajo pendiente

Un socket suele tener capacidad de escritura durante largos períodos. Vigilar escritura constantemente sin una cola pendiente puede despertar el bucle de forma continua. Registra ese interés cuando haya bytes por enviar y retíralo al vaciar la cola, según la API utilizada.

Si aún queda salida y apareció EAGAIN, conserva el interés. Cuando se notifique capacidad, vuelve a intentar desde el desplazamiento guardado. Una notificación de error o cierre también exige ejecutar la política correspondiente, sin asumir que significa éxito.

Contrapresión y presupuestos

O_NONBLOCK no limita la memoria que la aplicación decide encolar. Si un cliente lento no consume respuestas, debes acotar la salida por conexión y el total del servicio, frenar la producción o recepción de más trabajo y definir qué hacer al superar el límite.

Drenar una conexión hasta EAGAIN puede realizar mucho trabajo si el emisor produce continuamente. Un bucle con muchas conexiones necesita presupuestos de bytes o llamadas y una cola de trabajo listo. Al agotar un presupuesto, conserva el estado y permite avanzar a otros participantes.

El laboratorio tiene entrada finita y dos extremos propios, así que puede completar sus fases sin esa planificación general. Las diferencias entre level-triggered y edge-triggered, y cómo conservar trabajo que no llegó a drenarse, se desarrollarán en el tema 40.

14. Creación, accept y connect no bloqueantes

En Linux puedes solicitar SOCK_NONBLOCK y SOCK_CLOEXEC al crear un socket o un par. Así el modo y la política de herencia quedan instalados desde su nacimiento. El segundo programa utiliza esa combinación; las opciones se describen en socket(2).

C en Linux · creación y aceptación con flags explícitos
int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
/* Comprobar fd != -1 y configurar el resto del servicio. */

int cliente = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
/* Comprobar cliente y tratar EAGAIN si no hay conexion pendiente. */

Marcar la escucha como no bloqueante evita que accept espere una conexión inexistente. Marcar el socket aceptado controla las operaciones sobre ese cliente. Son decisiones distintas: en Linux, accept no garantiza heredar O_NONBLOCK de la escucha. accept4 permite fijarlo en el nuevo conectado; véase accept(2).

Una notificación sobre la escucha tampoco reserva una conexión para tu llamada. Otro aceptador puede retirarla antes. Por eso hay que gestionar EAGAIN aun después de observar preparación.

Conectar tiene su propio estado

En conexiones no bloqueantes que quedan en progreso, como el caso habitual de TCP con EINPROGRESS, se espera una condición de finalización y se consulta SO_ERROR con getsockopt. La preparación para escribir por sí sola no prueba que la conexión haya tenido éxito.

AF_UNIX requiere atención particular: connect puede devolver EAGAIN cuando no puede completar la conexión inmediatamente. No debe suponerse que cualquier EAGAIN equivale a una conexión pendiente iniciada de la misma manera que EINPROGRESS. Si se decide reintentar tras un fallo, se debe seguir el contrato de esa familia y recrear el socket cuando corresponda. Las reglas están en connect(2).

Los ejemplos de este tema evitan esas fases usando socketpair ya conectado. No añadas el mismo tratamiento genérico de EAGAIN a todas las llamadas sin distinguir recepción, envío, aceptación y establecimiento de conexión.

15. Explorar una transferencia por estados

El emisor prepara una trama de ocho bytes: cabecera de dos bytes que declara un cuerpo de seis, seguido del texto hola!!. El transporte didáctico tiene capacidad de cuatro bytes. Intenta enviar sin recibir para observar EAGAIN; después retira datos y reanuda desde el desplazamiento conservado.

Emisor: aceptados / pendientes0 / 8 bytes

Cola del transporte (máximo 4)Vacía

Receptor: parserCabecera: 0 de 2 bytes

Última observación de lecturaSin consultar

Último retorno de E/SSin llamada

Dirección de envíoAbierta

Una trama completa requiere cabecera y cuerpo; disponibilidad no significa finalización.

Primero observa preparación con la cola vacía; intenta recv y obtendrás EAGAIN. Envía datos, observa otra vez y usa «Otro lector» antes de recv: la observación seguirá mostrando su resultado anterior, pero la recepción ya no encontrará los bytes.

Ese otro lector retira bytes sin entregarlos al parser principal. Sirve para mostrar una observación desactualizada y también por qué los lectores de una misma conversación deben coordinarse. Reinicia antes de practicar la secuencia correcta para no interpretar un flujo del que se perdieron bytes.

En el recorrido correcto, completa cabecera y cuerpo y termina el envío. El receptor conserva su trama completa y después observa EOF. Si terminas antes de enviar todo, los bytes no enviados ya no llegarán y EOF puede revelar truncamiento. El modelo no representa errores de transporte, señales ni los tamaños reales del núcleo.

16. Pruebas y diagnóstico

Comprobaciones de los programas

  1. Compilar con advertencias. Ambos programas deben terminar correctamente sin advertencias de tipos ni conversiones problemáticas.
  2. Modo por llamada y persistente. Comprueba que MSG_DONTWAIT no cambia F_GETFL y que fcntl sí modifica el modo compartido por el alias.
  3. Preparación desactualizada. Después de consumir X mediante el alias, la recepción principal debe obtener EAGAIN.
  4. EAGAIN frente a EOF. Una cola vacía mantiene la espera temporal hasta que se termina el envío remoto.
  5. Salida completa. El segundo programa debe verificar todos los bytes y EOF sin exigir contadores idénticos entre máquinas.

Forzar fragmentación y errores útiles

En una copia del segundo ejemplo, limita cada send y recv a un byte. El contenido y la longitud deben mantenerse. Otra prueba puede envolver las llamadas reales para introducir EINTR antes de ciertas operaciones: el código debe conservar los avances previos.

No basta con devolver artificialmente un número positivo desde un wrapper: hay que transferir realmente ese prefijo. Un controlador que «finge» éxito puede ocultar que el programa no envió nada o generar un fallo que no pertenece al caso que se intentaba probar.

Haz que el emisor cierre antes de completar TOTAL: el receptor debe detectar EOF prematuro. Cambia un byte de la fuente manteniendo intacto el patrón esperado: debe informarse contenido fuera de secuencia. Prueba también un cierre del receptor mientras todavía queda salida y comprueba que el error de send no termina el programa por SIGPIPE.

Ejecuta avanzar_envio con el búfer de transporte lleno: debe retornar ESPERA conservando hechos. Retira datos, vuelve a llamar y comprueba que el prefijo no se repite. La prueba debe comparar contenido y posiciones, no solamente la cantidad final de bytes.

Observar llamadas y consumo

Bash · retornos de E/S y cambios de configuración
$ strace -s 32 -e trace=socketpair,fcntl,poll,sendto,recvfrom,shutdown,close ./lectura36
$ strace -c -e trace=sendto,recvfrom ./salida36

En Linux, send y recv suelen aparecer en strace como sendto y recvfrom. Busca retornos positivos, EAGAIN y cero después de SHUT_WR. Una traza no convierte un tamaño observado de recepción en un límite de mensaje garantizado.

Al construir el futuro bucle de eventos, prueba un cliente conectado que no envía nada y otro que no consume respuestas. El servicio debería dormir cuando no hay trabajo y mantener acotadas sus colas. Un número enorme de llamadas con EAGAIN sin cambios de estado señala sondeo innecesario.

Un controlador de fallos debe tener un plazo externo y limpiar sus recursos aunque una prueba falle. La E/S no bloqueante evita algunas esperas de transporte; no sustituye plazos de aplicación, cancelación ni limpieza de descriptores.

17. Errores frecuentes

ErrorConsecuenciaCorrección
F_SETFL con solo O_NONBLOCK.Se pueden quitar otros flags modificables.Obtener flags actuales y agregar el bit.
Usar F_SETFD para O_NONBLOCK.Se confunden flags de descriptor y de estado.Usar F_GETFL/F_SETFL.
Creer que el modo solo afecta al número local.Otro alias cambia de comportamiento.Considerar la descripción abierta compartida.
Interpretar EAGAIN como desconexión.Se pierde una conversación todavía válida.Guardar estado y esperar condiciones de avance.
Repetir recv inmediatamente después de EAGAIN.Se consume CPU sin datos nuevos.Atender trabajo listo o esperar disponibilidad.
Reiniciar el parser después de EAGAIN.Los fragmentos siguientes se interpretan desde un límite falso.Conservar cabecera, cuerpo y contadores.
Enviar desde cero tras un retorno positivo parcial.Se duplica el prefijo.Avanzar por el retorno real.
Liberar el búfer al aparecer EAGAIN.El sufijo pendiente queda inválido.Mantener su propiedad hasta completar o cancelar.
Confiar en que preparación implica mensaje completo.Se procesa una entrada parcial.Usar las reglas del protocolo para completar.
Vigilar escritura con cola vacía.El bucle puede despertar continuamente.Ajustar el interés a la salida pendiente.
Suponer que accept hereda el modo en Linux.Un cliente aceptado puede bloquear el bucle.Configurar el conectado o utilizar accept4.
Confundir no bloqueante con plazo garantizado.Se ignoran otras fuentes de espera y tareas pendientes.Definir plazos, supervisión y límites por separado.

18. Resumen

19. Preguntas de repaso y práctica

Razona separando estado del transporte, estado del parser, bytes pendientes e intereses del futuro bucle de eventos.

1. ¿Por qué se lee F_GETFL antes de usar F_SETFL?

Para agregar O_NONBLOCK conservando otros flags de estado modificables y comprobar que la consulta fue válida.

2. ¿O_NONBLOCK y FD_CLOEXEC son la misma clase de flag?

No. O_NONBLOCK es estado compartido de la descripción abierta; FD_CLOEXEC pertenece a una entrada de descriptor y controla exec.

3. ¿Un cambio por un alias puede afectar a otro proceso?

Sí, si ambos referencian la misma descripción abierta. O_NONBLOCK no pertenece únicamente al número usado en fcntl.

4. ¿MSG_DONTWAIT modifica permanentemente el socket?

No. Solicita el comportamiento para esa llamada y no cambia F_GETFL.

5. ¿EAGAIN en recv significa que llegó EOF?

No. Indica que la llamada no puede avanzar ahora. EOF es un retorno cero en una recepción STREAM con capacidad positiva.

6. ¿Qué se hace con una cabecera parcial al aparecer EAGAIN?

Se conservan sus bytes y el contador. La recepción siguiente continúa desde ese estado.

7. ¿Cuántos bytes se repiten si send aceptó cuatro y después apareció EAGAIN?

Ninguno de esos cuatro. Se reanuda desde el quinto byte cuando haya capacidad.

8. ¿Por qué el búfer de salida debe seguir vivo?

Porque las llamadas posteriores todavía necesitan leer el sufijo pendiente. La aceptación parcial no copia automáticamente todo el resto.

9. ¿Por qué el laboratorio obtiene EAGAIN después de observar lectura preparada?

Porque el alias retiró el byte entre la sonda y la recepción principal. La notificación no reservó los datos.

10. ¿Estar preparado para escribir garantiza aceptar toda la respuesta?

No. Puede haber un envío positivo parcial o un error. El código conserva el progreso real y comprueba cada retorno.

11. ¿Hay que vigilar escritura cuando no quedan bytes pendientes?

En general se retira ese interés para no recibir notificaciones continuas de una condición que no tiene trabajo asociado.

12. ¿Por qué el segundo ejemplo no necesita dormir entre EAGAIN y la reanudación?

Porque el controlador posee también al receptor y lo atiende para liberar capacidad. Un servicio con interlocutores externos necesita una espera de disponibilidad.

13. ¿O_NONBLOCK limita la memoria de las colas de aplicación?

No. Deben definirse límites por conexión y globales, contrapresión y una política ante consumidores lentos.

14. ¿Un accept sobre una escucha no bloqueante produce siempre un cliente no bloqueante en Linux?

No. El conectado debe configurarse explícitamente o crearse con accept4 y SOCK_NONBLOCK.

15. ¿Preparación y finalización son equivalentes?

No. La preparación informa una condición para intentar E/S; la finalización depende del resultado de la operación y del contrato del protocolo.

Para practicar y ampliar

  1. Ejecuta lectura36 y relaciona cada mensaje con una llamada y su estado previo.
  2. Comprueba con F_GETFL que marcar un extremo no marca al otro extremo del par.
  3. Agrega un alias y verifica el efecto de activar y desactivar O_NONBLOCK.
  4. Limita a un byte las llamadas del laboratorio de salida y verifica la secuencia completa.
  5. Cambia SO_SNDBUF y compara contadores sin exigir cifras idénticas.
  6. Provoca EOF prematuro y un byte incorrecto y comprueba los rechazos.
  7. Diseña el estado persistente necesario para adaptar el parser del tema 33 a EAGAIN.
  8. Define límites de cola para diez clientes y qué harías si uno deja de recibir.
  9. Propón un presupuesto por turno y explica cómo conservarías trabajo listo al agotarlo.
  10. Dibuja los intereses de lectura y escritura de una conexión mientras recibe, calcula, responde y cierra.
Próximo paso

El tema 37 utilizará select para dormir hasta que varios descriptores puedan avanzar. Aprenderás a reconstruir fd_set, calcular nfds y manejar tiempos de espera sin perder el estado de cada conversación.