1. De un flujo a una conversación
En el tema 13 conectamos la salida de un comando con la entrada de otro. El contenido avanzaba en una dirección. Ahora un proceso solicitará trabajo y el otro devolverá el resultado: por ejemplo, un padre envía un bloque y un hijo transforma sus letras ASCII minúsculas en mayúsculas.
Una tubería POSIX tiene un extremo lector y otro escritor. Para disponer de dos direcciones utilizaremos dos canales independientes. No intentaremos leer desde el extremo escritor ni usaremos un único flujo compartido para que cada proceso adivine a quién pertenece el contenido.
Dos tuberías ofrecen dos flujos unidireccionales. La aplicación debe añadir las reglas de la conversación: formato, orden, límites, respuestas y cierre.
Llamaremos cliente al padre que solicita la transformación y trabajador al hijo que la realiza. Los roles describen este protocolo; ambos procesos tendrán un descriptor para leer y otro para escribir.
2. Crear y nombrar los dos canales
Los nombres deben expresar hacia dónde circulan los datos. Usaremos peticion para padre → hijo y respuesta para hijo → padre. En cada array, el índice 0 sigue siendo el lector y el índice 1, el escritor.
int peticion[2], respuesta[2];
if (pipe(peticion) == -1) {
perror("pipe peticion");
return EXIT_FAILURE;
}
if (pipe(respuesta) == -1) {
perror("pipe respuesta");
close(peticion[0]);
close(peticion[1]);
return EXIT_FAILURE;
}Crear el segundo canal no duplica el primero ni vincula automáticamente sus estados. Cada uno tiene sus propios bytes pendientes y referencias abiertas. Si falla el segundo pipe, hay que retirar los dos extremos del primero.
3. Plan de cierres después de fork
Tras fork, cada proceso hereda los cuatro descriptores. Cada uno necesita solo dos. El plan de cierres se escribe antes del bucle de comunicación:
| Proceso | Conserva para escribir | Conserva para leer | Cierra inmediatamente |
|---|---|---|---|
| Padre. | peticion[1]. | respuesta[0]. | peticion[0] y respuesta[1]. |
| Hijo. | respuesta[1]. | peticion[0]. | peticion[1] y respuesta[0]. |
Si el hijo conserva peticion[1], el cierre del padre no basta para que el hijo observe EOF. Si el padre conserva respuesta[1], puede esperar el cierre de un escritor que él mismo mantiene. El extremo sobrante tampoco debe quedarse abierto «por si acaso».
Al terminar una dirección, se cierra su escritor. El otro canal sigue disponible: cerrar peticion[1] no impide al padre leer respuesta[0]. El EOF de una tubería requiere agotar sus datos y que no queden escritores; las reglas se resumen en pipe(7).
4. Definir peticiones y respuestas
El protocolo del proyecto admite una sola petición pendiente. El padre envía un bloque, recibe su respuesta completa y recién entonces envía el siguiente. El hijo recibe una petición completa, la transforma y contesta antes de volver a leer.
| Fase | Padre | Hijo |
|---|---|---|
| Petición. | Escribe cabecera y contenido. | Lee cabecera y contenido. |
| Respuesta. | Lee cabecera y contenido. | Transforma y escribe el resultado. |
| Repetición. | Puede iniciar la siguiente petición. | Vuelve a esperar una cabecera. |
| Fin. | Cierra peticiones y espera EOF de respuestas. | Reconoce EOF entre peticiones, cierra respuestas y termina. |
Esta alternancia permite progresar incluso si una trama supera la capacidad del canal: mientras uno escribe, el otro ya está leyendo. El trabajador no comienza a emitir la respuesta hasta haber consumido toda la petición. No se exige que la trama quepa de una vez en la tubería.
No necesitamos identificadores porque solo existe una solicitud pendiente. Si permitiéramos varias simultáneas, habría que definir su asociación con las respuestas, el orden permitido y cuántas pueden acumularse.
5. Separar mensajes dentro del flujo
Un write no equivale a un mensaje recibido por un read. Para reconstruir unidades utilizaremos una cabecera de cuatro bytes que codifica la longitud, seguida exactamente por esa cantidad de bytes de contenido.
+----------------------+------------------------------+
| longitud: 4 bytes | contenido: longitud bytes |
+----------------------+------------------------------+
00 00 00 03 61 62 63 petición: 3 bytes, abc
00 00 00 03 41 42 43 respuesta: 3 bytes, ABCLa longitud máxima aceptada será 8192 bytes. El receptor valida la cabecera antes de llenar su búfer. Una longitud mayor se rechaza; no se utiliza como tamaño de reserva ni como orden de lectura ilimitada.
El protocolo admite longitud cero como mensaje vacío. Eso es distinto de EOF: todavía se han recibido cuatro bytes de cabecera. El cliente del proyecto no genera esas tramas porque termina al agotar su entrada, pero el receptor puede interpretarlas.
No enviamos una estructura de C directamente: su representación puede incluir relleno y depender del equipo. La codificación byte a byte fija el orden. El contenido no necesita terminador NUL y puede contener bytes cero o saltos de línea.
Solo transformaremos los bytes ASCII entre a y z. Las letras acentuadas y el resto de los bytes se conservan. Convertir texto Unicode correctamente requiere reglas adicionales que no pertenecen a este protocolo de transporte.
6. Transferencias parciales y EOF prematuro
La función leer_exacto acumulará bytes hasta completar una cantidad. Distinguirá tres resultados: 1 para éxito, 0 para EOF sin ningún byte y −1 para fallo. Si EOF aparece después de un prefijo, lo convertirá en EPROTO: la unidad quedó truncada. El receptor también tratará como error un EOF justo al comenzar un cuerpo que debía contener bytes.
Un retorno positivo menor que lo solicitado no es un error de read. EINTR sin progreso se reintenta; cualquier progreso ya informado se conserva. El contrato está en read(2).
escribir_todo avanzará por los bytes aceptados hasta completar el envío. Reintenta EINTR y devuelve error si no puede continuar. Un retorno cero inesperado se convierte en EIO para evitar un bucle sin progreso. Véase write(2).
Estas funciones resuelven transferencias parciales, pero no garantizan por sí solas que el interlocutor lea. Tampoco convierten varias llamadas en una escritura atómica. El protocolo tiene un solo escritor por canal y no depende de PIPE_BUF para separar mensajes.
7. Proyecto: un transformador por petición
El padre lee su entrada estándar en bloques de hasta 8192 bytes. Envía cada bloque como una petición y vuelca la respuesta en stdout. Los límites de esos bloques son decisiones de transporte: no corresponden necesariamente a líneas.
Este programa independiente ignora SIGPIPE para gestionar EPIPE como error de escritura y restablece SIGCHLD para recoger al hijo. No instala manejadores ni ejecuta otro programa. En cualquier ruta de error el padre cierra sus canales antes de waitpid, y el hijo termina al recibir EOF, una trama inválida o un error.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#define MAX_BLOQUE 8192
static int escribir_todo(int fd, const void *datos, size_t cantidad)
{
const unsigned char *p = datos;
size_t enviados = 0;
while (enviados < cantidad) {
ssize_t n = write(fd, p + enviados, cantidad - enviados);
if (n > 0)
enviados += (size_t)n;
else if (n == -1 && errno == EINTR)
continue;
else {
if (n == 0)
errno = EIO;
return -1;
}
}
return 0;
}
static int leer_exacto(int fd, void *datos, size_t cantidad)
{
unsigned char *p = datos;
size_t recibidos = 0;
while (recibidos < cantidad) {
ssize_t n = read(fd, p + recibidos, cantidad - recibidos);
if (n > 0)
recibidos += (size_t)n;
else if (n == 0) {
if (recibidos == 0)
return 0;
errno = EPROTO;
return -1;
} else if (errno != EINTR)
return -1;
}
return 1;
}
static int enviar_trama(int fd, const unsigned char *datos, uint32_t n)
{
if (n > MAX_BLOQUE) {
errno = EMSGSIZE;
return -1;
}
unsigned char cabecera[4] = {
(unsigned char)(n >> 24), (unsigned char)(n >> 16),
(unsigned char)(n >> 8), (unsigned char)n
};
if (escribir_todo(fd, cabecera, sizeof cabecera) == -1)
return -1;
return escribir_todo(fd, datos, n);
}
static int recibir_trama(int fd, unsigned char *datos, uint32_t *longitud)
{
unsigned char cabecera[4];
int r = leer_exacto(fd, cabecera, sizeof cabecera);
if (r != 1)
return r; /* EOF entre tramas o cabecera incompleta/error. */
uint32_t n = ((uint32_t)cabecera[0] << 24) |
((uint32_t)cabecera[1] << 16) |
((uint32_t)cabecera[2] << 8) | cabecera[3];
if (n > MAX_BLOQUE) {
errno = EMSGSIZE;
return -1;
}
if (n != 0) {
r = leer_exacto(fd, datos, n);
if (r != 1) {
if (r == 0)
errno = EPROTO;
return -1;
}
}
*longitud = n;
return 1;
}
static int trabajar(int entrada, int salida)
{
unsigned char bloque[MAX_BLOQUE];
uint32_t n;
for (;;) {
int r = recibir_trama(entrada, bloque, &n);
if (r == 0)
return EXIT_SUCCESS;
if (r == -1) {
perror("hijo: recibir peticion");
return EXIT_FAILURE;
}
for (uint32_t i = 0; i < n; ++i) {
if (bloque[i] >= 'a' && bloque[i] <= 'z')
bloque[i] = (unsigned char)(bloque[i] - 'a' + 'A');
}
if (enviar_trama(salida, bloque, n) == -1) {
perror("hijo: enviar respuesta");
return EXIT_FAILURE;
}
}
}
static int conversar(int salida, int entrada)
{
unsigned char bloque[MAX_BLOQUE], respuesta[MAX_BLOQUE];
for (;;) {
ssize_t n;
do {
n = read(STDIN_FILENO, bloque, sizeof bloque);
} while (n == -1 && errno == EINTR);
if (n == 0)
return EXIT_SUCCESS;
if (n == -1) {
perror("padre: leer stdin");
return EXIT_FAILURE;
}
if (enviar_trama(salida, bloque, (uint32_t)n) == -1) {
perror("padre: enviar peticion");
return EXIT_FAILURE;
}
uint32_t longitud;
int r = recibir_trama(entrada, respuesta, &longitud);
if (r != 1) {
if (r == 0)
errno = EPROTO; /* Falta una respuesta esperada. */
perror("padre: recibir respuesta");
return EXIT_FAILURE;
}
if (longitud != (uint32_t)n) {
fprintf(stderr, "padre: longitud de respuesta inesperada\n");
return EXIT_FAILURE;
}
if (escribir_todo(STDOUT_FILENO, respuesta, longitud) == -1) {
perror("padre: escribir stdout");
return EXIT_FAILURE;
}
}
}
int main(void)
{
struct sigaction accion = {0};
accion.sa_handler = SIG_IGN;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGPIPE, &accion, NULL) == -1) {
perror("preparar SIGPIPE");
return EXIT_FAILURE;
}
accion.sa_handler = SIG_DFL;
if (sigaction(SIGCHLD, &accion, NULL) == -1) {
perror("preparar SIGCHLD");
return EXIT_FAILURE;
}
int peticion[2], respuesta[2];
if (pipe(peticion) == -1) {
perror("pipe peticion");
return EXIT_FAILURE;
}
if (pipe(respuesta) == -1) {
perror("pipe respuesta");
close(peticion[0]);
close(peticion[1]);
return EXIT_FAILURE;
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
close(peticion[0]);
close(peticion[1]);
close(respuesta[0]);
close(respuesta[1]);
return EXIT_FAILURE;
}
if (hijo == 0) {
close(peticion[1]);
close(respuesta[0]);
int resultado = trabajar(peticion[0], respuesta[1]);
close(peticion[0]);
close(respuesta[1]);
_exit(resultado);
}
close(peticion[0]);
close(respuesta[1]);
int resultado = conversar(peticion[1], respuesta[0]);
close(peticion[1]); /* No habra mas peticiones. */
if (resultado == EXIT_SUCCESS) {
unsigned char sobrante[MAX_BLOQUE];
uint32_t longitud;
int r = recibir_trama(respuesta[0], sobrante, &longitud);
if (r != 0) {
if (r == -1)
perror("padre: fin de respuestas");
else
fprintf(stderr, "padre: respuesta no solicitada\n");
resultado = EXIT_FAILURE;
}
}
close(respuesta[0]); /* Tambien en las rutas de error. */
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
fprintf(stderr, "El trabajador no termino correctamente\n");
resultado = EXIT_FAILURE;
}
return resultado;
}El cliente comprueba que la respuesta tenga la misma longitud que su petición: esa propiedad forma parte del servicio de transformación. En otros servicios la respuesta podría tener un tamaño distinto y haría falta otro contrato.
El uso de sizeof bloque sirve para limitar una lectura; no significa que siempre lleguen 8192 bytes. El programa transporta exactamente el número devuelto por read. Toda la salida de resultados utiliza write y los diagnósticos van a stderr.
8. Probar texto, binarios y entradas grandes
Compila y ejecuta sobre Linux o WSL. Los comandos siguientes no requieren programas de C adicionales.
$ gcc -std=c17 -Wall -Wextra -Wpedantic dialogo_tuberias.c -o dialogo_tuberias
$ printf 'hola\nproceso 14\n' | ./dialogo_tuberias
HOLA
PROCESO 14
$ ./dialogo_tuberias < /dev/null | wc -c
0
$ printf 'a\000z\n' | ./dialogo_tuberias | od -An -t x1
41 00 5a 0aEl byte 00 permanece dentro del contenido. No termina una cadena ni indica EOF. Con entrada vacía no se envía ninguna petición: el padre cierra su escritor y el hijo reconoce un EOF limpio antes de la siguiente cabecera.
$ head -c 1048576 /dev/zero | tr '\000' 'a' > entrada14.bin
$ ./dialogo_tuberias < entrada14.bin > salida14.bin
$ echo $?
0
$ wc -c < salida14.bin
1048576
$ LC_ALL=C tr 'a-z' 'A-Z' < entrada14.bin > esperado14.bin
$ cmp salida14.bin esperado14.bin
$ echo $?
0La entrada total supera ampliamente la capacidad habitual de una tubería. El programa avanza por turnos y mantiene memoria acotada. El número de peticiones depende de cuánto devuelva cada lectura; no debe usarse como parte del resultado esperado.
En una terminal puedes introducir líneas y finalizar con Ctrl+D sobre una línea vacía. El padre puede esperar más entrada después de mostrar cada respuesta: ese estado es normal, porque aún no recibió EOF de su entrada.
Para probar el receptor frente a datos inválidos, prepara una variante del emisor que cierre tras dos bytes de cabecera, otra que anuncie un cuerpo y envíe solo un prefijo y otra que anuncie 8193 bytes. Deben detectarse, respectivamente, EPROTO, EPROTO y EMSGSIZE. Esa prueba debe modificar el emisor interno: los bytes que entran por stdin se encapsulan como contenido válido y no pasan a ser cabeceras.
9. Cerrar una dirección y completar la otra
El cierre normal se realiza después de recibir todas las respuestas esperadas. El padre cierra peticion[1], mantiene abierta respuesta[0] y comprueba que el trabajador cierre su escritor. Solo entonces cierra su lector y recoge al hijo.
- Agotar la entrada del padre. Ya no habrá nuevas solicitudes.
- Cerrar el escritor de peticiones. El hijo podrá observar EOF entre tramas.
- Confirmar el fin de respuestas. Un mensaje adicional sería una infracción del protocolo.
- Cerrar el lector y ejecutar waitpid. Se recoge el hijo y se comprueba su estado.
Cerrar una dirección no obliga a cerrar inmediatamente la otra. Esta separación permite protocolos que emiten un resumen final después del EOF de peticiones, aunque el nuestro no lo hace.
Ante un error local el padre retira ambas referencias antes de esperar. Así el hijo puede encontrar EOF al leer o EPIPE al escribir, en lugar de quedar esperando a un padre que dejó de participar. Como SIGPIPE está ignorada, el código puede tratar el error.
Eso no constituye una cancelación universal: si el trabajador estuviera realizando un cálculo infinito y nunca volviera al canal, el cierre no lo interrumpiría. Un supervisor de tareas arbitrarias necesitaría una política adicional de tiempos límite y cancelación.
10. Por qué dos escritores pueden detenerse
El diseño peligroso es simétrico: ambos envían toda su salida antes de comenzar a leer. Si los dos envíos superan lo que sus canales pueden almacenar, ambos pueden quedar detenidos dentro de write.
/* Padre */ /* Hijo */
escribir_todo(peticion, grande); escribir_todo(respuesta, grande);
leer_respuesta(); leer_peticion();El padre necesita que el hijo lea peticiones para liberar espacio. El hijo necesita que el padre lea respuestas por la misma razón. Ninguno puede alcanzar su lectura sin completar antes la escritura que depende del otro.
También existe un bloqueo sin canales llenos: si ambos comienzan leyendo y ninguno envía el primer mensaje. Hay que definir quién inicia. Otro caso es esperar EOF de una petición para responder mientras el padre espera la respuesta antes de cerrar esa petición.
La capacidad mayor solo retrasa el punto de detención. PIPE_BUF tampoco evita la dependencia circular: una escritura pequeña puede esperar si el canal no tiene espacio. El problema es el orden de las operaciones y las condiciones necesarias para avanzar.
11. Experimento: provocar el interbloqueo
Este laboratorio es intencionalmente incorrecto. Cada proceso consulta la capacidad nominal de su canal de salida con F_GETPIPE_SZ e intenta escribir un byte más antes de leer. Ninguno puede terminar ese envío mientras el otro siga sin consumir.
Se utiliza una extensión de Linux y no se presupone una capacidad fija. Las reglas y limitaciones de la consulta están en F_GETPIPE_SZ(2const). El tamaño del búfer local de 4096 bytes no representa la capacidad total del canal.
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
static int enviar_antes_de_leer(int salida, int entrada, const char *rol)
{
int capacidad = fcntl(salida, F_GETPIPE_SZ);
if (capacidad == -1) {
perror("F_GETPIPE_SZ");
return EXIT_FAILURE;
}
size_t pendientes = (size_t)capacidad + 1;
unsigned char bloque[4096] = {0};
fprintf(stderr, "%s: intenta enviar %zu bytes antes de leer\n",
rol, pendientes);
while (pendientes > 0) {
size_t cantidad = pendientes < sizeof bloque ?
pendientes : sizeof bloque;
ssize_t n = write(salida, bloque, cantidad);
if (n > 0)
pendientes -= (size_t)n;
else if (n == -1 && errno == EINTR)
continue;
else {
if (n == 0)
errno = EIO;
perror("write");
return EXIT_FAILURE;
}
}
/* Con ambos procesos siguiendo el protocolo, no llegamos aqui. */
unsigned char byte;
ssize_t n;
do {
n = read(entrada, &byte, 1);
} while (n == -1 && errno == EINTR);
return n == 1 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(void)
{
int peticion[2], respuesta[2];
if (pipe(peticion) == -1) {
perror("pipe peticion");
return EXIT_FAILURE;
}
if (pipe(respuesta) == -1) {
perror("pipe respuesta");
close(peticion[0]);
close(peticion[1]);
return EXIT_FAILURE;
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
close(peticion[0]);
close(peticion[1]);
close(respuesta[0]);
close(respuesta[1]);
return EXIT_FAILURE;
}
if (hijo == 0) {
close(peticion[1]);
close(respuesta[0]);
int r = enviar_antes_de_leer(respuesta[1], peticion[0], "Hijo");
close(respuesta[1]);
close(peticion[0]);
_exit(r);
}
close(peticion[0]);
close(respuesta[1]);
int resultado = enviar_antes_de_leer(peticion[1], respuesta[0], "Padre");
close(peticion[1]);
close(respuesta[0]);
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
return resultado == EXIT_SUCCESS && WIFEXITED(estado) &&
WEXITSTATUS(estado) == EXIT_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic bloqueo_doble.c -o bloqueo_doble
$ timeout --kill-after=1s 2s ./bloqueo_doble
Padre: intenta enviar ... bytes antes de leer
Hijo: intenta enviar ... bytes antes de leer
$ echo $?
124Las cantidades y el orden de los mensajes pueden variar. GNU timeout, sin --foreground, permite señalar al grupo del comando; así esta prueba no se limita a terminar solo al padre. El 124 indica el vencimiento normal del plazo. Si fuera necesaria la escalada a SIGKILL, el estado puede ser distinto.
El tiempo límite permite recuperar el control, pero no arregla el programa. Compara el laboratorio con dialogo_tuberias: en el proyecto correcto el hijo ya consume mientras el padre envía, y el padre consume mientras el hijo responde.
12. Diseñar para permitir el progreso
| Estrategia | Qué permite | Qué hay que definir |
|---|---|---|
| Una petición y una respuesta por turno. | Lecturas y escrituras bloqueantes con un orden sencillo. | Inicio, límites y respuesta esperada. Es la estrategia del proyecto. |
| Dividir trabajo en bloques con confirmación. | Controlar cuántos datos quedan pendientes. | Tamaño, secuencia, confirmaciones y memoria máxima. |
| E/S no bloqueante con poll. | Atender lectura y escritura según disponibilidad. | Estado parcial de cada trama, colas acotadas y manejo de EAGAIN. |
| Lectura y escritura en tareas separadas. | Consumir mientras otra tarea produce. | Sincronización, errores compartidos, cancelación y cierre. |
Configurar O_NONBLOCK por sí solo no completa la solución: si write devuelve EAGAIN hay que conservar el sufijo pendiente, permitir que avance la recepción y esperar un evento útil. Reintentar sin espera puede consumir CPU sin resolver la dependencia.
poll permite esperar disponibilidad sobre varios descriptores. POLLOUT no promete que quepa una trama arbitrariamente grande; POLLHUP puede coexistir con datos que todavía deben leerse. Estas reglas se desarrollarán en el bloque de multiplexación y se documentan en poll(2).
Dos canales ofrecen la posibilidad de tráfico simultáneo, pero nuestro protocolo usa turnos. Si un servicio necesita notificaciones espontáneas o múltiples peticiones pendientes, debe cambiar su máquina de estados y gestionar la contrapresión en ambas direcciones.
13. Simular turnos y canales llenos
El modelo tiene capacidad de cuatro unidades en cada canal. Compara un intercambio por turnos con dos emisores que intentan enviar seis unidades antes de leer. Cada paso representa un progreso posible; las unidades y los tamaños no son valores reales de Linux.
PadreListo para enviar petición
HijoListo para leer petición
Canal de peticiones0/4 unidades
Canal de respuestas0/4 unidades
Avanza para observar el primer envío.
En el intercambio por turnos también se envían seis unidades, más que la capacidad del modelo. La diferencia es que el receptor consume antes de exigir una respuesta. En el otro caso, al llenarse los canales nadie ha llegado a su fase de lectura.
14. Diagnosticar bloqueos y fallos
$ printf 'abc\n' | strace -f -o dialogo14.log ./dialogo_tuberias
ABC
$ less dialogo14.logLocaliza los dos canales, los cierres después de fork, las cabeceras de cuatro bytes, los contenidos y el EOF final. No esperes que cada trama produzca exactamente una lectura. Según la biblioteca, pipe puede aparecer como pipe2 y fork como clone.
Para observar el interbloqueo, ejecuta el segundo laboratorio bajo strace y un límite de tiempo: timeout --kill-after=1s 2s strace -f -o bloqueo14.log ./bloqueo_doble. Busca las escrituras que no completan y comprueba que ninguna rama alcanzó su lectura.
| Síntoma | Hipótesis que comprobar |
|---|---|
| Ambos esperan dentro de write. | Los dos envían antes de consumir; los canales están llenos. |
| Ambos esperan dentro de read. | No se definió quién inicia o falta el cierre que permitiría EOF. |
| El trabajador no termina al agotar stdin del padre. | El padre no cerró peticiones o el hijo conservó peticion[1]. |
| El padre no observa fin de respuestas. | Queda un escritor, quizá respuesta[1] en el propio padre. |
| Se informa EPROTO. | Cabecera/cuerpo truncado, o EOF cuando faltaba una respuesta. |
| Se informa EMSGSIZE. | La longitud anunciada supera el máximo; no confíes en ella para reservar memoria. |
| Se informa EPIPE. | Ya no quedan lectores en esa dirección; revisa el error o cierre del interlocutor. |
| Una prueba pequeña funciona y una grande se detiene. | El orden dependía accidentalmente de que todo cupiera en el canal. |
El estado del proceso no basta para explicar la espera. Anota qué operación ejecuta, en qué canal, cuántos bytes faltan y qué participante debe actuar para permitir su progreso. Ese pequeño grafo de dependencias suele revelar el ciclo.
15. Resumen
- Dos tuberías proporcionan dos direcciones independientes entre padre e hijo.
- Cada proceso conserva un lector y un escritor; los otros extremos se cierran tras fork.
- El protocolo fija quién inicia, cuánto se lee y cuándo se responde.
- La cabecera de longitud reconstruye mensajes y permite limitar su tamaño.
- Las lecturas y escrituras parciales requieren conservar el progreso; un EOF a mitad de trama es un fallo.
- Una sola petición pendiente simplifica la asociación con su respuesta y el razonamiento de progreso.
- El cierre de peticiones y el fin de respuestas son pasos diferentes.
- Si ambos escriben demasiado antes de leer, pueden bloquearse mutuamente.
- Más capacidad y sleep no corrigen un protocolo con dependencias circulares.
16. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿Por qué usamos dos tuberías?
Cada tubería POSIX ofrece una dirección. Una lleva peticiones y la otra devuelve respuestas.
2. ¿Cuántos extremos conserva cada participante?
Dos: el padre escribe peticiones y lee respuestas; el hijo lee peticiones y escribe respuestas. Cada uno cierra los otros dos.
3. ¿Un write de cabecera y cuerpo garantiza una sola lectura?
No. El receptor debe acumular la cabecera y después la cantidad de contenido anunciada, independientemente de cómo se dividan los read.
4. ¿Una trama de longitud cero significa EOF?
No. Tiene una cabecera válida de cuatro bytes y contenido vacío. EOF es un resultado de read al terminar el flujo.
5. ¿Por qué se valida el máximo antes de leer el cuerpo?
Para evitar que un tamaño anunciado exceda el búfer y para mantener acotados los recursos del protocolo.
6. ¿Qué distingue un EOF limpio de una trama truncada?
El limpio aparece entre tramas cuando no falta una respuesta. Si ya se recibió parte de una unidad o se prometió un cuerpo incompleto, el flujo terminó prematuramente.
7. ¿La petición debe caber entera en el canal?
No con este orden. El hijo lee mientras el padre envía, liberando espacio. El hijo termina de recibir antes de responder.
8. ¿escribir_todo evita cualquier interbloqueo?
No. Conserva el progreso de escritura, pero puede esperar indefinidamente si el protocolo no permite que el otro proceso lea.
9. ¿Por qué el padre cierra peticiones antes de esperar el EOF de respuestas?
Para que el hijo pueda observar que no habrá más solicitudes, salir de su bucle y cerrar el escritor de respuestas.
10. ¿Por qué no basta con aumentar la capacidad?
Porque los dos emisores pueden superar también el nuevo límite. La dependencia circular sigue existiendo.
11. ¿Qué aporta ignorar SIGPIPE en el proyecto?
Permite tratar la desaparición de lectores mediante el retorno EPIPE de write y recorrer las rutas de limpieza. Es una política de este programa independiente.
12. ¿Pueden enviarse varias solicitudes sin esperar?
Eso requeriría otro protocolo: límites de solicitudes pendientes, asociación con respuestas y capacidad de consumir mientras se mantiene una salida pendiente.
Para practicar
- Dibuja los cuatro descriptores tras fork y marca los dos que cierra cada proceso. Explica qué fuga impediría cada EOF.
- Ejecuta el proyecto con entrada vacía, texto, bytes cero y un archivo de un MiB. Compara el contenido con una transformación independiente.
- Reduce MAX_BLOQUE a 7 en ambos participantes. Verifica que el resultado siga siendo el mismo aunque cambien las fronteras entre peticiones.
- En una copia del programa, envía cabeceras fragmentadas byte a byte. Comprueba que recibir_trama las reconstruye.
- Introduce una cabecera truncada, un cuerpo incompleto y una longitud excesiva. Comprueba el diagnóstico y la recolección del hijo.
- Ejecuta bloqueo_doble con el timeout indicado. Explica qué lectura necesita cada escritor para salir de su espera.
- Diseña una variante que devuelva el número de letras modificadas además del bloque. Define la nueva respuesta antes de cambiar el código.
- Propón una conversación en la que el hijo envíe un resumen después del EOF de peticiones. Indica qué lector debe seguir abierto y hasta cuándo.
El tema 15 integrará creación de procesos, redirecciones y planes de cierres en el proyecto de una shell con pipelines de varios comandos.