← Comunicación entre ProcesosBloque 10 · Protocolos, fallos y diagnóstico · Tema 41 de 52

Tema 41

Diseñar un protocolo de IPC

Vas a definir qué significan los bytes de una conversación, dónde termina cada mensaje y qué debe ocurrir ante entradas inválidas. El diseño incluirá versiones, límites, identificadores y errores de operación. Construirás un parser incremental independiente del transporte y comprobarás su compatibilidad con una implementación en otro lenguaje.

1. El contrato antes del código

Los temas anteriores explicaron cómo transferir bytes y cuándo puede avanzar una operación. Falta responder otra clase de preguntas: ¿qué bytes representan una petición?, ¿cómo se distingue una respuesta de un error?, ¿qué puede cambiar entre versiones?

Un protocolo debe permitir que dos implementaciones independientes coincidan sin compartir una estructura C, un compilador o un supuesto sobre el tamaño de las lecturas. El tema 33 introdujo un formato concreto; aquí separaremos sus responsabilidades y construiremos un parser reutilizable sobre fragmentos.

Un protocolo de IPC define representación, límites de mensajes, operaciones, estados de conversación y tratamiento de fallos. El mecanismo de transporte no completa ese contrato por sí solo.

PreguntaDecisión del ejemploComprobación
¿Dónde termina una trama?Cabecera fija de 20 bytes más cuerpo de longitud declarada.Acumular cabecera y cuerpo por separado.
¿Cuánto puede ocupar?Cuerpo de 0 a 1024 bytes.Rechazar antes de copiar un cuerpo excesivo.
¿Qué versión se interpreta?Versión 1, sin negociación.Rechazar otra versión al completar la cabecera.
¿Qué errores permiten continuar?Operación desconocida, longitud semántica incorrecta o suma fuera de rango.Responder un estado de aplicación con el mismo id.
¿Qué rompe la sesión?Cabecera incompatible, truncamiento o secuencia incorrecta.Fallo terminal; no buscar otra marca dentro del flujo.

El formato IPC4 de este tema es una especificación didáctica nueva, no una versión compatible con IPC3 del tema 33. Conserva las ideas de enmarcado y correlación, pero tiene otra cabecera y otro repertorio de operaciones.

2. Separar transporte, formato y conversación

CapaResponsabilidadEjemplo de fallo
Transporte.Entregar los bytes que la E/S logró retirar o aceptar.EAGAIN, EPIPE, cierre o timeout.
Formato.Reconstruir una trama y validar su cabecera.Versión desconocida, flags no permitidos o longitud excesiva.
Conversación.Ordenar peticiones y asociar respuestas.Id repetido o respuesta de otra operación.
Aplicación.Ejecutar una operación completa y válida.Argumentos de suma con tamaño incorrecto.

El parser que escribiremos no llama a recv, select ni epoll. Recibe fragmentos ya disponibles y notifica mensajes completos. Puede alimentarse desde una tubería, un socket STREAM, un archivo de prueba o un controlador que entregue un byte cada vez.

El programa de laboratorio usa entrada y salida estándar como flujos binarios. Su trabajo es probar el contrato, no construir otro servidor. La separación permitirá comprobar errores de formato sin depender de carreras de planificación o del tamaño real de una recepción.

3. Longitudes, delimitadores y EOF

EstrategiaVentajaRegla que debe especificarse
Tamaño fijo.Fronteras simples.Campos, relleno y costo de mensajes pequeños.
Delimitador, por ejemplo LF.Lectura cómoda de formatos textuales.Escape del delimitador, límite de búsqueda y política de caracteres.
Prefijo de longitud.Admite cuerpos binarios y mensajes consecutivos.Ancho, orden de bytes, qué cuenta y máximo permitido.
EOF.Final claro de una dirección del flujo.No sirve por sí solo para varias peticiones en esa dirección.

Un formato por líneas debe decidir qué ocurre con LF dentro de un dato. Un prefijo debe decidir si incluye la cabecera o solo el cuerpo. «Enviar JSON» tampoco resuelve por sí solo la delimitación de varios documentos consecutivos ni sus límites de memoria.

JSON define una representación de valores y sus propias reglas de cadenas, números y codificación; un protocolo que lo use debe añadir sus fronteras y restricciones. Véase RFC 8259.

Elegiremos longitud de cuerpo explícita. Una trama vacía sigue ocupando 20 bytes y no necesita EOF. El final del transporte se evalúa aparte: entre tramas puede ser un cierre de sesión; dentro de una trama es truncamiento.

4. Representación estable de los datos

No se enviará sizeof de una estructura nativa. El padding, la alineación y el orden de bytes de la máquina no forman parte del formato. Los campos se codifican por posiciones y los enteros usan primero el byte más significativo.

ejemplo · entero de 32 bits, independientemente de la máquina
valor decimal:     42
bytes del formato: 00 00 00 2a

longitud decimal:  1024
bytes del formato: 00 00 04 00

Las funciones htonl/ntohl y htons/ntohs son una alternativa para convertir enteros de 32 y 16 bits al orden de red. En el ejemplo se muestran desplazamientos explícitos para que la codificación resulte visible. Véase byteorder(3).

Un cuerpo es una secuencia de bytes con longitud; no se presupone NUL final. Si una operación definiera texto, debería fijar su codificación y validarla según ese contrato. Las operaciones de este laboratorio trabajan con binario o enteros sin signo.

También existen representaciones estandarizadas como XDR, que especifican tipos y representación externa. Este laboratorio no implementa XDR: define su propio formato pequeño para estudiar las decisiones; véase RFC 4506.

5. Formato binario IPC4

BytesCampoRegla de versión 1
0–3.Marca.ASCII IPC4.
4.Versión.1.
5.Clase.1 petición, 2 respuesta.
6.Operación.1 eco, 2 suma32, 3 ping; otros códigos producen error de aplicación.
7.Flags.Cero; no hay flags definidos.
8–11.Identificador.Entero de 32 bits, no cero, big-endian.
12–15.Longitud del cuerpo.Entero de 32 bits, de 0 a 1024, big-endian.
16–17.Estado.Entero de 16 bits; cero en peticiones, de cero a tres en respuestas.
18–19.Reservado.Dos bytes en cero.
20 en adelante.Cuerpo.Exactamente longitud bytes.
vector hexadecimal · eco de a/NUL/b, identificador uno
49 50 43 34  01 01 01 00  00 00 00 01  00 00 00 03  00 00 00 00
 I  P  C  4  ver/cl/op/fl       id          longitud     estado/reserva
61 00 62
 a NUL b

La longitud cuenta solo el cuerpo. El tamaño máximo de una trama es 20 + 1024 = 1044 bytes. La marca ayuda a identificar el formato esperado, pero no autentica al interlocutor ni autoriza a buscar una nueva cabecera dentro de datos corruptos.

6. Operaciones, resultados y errores

OperaciónCuerpo de peticiónRespuesta exitosa
1: eco.Entre 0 y 1024 bytes.Los mismos bytes y la misma longitud.
2: suma32.Dos enteros de 32 bits, exactamente ocho bytes.Un entero de 32 bits, exactamente cuatro bytes.
3: ping.Vacío.Vacía, estado de éxito.

Las respuestas repiten operación e id. El estado cero significa éxito; uno, operación no soportada; dos, longitud incompatible con la operación; tres, suma fuera de rango. Todas las respuestas de error llevan cuerpo vacío.

Una suma que excede UINT32_MAX no se reduce módulo 2³² ni se anuncia como éxito. El código comprueba el límite antes de sumar. Eso evita que dos implementaciones discrepen entre desbordamiento, saturación y rechazo.

Una operación desconocida dentro de una trama completa permite responder y continuar. Una longitud mayor que 1024 viola el formato y se rechaza al validar la cabecera. No se espera ni se reserva el cuerpo que declara.

7. Validar en orden y acotar recursos

  1. Completar la cabecera fija. No interpretar campos que todavía no llegaron.
  2. Validar marca, versión, clase y campos reservados. No ejecutar otro formato por aproximación.
  3. Validar id, estado y longitud máxima. Antes de copiar el cuerpo o sumar tamaños externos.
  4. Completar el cuerpo acotado. Conservar el avance entre fragmentos.
  5. Validar la conversación. Secuencia o correlación correspondiente.
  6. Aplicar reglas de operación. Tamaños semánticos, rangos y estado de respuesta.

El parser usa capacidad fija y no asigna memoria según una longitud recibida. El codificador comprueba primero que la capacidad cubra la cabecera y luego compara el cuerpo con capacidad − cabecera; no suma primero un tamaño externo sin validar.

Un máximo por trama no limita todas las fuentes de consumo: también se necesitan máximos de conexiones, mensajes por sesión, respuestas pendientes, trabajo y tiempo. El programa acepta hasta dieciséis peticiones por entrada procesada y no ejecuta una decimoséptima.

8. Versiones y evolución compatible

La versión 1 exige cero en flags y campos reservados. Un receptor no debe ignorar un flag desconocido cuyo significado podría alterar la interpretación de los demás bytes. Una versión desconocida cierra el parser sin procesar su cuerpo.

Este formato no negocia versiones. Si en el futuro se agrega negociación, el saludo inicial debe tener su propio enmarcado, límites y política de selección. No alcanza con «probar versiones hasta que alguna parezca funcionar».

Cambio propuestoDecisión que exigeRiesgo si queda implícito
Nueva operación.Código, cuerpo y errores definidos.Un receptor anterior debe responder no soportada, no ejecutar otra operación.
Nuevo flag obligatorio.Versión o negociación que permita exigirlo.Un receptor que lo ignore podría interpretar mal el trabajo.
Campo opcional extensible.Longitud, presencia y regla de ignorar o rechazar.Desplazar campos sin control rompe el parser anterior.
Aumento del máximo.Límites locales y acuerdo entre extremos.Que quepa en el campo no significa que el receptor lo admita.

No se añaden campos opcionales en el código de esta versión. Antes de implementar una evolución, redacta vectores que muestren qué acepta y qué rechaza cada versión.

9. Identificadores y reglas de sesión

En el procesador, las peticiones deben tener ids consecutivos desde uno y no superar dieciséis. Cada respuesta conserva ese id y la operación. El comprobador del laboratorio espera exactamente seis respuestas para seis peticiones conocidas.

El parser de formato no impone por sí solo esa secuencia: se comprueba en el callback de sesión. Así, la lógica que reconstruye una trama no se confunde con la política que decide si esa trama tiene sentido en la conversación actual.

Un identificador correlaciona dentro de esta sesión. No es una clave persistente de deduplicación ni demuestra ejecución exactamente una vez. La pérdida de una respuesta puede ocurrir después de producir un efecto; el tema 43 profundizará en reintentos e idempotencia.

Una sesión de peticiones vacía puede terminar entre tramas. Un comprobador que esperaba seis respuestas debe fallar si termina sin ellas. El significado de EOF depende tanto del estado de enmarcado como del trabajo pendiente.

10. Parser incremental y codificador completos

Guarda protocolo41.h. alimentar41 acepta un fragmento y llama al callback por cada trama completa, incluso si hay varias en ese fragmento. Un fallo deja el parser en estado terminal. finalizar41 comprueba que EOF no interrumpió una cabecera o cuerpo.

El mensaje pasado al callback pertenece al parser y se reutiliza al continuar. Si otro componente necesita conservarlo después, debe copiar los campos y el cuerpo que correspondan. El callback no debe reentrar en el mismo parser.

protocolo41.h · formato, parser y semántica sin operaciones de E/S
#ifndef PROTOCOLO41_H
#define PROTOCOLO41_H
#include <stdint.h>
#include <stddef.h>
#include <string.h>

#define CAB41 20u
#define MAX41 1024u
#define REQ41 1u
#define RESP41 2u
#define ECO41 1u
#define SUMA41 2u
#define PING41 3u
#define OK41 0u
#define OP41 1u
#define ARG41 2u
#define RANGO41 3u

struct mensaje41 {
    unsigned char clase, operacion;
    uint16_t estado;
    uint32_t id, longitud;
    unsigned char cuerpo[MAX41];
};
struct parser41 {
    unsigned char cabecera[CAB41];
    size_t cab_usados, cuerpo_usados;
    unsigned char clase_esperada;
    int fallo;
    const char *error;
    struct mensaje41 mensaje;
};
typedef int (*receptor41)(const struct mensaje41 *, void *);

static inline uint32_t leer32_41(const unsigned char *p)
{
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8) | (uint32_t)p[3];
}
static inline void poner32_41(unsigned char *p, uint32_t v)
{
    p[0] = (unsigned char)(v >> 24); p[1] = (unsigned char)(v >> 16);
    p[2] = (unsigned char)(v >> 8); p[3] = (unsigned char)v;
}
static inline int fallar41(struct parser41 *p, const char *razon)
{
    p->fallo = 1; p->error = razon; return -1;
}
static inline int iniciar41(struct parser41 *p, unsigned char clase)
{
    memset(p, 0, sizeof *p);
    p->clase_esperada = clase;
    if (clase != REQ41 && clase != RESP41) return fallar41(p, "clase local invalida");
    return 0;
}
static inline int cabecera41(struct parser41 *p)
{
    const unsigned char *h = p->cabecera;
    if (memcmp(h, "IPC4", 4) != 0) return fallar41(p, "marca incompatible");
    if (h[4] != 1) return fallar41(p, "version incompatible");
    if (h[5] != p->clase_esperada) return fallar41(p, "clase inesperada");
    if (h[7] != 0 || h[18] != 0 || h[19] != 0)
        return fallar41(p, "flags o reserva no permitidos");
    uint32_t id = leer32_41(h + 8), longitud = leer32_41(h + 12);
    uint16_t estado = (uint16_t)(((uint16_t)h[16] << 8) | h[17]);
    if (id == 0) return fallar41(p, "identificador cero");
    if (longitud > MAX41) return fallar41(p, "longitud excesiva");
    if ((h[5] == REQ41 && estado != 0) || estado > RANGO41)
        return fallar41(p, "estado incompatible");
    p->mensaje.clase = h[5]; p->mensaje.operacion = h[6];
    p->mensaje.id = id; p->mensaje.longitud = longitud; p->mensaje.estado = estado;
    return 0;
}
static inline int alimentar41(struct parser41 *p, const unsigned char *datos,
                             size_t total, receptor41 recibir, void *contexto)
{
    if (p->fallo) return -1;
    if (recibir == NULL || (total != 0 && datos == NULL))
        return fallar41(p, "argumento local invalido");
    size_t usados = 0;
    while (usados < total) {
        if (p->cab_usados < CAB41) {
            size_t n = CAB41 - p->cab_usados;
            if (n > total - usados) n = total - usados;
            memcpy(p->cabecera + p->cab_usados, datos + usados, n);
            p->cab_usados += n; usados += n;
            if (p->cab_usados < CAB41) continue;
            if (cabecera41(p) == -1) return -1;
        }
        size_t faltan = (size_t)p->mensaje.longitud - p->cuerpo_usados;
        size_t n = total - usados;
        if (n > faltan) n = faltan;
        if (n != 0) {
            memcpy(p->mensaje.cuerpo + p->cuerpo_usados, datos + usados, n);
            p->cuerpo_usados += n; usados += n;
        }
        if (p->cuerpo_usados == p->mensaje.longitud) {
            if (recibir(&p->mensaje, contexto) != 0)
                return fallar41(p, "rechazo de la sesion o de su salida");
            p->cab_usados = 0; p->cuerpo_usados = 0;
        }
    }
    return 0;
}
static inline int finalizar41(struct parser41 *p)
{
    if (p->fallo) return -1;
    if (p->cab_usados != 0 || p->cuerpo_usados != 0)
        return fallar41(p, "EOF dentro de una trama");
    return 0;
}
static inline int codificar41(const struct mensaje41 *m, unsigned char *salida,
                             size_t capacidad, size_t *total)
{
    if (m->longitud > MAX41 || m->id == 0 ||
        (m->clase != REQ41 && m->clase != RESP41) ||
        m->estado > RANGO41 || (m->clase == REQ41 && m->estado != 0) ||
        capacidad < CAB41 || m->longitud > capacidad - CAB41) return -1;
    memset(salida, 0, CAB41);
    memcpy(salida, "IPC4", 4);
    salida[4] = 1; salida[5] = m->clase; salida[6] = m->operacion;
    poner32_41(salida + 8, m->id); poner32_41(salida + 12, m->longitud);
    salida[16] = (unsigned char)(m->estado >> 8);
    salida[17] = (unsigned char)m->estado;
    memcpy(salida + CAB41, m->cuerpo, m->longitud);
    *total = CAB41 + m->longitud;
    return 0;
}
static inline int responder41(const struct mensaje41 *peticion, struct mensaje41 *r)
{
    if (peticion->clase != REQ41 || peticion->estado != 0 ||
        peticion->longitud > MAX41 || peticion->id == 0) return -1;
    memset(r, 0, sizeof *r);
    r->clase = RESP41; r->operacion = peticion->operacion; r->id = peticion->id;
    switch (peticion->operacion) {
    case ECO41:
        r->longitud = peticion->longitud;
        memcpy(r->cuerpo, peticion->cuerpo, r->longitud);
        break;
    case SUMA41:
        if (peticion->longitud != 8) { r->estado = ARG41; break; }
        {
            uint32_t a = leer32_41(peticion->cuerpo);
            uint32_t b = leer32_41(peticion->cuerpo + 4);
            if (a > UINT32_MAX - b) r->estado = RANGO41;
            else { r->longitud = 4; poner32_41(r->cuerpo, a + b); }
        }
        break;
    case PING41:
        if (peticion->longitud != 0) r->estado = ARG41;
        break;
    default:
        r->estado = OP41;
    }
    return 0;
}
static inline int verificar41(const struct mensaje41 *peticion, const struct mensaje41 *r)
{
    struct mensaje41 esperado;
    if (responder41(peticion, &esperado) == -1) return -1;
    if (r->clase != RESP41 || r->id != esperado.id ||
        r->operacion != esperado.operacion || r->estado != esperado.estado ||
        r->longitud != esperado.longitud) return -1;
    return memcmp(r->cuerpo, esperado.cuerpo, esperado.longitud) == 0 ? 0 : -1;
}
#endif

Una cabecera con longitud cero provoca el callback al completarse sus veinte bytes, aunque el fragmento termine exactamente allí. Una cabecera con cuerpo no vacío conserva su estado hasta recibirlo; el fragmento siguiente no se interpreta como una cabecera nueva.

La validación estructural permite un código de operación desconocido y estados de respuesta definidos. Las reglas específicas de cuerpo y correspondencia se aplican después en responder41 o verificar41. Esa separación es deliberada.

11. Programa de generación y procesamiento

Guarda laboratorio41.c. generar produce seis peticiones binarias; procesar las interpreta y responde; comprobar espera las seis respuestas correctas. El parámetro opcional de fragmento vale entre uno y 4096 y limita los bytes solicitados en cada read, sin cambiar el protocolo.

Las seis pruebas incluyen eco binario, 7 + 35, operación 99 no soportada, ping vacío, suma fuera de rango y suma con un solo byte de argumento. Los diagnósticos van a stderr para no mezclarse con el flujo binario.

laboratorio41.c · productor, procesador y comprobador de conversación
#define _POSIX_C_SOURCE 200809L
#include "protocolo41.h"
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

struct sesion41 {
    uint32_t siguiente;
    int comprobar;
    const char *error;
};

static int escribir41(const unsigned char *datos, size_t total)
{
    size_t hechos = 0;
    while (hechos < total) {
        ssize_t n = write(STDOUT_FILENO, datos + hechos, total - hechos);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else { if (n == 0) errno = EIO; perror("write"); return -1; }
    }
    return 0;
}
static int emitir41(const struct mensaje41 *m)
{
    unsigned char bytes[CAB41 + MAX41];
    size_t total;
    if (codificar41(m, bytes, sizeof bytes, &total) == -1) return -1;
    return escribir41(bytes, total);
}
static int ejemplo41(uint32_t id, struct mensaje41 *m)
{
    memset(m, 0, sizeof *m);
    m->clase = REQ41; m->id = id;
    switch (id) {
    case 1:
        m->operacion = ECO41; m->longitud = 3;
        m->cuerpo[0] = 'a'; m->cuerpo[1] = 0; m->cuerpo[2] = 'b';
        break;
    case 2:
        m->operacion = SUMA41; m->longitud = 8;
        poner32_41(m->cuerpo, 7); poner32_41(m->cuerpo + 4, 35);
        break;
    case 3:
        m->operacion = 99;
        break;
    case 4:
        m->operacion = PING41;
        break;
    case 5:
        m->operacion = SUMA41; m->longitud = 8;
        poner32_41(m->cuerpo, UINT32_MAX); poner32_41(m->cuerpo + 4, 1);
        break;
    case 6:
        m->operacion = SUMA41; m->longitud = 1;
        m->cuerpo[0] = 7;
        break;
    default: return -1;
    }
    return 0;
}
static int recibir41(const struct mensaje41 *m, void *contexto)
{
    struct sesion41 *s = contexto;
    if (m->id != s->siguiente || s->siguiente > (s->comprobar ? 6u : 16u)) {
        s->error = "identificador fuera de secuencia o limite de sesion"; return -1;
    }
    if (s->comprobar) {
        struct mensaje41 peticion;
        if (ejemplo41(s->siguiente, &peticion) == -1 || verificar41(&peticion, m) == -1) {
            s->error = "respuesta incompatible con la peticion pendiente"; return -1;
        }
    } else {
        struct mensaje41 respuesta;
        if (responder41(m, &respuesta) == -1 || emitir41(&respuesta) == -1) {
            s->error = "fallo al construir o emitir respuesta"; return -1;
        }
    }
    ++s->siguiente;
    return 0;
}

int main(int argc, char **argv)
{
    if (argc < 2 || argc > 3 ||
        (strcmp(argv[1], "generar") != 0 && strcmp(argv[1], "procesar") != 0 &&
         strcmp(argv[1], "comprobar") != 0) ||
        (argc == 3 && strcmp(argv[1], "generar") == 0)) {
        fprintf(stderr, "Uso: %s generar | procesar [fragmento] | comprobar [fragmento]\n", argv[0]);
        return EXIT_FAILURE;
    }
    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { perror("SIGPIPE"); return EXIT_FAILURE; }
    if (strcmp(argv[1], "generar") == 0) {
        for (uint32_t id = 1; id <= 6; ++id) {
            struct mensaje41 m;
            if (ejemplo41(id, &m) == -1 || emitir41(&m) == -1) return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
    }
    size_t fragmento = 64;
    if (argc == 3) {
        if (argv[2][0] == '\0') return EXIT_FAILURE;
        for (const char *p = argv[2]; *p; ++p)
            if (*p < '0' || *p > '9') return EXIT_FAILURE;
        errno = 0;
        char *fin;
        unsigned long valor = strtoul(argv[2], &fin, 10);
        if (errno || *fin || valor < 1 || valor > 4096) return EXIT_FAILURE;
        fragmento = (size_t)valor;
    }
    struct sesion41 sesion = {
        .siguiente = 1, .comprobar = strcmp(argv[1], "comprobar") == 0, .error = NULL
    };
    struct parser41 parser;
    if (iniciar41(&parser, sesion.comprobar ? RESP41 : REQ41) == -1) return EXIT_FAILURE;
    for (;;) {
        unsigned char datos[4096];
        ssize_t n = read(STDIN_FILENO, datos, fragmento);
        if (n > 0) {
            if (alimentar41(&parser, datos, (size_t)n, recibir41, &sesion) == -1) {
                fprintf(stderr, "Protocolo: %s\n", sesion.error ? sesion.error : parser.error);
                return EXIT_FAILURE;
            }
        } else if (n == 0) break;
        else if (errno != EINTR) { perror("read"); return EXIT_FAILURE; }
    }
    if (finalizar41(&parser) == -1) {
        fprintf(stderr, "Protocolo: %s\n", parser.error); return EXIT_FAILURE;
    }
    if (sesion.comprobar) {
        if (sesion.siguiente != 7) {
            fprintf(stderr, "Faltan respuestas del intercambio de prueba\n"); return EXIT_FAILURE;
        }
        puts("Seis respuestas verificadas: contenido, estados, ids y EOF entre tramas");
        if (fflush(stdout) == EOF) return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

Un fallo posterior no deshace respuestas anteriores que ya salieron. El parser se detiene, pero el flujo de salida puede contener un prefijo de conversaciones completas. La aplicación que lo recibe debe conocer qué resultados había aceptado y cuál quedó pendiente.

12. Compilar y fragmentar el intercambio

Bash en Linux · activar pipefail para no ocultar fallos anteriores
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 laboratorio41.c -o laboratorio41
$ set -o pipefail
$ ./laboratorio41 generar | ./laboratorio41 procesar 1 | ./laboratorio41 comprobar 7
Seis respuestas verificadas: contenido, estados, ids y EOF entre tramas
$ ./laboratorio41 generar | ./laboratorio41 procesar 4096 | ./laboratorio41 comprobar 1
Seis respuestas verificadas: contenido, estados, ids y EOF entre tramas

El tamaño pedido a read no garantiza que siempre retorne esa cantidad. Con fragmento uno, cada retorno positivo contiene como máximo un byte. Con 4096 se admite recibir varias tramas juntas, pero sigue siendo obligatorio reconstruirlas según el formato.

Bash · guardar vectores binarios en un directorio de prueba
$ ensayo=$(mktemp -d)
$ ./laboratorio41 generar > "$ensayo/peticiones.bin"
$ ./laboratorio41 procesar 7 < "$ensayo/peticiones.bin" > "$ensayo/respuestas.bin"
$ wc -c "$ensayo/peticiones.bin" "$ensayo/respuestas.bin"
140 .../peticiones.bin
127 .../respuestas.bin
267 total
$ ./laboratorio41 comprobar < "$ensayo/respuestas.bin"
$ od -An -tx1 -v "$ensayo/peticiones.bin"
$ rm -- "$ensayo/peticiones.bin" "$ensayo/respuestas.bin"
$ rmdir -- "$ensayo"

Las rutas de wc dependen del directorio generado. No imprimas mensajes de diagnóstico sobre stdout en los modos generar o procesar: un texto añadido allí sería parte del flujo y rompería la cabecera siguiente.

13. Verificación independiente en Python

Guarda referencia41.py. Este programa construye sus propias peticiones y sus propios resultados esperados, sin usar el codificador C ni la función de suma C. Comprueba el formato byte por byte y contrasta longitudes, estados, ids y cuerpos.

referencia41.py · interoperabilidad entre implementaciones
import struct
import subprocess
import sys

CAB = struct.Struct("!4sBBBBIIHH")
MAXIMO = 1024

def trama(operacion, identificador, cuerpo):
    return CAB.pack(b"IPC4", 1, 1, operacion, 0,
                    identificador, len(cuerpo), 0, 0) + cuerpo

def verificar(datos, esperadas):
    posicion = 0
    for identificador, (operacion, estado, cuerpo) in enumerate(esperadas, 1):
        if len(datos) - posicion < CAB.size:
            raise ValueError("cabecera de respuesta truncada")
        h = CAB.unpack_from(datos, posicion)
        posicion += CAB.size
        marca, version, clase, op, flags, ident, largo, status, reserva = h
        if (marca, version, clase, flags, reserva) != (b"IPC4", 1, 2, 0, 0):
            raise ValueError("formato de respuesta incompatible")
        if largo > MAXIMO or largo > len(datos) - posicion:
            raise ValueError("longitud de respuesta incompatible")
        recibido = datos[posicion:posicion + largo]
        posicion += largo
        if (ident, op, status, recibido) != (identificador, operacion, estado, cuerpo):
            raise ValueError("respuesta no corresponde al resultado esperado")
    if posicion != len(datos):
        raise ValueError("bytes o respuestas adicionales")

def main():
    if len(sys.argv) != 2:
        raise ValueError("Uso: python3 referencia41.py ./laboratorio41")
    casos = [
        (1, b"a\x00b"),
        (2, struct.pack("!II", 7, 35)),
        (99, b""),
        (3, b""),
        (2, struct.pack("!II", 0xffffffff, 1)),
        (2, b"\x07"),
    ]
    peticiones = b"".join(trama(op, i, cuerpo)
                          for i, (op, cuerpo) in enumerate(casos, 1))
    esperadas = [(1, 0, b"a\x00b"), (2, 0, struct.pack("!I", 42)),
                 (99, 1, b""), (3, 0, b""), (2, 3, b""), (2, 2, b"")]
    for fragmento in (1, 7, 4096):
        r = subprocess.run([sys.argv[1], "procesar", str(fragmento)],
                           input=peticiones, capture_output=True, timeout=5)
        if r.returncode != 0:
            raise ValueError("fallo del procesador: " + r.stderr.decode(errors="replace"))
        verificar(r.stdout, esperadas)
    print("Referencia Python: seis respuestas correctas con fragmentos 1, 7 y 4096")

if __name__ == "__main__":
    try:
        main()
    except (ValueError, OSError, subprocess.TimeoutExpired) as error:
        print(error, file=sys.stderr)
        sys.exit(1)
Bash · comprobar contra una referencia externa al código C
$ python3 referencia41.py ./laboratorio41
Referencia Python: seis respuestas correctas con fragmentos 1, 7 y 4096

El prefijo ! de struct especifica orden de red y tamaños estándar sin padding nativo; la cabecera resultante ocupa veinte bytes. Su semántica se documenta en struct de Python. La coincidencia entre dos programas no sustituye la especificación, pero ayuda a detectar supuestos de representación compartidos por error.

14. Integrar límites, plazos y bucles de eventos

En un socket no bloqueante, solo se alimenta al parser con los bytes que recv devolvió positivamente. EAGAIN conserva el estado sin llamar a finalizar41; recv igual a cero permite evaluar EOF. Un error de transporte falla la conversación según su política, sin inventar un cuerpo completo.

Los retornos de recepción y envío siguen las reglas de recv(2) y send(2). Una recepción no define una trama, y aceptar toda una respuesta para envío no acredita ejecución remota.

El callback del laboratorio escribe de forma síncrona porque es un filtro de pruebas. En un servidor de eventos tendría que encolar la respuesta en una salida acotada, conservar su sufijo y ajustar intereses como en los temas 36 a 40.

alimentar41 consume el fragmento completo salvo error y no ofrece un retorno de pausa con bytes consumidos. Si se necesita detener callbacks por contrapresión o presupuesto, hay que ampliar esa interfaz con un estado de pausa y un contador de consumo, o alimentar unidades cuya producción máxima pueda alojarse. No se debe usar un «error» de callback para pausar y después intentar reanudar un parser terminal.

Un límite de cuerpo no impide a un emisor entregar un byte cada tanto. Se necesitan plazos por etapa o por petición, límites de salida y de mensajes en vuelo, cancelación y limpieza. La integración de señales y temporizadores llegará en el tema 42.

La marca, el id y el formato no autentican. En sockets Unix, la autorización del canal y del recurso se diseña con permisos y credenciales, como en los temas 32 y 35. La especificación de bytes no reemplaza esa política.

15. Explorar el contrato por fragmentos

El modelo prepara una petición eco de tres bytes binarios seguida de un ping vacío. Elige fragmentos de uno, siete o todos los bytes y observa cómo los límites del transporte se separan de los límites de las tramas.

Bytes preparados sin entregar43

Estado de reconstrucciónCabecera: 0 de 20 bytes

Último fragmento hexadecimalNinguno

Siguiente id permitido1

Respuestas de aplicaciónNinguna

ConversaciónAbierta

Una trama eco ocupa 23 bytes y el ping ocupa 20.

Prueba el fragmento completo para observar dos mensajes dentro de una sola entrega. Prueba EOF después de un byte para ver truncamiento, y después de ambas tramas para ver final entre mensajes. Terminar antes de transmitir todo descarta aquí los bytes de prueba aún no entregados; no borra bytes que un núcleo real ya hubiera aceptado.

El modelo muestra eco, ping y error de operación; la suma y el resto de las comprobaciones se ejercitan en los programas. Una trama incompatible deja el modelo en fallo terminal sin buscar otra marca dentro de su cuerpo.

16. Pruebas de conformidad y fallos

Fragmentación sin depender de la planificación

Toma la secuencia de peticiones y pártela en cada posición posible: primero un prefijo y después el resto. Todas esas particiones deben producir las mismas respuestas que la secuencia reunida. Añade entregas de un byte, fragmentos aleatorios y varias tramas en una entrega.

Prueba EOF en cada posición. Si termina entre tramas completas, el procesador puede finalizar; si queda cabecera o cuerpo pendiente, debe fallar. El comprobador de respuestas además exige que estén las seis respuestas esperadas, incluso cuando el EOF estructural sea limpio.

Formato, aplicación y conversación

Entrada de pruebaResultado exigidoEtapa
Longitud 1024.Eco completo y binario.Límite válido.
Longitud 1025 o 0xffffffff.Fallo al completar la cabecera.Formato, sin esperar cuerpo.
Marca, versión, clase, flags o reserva incompatibles.Parser terminal.Formato.
Id cero o estado no permitido.Fallo de cabecera.Formato.
Operación desconocida seguida de ping con siguiente id.Error de operación y después éxito.Aplicación recuperable.
Suma con siete bytes o ping con cuerpo.Estado dos y cuerpo vacío.Argumentos.
UINT32_MAX + cero; UINT32_MAX + uno.Éxito con máximo; estado tres.Rango aritmético.
Id repetido, salteado o petición diecisiete.Fallo sin ejecutar esa petición.Conversación.
Respuesta con op, id, estado, longitud o contenido falsos.El comprobador falla.Correlación y semántica.

Las entradas incompatibles deben construirse como bytes independientes: el codificador normal impide producir algunos errores locales. No retires su validación para probar al receptor.

Comprueba que alimentar un parser ya fallado no invoca más callbacks, y que el máximo de cuerpo no se supera durante ninguna copia. Un callback que conserva un mensaje debe copiarlo antes de que se procese el siguiente.

La comparación Python evita depender solo de un emisor y receptor que comparten el mismo error en una función C. Conserva vectores con resultado conocido para cada nueva operación o versión.

Herramientas y límites del ensayo

Bash · compilación instrumentada para pruebas de memoria
$ gcc -std=c11 -Wall -Wextra -Wpedantic -g -fsanitize=address,undefined laboratorio41.c -o laboratorio41_san
$ python3 referencia41.py ./laboratorio41_san

La instrumentación ayuda a detectar accesos fuera de límites y operaciones inválidas; no demuestra que la semántica del protocolo sea correcta. El controlador debe tener un límite externo y tratar cualquier salida binaria parcial de una ejecución fallida como resultados que requieren revisión, no como una transacción revertida.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Definir el mensaje por un retorno de recv.Las tramas se parten o reúnen según la ejecución.Enmarcado explícito y acumulación incremental.
Transmitir una estructura nativa.Padding y representación dependientes de la ABI.Campos y orden de bytes especificados.
Reservar antes de validar longitud.Consumo de memoria o tamaños no controlados.Máximo comprobado al completar la cabecera.
Usar strlen para datos recibidos.Un NUL modifica el significado de la longitud.Operar sobre bytes y tamaño validado.
Ignorar una versión o flag desconocido.Se ejecutan bytes con reglas equivocadas.Política explícita de rechazo o negociación.
Confundir error de operación con formato roto.Se pierde continuidad o se intenta continuar sin fronteras fiables.Separar errores semánticos y errores terminales.
Buscar otra marca tras un fallo.Un cuerpo puede confundirse con una cabecera.Fallar la sesión salvo resincronización definida por diseño.
Tratar id como autenticación o deduplicación global.Se atribuyen garantías que no existen.Separar correlación, identidad y recuperación.
Conservar un puntero al mensaje del callback.La siguiente trama reutiliza su almacenamiento.Copiar lo necesario con límites y propiedad claros.
Usar error del callback como pausa temporal.Se intenta reanudar un parser terminal.Interfaz de pausa y consumo definida, o capacidad previamente garantizada.
Probar solo implementaciones que comparten el codificador.Un error común puede parecer interoperabilidad.Vectores conocidos y referencia independiente.
Escribir diagnósticos en el flujo binario.Los mensajes siguientes quedan corruptos.Canal de diagnóstico separado.

18. Resumen

19. Preguntas de repaso y práctica

Razona separando formato, sesión, operación y resultados pendientes antes de desplegar las respuestas.

1. ¿Por qué un protocolo no se define solo eligiendo un socket?

Porque el socket no especifica campos, fronteras de aplicación, operaciones, versiones ni políticas de error.

2. ¿Qué cuenta la longitud de IPC4?

Solo los bytes del cuerpo. La trama total ocupa veinte bytes de cabecera más esa longitud.

3. ¿Un cuerpo vacío necesita EOF para completarse?

No. Se completa al validar una cabecera de longitud cero, aunque no llegue otro byte.

4. ¿Por qué no se transmite sizeof(struct mensaje41)?

Porque es una representación local que puede contener padding y orden nativo. El formato se codifica por campos.

5. ¿Cuándo se rechaza una longitud excesiva?

Al completar y validar la cabecera, antes de copiar o esperar el cuerpo declarado.

6. ¿Una operación desconocida rompe necesariamente la conversación?

No. Si la trama es completa y válida, se responde estado uno con el mismo id y operación y puede continuar la siguiente.

7. ¿Una versión desconocida se interpreta como la más cercana?

No. Esta versión no negocia y la rechaza de forma terminal.

8. ¿Qué ocurre con UINT32_MAX + uno?

Se devuelve estado tres con cuerpo vacío. No se anuncia un resultado reducido por desbordamiento.

9. ¿El parser impone por sí solo los ids consecutivos?

No. El parser valida el formato; el callback de sesión comprueba la secuencia y el máximo de peticiones.

10. ¿EOF limpio prueba que llegaron todas las respuestas?

No. Solo indica que no quedó una trama parcial. El cliente debe comprobar también sus solicitudes pendientes.

11. ¿Se puede guardar el puntero recibido en el callback?

No como copia permanente. El almacenamiento pertenece al parser y se reutiliza; hay que copiar lo que deba conservarse.

12. ¿Un fallo de una trama posterior revierte respuestas anteriores?

No. Los resultados ya emitidos permanecen en el flujo; no existe una transacción implícita de toda la sesión.

13. ¿Por qué es útil la referencia Python?

Codifica y comprueba sin compartir las funciones C, ayudando a detectar supuestos de representación y resultados comunes equivocados.

14. ¿Puede usarse un retorno de error del callback para pausar por cola llena?

No en esta interfaz. El error deja el parser terminal. Una pausa reanudable necesita un contrato adicional de consumo y estado.

15. ¿El máximo de 1024 bytes sustituye un plazo?

No. Un interlocutor puede avanzar muy lentamente. El servicio necesita límites de tiempo y otros recursos además del tamaño.

Para practicar y ampliar

  1. Codifica a mano eco de tres bytes, ping vacío y suma de siete más treinta y cinco.
  2. Ejecuta el intercambio con fragmentos de uno, siete y 4096 bytes.
  3. Prueba todas las particiones en dos de la secuencia generada y compara resultados.
  4. Introduce EOF en cada posición y distingue fronteras válidas de truncamientos.
  5. Construye una longitud 1025 y comprueba el rechazo sin enviar cuerpo.
  6. Envía una operación desconocida seguida de una válida con el id siguiente.
  7. Prueba sumas en el máximo y fuera de rango y una respuesta falsa de éxito.
  8. Diseña una operación nueva con cuerpo, resultado y errores antes de programarla.
  9. Propón una versión dos y redacta una matriz de compatibilidad con la versión uno.
  10. Amplía el contrato del parser para pausarlo por contrapresión sin perder bytes ni repetir callbacks.
Próximo paso

El tema 42 integrará señales y temporizadores con el bucle de eventos: self-pipe, pselect y ppoll, además de signalfd y timerfd en Linux. El protocolo necesita que los plazos y la cancelación convivan con los datos sin carreras.