← Comunicación entre ProcesosBloque 4 · Tuberías con nombre: FIFO · Tema 18 de 52

Tema 18

Proyecto: un servicio local con FIFO

Vas a construir un servidor que recibe solicitudes de varios procesos por una FIFO compartida y devuelve cada resultado por un canal propio del cliente. El proyecto une formato de mensajes, atomicidad, aperturas no bloqueantes, plazos de espera y limpieza. También comprobarás qué ocurre cuando falta el servidor, un cliente abandona o una solicitud llega incompleta.

1. Contrato y alcance del servicio

El tema 16 presentó los nombres y permisos de las FIFO; el tema 17 separó ENXIO, EAGAIN, EOF y reconexión. Ahora vamos a darles un propósito: un cliente envía hasta 192 bytes de texto y recibe esos mismos bytes con las letras ASCII a–z convertidas en A–Z.

Se admite texto vacío y se conservan espacios, números y bytes que no pertenezcan a ese intervalo ASCII. El argumento de terminal no puede contener NUL. Las letras Unicode no se convierten mediante reglas de idioma; el servicio solo transforma los bytes ASCII indicados.

El protocolo debe decidir qué constituye una petición, cómo se envía sin mezclarse con otras, dónde se responde y quién retira cada nombre. Las FIFO proporcionan el transporte, pero esas reglas pertenecen a la aplicación.

Los participantes cooperan bajo el mismo usuario, en un directorio privado y estable. El servidor procesa una solicitud por vez. Varios clientes pueden presentar solicitudes concurrentemente, pero no hay un trabajador independiente por cliente ni autenticación entre procesos del mismo usuario.

2. Una entrada compartida y una respuesta por cliente

Una sola FIFO pública dentro del directorio del laboratorio recibe las peticiones. Cada cliente crea un subdirectorio único y una FIFO de respuesta propia, cuyo nombre relativo incluye en su solicitud.

Peticiones compartidas y respuestas privadas por clienteLos clientes A y B escriben registros en peticiones. El servidor lee esa FIFO y responde a cada cliente mediante su propia FIFO de respuesta. Cliente Arespuesta ACliente Brespuesta Bpeticionesregistros de 256Servidoratiende por turnorespuesta por el canal del cliente
Los clientes comparten el flujo de entrada, pero no compiten por leer las respuestas.

Si todos leyeran una FIFO de respuesta compartida, un cliente podría consumir bytes destinados a otro. Un identificador dentro del mensaje no impediría que el lector equivocado ya lo retirara del flujo. Un canal por cliente resuelve esa disputa en este diseño.

La FIFO de respuesta también identifica la única solicitud de esa invocación. Como cada cliente crea una nueva ruta para una sola petición, no necesitamos un identificador adicional dentro del registro. Si una conexión admitiera varias solicitudes pendientes, habría que definir esa correlación.

3. Organizar rutas y propietarios

estructura del laboratorio · todos los procesos usan la misma raíz absoluta
/home/usuario/servicio18.ABC123/        directorio privado del laboratorio
├── peticiones                       FIFO creada por el servidor
├── cliente.a1B2c3/                   directorio único del cliente A
│   └── respuesta                    FIFO creada por A
└── cliente.d4E5f6/                   directorio único del cliente B
    └── respuesta                    FIFO creada por B

El programa exige que la raíz sea un directorio real, pertenezca al usuario efectivo y no conceda permisos a grupo u otros. El cliente usa mkdtemp para crear su subdirectorio único con modo 0700; no utiliza únicamente el PID como nombre. La operación se describe en mkdtemp(3).

Las FIFO se crean con 0600. Se rechaza una ruta de servidor ya existente en lugar de borrarla al arrancar. El servidor no acepta una ruta de respuesta arbitraria: exige un nombre con el formato cliente. seguido de seis caracteres alfanuméricos, y añade él mismo /respuesta bajo la raíz.

Estas comprobaciones delimitan el laboratorio, pero no aíslan procesos hostiles del mismo usuario. La secuencia de inspeccionar y abrir una ruta no es atómica. Durante el uso, los participantes no deben sustituir los directorios o las FIFO de otros procesos.

4. Definir un registro de tamaño fijo

Tanto la petición como la respuesta ocupan 256 bytes. No enviamos una estructura de C: sus campos se codifican en posiciones explícitas para no depender de relleno o alineación.

PosiciónPeticiónRespuesta
0–3.Firma F18Q.Firma F18R.
4.Versión 1.Versión 1.
5.Operación 1: transformar.Estado 0: éxito; 1: petición inválida.
6–7.Longitud del texto, byte más significativo primero.Longitud del resultado o diagnóstico.
8–39.Nombre del subdirectorio, terminado en NUL.Reservado, a cero.
40–231.Hasta 192 bytes de texto.Hasta 192 bytes de contenido.
232–255.Reservado, a cero.Reservado, a cero.

El emisor pone a cero todo el registro antes de rellenarlo. Los receptores validan firma, versión y longitud; el servidor valida además la ruta y la operación. Los bytes de texto que excedan la longitud declarada no pertenecen al contenido.

Un registro fijo hace sencillo acumular lecturas parciales. Su coste es enviar 256 bytes incluso para un texto vacío. Esta elección prioriza la claridad del protocolo y no pretende ser óptima para cualquier volumen.

5. Enviar una petición sin entremezclar clientes

Todos los clientes escriben sobre la misma FIFO de peticiones. Para impedir que dos solicitudes se mezclen, cada una se envía mediante una sola llamada write de 256 bytes, tras comprobar con fpathconf que no supera _PC_PIPE_BUF.

Con O_NONBLOCK y un tamaño dentro de ese límite, la falta de espacio produce EAGAIN sin aceptar un prefijo. Se conserva el registro entero, se espera disponibilidad y se reintenta la unidad. Un retorno positivo inesperadamente menor que 256 se trata como fallo del contrato, sin enviar un sufijo que pudiera intercalarse con otro cliente.

No uses una escritura para la cabecera y otra para el texto en el canal compartido. La garantía de cada llamada no une ambas operaciones. Atomicidad tampoco significa que el servidor reciba 256 bytes en un solo read: sigue acumulando hasta completar el registro. Véase pipe(7).

La consulta del límite se realiza sobre el descriptor abierto. Si devuelve un límite insuficiente o indeterminado, el programa rechaza el envío en lugar de asumir una cifra del equipo. La interfaz se documenta en fpathconf(3).

6. Abrir la respuesta antes de anunciarla

  1. Preparar la respuesta. El cliente crea su directorio y FIFO, y abre su lector con O_NONBLOCK.
  2. Enviar la petición. Abre el escritor del servicio y envía un registro atómico.
  3. Atender. El servidor reconstruye la petición, valida el destino y abre su escritor de respuesta sin bloquear.
  4. Responder. Envía el registro al cliente y cierra ese escritor.
  5. Retirar recursos. El cliente valida y muestra la respuesta, cierra sus descriptores y elimina su FIFO y subdirectorio.

Cuando el servidor conoce la ruta de respuesta, el lector del cliente ya debe existir. Si abrir el escritor devuelve ENXIO, el cliente pudo haber abandonado. El servidor informa el fallo y continúa, sin esperar indefinidamente a un lector ausente.

El cliente puede observar un EOF inicial antes de que el servidor abra su escritor. Como todavía espera un registro completo, no considera ese cero una respuesta válida: conserva el lector y reintenta con una pausa limitada por su plazo.

7. Esperas con un plazo monotónico

El cliente dispone de cinco segundos para abrir el servicio, enviar y recibir. Se fija una fecha límite con CLOCK_MONOTONIC y se recalcula el tiempo restante antes de cada espera. Así un EINTR o una actividad parcial no reinician el plazo completo. El reloj se describe en clock_gettime(2).

El servidor limita a un segundo la emisión de cada respuesta. También permite hasta cinco segundos para completar un registro una vez recibido su primer byte. Un canal inactivo puede permanecer esperando; la ausencia de peticiones no es un error.

Los descriptores FIFO son no bloqueantes y las esperas poll se dividen en intervalos de hasta 250 ms, lo que permite revisar la solicitud de parada. Ante EOF inicial del cliente se usa una pausa de hasta 100 ms: no se gira sobre read o sobre un POLLHUP persistente.

8. Código compartido del protocolo

Guarda los tres archivos de código en el mismo directorio. Esta cabecera contiene el formato, validación de rutas, manejo de señales y operaciones con plazo. Sus funciones son static inline para que cada ejecutable tenga su propia copia sin exigir un archivo objeto adicional.

comun_fifo.h · formato explícito y operaciones acotadas
#ifndef COMUN_FIFO_H
#define COMUN_FIFO_H
#define _POSIX_C_SOURCE 200809L
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

#define REGISTRO 256
#define TEXTO 192
#define RUTA 512
static volatile sig_atomic_t parada = 0;

static inline void solicitar_parada(int senal) { parada = senal; }

static inline int preparar(void)
{
    struct sigaction a = {0};
    a.sa_handler = solicitar_parada;
    if (sigemptyset(&a.sa_mask) == -1 ||
        sigaction(SIGINT, &a, NULL) == -1 ||
        sigaction(SIGTERM, &a, NULL) == -1)
        return -1;
    a.sa_handler = SIG_IGN;
    return sigaction(SIGPIPE, &a, NULL);
}

static inline int64_t ahora(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 inline int64_t plazo(int ms)
{
    int64_t t = ahora();
    return t == -1 ? -1 : t + ms;
}

static inline int restante(int64_t fin)
{
    if (parada) { errno = EINTR; return -1; }
    int64_t t = ahora();
    if (t == -1) return -1;
    if (fin <= t) { errno = ETIMEDOUT; return -1; }
    return fin - t > 250 ? 250 : (int)(fin - t);
}

static inline int esperar(int fd, short evento, int64_t fin)
{
    for (;;) {
        int ms = restante(fin);
        if (ms == -1) return -1;
        struct pollfd p = {.fd = fd, .events = evento};
        int r = poll(&p, 1, ms);
        if (r == -1) {
            if (errno == EINTR) continue;
            return -1;
        }
        if (r == 0) continue;
        if (p.revents & POLLNVAL) { errno = EBADF; return -1; }
        if (evento == POLLOUT && (p.revents & (POLLERR | POLLHUP))) {
            errno = EPIPE;
            return -1;
        }
        return 0;
    }
}

static inline int pausar(int64_t fin)
{
    int ms = restante(fin);
    if (ms == -1) return -1;
    if (ms > 100) ms = 100;
    if (poll(NULL, 0, ms) == -1 && errno != EINTR) return -1;
    return 0;
}

static inline int unir(char salida[RUTA], const char *a, const char *b)
{
    int n = snprintf(salida, RUTA, "%s/%s", a, b);
    if (n < 0 || n >= RUTA) { errno = ENAMETOOLONG; return -1; }
    return 0;
}

static inline int directorio_privado(const char *ruta)
{
    struct stat st;
    if (lstat(ruta, &st) == -1) return -1;
    if (!S_ISDIR(st.st_mode) || st.st_uid != geteuid() ||
        (st.st_mode & 0077) != 0) {
        errno = EACCES;
        return -1;
    }
    return 0;
}

static inline int abrir_fifo(const char *ruta, int modo)
{
    struct stat a, b;
    if (lstat(ruta, &a) == -1) return -1;
    if (!S_ISFIFO(a.st_mode) || a.st_uid != geteuid()) {
        errno = EINVAL;
        return -1;
    }
    int fd = open(ruta, modo | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    if (fd == -1) return -1;
    int causa = 0;
    if (fstat(fd, &b) == -1) causa = errno;
    else if (!S_ISFIFO(b.st_mode) || a.st_dev != b.st_dev ||
             a.st_ino != b.st_ino) causa = EINVAL;
    if (causa) { close(fd); errno = causa; return -1; }
    return fd;
}

static inline unsigned longitud(const unsigned char *r)
{
    return ((unsigned)r[6] << 8) | r[7];
}

static inline void iniciar(unsigned char *r, const char *firma,
                            unsigned estado, unsigned n)
{
    memset(r, 0, REGISTRO);
    memcpy(r, firma, 4);
    r[4] = 1; r[5] = (unsigned char)estado;
    r[6] = (unsigned char)(n >> 8); r[7] = (unsigned char)n;
}

static inline int nombre_valido(const unsigned char *p)
{
    if (memcmp(p, "cliente.", 8) != 0 || p[14] != '\0') return 0;
    for (int i = 8; i < 14; ++i)
        if (!isalnum(p[i])) return 0;
    return 1;
}

static inline int enviar_registro(int fd, const unsigned char *r, int64_t fin)
{
    long limite = fpathconf(fd, _PC_PIPE_BUF);
    if (limite < REGISTRO) { errno = ENOTSUP; return -1; }
    for (;;) {
        if (restante(fin) == -1) return -1;
        ssize_t n = write(fd, r, REGISTRO);
        if (n == REGISTRO) return 0;
        if (n >= 0) { errno = EIO; return -1; }
        if (errno == EINTR) continue;
        if (errno != EAGAIN && errno != EWOULDBLOCK) return -1;
        if (esperar(fd, POLLOUT, fin) == -1) return -1;
    }
}

static inline int recibir_respuesta(int fd, unsigned char *r, int64_t fin)
{
    size_t usados = 0;
    while (usados < REGISTRO) {
        if (restante(fin) == -1) return -1;
        ssize_t n = read(fd, r + usados, REGISTRO - usados);
        if (n > 0) usados += (size_t)n;
        else if (n == 0) {
            if (usados) { errno = EPROTO; return -1; }
            if (pausar(fin) == -1) return -1;
        } else if (errno == EINTR) continue;
        else if (errno == EAGAIN || errno == EWOULDBLOCK) {
            if (esperar(fd, POLLIN, fin) == -1) return -1;
        } else return -1;
    }
    return 0;
}
#endif

Los plazos de esta cabecera se aplican a las operaciones de IPC. Mostrar el resultado en stdout no tiene ese límite y puede esperar si su destino es lento. Las señales se gestionan con un flag; no se hace unlink desde el manejador.

9. Código del servidor

El servidor crea peticiones y abre primero su lector. Después abre un escritor auxiliar sobre la misma FIFO. Esa referencia es deliberada: evita EOF y POLLHUP cuando no hay clientes, porque el protocolo se basa en registros, no en cierres por cliente. No usa O_RDWR ni envía bytes por ese escritor auxiliar.

Una respuesta a un cliente ausente se descarta con diagnóstico. Un registro con firma inválida o un prefijo que no se completa dentro del plazo detiene el servidor: el formato fijo no incorpora recuperación de sincronización ante emisores que incumplen el protocolo.

servidor_fifo.c · un lector compartido y respuestas dirigidas
#include "comun_fifo.h"

static int responder(const char *raiz, const unsigned char *peticion)
{
    if (!nombre_valido(peticion + 8)) { errno = EPROTO; return -1; }
    char dir[RUTA], ruta[RUTA];
    if (unir(dir, raiz, (const char *)peticion + 8) == -1 ||
        directorio_privado(dir) == -1 || unir(ruta, dir, "respuesta") == -1)
        return -1;
    int fd = abrir_fifo(ruta, O_WRONLY);
    if (fd == -1) return -1; /* ENXIO si el cliente ya no lee. */
    unsigned n = longitud(peticion);
    unsigned char respuesta[REGISTRO];
    if (peticion[5] != 1 || n > TEXTO) {
        const char *error = "Peticion invalida";
        iniciar(respuesta, "F18R", 1, (unsigned)strlen(error));
        memcpy(respuesta + 40, error, strlen(error));
    } else {
        iniciar(respuesta, "F18R", 0, n);
        for (unsigned i = 0; i < n; ++i) {
            unsigned char c = peticion[40 + i];
            respuesta[40 + i] = c >= 'a' && c <= 'z' ?
                                 (unsigned char)(c - 'a' + 'A') : c;
        }
    }
    int64_t fin = plazo(1000);
    int r = fin == -1 ? -1 : enviar_registro(fd, respuesta, fin);
    int causa = errno;
    close(fd);
    errno = causa;
    return r;
}

static int servir(int fd, const char *raiz)
{
    unsigned char registro[REGISTRO];
    size_t usados = 0;
    int64_t fin = 0;
    while (!parada) {
        if (usados && restante(fin) == -1) return -1;
        ssize_t n = read(fd, registro + usados, REGISTRO - usados);
        if (n > 0) {
            if (usados == 0 && (fin = plazo(5000)) == -1) return -1;
            usados += (size_t)n;
            if (usados != REGISTRO) continue;
            if (memcmp(registro, "F18Q", 4) != 0 || registro[4] != 1) {
                errno = EPROTO;
                return -1;
            }
            if (responder(raiz, registro) == -1 && !parada)
                perror("respuesta descartada");
            usados = 0;
        } else if (n == 0) {
            errno = EPROTO; /* No deberia ocurrir con el escritor auxiliar. */
            return -1;
        } else if (errno == EINTR) continue;
        else if (errno == EAGAIN || errno == EWOULDBLOCK) {
            int64_t espera = usados ? fin : plazo(1000);
            if (espera == -1) return -1;
            if (esperar(fd, POLLIN, espera) == -1) {
                if (!usados && errno == ETIMEDOUT) continue;
                return -1;
            }
        } else return -1;
    }
    errno = EINTR;
    return -1;
}

int main(int argc, char *argv[])
{
    if (argc != 2 || argv[1][0] != '/') {
        fprintf(stderr, "Uso: %s directorio_privado_absoluto\n", argv[0]);
        return 1;
    }
    if (preparar() == -1 || directorio_privado(argv[1]) == -1) {
        perror("preparar servidor");
        return 1;
    }
    char ruta[RUTA];
    if (unir(ruta, argv[1], "peticiones") == -1 || mkfifo(ruta, 0600) == -1) {
        perror("crear FIFO de peticiones");
        return 1; /* No retirar una ruta que no creamos. */
    }
    int lector = abrir_fifo(ruta, O_RDONLY);
    int auxiliar = lector == -1 ? -1 : abrir_fifo(ruta, O_WRONLY);
    int resultado = 0;
    if (lector == -1 || auxiliar == -1) {
        perror("abrir FIFO del servidor");
        resultado = 1;
    } else {
        fprintf(stderr, "Servicio listo: %s\n", ruta);
        if (servir(lector, argv[1]) == -1 && !parada) {
            perror("servicio");
            resultado = 1;
        }
    }
    if (auxiliar != -1) close(auxiliar);
    if (lector != -1) close(lector);
    if (unlink(ruta) == -1) { perror("unlink peticiones"); resultado = 1; }
    return parada ? 128 + (int)parada : resultado;
}

El servidor no mantiene una lista ilimitada de clientes. Reconstruye una solicitud, intenta responder dentro del plazo y vuelve al canal compartido. Un cliente lento puede retrasar a los siguientes hasta ese límite; el diseño es secuencial y su capacidad de atender peticiones es finita.

10. Código del cliente

El cliente valida el texto antes de crear recursos. Una vez creada su FIFO, abre el lector antes de enviar la petición. Si no existe el servicio, falla; si existe su FIFO pero todavía no hay lector, reintenta ENXIO hasta su fecha límite.

cliente_fifo.c · una solicitud, una FIFO propia y una respuesta
#include "comun_fifo.h"

int main(int argc, char *argv[])
{
    if (argc != 3 || argv[1][0] != '/' || strlen(argv[2]) > TEXTO) {
        fprintf(stderr, "Uso: %s directorio_absoluto texto_de_hasta_192_bytes\n",
                argv[0]);
        return 1;
    }
    if (preparar() == -1 || directorio_privado(argv[1]) == -1) {
        perror("preparar cliente");
        return 1;
    }
    char dir[RUTA], respuesta[RUTA], entrada[RUTA];
    if (unir(dir, argv[1], "cliente.XXXXXX") == -1 ||
        unir(entrada, argv[1], "peticiones") == -1) {
        perror("ruta");
        return 1;
    }
    if (mkdtemp(dir) == NULL) { perror("mkdtemp"); return 1; }
    int creada = 0, lector = -1, escritor = -1, resultado = 1;
    if (unir(respuesta, dir, "respuesta") == -1 ||
        mkfifo(respuesta, 0600) == -1) { perror("crear respuesta"); goto limpieza; }
    creada = 1;
    lector = abrir_fifo(respuesta, O_RDONLY);
    if (lector == -1) { perror("abrir lector propio"); goto limpieza; }
    unsigned char peticion[REGISTRO], recibida[REGISTRO];
    iniciar(peticion, "F18Q", 1, (unsigned)strlen(argv[2]));
    const char *nombre = strrchr(dir, '/') + 1;
    memcpy(peticion + 8, nombre, strlen(nombre));
    memcpy(peticion + 40, argv[2], strlen(argv[2]));
    int64_t fin = plazo(5000);
    if (fin == -1) { perror("reloj"); goto limpieza; }
    while (!parada) {
        if (restante(fin) == -1) break;
        escritor = abrir_fifo(entrada, O_WRONLY);
        if (escritor != -1 || errno != ENXIO) break;
        if (pausar(fin) == -1) break;
    }
    if (escritor == -1) { if (!parada) perror("abrir servicio"); goto limpieza; }
    if (enviar_registro(escritor, peticion, fin) == -1 ||
        recibir_respuesta(lector, recibida, fin) == -1) {
        if (!parada) perror("intercambio");
        goto limpieza;
    }
    unsigned n = longitud(recibida);
    if (memcmp(recibida, "F18R", 4) != 0 || recibida[4] != 1 ||
        recibida[5] > 1 || n > TEXTO ||
        (recibida[5] == 0 && n != strlen(argv[2]))) {
        fprintf(stderr, "Respuesta invalida\n");
        goto limpieza;
    }
    FILE *destino = recibida[5] ? stderr : stdout;
    if (fwrite(recibida + 40, 1, n, destino) != n ||
        fputc('\n', destino) == EOF || fflush(destino) == EOF) {
        perror("mostrar respuesta");
        goto limpieza;
    }
    resultado = recibida[5] ? 2 : 0;
limpieza:
    if (escritor != -1) close(escritor);
    if (lector != -1) close(lector);
    if (creada && unlink(respuesta) == -1) { perror("unlink respuesta"); resultado = 1; }
    if (rmdir(dir) == -1) { perror("rmdir cliente"); resultado = 1; }
    return parada ? 128 + (int)parada : resultado;
}

El cliente no borra peticiones ni otros directorios. Un resultado cero requiere una respuesta válida, su impresión correcta y la retirada de los recursos propios. Recibir un error del servicio devuelve 2; un fallo local o de transporte devuelve 1.

11. Compilar y ejecutar el servicio

Bash en Linux o WSL · compilar ambos ejecutables
$ gcc -std=c17 -Wall -Wextra -Wpedantic servidor_fifo.c -o servidor_fifo
$ gcc -std=c17 -Wall -Wextra -Wpedantic cliente_fifo.c -o cliente_fifo
$ raiz=$(mktemp -d "$HOME/servicio18.XXXXXX")
$ ./servidor_fifo "$raiz" &
$ servidor=$!
Servicio listo: /home/usuario/servicio18.ABC123/peticiones

Espera el mensaje «Servicio listo» antes de iniciar las pruebas. Guarda los programas en el sistema de archivos Linux de WSL: los archivos especiales pueden no estar disponibles de igual forma en otros montajes.

Bash · consultar y comprobar los recursos restantes
$ ./cliente_fifo "$raiz" 'hola desde el cliente'
HOLA DESDE EL CLIENTE
$ ./cliente_fifo "$raiz" ''
... una línea vacía ...
$ ls -A "$raiz"
peticiones

Las comillas las interpreta la shell exterior para entregar el texto como un argumento. El cliente envía exactamente su longitud en bytes. Después de cada respuesta, su subdirectorio debe desaparecer y la FIFO del servidor debe permanecer disponible.

12. Probar clientes concurrentes y entradas límite

Bash · diez clientes y espera de sus PID, sin esperar al servidor persistente
$ clientes=()
$ for i in {1..10}; do ./cliente_fifo "$raiz" "cliente $i" > "resultado18-$i.txt" & clientes+=("$!"); done
$ for pid in "${clientes[@]}"; do wait "$pid" || echo "Falló el cliente $pid"; done
$ cat resultado18-1.txt
CLIENTE 1
$ cat resultado18-10.txt
CLIENTE 10
$ ls -A "$raiz"
peticiones

No uses un wait sin argumentos en esa terminal para completar la prueba: también esperaría al servidor, que sigue atendiendo. Los archivos de resultados se crean fuera de la raíz para no mezclarlos con los recursos del protocolo.

Prueba además 192 bytes ASCII y después 193. El primero debe aceptarse; el segundo debe rechazarse antes de crear el subdirectorio cliente. La cantidad se mide en bytes, no en caracteres visibles: un carácter UTF-8 puede ocupar varios.

El orden de las respuestas entre clientes no está fijado por su número ni por el momento de creación del proceso. Lo que debe mantenerse es que cada archivo reciba la respuesta correspondiente a su propia petición, sin bytes de otro cliente.

13. Ausencias, abandonos y solicitudes truncadas

PruebaResultado esperadoQué debe conservarse
No existe peticiones.El cliente falla con ENOENT.No quedan recursos de ese cliente.
Existe la FIFO, pero no hay servidor lector.Reintentos ENXIO hasta vencer el plazo.El cliente retira su respuesta y directorio.
Un proceso recibe la petición, pero no responde.El cliente termina por su fecha límite.La aceptación del envío no se confunde con éxito del servicio.
El cliente desaparece antes de que se abra su respuesta.El servidor descarta el destino ausente o sin lector.El servidor puede atender solicitudes posteriores.
Operación desconocida o longitud excesiva en un registro completo.Respuesta de estado 1 si la ruta es válida.No se accede fuera del área de texto.
Firma inválida o registro incompleto.El servidor termina por error de protocolo o plazo.Se cierra el canal y se retira su nombre propio.

Para probar un prefijo truncado usa una variante de prueba que escriba menos de 256 bytes sin otros clientes. No forma parte del protocolo válido. El escritor auxiliar impide que EOF revele el abandono, por lo que el límite de cinco segundos desde el primer byte evita esperar indefinidamente.

Si otro cliente envía un registro después de ese prefijo, los límites pueden quedar desalineados. No hay garantía de recuperación frente a emisores arbitrarios. El servicio está diseñado para clientes cooperativos que realizan una escritura atómica completa.

Un timeout después de enviar deja incierto si el servidor ya procesó la petición. Esta transformación no tiene efectos externos, pero un servicio que cobre, reserve o modifique datos necesitaría identificadores e idempotencia antes de añadir reenvíos automáticos.

14. Parada y limpieza de cada recurso

RecursoQuién lo creaQuién lo retira
Raíz privada del laboratorio.La persona que ejecuta mktemp.Esa persona, cuando ya no quedan participantes.
FIFO peticiones.El servidor que arrancó correctamente su creación.Ese servidor al salir por error tratado, SIGINT o SIGTERM.
Subdirectorio cliente y respuesta.La invocación correspondiente del cliente.Ese cliente al terminar o recorrer sus rutas de error.
Bash · detener después de que terminen los clientes y retirar la raíz vacía
$ kill -TERM "$servidor"
$ wait "$servidor"
$ echo $?
143
$ ls -A "$raiz"
... sin entradas ...
$ rmdir -- "$raiz"

Los manejadores solo solicitan parar. El flujo normal cierra descriptores y retira nombres. Retirar una ruta no cierra las referencias de otros procesos; su semántica se explica en unlink(2).

Esta parada no drena solicitudes pendientes: se detiene la aceptación y pueden quedar clientes que fallen o agoten su plazo. SIGKILL, una caída del sistema o un fallo ajeno a las rutas tratadas pueden dejar nombres residuales. Al reiniciar se rechaza EEXIST; antes de retirar un residuo debe comprobarse que no pertenezca a un servicio todavía activo.

15. Explorar el orden del intercambio

Avanza por la solicitud de un cliente. Compara el orden correcto con una petición que se anuncia antes de abrir el lector de respuesta, y con un cliente que abandona después de enviar. El modelo supone que no hay otro cliente usando esa ruta.

ClienteSin recursos propios

FIFO de respuestaNo existe

PeticionesServidor listo, sin registro

ServidorEspera una petición

El cliente debe preparar su destino antes de anunciarlo.

El servidor no bloquea una apertura de respuesta esperando a un cliente que quizá no vuelva. El plazo y la limpieza convierten ese abandono en un fallo acotado de la solicitud, en lugar de detener para siempre el servicio.

16. Diagnóstico y límites del diseño

Bash · observar el intercambio de un cliente
$ strace -o cliente18.log ./cliente_fifo "$raiz" 'prueba local'
PRUEBA LOCAL
$ less cliente18.log

Busca creación del directorio y FIFO propia, apertura del lector, apertura de peticiones, consulta de PIPE_BUF, una escritura de 256 bytes y lecturas hasta completar la respuesta. Al final deben aparecer close, unlink y rmdir. Los nombres concretos de llamadas pueden variar según la biblioteca.

En el servidor comprueba que un periodo sin clientes utiliza poll y no un bucle de EOF. El escritor auxiliar mantiene el canal abierto; no indica que haya clientes reales. El uso de eventos de disponibilidad está documentado en poll(2).

Tras muchas solicitudes completadas, la cantidad de descriptores del servidor debe volver al mismo valor y en la raíz debe quedar solo peticiones. Este diseño no crea hijos, así que no necesita waitpid ni produce zombis como parte de su funcionamiento.

El servicio no ofrece persistencia, autenticación por cliente, tolerancia a emisores maliciosos ni recuperación automática de solicitudes desalineadas. Las FIFO transportan bytes y sus aperturas dependen de los extremos existentes, según fifo(7). Para aislamiento entre usuarios, autenticación del interlocutor o conexiones independientes más generales, los sockets Unix serán una alternativa del curso.

17. Resumen

18. Preguntas de repaso y ampliaciones

Responde antes de desplegar las explicaciones.

1. ¿Por qué la respuesta no usa una FIFO compartida entre todos?

Porque los lectores competirían por el flujo. Un cliente podría consumir bytes destinados a otro antes de descubrir su identificador.

2. ¿Qué evita que se mezclen dos peticiones?

Enviar cada registro entero en una sola llamada write cuyo tamaño no supera el PIPE_BUF comprobado. La falta de espacio se reintenta como unidad.

3. ¿Por qué el servidor acumula bytes si la escritura es atómica?

Porque la atomicidad evita entremezclar escrituras, pero no obliga a que read entregue el registro completo de una vez.

4. ¿Por qué abrir primero el lector de respuesta?

Para que el servidor encuentre un lector al abrir su escritor no bloqueante después de conocer la ruta. Así se evita depender de una apertura futura del cliente.

5. ¿Qué significa un EOF inicial para el cliente?

Que todavía no hay escritor ni contenido en ese instante. Como falta la respuesta esperada, el cliente conserva el lector y reintenta hasta su plazo.

6. ¿Por qué se mantiene un escritor auxiliar en el servidor?

Para evitar EOF y avisos persistentes de cierre entre solicitudes. El servicio delimita peticiones por sus registros, no por la presencia de clientes.

7. ¿Qué evita el plazo de un registro incompleto?

Que el servidor espere indefinidamente un sufijo que un emisor defectuoso nunca enviará, mientras su escritor auxiliar mantiene vivo el flujo.

8. ¿Por qué el nombre incluye un componente aleatorio y no solo el PID?

Para crear de forma exclusiva un directorio por invocación y evitar colisiones con nombres residuales o reutilización de PID.

9. ¿El servidor elimina una FIFO de respuesta si no puede abrirla?

No. Esa ruta pertenece al cliente. El servidor descarta la respuesta y no retira recursos que no creó.

10. ¿Por qué un reloj monotónico?

Porque el plazo mide tiempo transcurrido y no debe reiniciarse ni depender de ajustes del reloj de calendario.

11. ¿Un timeout permite reenviar sin riesgo una operación con efectos?

No. La primera solicitud pudo haberse procesado. Se necesitan identificadores, confirmaciones y una política de idempotencia o deduplicación.

12. ¿La parada con SIGTERM garantiza responder todo lo pendiente?

No. El código retira sus recursos y termina; los clientes pendientes pueden fallar o agotar el plazo. Una parada que drene trabajo requiere otro protocolo.

Para practicar y ampliar

  1. Ejecuta un cliente, diez concurrentes y cien sucesivos. Verifica los resultados, rutas restantes y cantidad de descriptores del servidor.
  2. Prueba texto vacío, espacios, 192 bytes y 193 bytes. Comprueba qué entradas se rechazan antes de crear recursos.
  3. Arranca un segundo servidor sobre la misma raíz y verifica que EEXIST no elimina la FIFO del primero.
  4. Simula un cliente que anuncia una respuesta sin lector. Comprueba que el servicio continúa atendiendo a otros.
  5. Simula una petición aceptada sin respuesta y verifica el plazo total del cliente y la eliminación de su directorio.
  6. Envía un registro completo con operación desconocida y un destino válido. Comprueba la respuesta de estado 1.
  7. En un laboratorio aislado, envía un prefijo de registro y comprueba la parada por plazo del servidor.
  8. Añade una operación para contar bytes. Define primero su resultado y cómo distinguirlo de la transformación actual.
  9. Diseña una parada que deje de aceptar clientes nuevos pero responda a solicitudes ya admitidas. Indica cómo se reconoce ese límite.
Próximo paso

Con este proyecto termina el bloque de FIFO. El tema 19 comparará mensajes con flujos de bytes y abrirá el estudio de las colas de mensajes POSIX y System V.