1. Reconocer las capacidades construidas
Ahora puedes tratar a un conjunto de procesos como un sistema que coopera mediante contratos. Cada participante tiene información parcial, puede esperar y puede terminar antes que los demás. La corrección depende de cómo se intercambian datos y de cómo se administran esas transiciones.
La capacidad central del curso es diseñar y verificar conversaciones entre procesos con recursos y esperas acotados. Las llamadas concretas son herramientas para sostener ese contrato.
| Capacidad | Qué deberías poder explicar | Evidencia posible |
|---|---|---|
| Notificar y transportar. | Qué representa una señal, un flujo y un mensaje. | Recepción parcial, EOF y estados pendientes contrastados. |
| Compartir y coordinar. | Quién puede escribir, consumir y reutilizar una región. | Publicaciones sincronizadas e identidades de ranura. |
| Atender varios clientes. | Cómo avanza cada sesión sin bloquear a las demás. | El servidor del tema 49 bajo carga y contrapresión. |
| Distribuir trabajo. | Qué diferencia aceptación, cálculo y resultado publicado. | El conjunto de trabajadores del tema 50. |
| Diagnosticar y probar. | Qué observación demuestra una hipótesis y qué queda incierto. | Capturas y pruebas del tema 51. |
Haber visitado los temas no equivale a demostrar esas capacidades. Conserva programas, casos, entradas y resultados que otra persona pueda ejecutar. Una explicación apoyada en un ensayo reproducible permite revisar tanto lo que funciona como sus límites.
La transición a redes agrega nuevas condiciones de dirección, identidad y fallo. No exige olvidar los invariantes locales: muchos errores remotos empiezan por perder el framing, renovar un timeout indefinidamente o aceptar una confirmación con significado equivocado.
2. Elegir por contrato y restricciones
Antes de elegir un mecanismo, escribe qué se comunica, entre quiénes, con qué confianza, cuánto puede ocupar y qué significa éxito. Descarta primero opciones que no cumplen una restricción; después compara el costo de las que sí pueden sostener el contrato.
| Necesidad | Familia que conviene evaluar | Garantía que todavía debes construir |
|---|---|---|
| Intención de parada. | Señales integradas de forma segura en el flujo de control. | Observación durante las esperas y finalización comprobada. |
| Pipeline entre procesos preparados juntos. | Pipes o canales heredados. | Cierre por rama, framing si corresponde y contrapresión. |
| Servicio local independiente. | Socket Unix con protocolo y permisos. | Identidad, límites, sesiones y ciclo del nombre. |
| Trabajo estructurado acotado. | Cola de mensajes. | Identidad, capacidad, finalización y recuperación. |
| Bloques comunes entre participantes propios. | Memoria compartida y sincronización. | Propiedad, generaciones y abandono seguro. |
| Conversación entre máquinas. | Transporte de red con contrato de aplicación. | Direcciones, autenticación, protección y fallo remoto. |
La memoria compartida no es una cola ni un diario. Una señal estándar no es un contador exacto de trabajos. Una cola no demuestra que su mensaje ya se ejecutó. La elección se apoya en estas diferencias, no en una lista universal de velocidades.
El tema 48 reúne la matriz y la ficha de decisión. Úsala también al migrar a redes: el transporte nuevo debe evaluarse con el mismo resultado verificable, no con un trabajo reducido que parezca más rápido.
3. Conservar invariantes entre mecanismos
| Invariante | En IPC local | Al pasar a red |
|---|---|---|
| Contenido válido antes de usarlo. | Longitud, tipo, índice y generación. | Los mismos campos, más una identidad remota apropiada. |
| Desplazamientos dentro del rango. | Recibidos ≤ esperados; enviados ≤ preparados. | TCP conserva esa necesidad; UDP exige tratar cada datagrama. |
| Propietario por fase. | Ranura libre, publicada, en uso y terminada. | Solicitud pendiente, resultado tardío y estado de conexión. |
| Capacidad antes de admitir. | Huecos, buffers y ranuras disponibles. | Cupos de sesiones, dependencias y respuestas pendientes. |
| Identidad no confundida por reutilización. | Índice y generación de ranura o conexión. | ID de solicitud y de operación con alcance definido. |
| Espera acotada. | Plazo monotónico y control durante bloqueo. | Presupuesto del recorrido y cancelación con semántica explícita. |
Una invariante debe poder revisarse después de cualquier retorno: éxito parcial, EINTR, EAGAIN, EOF, error o señal. El camino normal y el de error no son dos implementaciones sin relación: ambos deben mantener un inventario válido de estado y recursos.
Los tokens y generaciones sirven para identificar usos, no para otorgar autorización. Un atacante puede escribir un entero que coincida con un ID; eso no acredita su derecho a ejecutar una operación.
Un protocolo revisable expresa también sus límites: una trama por conexión o varias, respuestas ordenadas o correlacionadas por ID, máximo de cuerpo y tratamiento de bytes no admitidos. Si esa definición cambia, se actualizan pruebas y versión.
4. Revisar propiedad y ciclo de recursos
crear → configurar → publicar → usar → dejar de admitir → cerrar → retirar
│ │
└── fallo de arranque └── fallo durante trabajo
¿que existe ya? ¿quien sigue usandolo?
¿quien debe cerrarlo? ¿como se confirma su salida?El descriptor, el recurso subyacente y su nombre no son lo mismo. Cerrar una copia no cierra las de otros procesos. Retirar un nombre no elimina necesariamente mapeos o descriptores ya abiertos. Un fd puede reutilizarse para otro recurso.
En el proyecto 49, la escucha y los conectados tenían vidas distintas. En el 50, los nombres se retiraban antes de fork, pero los mapeos y la cola seguían vivos. En ambos, la limpieza se definió por propiedad y referencias, no por borrar patrones de archivos.
En TCP no retiras un archivo de socket Unix: cierras escucha y conectados bajo otras reglas de direccionamiento. El cierre de una escucha tampoco cancela las conversaciones que ya se aceptaron.
Un proceso terminado y uno recogido son estados diferentes. La salida de un trabajador no libera por sí sola un permiso de aplicación ni reconstruye su tarea. El supervisor confirma waitpid y aplica la política definida para trabajo incompleto.
5. Separar transporte, ejecución y confirmación
se prepararon bytes
↓
la llamada de envio acepto bytes o un mensaje
↓
el otro extremo recibio una solicitud completa
↓
la aplicacion admitio y ejecuto la operacion
↓
se cumplio la garantia de confirmacion
↓
el cliente recibio y valido la respuestaNo puedes saltar de send exitoso a «el otro programa ejecutó». TCP puede confirmar transporte dentro de su funcionamiento y aun así la aplicación remota no haber ejecutado el trabajo. Una respuesta de aplicación también puede perderse después de una ejecución válida.
Si el cliente agota su plazo sin respuesta, el resultado puede ser desconocido. Reintentar una suma pura no duplica efectos; reintentar una reserva o una modificación requiere una identidad estable y reglas de deduplicación.
El ID de intento puede cambiar al abrir otra conexión; la identidad de operación puede necesitar mantenerse. Mezclarlos provoca tanto respuestas mal correlacionadas como efectos duplicados. El tema 43 desarrolla esa distinción.
Una cancelación solicitada no es una cancelación aceptada ni una reversión. El servicio debe decidir qué ocurre si el trabajo terminó mientras llegaba la orden y cómo lo comunica.
6. Presupuestar memoria, tiempo y capacidad
Un límite por mensaje no limita toda la aplicación si se aceptan infinitos mensajes o clientes. Calcula también trabajos en vuelo, buffers por sesión, ranuras, conexiones a dependencias y resultados todavía no recogidos.
| Presupuesto | Regla necesaria | Error frecuente |
|---|---|---|
| Memoria. | Capacidad por recurso y máximo global. | Reservar según una longitud no validada. |
| Tiempo. | Plazo y condición de finalización. | Reiniciar timeout por cada fragmento. |
| Concurrencia. | Cupos y tratamiento de saturación. | Un hilo, tarea o conexión sin límite por cliente. |
| Trabajo por visita. | Cuota compatible con el modo de notificación. | Un participante monopoliza el bucle. |
| Reintentos. | Responsable, clase de fallo y presupuesto total. | Multiplicar intentos desde cada capa. |
La contrapresión conserva capacidad: pausar lectura, esperar un hueco con plazo o rechazar explícitamente. Si la salida no avanza, seguir produciendo respuestas sin límite no mejora disponibilidad.
El reloj monotónico es apropiado para duración local. Su valor absoluto no debe copiarse entre máquinas como si compartieran origen. Para un recorrido remoto puede propagarse un presupuesto restante acotado bajo una política definida.
El límite del cliente describe cuánto esperará ese cliente. El servidor todavía puede seguir trabajando, salvo que exista otro contrato de cancelación. Esa incertidumbre debe aparecer en el diseño y en las pruebas.
7. Distinguir publicación y persistencia
Un semáforo permite que otro proceso consuma una publicación válida. No convierte esa memoria en un diario recuperable. Un objeto con nombre puede sobrevivir a un proceso y aun así no sostener persistencia frente a reinicio o pérdida de energía.
El tema 46 separó ver un valor de poder reconstruirlo después de un fallo. Si el contrato promete éxito durable, requiere orden de escritura, sincronización comprobada, formato y recuperación.
El cierre de una conexión no revierte una actualización durable ya confirmada internamente. Tampoco una retransmisión de transporte proporciona exactamente una ejecución de negocio. Las garantías pertenecen a capas distintas.
Al documentar un servicio, escribe qué frontera de fallo soporta: proceso, conjunto de procesos, reinicio de host o pérdida de almacenamiento. Probar una frontera menor no certifica automáticamente una mayor.
8. Qué cambia entre Unix, TCP y UDP
| Propiedad | Unix de flujo | TCP | UDP de Internet |
|---|---|---|---|
| Unidad de aplicación. | Flujo; framing propio. | Flujo; framing propio. | Datagramas con límites. |
| Ámbito. | Comunicación local bajo su namespace y permisos. | Loopback o red entre endpoints. | Loopback o red entre endpoints. |
| Orden y entrega. | Contrato del flujo local. | Entrega ordenada del flujo o fallo; no ejecución de aplicación. | Puede haber pérdida, duplicación o reordenamiento. |
| Mensaje vacío. | Una trama vacía requiere framing; recv cero confirma EOF de flujo con capacidad positiva. | La misma distinción de trama y EOF. | Un datagrama de longitud cero es válido y no representa EOF. |
| Credenciales. | Puede ofrecer mecanismos locales específicos. | Necesita identidad de aplicación y transporte apropiadas. | Necesita identidad y política propias; dirección no es autenticación. |
| Referencias del núcleo. | Puede transferir descriptores mediante mecanismos Unix. | No transporta un descriptor local a otro núcleo. | Tampoco comparte una tabla de descriptores remota. |
TCP no conserva fronteras entre send y recv; se documenta en tcp(7). Esa continuidad con un flujo Unix permite reutilizar un protocolo de longitud y cuerpo, manteniendo límites y desplazamientos.
UDP conserva datagramas, pero no garantiza su entrega, orden o unicidad. Un buffer insuficiente puede truncar un datagrama; no se recupera su resto con otra lectura. Estas reglas se describen en udp(7).
No extrapoles el comportamiento de datagramas Unix a UDP remoto. Tampoco supongas que agregar connect a UDP lo transforma en TCP: se configura una asociación o destino según la API, sin crear las garantías de un flujo fiable.
9. Preparar direcciones, puertos y resolución
Una ruta Unix identifica un endpoint local dentro de una vista de nombres. Una dirección IP y un puerto identifican un endpoint de red en su ámbito. 127.0.0.1 es loopback IPv4; no implica que puedas alcanzar el loopback de otro contenedor o máquina.
El laboratorio usa dirección numérica de loopback y puerto cero al enlazar la escucha: el sistema asigna un puerto disponible y getsockname permite conocerlo. No depende de un puerto fijo que otra aplicación pudiera estar usando.
Un programa de red general debe contemplar IPv4, IPv6 y resolución. getaddrinfo(3) devuelve candidatos con familia y dirección; no se debe asumir que un nombre produce una única dirección IPv4.
La resolución puede agregar espera y fallos propios. Marcar un socket como no bloqueante no convierte automáticamente getaddrinfo en una operación acotada por ese socket. El presupuesto de un cliente debe incluir las fases que realmente ejecuta.
connect no bloqueante puede informar EINPROGRESS. Que luego aparezca escritura disponible no prueba conexión exitosa: hay que consultar SO_ERROR. Esa transición se describe en connect(2) y se usa en el ejemplo siguiente.
10. Laboratorio: el mismo framing por Unix y TCP
Guarda flujo52.c. Es un ensayo autónomo Linux: prepara dos extremos conectados, crea un hijo que hace un eco de una trama y verifica cuerpo, longitud, EOF y salida del hijo. unix usa socketpair; tcp crea una escucha solo en 127.0.0.1, conecta y acepta antes de fork.
La trama conserva cuatro bytes de longitud big endian y un cuerpo de cero a 4096 bytes. El padre produce el patrón i módulo 256. Las escrituras reales se limitan a fragmentos de hasta tres bytes; eso no obliga al receptor a leer los mismos fragmentos.
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <poll.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define MAX52 4096u
static int cerrar52(int *fd)
{
if (*fd < 0) return 0;
int n = *fd; *fd = -1;
if (close(n) == -1) { perror("close"); return -1; }
return 0;
}
static int64_t ahora52(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 int restante52(int64_t fin)
{
int64_t ahora = ahora52();
if (ahora < 0) return -1;
if (ahora >= fin) { errno = ETIMEDOUT; return -1; }
return (int)(fin - ahora);
}
static int control52(int fd)
{
struct signalfd_siginfo s;
ssize_t n = read(fd, &s, sizeof s);
if (n == -1 && (errno == EINTR || errno == EAGAIN)) return 0;
if (n != (ssize_t)sizeof s) { errno = EIO; return -1; }
errno = ECANCELED; return -1;
}
static int esperar52(int fd, short eventos, int control, int64_t fin)
{
for (;;) {
int ms = restante52(fin);
if (ms == -1) return -1;
struct pollfd p[2] = {
{ .fd = fd, .events = eventos },
{ .fd = control, .events = POLLIN }
};
int r = poll(p, 2, ms);
if (r == -1) { if (errno == EINTR) continue; return -1; }
if (p[1].revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
if ((p[1].revents & POLLIN) && control52(control) == -1) return -1;
if (p[0].revents & POLLNVAL) { errno = EBADF; return -1; }
if (p[0].revents & (eventos | POLLERR | POLLHUP)) return 0;
}
}
static int transferir52(int fd, unsigned char *p, size_t total,
int escribir, int control, int64_t fin)
{
size_t hechos = 0;
while (hechos < total) {
if (esperar52(fd, escribir ? POLLOUT : POLLIN, control, fin) == -1) return -1;
size_t nbytes = total - hechos;
if (escribir && nbytes > 3) nbytes = 3;
ssize_t n = escribir ? send(fd, p + hechos, nbytes, MSG_NOSIGNAL) :
recv(fd, p + hechos, nbytes, 0);
if (n > 0) hechos += (size_t)n;
else if (n == 0) { errno = EPIPE; return -1; }
else if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return -1;
}
return 0;
}
static int eof52(int fd, int control, int64_t fin)
{
for (;;) {
if (esperar52(fd, POLLIN, control, fin) == -1) return -1;
unsigned char b;
ssize_t n = recv(fd, &b, 1, 0);
if (n == 0) return 0;
if (n > 0) { errno = EPROTO; return -1; }
if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) return -1;
}
}
static void poner52(unsigned char *p, uint32_t n)
{
for (unsigned i = 0; i < 4; ++i) p[i] = (unsigned char)(n >> (24u - 8u * i));
}
static uint32_t obtener52(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | p[3];
}
static int tcp52(int par[2], int control, int64_t fin)
{
int escucha = -1, salida = -1;
escucha = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (escucha == -1) goto fin;
struct sockaddr_in a = { .sin_family = AF_INET,
.sin_addr.s_addr = htonl(INADDR_LOOPBACK), .sin_port = 0 };
if (bind(escucha, (struct sockaddr *)&a, sizeof a) == -1 || listen(escucha, 1) == -1) goto fin;
socklen_t tam = sizeof a;
if (getsockname(escucha, (struct sockaddr *)&a, &tam) == -1 || tam != sizeof a) goto fin;
par[0] = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (par[0] == -1) goto fin;
if (connect(par[0], (struct sockaddr *)&a, sizeof a) == -1) {
if (errno != EINPROGRESS || esperar52(par[0], POLLOUT, control, fin) == -1) goto fin;
int error = 0;
tam = sizeof error;
if (getsockopt(par[0], SOL_SOCKET, SO_ERROR, &error, &tam) == -1) goto fin;
if (error) { errno = error; goto fin; }
}
for (;;) {
if (esperar52(escucha, POLLIN, control, fin) == -1) goto fin;
par[1] = accept4(escucha, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (par[1] >= 0) break;
if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK) goto fin;
}
fprintf(stderr, "TCP52 escucha=127.0.0.1:%u\n", (unsigned)ntohs(a.sin_port));
salida = 0;
fin:
if (cerrar52(&escucha) == -1) salida = -1;
if (salida == -1) {
if (cerrar52(&par[0]) == -1) salida = -1;
if (cerrar52(&par[1]) == -1) salida = -1;
}
return salida;
}
static int eco52(int fd, int64_t fin)
{
unsigned char cab[4], cuerpo[MAX52];
if (transferir52(fd, cab, sizeof cab, 0, -1, fin) == -1) return -1;
uint32_t longitud = obtener52(cab);
if (longitud > MAX52) { errno = EPROTO; return -1; }
if (transferir52(fd, cuerpo, longitud, 0, -1, fin) == -1 ||
eof52(fd, -1, fin) == -1 ||
transferir52(fd, cab, sizeof cab, 1, -1, fin) == -1 ||
transferir52(fd, cuerpo, longitud, 1, -1, fin) == -1) return -1;
return 0;
}
static int recoger52(pid_t hijo, int *estado, int control, int64_t fin)
{
for (;;) {
pid_t r = waitpid(hijo, estado, WNOHANG);
if (r == hijo) return 0;
if (r == -1 && errno == EINTR) continue;
if (r == -1) return -1;
int ms = restante52(fin);
if (ms == -1) return -1;
if (ms > 20) ms = 20;
struct pollfd p = { .fd = control, .events = POLLIN };
int n = poll(&p, 1, ms);
if (n == -1) { if (errno == EINTR) continue; return -1; }
if (p.revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
if ((p.revents & POLLIN) && control52(control) == -1) return -1;
}
}
static int numero52(const char *s, unsigned *v)
{
if (!*s) return -1;
for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
errno = 0; char *fin;
unsigned long n = strtoul(s, &fin, 10);
if (errno || *fin || n > MAX52) return -1;
*v = (unsigned)n; return 0;
}
int main(int argc, char **argv)
{
unsigned bytes;
if (argc != 3 || (strcmp(argv[1], "unix") && strcmp(argv[1], "tcp")) ||
numero52(argv[2], &bytes) == -1) {
fprintf(stderr, "Uso: %s unix|tcp bytes(0..4096)\n", argv[0]); return EXIT_FAILURE;
}
sigset_t mascara;
sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
signal(SIGCHLD, SIG_DFL) == SIG_ERR || signal(SIGPIPE, SIG_IGN) == SIG_ERR ||
sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) { perror("senales"); return EXIT_FAILURE; }
int control = -1, par[2] = { -1, -1 }, recogido = 0, estado = 0;
int salida = EXIT_FAILURE;
pid_t hijo = -1;
control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
int64_t limite = ahora52();
if (control == -1 || limite < 0) goto error;
limite += 5000;
if (strcmp(argv[1], "unix") == 0) {
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, par) == -1) goto error;
} else if (tcp52(par, control, limite) == -1) goto error;
hijo = fork();
if (hijo == -1) goto error;
if (hijo == 0) {
sigset_t vacia; sigemptyset(&vacia);
if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
sigprocmask(SIG_SETMASK, &vacia, NULL) == -1 ||
cerrar52(&control) == -1 || cerrar52(&par[0]) == -1) _exit(2);
int r = eco52(par[1], limite);
if (r == -1) perror("eco");
if (cerrar52(&par[1]) == -1) r = -1;
_exit(r == 0 ? 0 : 3);
}
if (cerrar52(&par[1]) == -1) goto error;
unsigned char cab[4], respuesta[4], cuerpo[MAX52], recibido[MAX52];
for (unsigned i = 0; i < bytes; ++i) cuerpo[i] = (unsigned char)(i % 256u);
poner52(cab, bytes);
if (transferir52(par[0], cab, sizeof cab, 1, control, limite) == -1 ||
transferir52(par[0], cuerpo, bytes, 1, control, limite) == -1 ||
shutdown(par[0], SHUT_WR) == -1 ||
transferir52(par[0], respuesta, sizeof respuesta, 0, control, limite) == -1) goto error;
if (obtener52(respuesta) != bytes) { errno = EPROTO; goto error; }
if (transferir52(par[0], recibido, bytes, 0, control, limite) == -1 ||
eof52(par[0], control, limite) == -1) goto error;
if (memcmp(cuerpo, recibido, bytes) != 0) { errno = EPROTO; goto error; }
if (recoger52(hijo, &estado, control, limite) == -1) goto error;
recogido = 1;
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) { errno = ECHILD; goto error; }
salida = EXIT_SUCCESS;
goto fin;
error:
perror("ensayo");
fin:
if (hijo > 0 && !recogido) {
if (kill(hijo, SIGKILL) == -1 && errno != ESRCH) perror("kill propio");
pid_t r;
do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
if (r != hijo) salida = EXIT_FAILURE;
}
if (cerrar52(&par[0]) == -1) salida = EXIT_FAILURE;
if (cerrar52(&par[1]) == -1) salida = EXIT_FAILURE;
if (cerrar52(&control) == -1) salida = EXIT_FAILURE;
if (salida == EXIT_SUCCESS) {
puts("transporte,bytes,verificado");
printf("%s,%u,1\n", argv[1], bytes);
if (fflush(stdout) == EOF) salida = EXIT_FAILURE;
}
return salida;
}El plazo de cinco segundos se crea antes de preparar el transporte y se conserva para conexión, conversación y espera cooperativa del hijo. El padre atiende SIGINT y SIGTERM durante las esperas mediante signalfd; un error abandona el intercambio y recoge al hijo antes de terminar.
El ensayo no es un servidor de red pública: no incluye DNS, IPv6, TLS, usuarios remotos ni múltiples clientes. Su alcance es comprobar qué parte del contrato de flujo permanece al cambiar de familia de socket.
11. Laboratorio: vacío y truncamiento en UDP
Guarda datagramas52.py. Crea dos sockets UDP IPv4 propios sobre loopback, con puertos asignados por el sistema. Envía y recibe un datagrama por paso para observar límites, no para medir capacidad ni demostrar fiabilidad remota.
import json
import socket
import sys
import time
def restante(fin):
valor = fin - time.monotonic()
if valor <= 0:
raise TimeoutError("plazo del ensayo UDP agotado")
return valor
def ensayar():
if not hasattr(socket.socket, "recvmsg") or not hasattr(socket, "MSG_TRUNC"):
raise RuntimeError("se requiere recvmsg y MSG_TRUNC, como en Linux")
casos = [("vacio", b"", 16), ("binario", b"A\x00B", 16),
("truncado", b"ABCDEFGH", 4), ("siguiente", b"NEXT", 16)]
resultados = []
fin = time.monotonic() + 2
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as receptor, \
socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as emisor:
receptor.bind(("127.0.0.1", 0))
emisor.settimeout(restante(fin))
emisor.connect(receptor.getsockname())
origen_esperado = emisor.getsockname()
for nombre, cuerpo, capacidad in casos:
emisor.settimeout(restante(fin))
n = emisor.send(cuerpo)
if n != len(cuerpo):
raise ValueError("longitud de envio UDP inesperada")
# Para un datagrama vacio, n == 0 es el resultado correcto.
receptor.settimeout(restante(fin))
datos, auxiliares, flags, origen = receptor.recvmsg(capacidad)
truncado = bool(flags & socket.MSG_TRUNC)
if origen != origen_esperado or datos != cuerpo[:capacidad]:
raise ValueError("origen o contenido UDP inesperado")
if truncado != (len(cuerpo) > capacidad):
raise ValueError("truncamiento UDP no coincide con el contrato")
resultados.append({"caso": nombre, "enviados": len(cuerpo),
"recibidos": len(datos), "datos_hex": datos.hex(),
"truncado": truncado})
return {"ambito": "127.0.0.1", "casos": resultados}
if __name__ == "__main__":
try:
print(json.dumps(ensayar(), sort_keys=True))
except (OSError, ValueError, RuntimeError) as error:
print(error, file=sys.stderr)
sys.exit(1)El primer datagrama lleva cero bytes y se recibe correctamente. El programa no ejecuta «si no hay datos, terminar», porque en UDP ese tamaño no representa el EOF de un flujo.
ABCDEFGH se recibe con capacidad cuatro: devuelve ABCD y MSG_TRUNC. Luego llega NEXT como un mensaje nuevo, no EFGH como resto de una supuesta lectura de flujo. El laboratorio verifica esa diferencia de manera concreta.
connect se utiliza para fijar el destino del emisor. No añade retransmisión, entrega ordenada ni una sesión TCP. La comprobación de dirección de origen solo identifica el endpoint observado en este ensayo; no autentica un usuario remoto.
La API de Python y la disponibilidad de recvmsg se documentan en socket. Se requiere un entorno con recvmsg y MSG_TRUNC, como el Linux usado en el curso. No se crean escuchas en interfaces externas ni se cambia la configuración del equipo.
Que estos cuatro datagramas lleguen en loopback no demuestra que UDP siempre entregue, mantenga orden o evite duplicados. Además, el orden de este ensayo está impuesto por enviar y recibir secuencialmente.
12. Verificar los laboratorios del cierre
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 flujo52.c -o flujo52
./flujo52 unix 257
./flujo52 tcp 257
python3 datagramas52.pyEl CSV del programa C solo aparece después de comprobar la respuesta, EOF y salida correcta del hijo. El puerto TCP asignado aparece en stderr como dato de diagnóstico. Ninguna cifra de esos programas constituye un benchmark.
Guarda verificar52.py para contrastar ocho casos de flujo y los cuatro casos UDP. El archivo de evidencia se crea exclusivamente y se completa después de validar todo el conjunto.
import argparse
import csv
import hashlib
import io
import json
import os
from pathlib import Path
import signal
import subprocess
import sys
def ejecutar(args):
proceso = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, start_new_session=True)
try:
salida, errores = proceso.communicate(timeout=8)
except BaseException:
try:
os.killpg(proceso.pid, signal.SIGKILL)
except ProcessLookupError:
pass
proceso.communicate()
raise
if proceso.returncode != 0:
raise ValueError("ensayo fallido: " + errores.strip())
return salida
def main():
p = argparse.ArgumentParser()
p.add_argument("flujo", type=Path)
p.add_argument("--udp", type=Path, default=Path(__file__).with_name("datagramas52.py"))
p.add_argument("--salida", type=Path, required=True)
a = p.parse_args()
exe, udp = a.flujo.resolve(strict=True), a.udp.resolve(strict=True)
flujos = []
with a.salida.open("x", encoding="utf-8") as archivo:
for modo in ["unix", "tcp"]:
for cantidad in [0, 1, 257, 4096]:
salida = ejecutar([str(exe), modo, str(cantidad)])
lector = csv.DictReader(io.StringIO(salida))
filas = list(lector)
esperado = {"transporte": modo, "bytes": str(cantidad), "verificado": "1"}
if lector.fieldnames != ["transporte", "bytes", "verificado"] or filas != [esperado]:
raise ValueError("CSV de flujo incompatible o no verificado")
flujos.append({"transporte": modo, "bytes": cantidad, "verificado": True})
resultado = json.loads(ejecutar([sys.executable, str(udp)]))
esperado_udp = {"ambito": "127.0.0.1", "casos": [
{"caso": "vacio", "enviados": 0, "recibidos": 0, "datos_hex": "", "truncado": False},
{"caso": "binario", "enviados": 3, "recibidos": 3, "datos_hex": "410042", "truncado": False},
{"caso": "truncado", "enviados": 8, "recibidos": 4, "datos_hex": "41424344", "truncado": True},
{"caso": "siguiente", "enviados": 4, "recibidos": 4, "datos_hex": "4e455854", "truncado": False}]}
if resultado != esperado_udp:
raise ValueError("el ensayo UDP no respeta las observaciones previstas")
json.dump({"alcance": "Flujos locales y UDP loopback; no certifica una red remota",
"flujo_sha256": hashlib.sha256(exe.read_bytes()).hexdigest(),
"udp_sha256": hashlib.sha256(udp.read_bytes()).hexdigest(),
"casos_flujo": flujos, "datagramas": resultado},
archivo, indent=2)
archivo.write("\n")
print("8 intercambios de flujo y 4 datagramas verificados; evidencia guardada")
if __name__ == "__main__":
try:
main()
except (OSError, ValueError, subprocess.TimeoutExpired) as error:
print(error, file=sys.stderr)
sys.exit(1)python3 verificar52.py ./flujo52 --udp ./datagramas52.py --salida cierre52.json
python3 -m json.tool cierre52.jsonEl controlador aplica un límite externo por programa y recoge su proceso directo; ante una excepción termina su grupo propio. Estos programas conocidos producen salida pequeña. Para capturar programas con volumen de salida desconocido o descendientes que retienen tuberías, utiliza la captura acotada y el modelo de supervisión del tema 51.
Si ya existe cierre52.json, elige otro nombre. Un fallo anterior a la validación final puede dejar el archivo vacío. Los hashes identifican el binario y script que participaron, no demuestran por sí solos que no tengan defectos.
| Comprobación adicional | Resultado esperado |
|---|---|
| send y recv reales de un byte con EINTR en una copia C. | Los mismos ocho casos mantienen framing e integridad. |
| Alterar un byte en el eco antes de enviarlo. | El padre falla sin publicar CSV de éxito. |
| Hijo sale antes de completar respuesta. | Truncamiento detectado y estado recogido. |
| Cliente o hijo queda detenido. | Plazo o cancelación; limpieza del conjunto propio. |
| UDP recibido en buffer insuficiente. | Truncamiento explícito; no reconstruir con el siguiente datagrama. |
13. Replantear identidad y seguridad remotas
Una ruta local protegida y credenciales del núcleo pueden ayudar a controlar un servicio Unix. Esas propiedades no se convierten automáticamente en autenticación de red al cambiar a AF_INET o AF_INET6.
La dirección IP y puerto observados son información de endpoint, no prueba suficiente de identidad de usuario o autorización de una operación. Un ID dentro del mensaje también puede ser elegido por el emisor.
Un diseño remoto necesita definir quién se autentica, cómo se valida al servicio, qué operaciones puede hacer cada identidad y cómo se protegen los datos. TLS aporta protección del canal bajo su protocolo y configuración; no sustituye el control de acceso de la aplicación. La especificación de TLS 1.3 está en RFC 8446.
Validar certificados, nombres y claves forma parte del uso correcto de ese canal. Desactivar comprobaciones para que una conexión «funcione» cambia el contrato de seguridad. El laboratorio de loopback no implementa TLS ni se presenta como servicio remoto listo para desplegar.
La deserialización también debe permanecer acotada después de autenticar. Un usuario legítimo puede enviar una longitud excesiva, un mensaje incompatible o una secuencia que agote capacidad. Identidad y validación estructural resuelven problemas distintos.
14. Trasladar las pruebas a otra frontera de fallo
Las pruebas locales ya separaron recepción parcial, cliente lento, cola llena, publicación ausente y proceso caído. La red agrega fallos de dirección, resolución, establecimiento y trayecto, y más oportunidades de respuesta tardía.
| Garantía que se conserva | Ensayo local conocido | Extensión al recorrido remoto |
|---|---|---|
| Framing. | Cabecera dividida y varias tramas juntas. | Conservar la misma comprobación sobre TCP. |
| Presupuesto. | Cliente que no completa su trama. | Incluir resolución, establecimiento y protección del canal cuando existan. |
| Capacidad. | Salida bloqueada y lectura pausada. | Limitar también trabajo hacia dependencias remotas. |
| Identidad. | Generación de ranura y solicitud. | Respuesta tardía, reintento e identidad de operación. |
| Resultado desconocido. | Proceso termina después de ejecutar. | Conexión perdida tras enviar o después de confirmar internamente. |
| Limpieza. | Hijos recogidos y nombres propios retirados. | Conexiones y tareas abandonadas bajo su política, sin borrar evidencia. |
En UDP, agrega pérdida, duplicación y reordenamiento a tu modelo si la aplicación debe tolerarlos. Un protocolo puede elegir no recuperar mensajes perdidos o puede necesitar confirmaciones y límites; la decisión depende de su semántica.
Una simulación de pérdida en el emisor no es una captura de pérdida real en la red. Ambas pueden ser útiles si se documenta qué frontera se ejercitó. Mantén precondición, inyección, oráculo y evidencia, como en el tema 51.
Un timeout y posterior rescate del controlador no prueban limpieza correcta. Conserva esa distinción al probar servidores remotos, procesos auxiliares o clientes que retienen referencias.
15. Resolver escenarios de autoevaluación
Resuelve ocho decisiones y comprueba su explicación. Puedes volver a una respuesta; el resultado refleja las opciones actualmente comprobadas. Este ejercicio no sustituye ejecutar los proyectos ni certifica competencias por haber visitado páginas.
Escenario 1 de 8
Activa JavaScript para resolver los escenarios interactivos o utiliza las preguntas de repaso.
Avance de este ejercicio0 de 8 comprobados
Resultado de la decisiónSin comprobar
Elige una opción y comprueba su fundamento.
Las explicaciones remiten a temas del curso. Si una respuesta fue incorrecta, revisa el invariante y construye un caso breve que muestre el error. Cambiar una opción sin poder justificarla no aporta la misma evidencia que observar el comportamiento.
16. Definir un trabajo integrador verificable
Una ampliación natural es unir el servidor del tema 49 con los trabajadores del 50. El objetivo no consiste en copiar sus bucles uno dentro del otro: hace falta un contrato que relacione conexión, solicitud y ranura de trabajo.
cliente → trama validada → solicitud admitida
│
conexion_indice + conexion_generacion + solicitud_id
│
ranura_indice + ranura_generacion
▼
trabajador
│
publicacion de resultado
▼
comprobar solicitud pendiente y capacidad de respuesta
│
enviar o abandonar segun contrato- Definir la operación, tamaños y significado de una respuesta de éxito.
- Limitar solicitudes pendientes por cliente y en todo el servicio.
- Entregar metadatos al trabajador solo después de publicar la entrada.
- Despertar el bucle de resultados sin sustituir su sincronización autoritativa.
- Rechazar resultados para una conexión antigua sin liberar una ranura todavía en uso.
- Definir qué pasa al desconectarse un cliente y al solicitar drenaje.
- Probar cola llena, respuesta tardía, trabajador caído y limpieza antes de medir.
El entregable debe incluir una ficha de arquitectura, el programa, casos reproducibles y un informe de límites. No necesita afirmar recuperación durable si la operación solo vive en memoria. Si incorpora efectos externos, ese requisito debe añadirse explícitamente.
Esta ampliación queda como práctica integradora: los proyectos originales conservan sus contratos y sus bancos de prueba. Antes de sustituirlos por la unión, mantén una versión base que permita comparar y localizar regresiones.
17. Organizar el siguiente recorrido de aprendizaje
La ruta del índice sitúa a continuación Redes desde el Sistema Operativo. Los laboratorios de este cierre preparan conceptos; no reemplazan el estudio completo de direcciones, transporte y seguridad remota.
| Paso siguiente | Pregunta guía | Base que ya tienes |
|---|---|---|
| Direcciones y puertos. | ¿Qué endpoint se está intentando alcanzar y en qué ámbito? | Descubrimiento, nombres y propiedad. |
| IPv4, IPv6 y resolución. | ¿Qué candidatos existen y cómo se presupuestan intentos? | Estados, errores y plazos. |
| TCP. | ¿Cómo se reconstruye el protocolo sobre un flujo? | Framing, progreso parcial, EOF y contrapresión. |
| UDP. | ¿Qué semántica necesita cada datagrama y qué hacer si no llega? | Identidad, límites y contrato de fallo. |
| Concurrencia de red. | ¿Qué estado y memoria mantiene cada sesión? | Bucle de eventos, cuotas y generaciones. |
| Canales protegidos. | ¿Quién se autentica y qué operaciones se autorizan? | Credenciales, validación y aislamiento. |
| Pruebas y observabilidad. | ¿Qué evidencia demuestra el contrato completo? | Banco reproducible y diagnóstico del sistema. |
Una secuencia razonable es dominar un eco local verificable, agregar direccionamiento sin perder framing, introducir concurrencia con límites y después ampliar seguridad y fallos. Cada paso conserva un caso base que pueda ejecutarse sin infraestructura externa.
Evita comenzar exponiendo el ejemplo a todas las interfaces. Primero identifica el contrato que falta: autenticación, cifrado, política de admisión, presupuesto o seguimiento de operaciones. Un cambio de dirección de bind no implementa esos requisitos.
18. Auditar lo que puedes demostrar
| Pregunta final | Evidencia que deberías conservar |
|---|---|
| ¿Por qué elegiste ese mecanismo? | Restricciones, alternativas descartadas y costo que mediste. |
| ¿Qué representa cada mensaje? | Formato, límites, versión e identidad. |
| ¿Quién puede usar cada recurso? | Inventario de dueños, permisos y fases de acceso. |
| ¿Cómo progresa una operación parcial? | Desplazamientos conservados y pruebas de fragmentación. |
| ¿Qué ocurre con un participante lento? | Contrapresión, plazo y aislamiento de capacidad. |
| ¿Qué sabes después de un fallo? | Resultado conocido o desconocido y política de reintento. |
| ¿Cómo confirmas el cierre? | Salida, recogida, referencias y nombres comprobados. |
| ¿Qué garantía no probaste? | Alcance explícito: host, red, energía, plataforma y carga. |
Un informe honesto puede decir «verificado en Linux y loopback para cuerpos hasta 4096 bytes, sin efectos persistentes». Esa precisión es más útil que declarar «funciona siempre» a partir de unas pocas consultas.
Las mediciones se interpretan después de esa auditoría. No compares una suma verificada con un envío sin consumo ni una confirmación durable con otra que omite sincronización. Conserva resultados crudos y costos incluidos.
Si un requisito cambia, revisa la decisión. Las invariantes son una guía para adaptar el programa; la implementación anterior no se convierte automáticamente en correcta bajo una topología, confianza o frontera de fallo nuevas.
19. Síntesis final, repaso y práctica
Comunicar procesos exige dar significado a bytes, permisos, notificaciones y referencias. El curso pasó de esas piezas a servidores y trabajadores con identidades, límites y pruebas. El puente a redes conserva ese método y añade nuevas decisiones sobre endpoints, identidad y entrega.
- Contrato: definir datos, resultado y garantía de finalización.
- Estado: conservar progreso e identidad a través de cada fase.
- Capacidad: limitar memoria, tiempo y trabajo admitido.
- Fallo: reconocer incertidumbre y evitar reintentos o reparaciones ficticias.
- Evidencia: demostrar integridad y limpieza con un experimento reproducible.
Preguntas de repaso
1. ¿Qué debes decidir antes del mecanismo?
Contrato, ubicación, confianza, volumen, capacidad y frontera de fallo que debes soportar.
2. ¿Por qué no basta un mensaje de terminado?
Su identidad y resultado deben ser válidos bajo el protocolo. Además, puede faltar recogida del proceso o durabilidad.
3. ¿Qué conserva un envío parcial?
El sufijo pendiente y su desplazamiento. Un retorno positivo corto no autoriza a reenviar todo el cuerpo.
4. ¿Qué elimina retirar un nombre?
El acceso por ese nombre según la API. No necesariamente elimina referencias o mapeos ya abiertos.
5. ¿Qué significa timeout del cliente?
Que agotó su espera. La aplicación remota puede haber ejecutado la operación y el resultado quedar desconocido.
6. ¿Una región compartida publicada es durable?
No por esa publicación. La recuperación persistente necesita otro protocolo y una frontera de fallo definida.
7. ¿Qué permanece al pasar de Unix de flujo a TCP?
Framing, desplazamientos, validación, límites y distinción entre transporte y ejecución.
8. ¿TCP conserva cada escritura como un mensaje?
No. La aplicación reconstruye sus unidades sobre un flujo ordenado.
9. ¿Cuándo recv igual a cero representa EOF?
En una lectura de flujo con capacidad positiva. Una trama de cuerpo cero y un datagrama UDP vacío son otros casos.
10. ¿Cómo se recupera el resto de un datagrama truncado?
No se obtiene con la siguiente lectura. El resto de ese datagrama se descarta bajo la recepción utilizada; el siguiente es otro mensaje.
11. ¿Qué verifica SO_ERROR después de connect no bloqueante?
El resultado del establecimiento. Escritura disponible puede corresponder también a una conexión fallida.
12. ¿Una dirección IP o un ID autentican una operación?
No. Se necesita identidad verificada y autorización bajo una política de aplicación.
13. ¿TLS decide qué registros puede modificar un usuario?
No. Protege el canal bajo su configuración; la autorización de operaciones pertenece a la aplicación.
14. ¿Un rescate exitoso hace pasar un ensayo?
No. Se registra que el controlador intervino y se distingue de la limpieza propia del programa.
15. ¿Qué significa completar este curso con evidencia?
Poder justificar decisiones, ejecutar contratos e interpretar fallos y límites. Visitar los 52 temas o acertar el cuestionario no sustituye esa demostración.
Para practicar y continuar
- Reescribe la ficha de decisión de uno de tus programas sin nombrar primero una API.
- Dibuja recursos y propietarios antes y después de fork.
- Ejecuta ambos transportes del laboratorio con cuerpos vacíos y máximos.
- Fuerza operaciones reales de un byte y EINTR sin progreso ficticio.
- Corrompe la respuesta y verifica rechazo y recogida del hijo.
- Explica cada resultado UDP sin aplicar reglas de flujo.
- Diseña una versión de protocolo con identidad de operación separada del intento.
- Presupuesta una solicitud con resolución, conexión, procesamiento y respuesta.
- Define contrapresión entre un servidor y un conjunto de trabajadores.
- Documenta autenticación y autorización antes de proponer un despliegue remoto.
- Conserva una ejecución reproducible del banco del tema 51.
- Escribe un informe que indique qué comprobaste y qué queda fuera de alcance.
Has llegado al último tema. Conserva los proyectos y sus evidencias como base para continuar con Redes desde el Sistema Operativo. El objetivo que permanece es el mismo: contratos claros, recursos con dueño, capacidad acotada y resultados que puedas comprobar.