1. Qué vamos a construir
El tema 33 utilizó un servicio con ruta y mensajes enmarcados para mantener varias peticiones dentro de una conexión. Aquí cambia el escenario: un proceso crea el canal antes de fork y entrega un extremo al hijo mediante la herencia de descriptores.
El padre envía entre cero y 4096 bytes, termina su dirección de envío y espera el resultado. El hijo lee hasta EOF, transforma las letras ASCII minúsculas en mayúsculas, envía el cuerpo completo y termina su propia dirección de envío. El padre verifica contenido, longitud y terminación antes de informar éxito.
Un socket conectado tiene dos direcciones de comunicación. Terminar el envío local permite que el interlocutor alcance EOF en su recepción, mientras la dirección inversa puede seguir transportando una respuesta.
| Decisión | Regla del laboratorio | Consecuencia |
|---|---|---|
| Canal. | AF_UNIX, SOCK_STREAM, sin nombre. | No hay ruta, bind, listen ni accept. |
| Participantes. | Un padre y un hijo creado con fork. | Hay que cerrar los extremos sobrantes en ambos. |
| Fin de petición. | EOF después de shutdown con SHUT_WR. | Solo hay una petición por dirección de envío. |
| Respuesta. | Misma longitud, transformación ASCII y EOF. | La recepción completa se verifica en la aplicación. |
| Recursos. | Búferes acotados y espera de E/S por llamada. | No se espera ni reserva una entrada de tamaño ilimitado. |
La transformación no interpreta Unicode ni necesita un terminador NUL dentro del flujo. El argumento de la terminal sí se mide con strlen. Para transmitir un NUL interno habría que modificar la fuente de entrada; el canal y las funciones de E/S trabajan con bytes y longitudes.
2. Crear un par ya conectado
#include <sys/socket.h>
int par[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, par) == -1) {
perror("socketpair");
/* No usar par como si la creacion hubiera tenido exito. */
}
/* En caso de exito, par[0] y par[1] ya estan conectados. */El retorno es cero en éxito y −1 en error. Los dos descriptores se escriben en el arreglo; ninguno es «el descriptor de lectura» de una tubería: ambos pueden enviar y recibir. Los bytes enviados por par[0] se reciben en par[1], y los enviados por par[1] se reciben en par[0]. Véase socketpair(2).
El cero del tercer argumento solicita el protocolo predeterminado para esta familia y tipo. El arreglo contiene dos enteros locales; los números concretos dependen de qué descriptores estaban libres. No conviene suponer que siempre serán tres y cuatro.
El par del laboratorio no crea una entrada en el sistema de archivos ni necesita unlink. Tampoco publica una dirección a la que cualquier programa pueda hacer connect. Otro participante necesita obtener una referencia: por herencia o mediante una transferencia de descriptores, que estudiaremos en el tema 35.
Elegir SOCK_STREAM conserva las reglas del tema anterior: los envíos no son mensajes indivisibles y las recepciones pueden ser parciales. Crear el canal de una vez simplifica el establecimiento de la conexión, pero no sustituye un protocolo.
3. Un par frente a dos tuberías y un servidor
| Mecanismo | Preparación | Uso habitual en este curso |
|---|---|---|
| Dos pipe. | Cuatro descriptores iniciales; cada tubería tiene una dirección. | Redirecciones y diálogo de programas mediante entrada/salida estándar. |
| socketpair STREAM. | Dos extremos conectados y bidireccionales. | Supervisor y trabajador que reciben el canal por herencia. |
| Socket Unix con ruta. | Publicar dirección, escuchar, conectar y aceptar. | Clientes que arrancan de forma independiente y descubren un servicio. |
Con dos tuberías, cerrar la escritura de una no elimina el descriptor de lectura de la otra. En un socket bidireccional, close sobre la única referencia local elimina también la posibilidad de leer la respuesta. shutdown permite expresar el final de una sola dirección conservando el descriptor.
Un par también permite las operaciones específicas de sockets que requieren otros diseños de IPC. Este tema se concentra en datos y terminación; el envío de descriptores y las credenciales quedan para el siguiente.
4. fork y las cuatro referencias iniciales
Después de fork, padre e hijo poseen una entrada para cada uno de los dos extremos. Eso deja cuatro referencias de descriptor en total, aunque solo existen dos extremos de socket. Cada proceso debe elegir el suyo y cerrar inmediatamente el que pertenece al otro.
pid_t hijo = fork();
if (hijo == 0) {
close(par[0]); /* El hijo utiliza B. */
/* Trabajar con par[1]. */
} else if (hijo > 0) {
close(par[1]); /* El padre utiliza A. */
/* Trabajar con par[0]. */
} else {
/* Fallo de fork: el proceso original sigue teniendo ambos. */
close(par[0]);
close(par[1]);
}La copia sobrante no es inofensiva. Si el hijo conserva A y el padre cierra A, B aún tiene un interlocutor referenciado dentro del propio hijo. Una lectura puede quedarse esperando un final que la aplicación creía haber provocado.
El error inverso también existe: si el padre conserva B, la muerte del hijo no retira la última referencia a B. Para razonar sobre cierres, dibuja las referencias de todos los procesos, incluidos nietos y programas ejecutados después.
5. Qué cierra realmente close
close retira una entrada de la tabla de descriptores del proceso que lo llama. El número queda disponible para reutilizarse. Cuando desaparece la última referencia al recurso subyacente se libera ese recurso; una copia creada con dup o heredada con fork puede mantenerlo vivo. Consulta close(2).
int copia = dup(fd);
/* Comprobar copia != -1 antes de continuar. */
close(fd);
/* copia sigue refiriendose al mismo extremo. */El envío y la recepción pertenecen al extremo, no a la variable de C. Asignar −1 después de cerrar ayuda a que el programa no reutilice por error una variable, pero esa asignación no cierra ninguna copia ni modifica las tablas de otros procesos.
En los ejemplos se informa un fallo de close y no se repite ciegamente la llamada. En Linux, reintentar con el mismo número puede cerrar otro recurso si el número ya fue liberado y reutilizado. No debe copiarse el bucle de reintento de recv a close sin estudiar sus reglas.
6. Cerrar una dirección con shutdown
if (shutdown(fd, SHUT_WR) == -1) {
perror("shutdown SHUT_WR");
}
/* fd sigue abierto: se puede recibir la respuesta. */| Operación | Efecto local | Qué queda pendiente |
|---|---|---|
| shutdown(fd, SHUT_WR). | Inhabilita nuevos envíos desde ese extremo. | Recibir datos y cerrar después el descriptor. |
| shutdown(fd, SHUT_RD). | Inhabilita futuras recepciones de aplicación. | No debe usarse para recoger una respuesta pendiente. |
| shutdown(fd, SHUT_RDWR). | Inhabilita ambas direcciones locales. | close sigue siendo necesario. |
| close(fd). | Retira ese descriptor. | Puede haber otras referencias al mismo extremo. |
shutdown devuelve cero o −1 con errno. Su argumento how debe ser una constante válida. La interfaz y sus errores se documentan en shutdown(2).
El cambio afecta al socket compartido por sus alias. Si dos descriptores apuntan a A y uno ejecuta SHUT_WR, el otro tampoco permite seguir enviando por A. No es una alternativa para cerrar únicamente una copia sobrante tras fork: para retirar esa referencia se utiliza close.
No hay una operación que «reabra» la escritura después de SHUT_WR. El protocolo debe decidir cuándo es definitivo el final. SHUT_RD tampoco es una petición para que el otro proceso termine, una confirmación de lectura ni una forma portable de conservar datos para leerlos más tarde.
Estas reglas se aplican aquí a una conexión STREAM. No traslades el uso de EOF como delimitador a SOCK_DGRAM: un datagrama de longitud cero tiene su propio significado y no equivale al cierre ordenado de un flujo.
7. Datos pendientes, EOF y errores
Con un búfer de capacidad positiva, recv distingue tres clases de resultado. Su interpretación requiere mirar el retorno antes de consultar errno; el valor de errno no se borra automáticamente después de una llamada exitosa.
| Resultado | Interpretación en STREAM | Acción del ejemplo |
|---|---|---|
| n > 0. | Se retiraron n bytes, quizá menos de los pedidos. | Acumularlos y continuar. |
| n == 0. | Final de la dirección de entrada. | Validar si ese final completa el contrato. |
| n == −1, EINTR. | La llamada fue interrumpida. | Reintentar conservando progreso anterior. |
| n == −1, EAGAIN/EWOULDBLOCK. | No pudo avanzar según la modalidad o espera configurada. | En este programa bloqueante con timeout, fallar la conversación. |
| Otro error. | Fallo de recepción. | Informar, limpiar y recoger al hijo. |
El cierre de envío no borra los bytes previamente aceptados por el flujo. Si A envía hola y hace SHUT_WR, B puede recibir ho, luego la y finalmente cero. No tiene por qué recibir todo en una llamada. El contrato de recepción se detalla en recv(2).
Una llamada con longitud cero no sirve para detectar EOF. El programa siempre pide al menos un byte; incluso al alcanzar el máximo hace una recepción adicional en un búfer auxiliar para distinguir «exactamente el máximo y después EOF» de «hay un byte excesivo».
EOF no significa necesariamente que murió el otro proceso. El interlocutor puede haber ejecutado SHUT_WR y estar esperando su respuesta. Tampoco confirma que una tarea se realizó correctamente: eso depende del contenido recibido y del contrato de aplicación.
En el protocolo del tema 33, EOF a mitad de una trama era truncamiento. En este tema el cuerpo de petición termina por EOF, así que cualquier longitud dentro del límite es una entrada completa. Elegimos otra regla de enmarcado de forma explícita.
8. Petición hasta EOF y respuesta posterior
PADRE (A) HIJO (B)
enviar peticion --------------------> acumular bytes
shutdown(A, SHUT_WR) ----------------> recv devuelve 0 tras los datos
transformar peticion completa
recibir respuesta <------------------ enviar resultado
recv devuelve 0 <------------------ shutdown(B, SHUT_WR)
validar resultado close(B), _exit
close(A)
waitpid(hijo)La regla que permite progresar es que el padre marca el final antes de esperar la respuesta. Si ambos participantes empiezan esperando EOF sin terminar ningún envío, ninguno tiene motivos para dejar de esperar.
No se puede enviar una segunda petición por A después del cierre de escritura. Para varias solicitudes se necesita otro par o un formato con longitudes o delimitadores, como el del tema 33, reservando SHUT_WR para el final de la sesión.
El padre lee antes de waitpid. Esperar primero al hijo puede bloquear el diálogo si el hijo necesita que alguien retire su respuesta para completar el envío y terminar. La recogida del proceso y el drenaje de sus datos son tareas distintas.
9. Programa completo entre padre e hijo
Guarda el siguiente archivo como dialogo34.c. Es autónomo: no necesita las cabeceras de apoyo de temas anteriores. Se ejecuta en Linux con una biblioteca C que proporcione las interfaces usadas.
Las funciones de envío avanzan por resultados positivos. La recepción acumula como máximo 4096 bytes y no añade NUL. El padre calcula también el resultado esperado, comprueba todos sus bytes y exige salida exitosa del hijo.
#define _POSIX_C_SOURCE 200809L
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_DATOS 4096u
static int cerrar(int fd)
{
if (close(fd) == -1) {
perror("close");
return -1; /* No reintentar close en Linux. */
}
return 0;
}
static int limitar_espera(int fd)
{
struct timeval tv = { .tv_sec = 3, .tv_usec = 0 };
if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO,
&tv, sizeof tv) == -1 ||
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO,
&tv, sizeof tv) == -1) {
perror("setsockopt");
return -1;
}
return 0;
}
static int enviar_todo(int fd, const unsigned char *p, size_t total)
{
size_t hechos = 0;
while (hechos < total) {
ssize_t n = send(fd, p + hechos, total - hechos, MSG_NOSIGNAL);
if (n > 0) {
hechos += (size_t)n;
} else if (n == -1 && errno == EINTR) {
continue;
} else {
if (n == 0) errno = EIO;
perror("send");
return -1;
}
}
return 0;
}
static int recibir_hasta_eof(int fd, unsigned char *p, size_t *total)
{
size_t usados = 0;
for (;;) {
unsigned char extra;
void *destino = usados < MAX_DATOS ? p + usados : &extra;
size_t espacio = usados < MAX_DATOS ? MAX_DATOS - usados : 1;
ssize_t n = recv(fd, destino, espacio, 0);
if (n > 0) {
if (usados == MAX_DATOS) {
fprintf(stderr, "Entrada mayor que %u bytes\n", MAX_DATOS);
return -1;
}
usados += (size_t)n;
} else if (n == 0) {
*total = usados;
return 0;
} else if (errno != EINTR) {
perror("recv");
return -1;
}
}
}
static void mayus_ascii(unsigned char *p, size_t n)
{
for (size_t i = 0; i < n; ++i)
if (p[i] >= 'a' && p[i] <= 'z')
p[i] = (unsigned char)(p[i] - 'a' + 'A');
}
static int terminar_envio(int fd)
{
if (shutdown(fd, SHUT_WR) == -1) {
perror("shutdown SHUT_WR");
return -1;
}
return 0;
}
static int trabajar(int fd)
{
unsigned char datos[MAX_DATOS];
size_t n;
if (recibir_hasta_eof(fd, datos, &n) == -1) return -1;
mayus_ascii(datos, n);
if (enviar_todo(fd, datos, n) == -1) return -1;
return terminar_envio(fd);
}
int main(int argc, char **argv)
{
const char *texto = argc == 2 ? argv[1] : "hola desde socketpair";
if (argc > 2) {
fprintf(stderr, "Uso: %s [texto]\n", argv[0]);
return EXIT_FAILURE;
}
size_t longitud = strlen(texto);
if (longitud > MAX_DATOS) {
fprintf(stderr, "Maximo: %u bytes\n", MAX_DATOS);
return EXIT_FAILURE;
}
int par[2];
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) {
perror("socketpair");
return EXIT_FAILURE;
}
if (limitar_espera(par[0]) == -1 || limitar_espera(par[1]) == -1) {
cerrar(par[0]); cerrar(par[1]);
return EXIT_FAILURE;
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
cerrar(par[0]); cerrar(par[1]);
return EXIT_FAILURE;
}
if (hijo == 0) {
int fallo = cerrar(par[0]) == -1;
if (!fallo && trabajar(par[1]) == -1) fallo = 1;
if (cerrar(par[1]) == -1) fallo = 1;
_exit(fallo ? EXIT_FAILURE : EXIT_SUCCESS);
}
int fallo = cerrar(par[1]) == -1;
unsigned char respuesta[MAX_DATOS], esperado[MAX_DATOS];
size_t recibidos = 0;
memcpy(esperado, texto, longitud);
mayus_ascii(esperado, longitud);
if (!fallo && enviar_todo(par[0],
(const unsigned char *)texto, longitud) == -1)
fallo = 1;
if (!fallo && terminar_envio(par[0]) == -1) fallo = 1;
if (!fallo && recibir_hasta_eof(par[0], respuesta, &recibidos) == -1)
fallo = 1;
if (!fallo && (recibidos != longitud ||
memcmp(respuesta, esperado, longitud) != 0)) {
fprintf(stderr, "Respuesta incompatible\n");
fallo = 1;
}
if (cerrar(par[0]) == -1) fallo = 1;
int estado;
pid_t r;
do {
r = waitpid(hijo, &estado, 0);
} while (r == -1 && errno == EINTR);
if (r == -1) {
perror("waitpid");
fallo = 1;
} else if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
fprintf(stderr, "El hijo no termino correctamente\n");
fallo = 1;
}
if (fallo) return EXIT_FAILURE;
printf("Respuesta verificada: %zu bytes: ", recibidos);
if (fwrite(respuesta, 1, recibidos, stdout) != recibidos ||
putchar('\n') == EOF || fflush(stdout) == EOF) {
perror("salida");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}Por qué estas decisiones forman parte del ejemplo
El límite se comprueba antes de crear el par y también al recibir. Una entrada que llena exactamente el búfer se acepta solo si la recepción siguiente devuelve EOF. No se escribe fuera de los arreglos ni se interpreta un bloque recibido como una cadena terminada en cero.
Se configuran los dos extremos antes de fork. Cada uno conserva sus opciones cuando el proceso que lo utilizará lo hereda. Los tres segundos son una espera por llamada bloqueante, no un plazo absoluto para toda la conversación.
El hijo utiliza _exit para no ejecutar la finalización de stdio heredada del padre. El padre recoge su estado incluso después de un fallo de intercambio. No usa el estado de salida del hijo como sustituto de la validación de los bytes.
10. Compilar y comprobar resultados
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 dialogo34.c -o dialogo34
$ ./dialogo34
Respuesta verificada: 21 bytes: HOLA DESDE SOCKETPAIR
$ ./dialogo34 "hola"
Respuesta verificada: 4 bytes: HOLA
$ ./dialogo34 ""
Respuesta verificada: 0 bytes:
$ ./dialogo34 "acción"
Respuesta verificada: 7 bytes: ACCIóN
$ echo $?
0La longitud del último ejemplo presupone una terminal que suministra UTF-8. La ó ocupa dos bytes y permanece igual: solo cambiamos bytes ASCII entre a y z. Una cadena vacía no envía datos, pero sí necesita SHUT_WR para que el hijo reconozca el final de la petición.
$ texto=$(python3 -c 'print("a" * 4096, end="")')
$ timeout 10s ./dialogo34 "$texto" > /dev/null
$ echo $?
0
$ texto=$(python3 -c 'print("a" * 4097, end="")')
$ ./dialogo34 "$texto"
Maximo: 4096 bytes
$ echo $?
1timeout impone un límite externo al ensayo y no es parte del protocolo. Un código 124 indica que esa herramienta agotó su espera. No se debe presentar como un rechazo normal de entrada ni como una respuesta correcta del hijo.
11. Experimento con un descriptor duplicado
El siguiente programa conserva dos referencias al extremo A. Primero cierra la original y comprueba que B sigue sin tener EOF. Después termina el envío por la copia, observa EOF en B y prueba que B todavía puede enviar una respuesta a A.
Usamos MSG_DONTWAIT únicamente en la comprobación inicial para obtener un resultado inmediato sin detener el laboratorio. No cambia permanentemente el modo del socket. La E/S no bloqueante se desarrollará en el tema 36.
#define _POSIX_C_SOURCE 200809L
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int par[2];
int copia = -1;
int fallo = 1;
char byte;
ssize_t n;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, par) == -1) {
perror("socketpair"); return EXIT_FAILURE;
}
copia = dup(par[0]);
if (copia == -1) { perror("dup"); goto fin; }
int original = par[0];
par[0] = -1; /* No volver a cerrar este numero. */
if (close(original) == -1) { perror("close"); goto fin; }
do {
n = recv(par[1], &byte, 1, MSG_DONTWAIT);
} while (n == -1 && errno == EINTR);
if (n != -1 || (errno != EAGAIN && errno != EWOULDBLOCK)) {
fprintf(stderr, "Se esperaba ausencia temporal de datos\n");
goto fin;
}
puts("close(original): sin datos y sin EOF; la copia sigue abierta");
if (shutdown(copia, SHUT_WR) == -1) {
perror("shutdown"); goto fin;
}
do {
n = recv(par[1], &byte, 1, MSG_DONTWAIT);
} while (n == -1 && errno == EINTR);
if (n != 0) {
fprintf(stderr, "Se esperaba EOF en B\n"); goto fin;
}
puts("shutdown(copia, SHUT_WR): B observa EOF");
do {
n = send(copia, "x", 1, MSG_NOSIGNAL);
} while (n == -1 && errno == EINTR);
if (n != -1 || errno != EPIPE) {
fprintf(stderr, "Se esperaba EPIPE al enviar desde A\n"); goto fin;
}
puts("Enviar desde A despues de SHUT_WR: EPIPE");
do {
n = send(par[1], "R", 1, MSG_NOSIGNAL);
} while (n == -1 && errno == EINTR);
if (n != 1) { perror("send respuesta"); goto fin; }
do {
n = recv(copia, &byte, 1, MSG_DONTWAIT);
} while (n == -1 && errno == EINTR);
if (n != 1 || byte != 'R') {
fprintf(stderr, "No se recibio la respuesta esperada\n"); goto fin;
}
puts("La direccion B hacia A sigue entregando la respuesta R");
fallo = 0;
fin:
if (par[0] != -1 && close(par[0]) == -1) fallo = 1;
if (copia != -1 && close(copia) == -1) fallo = 1;
if (close(par[1]) == -1) fallo = 1;
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 referencias34.c -o referencias34
$ ./referencias34
close(original): sin datos y sin EOF; la copia sigue abierta
shutdown(copia, SHUT_WR): B observa EOF
Enviar desde A despues de SHUT_WR: EPIPE
La direccion B hacia A sigue entregando la respuesta REl experimento se ejecuta en un solo proceso para controlar todas las referencias. Con fork aparece el mismo problema de propiedad distribuido entre procesos. Lo que importa es a qué extremo apunta cada entrada, no si sus números son iguales o diferentes.
Como ampliación, crea dos copias, aplica SHUT_WR mediante una y prueba send mediante la otra. Ambas comparten el estado de envío del mismo extremo. En cambio, cerrar una de ellas deja a la otra disponible hasta que se cierre o se inhabilite la dirección.
12. SIGPIPE, EPIPE y límites de la confirmación
Intentar enviar por una dirección que ya se cerró puede producir EPIPE y SIGPIPE. La acción predeterminada de esa señal puede terminar el proceso antes de que su código gestione el error. Los ejemplos usan send con MSG_NOSIGNAL para suprimir la señal en esa llamada y comprobar el retorno.
MSG_NOSIGNAL no transforma un envío fallido en éxito ni suprime errno. Tampoco configura las llamadas write que se hagan en otro lugar. Una política global con sigaction y SIG_IGN tiene alcance sobre el proceso y debe decidirse explícitamente. Véase send(2).
Después del SHUT_WR local, el experimento exige EPIPE al intentar enviar un byte. Para una caída o cierre remoto en un escenario distinto, no debe prometerse que cualquier fallo aparecerá siempre con ese único código: la aplicación debe gestionar los demás errores del transporte.
Un send completo indica que la llamada aceptó los bytes; no demuestra que el otro proceso los consumió o realizó una operación. shutdown tampoco agrega esa confirmación. En nuestro programa la evidencia es una respuesta completa con el contenido esperado y una salida normal del hijo.
Si el padre muere antes de leer la respuesta, el hijo puede fallar al enviarla. Si el hijo muere después de calcular y antes de responder, el padre no puede inferir el resultado solo por el cierre. Para operaciones con efectos externos haría falta definir recuperación e idempotencia.
13. Interbloqueos, capacidad y plazos
Esperar el final sin marcar el propio
El hijo espera EOF para transformar la petición. Si el padre termina de enviar sus bytes y llama directamente a recv sin SHUT_WR, la petición sigue abierta. El padre espera respuesta y el hijo espera más entrada. La ausencia temporal de bytes no es una frontera de mensaje.
Enviar en ambas direcciones sin leer
Full-duplex permite tráfico en los dos sentidos, pero cada dirección tiene capacidad finita. Si los dos procesos intentan completar envíos grandes antes de leer, ambos pueden quedar bloqueados por contrapresión. socketpair no vuelve infinitos los búferes.
El ejemplo organiza fases: el hijo retira la petición antes de responder y el padre comienza a leer cuando terminó de enviarla. Además, la entrada y la respuesta están acotadas. Un protocolo que produzca respuestas mientras aún recibe peticiones necesita revisar ese orden y posiblemente multiplexar lectura y escritura.
Timeout de operación y supervisión
SO_RCVTIMEO y SO_SNDTIMEO evitan algunas esperas indefinidas de E/S en este laboratorio. Un retorno positivo parcial sigue siendo progreso; el bucle conserva esos bytes. Si una llamada posterior agota su espera, se abandona la conversación en lugar de empezar otra desde un punto desconocido.
Los reintentos por EINTR y las llamadas sucesivas pueden extender el tiempo total. Además, waitpid no queda limitado por esas opciones de socket. Si el hijo queda detenido con SIGSTOP, un timeout de recepción del padre no lo hará terminar ni garantizará que waitpid retorne.
Un supervisor real necesita un plazo global, una política de cancelación y recogida de procesos, y tratamiento de estados detenidos o caídas. En las pruebas usa un controlador externo que termine y recoja todos los procesos que lanzó. No presentes el timeout por llamada como una garantía de duración total.
14. Herencia a través de exec
Un descriptor que permanece abierto tras exec puede escapar al programa previsto y mantener vivo un extremo. El primer ejemplo solicita SOCK_CLOEXEC al crear el par en Linux. Eso instala FD_CLOEXEC en ambos descriptores desde el comienzo; se cerrarán cuando un exec tenga éxito. El indicador no impide que fork los herede.
La opción de creación se describe en socket(2) y se admite también en socketpair en Linux. Si se configura después con fcntl en un programa con varios hilos, existe una ventana entre crear y marcar en la que otro hilo podría ejecutar fork y exec.
Si el propósito es entregar un extremo a un ejecutable trabajador, hay que planificar esa entrega: conservar solo el descriptor necesario y configurar explícitamente su herencia. Por ejemplo, dup2 puede instalarlo como entrada/salida estándar, cerrando después las copias sobrantes según el diseño.
Conviene revisar el caso especial en que el descriptor de origen ya coincide con el de destino: dup2(fd, fd) no crea una entrada nueva ni elimina FD_CLOEXEC. No basta con asumir que cualquier llamada a dup2 prepara automáticamente la herencia deseada.
Si no se necesita exec, como aquí, SOCK_CLOEXEC actúa como protección ante futuras ampliaciones. No reemplaza los close de los extremos sobrantes después de fork.
15. Explorar un cierre por dirección
El modelo comienza con dos referencias a A y una a B. Envía bloques de cuatro bytes, termina una dirección y recibe de dos en dos. También puedes cerrar referencias para comparar el cierre de una copia con el cierre del envío del extremo.
Extremo A2 referencias; envío abierto
Extremo B1 referencia; envío abierto
Cola A → BVacía
Cola B → AVacía
Última recepción en ASin llamada
Última recepción en BSin llamada
Cerrar una referencia a A deja otra disponible.
Prueba esta secuencia: enviar desde A, terminar su envío y recibir tres veces en B. Verás dos fragmentos y después EOF. Envía entonces desde B: el cierre de envío de A no bloquea su recepción. La cola se muestra como texto ASCII para facilitar la lectura.
El simulador representa el cierre ordenado, no los detalles de planificación del núcleo. «Esperaría» significa que una recepción bloqueante no tiene datos ni final disponible; no congela el navegador. Las colas didácticas se limitan a 16 bytes y un cierre completo del receptor descarta en el modelo su cola pendiente. Los errores por abortos, SHUT_RD y señales quedan fuera del modelo.
16. Pruebas y diagnóstico
Comprobar el protocolo y las referencias
- Compilar con advertencias. Ambos programas deben compilar sin advertencias y retornar cero en sus ensayos correctos.
- Vacío, tamaño habitual y máximo. Comprueba cero, cuatro y 4096 bytes. El caso 4097 debe fallar antes de crear procesos.
- Bytes y caracteres. Contrasta ASCII con UTF-8 para comprobar qué transforma la operación.
- Copia sobrante. Ejecuta referencias34 y observa ausencia de datos después de close, y EOF solo después de terminar el envío.
- Orden de cierre. Comprueba que la petición termina antes de que el padre espere respuesta y que waitpid ocurre después de recibir.
Fragmentar y provocar fallos de forma controlada
Para forzar recepciones cortas, limita temporalmente el argumento espacio de recv a un byte. Para probar envíos parciales, limita la longitud solicitada a send a uno o dos bytes. La llamada real debe transferir esos bytes: no se debe fingir un retorno positivo sin ejecutar el envío.
En una copia de prueba, omite el SHUT_WR del padre. Debe aparecer un fallo de espera o de intercambio y el programa no debe anunciar éxito. Si el hijo agota su espera y cierra, el padre podría obtener EOF antes de su propio timeout; exige un fallo de aplicación, no un orden exacto de errores.
Haz que el hijo termine sin responder a una petición no vacía. El padre debe rechazar longitud o contenido, o informar el error de transporte correspondiente. Para una petición vacía, la comparación de cero bytes no distingue por sí sola una caída de una respuesta vacía: por eso también se examina el estado del hijo.
Prueba datos excesivos modificando un emisor de laboratorio que ignore el límite local. El receptor debe detectar el primer byte sobrante sin escribir fuera del búfer. No elimines la validación del código normal para transmitir entradas arbitrarias.
$ strace -f -s 80 -e trace=socketpair,clone,clone3,fork,vfork,sendto,recvfrom,shutdown,close,wait4 ./dialogo34 "hola"El filtro contempla distintos mecanismos con los que la biblioteca puede implementar fork. En Linux, send y recv suelen aparecer en la traza como sendto y recvfrom. La salida de los procesos puede intercalarse: identifica sus PIDs y reconstruye el orden dentro de cada participante.
Busca la creación del par, los dos close de extremos sobrantes, los envíos, SHUT_WR en cada extremo y la recogida del hijo. Un cero en recv después de bytes pendientes es distinto de una llamada que retorna −1 con EAGAIN.
Si una lectura parece esperar para siempre, inspecciona /proc/PID/fd de todos los participantes o utiliza lsof -p PID. Los enlaces socket:[inodo] ayudan a localizar copias heredadas. No esperes encontrar un archivo de socket publicado por este par sin nombre.
17. Errores frecuentes
| Error | Consecuencia | Corrección |
|---|---|---|
| Tratar par[0] como solo lectura. | Se confunde el par con los extremos de pipe. | Recordar que ambos sockets son bidireccionales. |
| No cerrar el extremo ajeno tras fork. | Una referencia imprevista puede retrasar EOF. | Asignar propiedad y cerrar en ambas ramas. |
| Usar shutdown para retirar una copia sobrante. | Se inhabilita una dirección del extremo usado por otro proceso. | Retirar esa copia mediante close. |
| Cerrar A para terminar la petición y luego leer A. | El descriptor ya no está disponible. | SHUT_WR, recepción y finalmente close. |
| Enviar cero bytes como marca de final. | No se establece EOF en STREAM. | Usar un formato explícito o terminar el envío. |
| Interpretar una lectura corta como final. | Se acepta una petición incompleta. | Acumular hasta el final definido por el protocolo. |
| Usar SHUT_RDWR antes de recoger la respuesta. | Se abandona la dirección necesaria para recibirla. | Cerrar solo el envío en ese punto. |
| Creer que shutdown libera el descriptor. | Quedan entradas abiertas. | Ejecutar close cuando ya no se use. |
| Consultar errno tras un retorno positivo. | Un error antiguo invalida progreso real. | Examinar primero el retorno. |
| Esperar al hijo antes de leer su salida. | Puede bloquearse al llenar el búfer de respuesta. | Drenar según el protocolo antes de recogerlo. |
| Confundir EOF con confirmación de trabajo. | Se anuncia éxito sin una respuesta válida. | Verificar el resultado de aplicación. |
| Reintentar todo tras un fallo de envío parcial. | Se duplican bytes o efectos. | Conservar progreso; ante fallo fatal, abandonar según el contrato. |
18. Resumen
- socketpair crea dos extremos conectados y sin una ruta pública.
- Ambos extremos de un par STREAM pueden enviar y recibir.
- fork hereda referencias a los dos extremos; cada proceso cierra el que no utiliza.
- close retira un descriptor; otra referencia puede mantener vivo el extremo.
- SHUT_WR termina el envío y conserva la posibilidad de recibir.
- shutdown afecta al extremo compartido por sus alias y no sustituye close.
- Los datos pendientes se reciben antes del EOF de un cierre ordenado.
- EOF se interpreta según el protocolo y no certifica la muerte del interlocutor.
- Una petición terminada por EOF consume esa dirección para el resto de la conexión.
- MSG_NOSIGNAL permite tratar el fallo de send sin la terminación predeterminada por SIGPIPE.
- Capacidad finita y orden de operaciones siguen importando en un canal bidireccional.
- Validar respuesta, cerrar referencias y recoger al hijo son obligaciones distintas.
19. Preguntas de repaso y práctica
Razona con dos extremos y dos direcciones. Dibuja además una entrada por cada descriptor heredado o duplicado antes de desplegar las respuestas.
1. ¿Qué devuelve socketpair en caso de éxito?
Retorna cero y coloca dos descriptores conectados en el arreglo. Ambos son extremos bidireccionales.
2. ¿Es necesario eliminar una ruta al terminar este programa?
No. El par utilizado no publica una ruta del sistema de archivos. Se cierran sus referencias y se recoge al hijo.
3. ¿Cuántas referencias de descriptor hay justo después de fork?
Cuatro: el padre tiene dos y el hijo hereda otras dos, referidas a los mismos dos extremos. Después del reparto correcto queda una por proceso.
4. ¿Por qué se usa close y no shutdown para el extremo sobrante?
Porque se quiere retirar una referencia local, sin inhabilitar una dirección del extremo que utilizará el otro proceso.
5. ¿Qué conserva el padre después de SHUT_WR?
Su descriptor y la capacidad de recibir la respuesta por la dirección inversa. Después deberá cerrar el descriptor.
6. ¿Se puede enviar otra petición después de SHUT_WR?
No por ese mismo extremo. El cierre del envío es definitivo. Para varias peticiones conviene otro enmarcado y reservar el medio cierre para el final de la sesión.
7. ¿Cerrar un descriptor duplicado garantiza EOF en el otro extremo?
No si aún existe otra referencia al mismo extremo emisor y su envío sigue abierto. El experimento conserva precisamente esa copia.
8. ¿Un shutdown realizado por un alias afecta a los demás?
Sí. Cambia el estado del socket compartido. Una segunda copia no permite continuar enviando después de SHUT_WR.
9. ¿Puede recv devolver datos después de que el emisor haya terminado su envío?
Sí. Puede retirar los bytes ya pendientes y solo después alcanzar EOF. Una recepción no tiene por qué agotar toda la cola.
10. ¿EOF prueba que murió el proceso remoto?
No. Puede seguir vivo tras cerrar solo su envío y estar esperando datos por la otra dirección.
11. ¿Por qué se lee un byte auxiliar cuando el búfer está lleno?
Para distinguir el tamaño máximo válido seguido de EOF de una entrada excesiva. La lectura auxiliar no escribe fuera del búfer principal.
12. ¿Qué hace MSG_NOSIGNAL ante EPIPE?
Evita SIGPIPE para ese envío, pero la llamada sigue fallando y el programa debe comprobar el retorno y errno.
13. ¿Un socket bidireccional elimina los interbloqueos?
No. Ambos sentidos tienen capacidad finita y un orden incorrecto de envíos y esperas puede bloquear a los participantes.
14. ¿Los timeouts del socket limitan waitpid?
No. Se aplican a operaciones de E/S del socket. La espera del hijo necesita una política de supervisión si se requiere un plazo total.
15. ¿SOCK_CLOEXEC evita la herencia con fork?
No. Marca los descriptores para cierre al completar exec. Los close de extremos sobrantes tras fork siguen siendo necesarios.
Para practicar y ampliar
- Dibuja las cuatro referencias después de fork y tacha las dos que deben cerrarse.
- Ejecuta ambos programas y relaciona cada mensaje con close, shutdown, send o recv.
- Fuerza recepciones de un byte y verifica vacío, cuatro y 4096 bytes.
- Introduce un NUL en un arreglo de entrada de prueba y valida longitud y contenido binario.
- Crea dos alias de A y demuestra que SHUT_WR mediante uno inhabilita send mediante el otro.
- Omite el medio cierre en una copia de prueba y explica por qué el diálogo deja de progresar.
- Haz que el hijo termine con error después de recibir una petición vacía; comprueba que el padre no informe éxito.
- Utiliza strace para identificar datos pendientes antes de la recepción que devuelve cero.
- Adapta el protocolo del tema 33 para varias solicitudes sobre un par y utiliza SHUT_WR al terminar la sesión.
- Diseña cómo un supervisor entregaría un extremo a un trabajador mediante exec sin filtrar el otro.
El tema 35 utilizará sendmsg y recvmsg para transferir descriptores con SCM_RIGHTS y verificará credenciales con SO_PEERCRED en Linux. Un canal local puede transportar referencias a recursos además de bytes de aplicación.