1. Convertir garantías en observaciones
«No se cuelga» es demasiado impreciso para evaluar un sistema con procesos, descriptores y memoria compartida. Hay que definir qué operación debía terminar, en qué plazo, con qué resultado y qué recursos debían dejar de existir.
Un ensayo completo fija precondición, punto de inyección, resultado esperado y evidencia de limpieza. Pasar requiere todas esas condiciones; que el controlador consiga detener el programa no demuestra que el programa se limpió correctamente.
| Garantía | Observación verificable | Insuficiente por sí sola |
|---|---|---|
| Eco íntegro. | Longitudes, cuerpos binarios y orden coinciden. | Recibir algún byte. |
| Cliente lento aislado. | Otro cliente progresa mientras la primera sesión sigue abierta y confirmada. | Dos connect exitosos. |
| Contrapresión. | Salida pendiente, lectura retirada y recuperación posterior. | Enviar una trama pequeña y esperar. |
| Resultado de trabajador válido. | ID, ranura, generación, PID y suma correctos. | Un permiso de semáforo disponible. |
| Fallo acotado. | Retorno esperado dentro del límite sin rescate. | El banco lo mató al vencer su timeout. |
| Limpieza. | Proceso directo recogido, hijos originales ausentes y nombres propios retirados. | El nombre ya no aparece en una lista global. |
Los códigos de salida esperados dependen del caso. Un retorno uno puede ser correcto si se inyectó corrupción y el contrato exige rechazarla. El mismo retorno en el caso base es un fallo. Un timeout externo es fallo del ensayo, aunque luego el rescate termine los procesos.
2. Construir una matriz de fallos
| Proyecto | Frontera | Inyección | Oráculo |
|---|---|---|---|
| 49, servidor. | Recepción y envío parciales. | Operaciones reales de un byte y EINTR. | Mismo eco completo y cierre normal. |
| 49, servidor. | Framing. | Longitud excesiva y EOF parcial. | Solo esa sesión termina; otra sigue funcionando. |
| 49, servidor. | Capacidad. | Cliente no lee y envío del servidor pequeño. | EPOLLOUT sin EPOLLIN; después se recupera progreso. |
| 49, servidor. | Drenaje. | Salida sigue bloqueada durante la gracia. | Fallo declarado y retirada de recursos propios. |
| 50, trabajadores. | Cola. | EAGAIN y EINTR antes de llamadas reales. | IDs únicos y resultados completos. |
| 50, trabajadores. | Publicación. | Suma alterada antes de terminado. | No emitir CSV de éxito. |
| 50, trabajadores. | Vida de hijos. | Detención confirmada, muerte o cancelación. | Supervisor falla y recoge a ambos hijos. |
| 50, trabajadores. | Arranque. | Segundo fork o quinto sem_init fallan. | Cerrar solo recursos creados y recoger el hijo existente. |
La matriz no pretende agotar todos los fallos posibles. El banco implementa estos casos y un control negativo deliberadamente defectuoso. Generaciones antiguas, mensajes de cola malformados y errores de almacenamiento pueden incorporarse después con su punto de inyección propio.
Conviene separar una prueba de identidad, una de capacidad y una de limpieza en lugar de introducir varios defectos simultáneamente y no saber cuál causó el resultado. Cada variante tendrá fuente, argumentos y evidencia conservados.
3. Sincronizar antes de inyectar
Una pausa fija no demuestra que el programa haya llegado a la fase deseada. En un equipo lento puedes inyectar antes de tiempo; en otro, el proceso ya habrá terminado. El controlador debe esperar una condición observable con su propio plazo.
- Para iniciar consultas, esperar el anuncio E49 listo y comprobar su PID.
- Para mantener una sesión incompleta, verificar primero un eco por esa misma sesión y luego enviar parte de la cabecera siguiente.
- Para presión de salida, observar intereses reales del epoll de esa instancia.
- Para señalar un trabajador, usar una variante que publique preparado y se detenga antes de recibir.
- Comprobar en /proc que ambos hijos pertenecen al supervisor y están detenidos.
El banco utiliza pidfd para señalar al trabajador elegido mediante una referencia estable. Abrir el descriptor no autoriza señalar cualquier proceso: primero se comprueban parentesco, grupo y sesión de esta ejecución. La interfaz de Linux se documenta en pidfd_open(2); Python expone os.pidfd_open y signal.pidfd_send_signal.
Esperar un estado mediante revisiones breves de una condición no equivale a asumirlo después de sleep. Cada revisión conserva el mismo plazo y un incumplimiento se informa como fallo, no como permiso para continuar con una precondición falsa.
4. Inyectar sin inventar progreso
Para forzar una transferencia corta, la cabecera de prueba reduce la longitud de la llamada real a un byte. Si la llamada transfiere uno, devuelve uno. Para introducir EINTR, devuelve -1 antes de hacer la transferencia y establece errno.
No se llama mq_send y luego se devuelve EAGAIN como si no se hubiese aceptado el mensaje: el padre lo volvería a enviar y estaríamos probando otra semántica. El fallo artificial se produce antes de la llamada real.
Tampoco se sustituye send por EAGAIN constantemente mientras el núcleo sigue anunciando escritura. Eso fabricaría giro sin modelar presión de salida. La prueba de cliente lento usa buffers reales y deja de leer para que el transporte alcance su condición efectiva.
Las sustituciones de fuente se aplican únicamente si una cadena ancla aparece exactamente una vez. Si el proyecto cambió y el ancla no coincide, se aborta la preparación; el banco no intenta adivinar dónde insertar una instrucción que podría alterar otro camino.
5. Aislar procesos, fuentes y objetos
Las fuentes de los temas 49 y 50 se leen, se identifican con SHA-256 y se copian a un directorio de evidencia nuevo. Las variantes se compilan allí. Los originales no se sobrescriben y un directorio existente no se reutiliza.
Cada caso arranca su proceso en una sesión nueva. Sus hijos heredan ese grupo y el controlador conserva el Popen del proceso directo. No usa killall, pkill ni patrones de nombres para terminar participantes.
La instrumentación registra el directorio y los nombres de memoria y cola solo después de crearlos con éxito. La comprobación de limpieza consulta esas identidades concretas. No borra objetos para conseguir que una prueba parezca limpia.
En el proyecto 50, los nombres se retiran antes de fork. La ausencia de nombres durante una pausa no demuestra que el mapeo o la cola estén cerrados: todavía pueden existir referencias heredadas. Se comprueban por separado nombres y procesos.
Los procesos que deliberadamente se daemonizan o abandonan su sesión no pertenecen al contrato de este banco. Para supervisar conjuntos arbitrarios se necesitaría otro límite de administración, por ejemplo un gestor con control del conjunto. Aquí solo se ejecutan binarios propios que conservan la topología conocida.
6. Diseñar un controlador que no se bloquee
El controlador drena stdout y stderr al mismo tiempo con descriptores no bloqueantes y selectors. Mantiene como máximo un MiB por flujo; excederlo falla la captura en vez de crecer sin límite. Al rescatar sigue drenando y guarda el prefijo disponible.
Un proceso puede terminar mientras un descendiente conserva una tubería abierta. Por eso se espera tanto la salida del proceso directo como EOF de las capturas, bajo un plazo. La documentación de subprocess distingue comunicación, espera y tratamiento de timeout; el controlador implementa su propia captura acotada.
Al cerrar un caso que todavía necesita intervención, se termina su grupo propio y se marca rescate. Ese dato hace fallar el ensayo aunque el retorno posterior parezca aceptable. El límite externo es una defensa del banco, no una característica que se atribuye al programa probado.
El supervisor del proyecto 50 recoge sus hijos. El controlador solo puede esperar directamente a su proceso hijo; observar un pidfd legible indica terminación, pero no demuestra que el supervisor haya recogido ese trabajador. La diferencia se contrasta con la identidad original en /proc y con la salida del supervisor. Véase wait(2).
7. Cabecera C de instrumentación
Guarda fallos51.h junto al controlador siguiente. Sus funciones se activan solo mediante macros de compilación de cada variante. El generador inserta el include después de las cabeceras de sistema de las copias de prueba.
#ifndef FALLOS51_H
#define FALLOS51_H
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <mqueue.h>
#include <semaphore.h>
#include <inttypes.h>
#if defined(F51_ID49) || defined(F51_ID50)
static char *f51_mkdtemp(char *p)
{
char *r = mkdtemp(p);
if (r) dprintf(STDERR_FILENO, "F51 dir=%s\n", r);
return r;
}
#define mkdtemp f51_mkdtemp
#endif
#ifdef F51_ID50
static int f51_shm_open(const char *n, int flags, mode_t mode)
{
int fd = shm_open(n, flags, mode);
if (fd >= 0 && (flags & O_EXCL)) dprintf(STDERR_FILENO, "F51 shm=%s\n", n);
return fd;
}
static mqd_t f51_mq_open(const char *n, int flags, mode_t mode, const struct mq_attr *a)
{
mqd_t q = mq_open(n, flags, mode, a);
if (q != (mqd_t)-1 && (flags & O_EXCL)) dprintf(STDERR_FILENO, "F51 mq=%s\n", n);
return q;
}
#define shm_open f51_shm_open
#define mq_open f51_mq_open
#endif
#ifdef F51_IO
static ssize_t f51_recv(int fd, void *p, size_t n, int flags)
{
static unsigned k;
if (++k % 7u == 0) { errno = EINTR; return -1; }
return recv(fd, p, n > 1 ? 1 : n, flags);
}
static ssize_t f51_send(int fd, const void *p, size_t n, int flags)
{
static unsigned k;
if (++k % 7u == 0) { errno = EINTR; return -1; }
return send(fd, p, n > 1 ? 1 : n, flags);
}
#define recv f51_recv
#define send f51_send
#endif
#ifdef F51_MQ
static int f51_mq_send(mqd_t q, const char *p, size_t n, unsigned prioridad)
{
static unsigned k;
++k;
if (k <= 8u) { errno = EAGAIN; return -1; }
if (k % 7u == 0) { errno = EINTR; return -1; }
return mq_send(q, p, n, prioridad);
}
static ssize_t f51_mq_receive(mqd_t q, char *p, size_t n, unsigned *prioridad)
{
static unsigned k;
if (++k % 5u == 0) { errno = EINTR; return -1; }
return mq_receive(q, p, n, prioridad);
}
#define mq_send f51_mq_send
#define mq_receive f51_mq_receive
#endif
#ifdef F51_FORK
static pid_t f51_fork(void)
{
static unsigned k;
if (++k == 2u) { errno = EAGAIN; return -1; }
pid_t p = fork();
if (p > 0) dprintf(STDERR_FILENO, "F51 hijo=%jd\n", (intmax_t)p);
return p;
}
#define fork f51_fork
#endif
#ifdef F51_SEM
static int f51_sem_init(sem_t *s, int compartido, unsigned valor)
{
static unsigned k;
if (++k == 5u) { errno = ENOSPC; return -1; }
return sem_init(s, compartido, valor);
}
#define sem_init f51_sem_init
#endif
#endifF51 dir, shm y mq son evidencias de propiedad, no instrucciones para eliminar recursos. F51 hijo registra el primer hijo de la variante cuyo segundo fork fallará. No se considera publicado un nombre si la creación exclusiva no tuvo éxito.
8. Banco completo de pruebas en Python
Guarda fallos51.py. Se requieren Linux con /proc, soporte de pidfd y sus interfaces en Python, GCC, los recursos POSIX del proyecto 50 y cliente49.py del tema 49. El script usa también ctypes para comprobar nombres concretos mediante aperturas de solo lectura, sin crear objetos.
import argparse
import csv
import ctypes
import ctypes.util
import errno
import hashlib
import importlib.util
import io
import json
import os
from pathlib import Path
import re
import selectors
import signal
import socket
import subprocess
import sys
import time
LIMITE = 1024 * 1024
def exigir(condicion, mensaje):
if not condicion:
raise ValueError(mensaje)
class Proceso51:
def __init__(self, args, prefijo):
self.args, self.prefijo = args, prefijo
self.p = subprocess.Popen(args, stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
start_new_session=True)
self.sel = selectors.DefaultSelector()
self.datos = {"out": bytearray(), "err": bytearray()}
self.exceso = self.rescate = False
for nombre, f in [("out", self.p.stdout), ("err", self.p.stderr)]:
os.set_blocking(f.fileno(), False)
self.sel.register(f, selectors.EVENT_READ, nombre)
def bombear(self, segundos=0.02):
for key, mask in self.sel.select(segundos):
try:
bloque = os.read(key.fd, 65536)
except (BlockingIOError, InterruptedError):
continue
if not bloque:
self.sel.unregister(key.fileobj)
key.fileobj.close()
continue
destino = self.datos[key.data]
espacio = LIMITE - len(destino)
if len(bloque) > espacio:
self.exceso = True
destino.extend(bloque[:espacio])
def patron(self, flujo, expresion, segundos=3):
fin = time.monotonic() + segundos
while True:
self.bombear()
exigir(not self.exceso, "captura excede un MiB")
m = re.search(expresion, self.datos[flujo], re.MULTILINE)
if m:
return m
if self.p.poll() is not None and not self.sel.get_map():
raise ValueError("proceso termino antes de la precondicion")
exigir(time.monotonic() < fin, "precondicion no observada dentro del plazo")
def terminar(self, codigo, segundos=4):
fin = time.monotonic() + segundos
while self.p.poll() is None or self.sel.get_map():
self.bombear()
exigir(not self.exceso, "captura excede un MiB")
exigir(time.monotonic() < fin, "sin salida y EOF de capturas dentro del plazo")
exigir(self.p.returncode == codigo,
"retorno " + str(self.p.returncode) + "; esperado " + str(codigo))
def __enter__(self):
return self
def __exit__(self, tipo, valor, traceback):
problema = None
try:
self.bombear(0)
if self.p.poll() is None or self.sel.get_map():
self.rescate = True
try:
os.killpg(self.p.pid, signal.SIGKILL)
except ProcessLookupError:
pass
self.p.wait(timeout=3)
fin = time.monotonic() + 2
while self.sel.get_map() and time.monotonic() < fin:
self.bombear()
exigir(not self.sel.get_map(), "capturas siguen abiertas tras rescate")
except Exception as error:
problema = str(error)
finally:
for key in list(self.sel.get_map().values()):
self.sel.unregister(key.fileobj)
key.fileobj.close()
self.sel.close()
self.prefijo.with_suffix(".stdout").write_bytes(self.datos["out"])
self.prefijo.with_suffix(".stderr").write_bytes(self.datos["err"])
self.prefijo.with_suffix(".proceso.json").write_text(json.dumps({
"args": self.args, "pid": self.p.pid, "retorno": self.p.returncode,
"rescate": self.rescate, "captura_excedida": self.exceso,
"error_limpieza_controlador": problema}, indent=2), encoding="utf-8")
if problema and tipo is None:
raise RuntimeError(problema)
return False
def cambiar(texto, antes, despues):
exigir(texto.count(antes) == 1, "ancla ausente o ambigua: " + antes)
return texto.replace(antes, despues, 1)
def construir(fuentes, salida):
nombres = ["epoll49.c", "trabajadores50.c", "cliente49.py"]
contenidos = {n: (fuentes / n).read_bytes() for n in nombres}
for nombre, datos in contenidos.items():
(salida / ("base_" + nombre)).write_bytes(datos)
cabecera = Path(__file__).resolve().with_name("fallos51.h").read_bytes()
(salida / "fallos51.h").write_bytes(cabecera)
hashes = {n: hashlib.sha256(b).hexdigest() for n, b in contenidos.items()}
hashes["fallos51.h"] = hashlib.sha256(cabecera).hexdigest()
base49 = contenidos["epoll49.c"].decode("utf-8")
base50 = contenidos["trabajadores50.c"].decode("utf-8")
corta = cambiar(base49, "c->vence = ahora + 10000;", "c->vence = ahora + 250;")
presion = cambiar(base49, "uint32_t nueva = c->generacion + 1u;",
"int pequeno=1024; if(setsockopt(fd,SOL_SOCKET,SO_SNDBUF,&pequeno,sizeof pequeno)==-1)"
"{cerrar49(&fd);return -1;}\n uint32_t nueva = c->generacion + 1u;")
presion = cambiar(presion, "s->gracia = ahora + 3000;", "s->gracia = ahora + 150;")
defectuoso = cambiar(base49,
"memcpy(c->salida + c->salida_usada, c->cuerpo, c->longitud);",
"if(c->longitud)c->cuerpo[0]^=1;\n "
"memcpy(c->salida + c->salida_usada, c->cuerpo, c->longitud);")
pausa = cambiar(base50, "if (sem_post(&r->preparados) == -1) return -1;",
"if (sem_post(&r->preparados) == -1) return -1;\n raise(SIGSTOP);")
roto = cambiar(base50, "s->suma = suma;", "s->suma = suma + 1;")
variantes = {
"epoll_base": (base49, ["F51_ID49"]),
"epoll_io": (base49, ["F51_ID49", "F51_IO"]),
"epoll_corto": (corta, ["F51_ID49"]),
"epoll_presion": (presion, ["F51_ID49"]),
"epoll_defectuoso": (defectuoso, ["F51_ID49"]),
"pool_base": (base50, ["F51_ID50"]),
"pool_retry": (base50, ["F51_ID50", "F51_MQ"]),
"pool_roto": (roto, ["F51_ID50"]),
"pool_pausa": (pausa, ["F51_ID50"]),
"pool_plazo": (cambiar(pausa, "limite += 8000;", "limite += 300;"), ["F51_ID50"]),
"pool_fork": (base50, ["F51_ID50", "F51_FORK"]),
"pool_sema": (base50, ["F51_ID50", "F51_SEM"])}
manifiesto = {"fuentes_sha256": hashes, "python": sys.version,
"sistema": list(os.uname()), "compilaciones": []}
binarios = {}
for nombre, (texto, macros) in variantes.items():
ancla = "#define CLIENTES49" if nombre.startswith("epoll") else "#define HIJOS50"
texto = cambiar(texto, ancla, '#include "fallos51.h"\n' + ancla)
src, exe = salida / (nombre + ".c"), salida / nombre
src.write_text(texto, encoding="utf-8")
args = ["gcc", "-std=c11", "-Wall", "-Wextra", "-Wpedantic", "-Werror",
"-fmax-errors=5", "-O2"] + ["-D" + m for m in macros]
args += [str(src), "-o", str(exe), "-pthread", "-lrt"]
with (salida / (nombre + ".gcc.log")).open("wb") as log:
compilador = subprocess.Popen(args, stdout=log, stderr=subprocess.STDOUT,
start_new_session=True)
try:
codigo = compilador.wait(timeout=20)
except BaseException:
try:
os.killpg(compilador.pid, signal.SIGKILL)
except ProcessLookupError:
pass
compilador.wait()
raise
exigir(codigo == 0, "compilacion fallida; revisar " + nombre + ".gcc.log")
binarios[nombre] = exe
manifiesto["compilaciones"].append({"nombre": nombre, "args": args,
"variante_sha256": hashlib.sha256(src.read_bytes()).hexdigest()})
(salida / "manifiesto.json").write_text(json.dumps(manifiesto, indent=2), encoding="utf-8")
return binarios
def servicio(p):
m = p.patron("out", rb"^E49 listo pid=([0-9]+) socket=(\S+) max=32$")
exigir(int(m[1]) == p.p.pid, "PID de servicio incompatible")
return os.fsdecode(m[2])
def limpiar_nombres(p):
texto = bytes(p.datos["err"]).decode("utf-8", errors="replace")
for ruta in re.findall(r"^F51 dir=(\S+)$", texto, re.MULTILINE):
exigir(ruta.startswith(("/tmp/epoll49.", "/tmp/ipc50.")), "ruta de propiedad incompatible")
exigir(not os.path.lexists(ruta), "directorio propio residual: " + ruta)
lib = ctypes.CDLL(ctypes.util.find_library("rt") or None, use_errno=True)
lib.shm_open.argtypes = [ctypes.c_char_p, ctypes.c_int, ctypes.c_uint]
lib.shm_open.restype = ctypes.c_int
lib.mq_open.argtypes = [ctypes.c_char_p, ctypes.c_int]
lib.mq_open.restype = ctypes.c_int
lib.mq_close.argtypes = [ctypes.c_int]
for tipo, nombre in re.findall(r"^F51 (shm|mq)=(\S+)$", texto, re.MULTILINE):
prefijo = "/p50m_" if tipo == "shm" else "/p50q_"
exigir(nombre.startswith(prefijo + str(p.p.pid) + "_"), "nombre no pertenece al proceso")
ctypes.set_errno(0)
fd = lib.shm_open(nombre.encode(), os.O_RDONLY, 0) if tipo == "shm" else \
lib.mq_open(nombre.encode(), os.O_RDONLY | os.O_NONBLOCK)
error = ctypes.get_errno()
if fd != -1:
os.close(fd) if tipo == "shm" else lib.mq_close(fd)
raise ValueError("objeto propio sigue publicado: " + nombre)
exigir(error == errno.ENOENT, "no se pudo demostrar ausencia de " + nombre)
def epoll_caso(p, cli, tipo):
ruta = servicio(p)
if tipo in ("fragmentos", "io"):
cli.intercambiar(ruta, [b"", b"A\x00B", bytes(range(256))*16],
fragmentado=(tipo == "fragmentos"))
elif tipo == "invalidas":
for datos in [b"\x00\x00", b"\x00\x00\x00\x08abc",
(4097).to_bytes(4, "big"), (4294967295).to_bytes(4, "big")]:
cli.invalida(ruta, datos)
cli.intercambiar(ruta, [b"escucha sigue viva"])
elif tipo == "vida":
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.settimeout(2); s.connect(ruta)
ping = cli.tramas([b"aceptado"])
s.sendall(ping)
exigir(cli.leer_exacto(s, len(ping), time.monotonic()+1) == ping, "sin eco inicial")
s.sendall(b"\x00\x00")
cli.intercambiar(ruta, [b"otro cliente"], segundos=1)
exigir(s.recv(1) == b"", "no cerro la sesion vencida")
elif tipo == "control":
detectado = False
try:
cli.intercambiar(ruta, [b"debe detectar corrupcion"])
except ValueError:
detectado = True
exigir(detectado, "el oraculo acepto el servidor deliberadamente defectuoso")
p.p.terminate()
p.terminar(0)
def presion_caso(p, cli, abandonar):
ruta = servicio(p)
epfd = next(f.name for f in Path("/proc", str(p.p.pid), "fd").iterdir()
if os.readlink(f) == "anon_inode:[eventpoll]")
esperado = cli.tramas([bytes((i+j)%251 for j in range(4096)) for i in range(128)])
enviados = recibidos = 0
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(ruta); s.setblocking(False)
fin = time.monotonic()+2
while True:
if enviados < len(esperado):
try:
enviados += s.send(memoryview(esperado)[enviados:enviados+65536])
except BlockingIOError:
pass
p.bombear(0)
texto = Path("/proc", str(p.p.pid), "fdinfo", epfd).read_text()
pausado = False
for linea in texto.splitlines():
m = re.search(r"events:\s*([0-9a-f]+).*data:\s*([0-9a-f]+)", linea)
if m and int(m[2],16) == 1 << 32:
mascara = int(m[1],16)
pausado = bool(mascara & 4) and not bool(mascara & (1 | 0x2000))
if pausado:
break
exigir(time.monotonic() < fin, "no se observo pausa real de lectura")
time.sleep(0.005)
cli.intercambiar(ruta, [b"otro cliente progresa"], segundos=1)
if abandonar:
p.p.terminate()
p.terminar(1, 2)
exigir(b"gracia agotada" in p.datos["err"], "no se observo vencimiento de gracia")
return
fin = time.monotonic()+4
cerrado = False
with selectors.DefaultSelector() as sel:
sel.register(s, selectors.EVENT_READ | selectors.EVENT_WRITE)
while True:
if enviados == len(esperado) and not cerrado:
s.shutdown(socket.SHUT_WR); cerrado = True
sel.modify(s, selectors.EVENT_READ | (0 if cerrado else selectors.EVENT_WRITE))
eventos = sel.select(max(0, fin-time.monotonic()))
exigir(eventos, "sin reanudacion dentro del plazo")
terminado = False
for key, mask in eventos:
if mask & selectors.EVENT_WRITE and not cerrado:
try:
enviados += s.send(memoryview(esperado)[enviados:enviados+65536])
except BlockingIOError:
pass
if mask & selectors.EVENT_READ:
try:
bloque = s.recv(65536)
except BlockingIOError:
continue
if not bloque:
terminado = True; break
exigir(bloque == esperado[recibidos:recibidos+len(bloque)], "eco desordenado o corrupto")
recibidos += len(bloque)
p.bombear(0)
if terminado:
break
exigir(enviados == recibidos == len(esperado), "pipeline incompleto")
p.p.terminate()
p.terminar(0)
def anuncio_pool(p):
m = p.patron("err", rb"^P50 listo padre=([0-9]+) hijos=([0-9]+),([0-9]+) ranuras=4 tareas=17 elementos=1024$")
exigir(int(m[1]) == p.p.pid, "PID de supervisor incompatible")
hijos = [int(m[2]), int(m[3])]
exigir(len(set(hijos)) == 2, "identidades de hijos repetidas")
return hijos
def csv_pool(p, hijos):
lector = csv.DictReader(io.StringIO(bytes(p.datos["out"]).decode()))
campos = ["tarea", "ranura", "generacion", "trabajador", "elementos", "suma"]
filas = list(lector)
exigir(lector.fieldnames == campos and len(filas) == 17, "CSV incompleto")
vistos, generaciones = set(), [0]*4
for fila in filas:
exigir(None not in fila and all(v is not None for v in fila.values()), "columnas incompatibles")
f = {k: int(v) for k,v in fila.items()}
ident, i = f["tarea"], f["ranura"]
exigir(1 <= ident <= 17 and ident not in vistos and 0 <= i < 4, "identidad invalida")
exigir(f["generacion"] == generaciones[i]+1, "generacion incorrecta")
exigir(f["trabajador"] in hijos and f["elementos"] == 1024, "PID o carga incorrectos")
exigir(f["suma"] == sum((ident+j)%1000 for j in range(1024)), "suma incorrecta")
generaciones[i] = f["generacion"]; vistos.add(ident)
def identidad(pid):
campos = Path("/proc", str(pid), "stat").read_text().rsplit(")",1)[1].split()
return campos[0], int(campos[1]), int(campos[2]), int(campos[3]), campos[19]
def sin_hijos_del_grupo(p, hijos):
for pid in hijos:
try:
actual = identidad(pid)
except FileNotFoundError:
continue
exigir(actual[2:4] != (p.p.pid, p.p.pid), "hijo original sigue en el grupo, vivo o zombie")
def pool_caso(p, tipo):
if tipo in ("fork", "sema"):
p.terminar(1)
exigir(not p.datos["out"], "salida de exito tras arranque fallido")
sin_hijos_del_grupo(p, [int(pid) for pid in
re.findall(rb"^F51 hijo=([0-9]+)$", p.datos["err"], re.MULTILINE)])
return
hijos = anuncio_pool(p)
if tipo in ("base", "retry"):
p.terminar(0, 10)
csv_pool(p, hijos)
sin_hijos_del_grupo(p, hijos)
return
if tipo == "roto":
p.terminar(1)
exigir(not p.datos["out"], "CSV de exito tras corrupcion")
sin_hijos_del_grupo(p, hijos)
return
referencias = []
try:
for pid in hijos:
fd = os.pidfd_open(pid)
referencias.append((pid, fd, identidad(pid)[4]))
fin = time.monotonic()+1
while True:
estados = [identidad(pid) for pid in hijos]
exigir(all(e[1:4] == (p.p.pid,p.p.pid,p.p.pid) for e in estados), "hijo fuera del grupo propio")
if all(e[0] == "T" for e in estados):
break
exigir(time.monotonic() < fin, "trabajadores no se detuvieron en el punto previsto")
p.bombear()
if tipo == "caida":
signal.pidfd_send_signal(referencias[0][1], signal.SIGKILL)
elif tipo == "cancelar":
p.p.terminate()
p.terminar(1, 2)
exigir(not p.datos["out"], "salida de exito tras fallo del grupo")
for pid, fd, inicio in referencias:
try:
actual = identidad(pid)
except FileNotFoundError:
continue
exigir(actual[4] != inicio, "hijo original sigue vivo o zombie")
finally:
for pid, fd, inicio in referencias:
os.close(fd)
def main():
a = argparse.ArgumentParser()
a.add_argument("--fuentes", type=Path, default=Path("."))
a.add_argument("--evidencia", type=Path, required=True)
op = a.parse_args()
exigir(sys.platform.startswith("linux"), "este banco requiere Linux")
exigir(hasattr(os,"pidfd_open") and hasattr(signal,"pidfd_send_signal"), "Python sin interfaces pidfd")
fuentes = op.fuentes.resolve(strict=True)
salida = op.evidencia.absolute()
salida.mkdir(mode=0o700)
resultados = []
try:
binarios = construir(fuentes, salida)
sys.dont_write_bytecode = True
spec = importlib.util.spec_from_file_location("cliente49_prueba51", salida/"base_cliente49.py")
cli = importlib.util.module_from_spec(spec); spec.loader.exec_module(cli)
casos = [
("49_fragmentos","epoll_base","fragmentos"), ("49_io","epoll_io","io"),
("49_invalidas","epoll_base","invalidas"), ("49_vida","epoll_corto","vida"),
("49_presion","epoll_presion","recuperar"), ("49_gracia","epoll_presion","abandonar"),
("49_control_negativo","epoll_defectuoso","control"),
("50_base","pool_base","base"), ("50_reintentos","pool_retry","retry"),
("50_resultado_roto","pool_roto","roto"), ("50_caida","pool_pausa","caida"),
("50_cancelacion","pool_pausa","cancelar"), ("50_plazo","pool_plazo","plazo"),
("50_fork_parcial","pool_fork","fork"), ("50_sem_parcial","pool_sema","sema")]
for nombre, binario, tipo in casos:
p = None; error = None
inicio = time.monotonic()
try:
args = [str(binarios[binario])] + (["17","1024"] if nombre.startswith("50") else [])
p = Proceso51(args, salida/nombre)
with p:
if nombre.startswith("50"):
pool_caso(p,tipo)
elif tipo in ("recuperar","abandonar"):
presion_caso(p,cli,tipo == "abandonar")
else:
epoll_caso(p,cli,tipo)
limpiar_nombres(p)
exigir(not p.rescate and not p.exceso, "caso necesitó rescate o excedió captura")
except Exception as exc:
error = str(exc)
resultados.append({"caso": nombre, "correcto": error is None, "error": error,
"rescate": p.rescate if p else False, "duracion_s": time.monotonic()-inicio})
(salida/"resultados.json").write_text(json.dumps(resultados,indent=2),encoding="utf-8")
print(("OK " if error is None else "FALLO ") + nombre, flush=True)
except Exception as exc:
(salida/"preparacion_error.txt").write_text(str(exc),encoding="utf-8")
raise
exigir(resultados and all(r["correcto"] for r in resultados), "hay casos fallidos; revisar evidencia")
if __name__ == "__main__":
try:
main()
except (OSError, ValueError, RuntimeError, subprocess.TimeoutExpired) as error:
print(error, file=sys.stderr)
sys.exit(1)9. Preparar y ejecutar el conjunto
Guarda los bloques de los temas anteriores en archivos reales: epoll49.c, trabajadores50.c y cliente49.py. Coloca también fallos51.py y fallos51.h. El banco no extrae código de las páginas HTML durante su ejecución.
# Archivos necesarios en el directorio actual:
# epoll49.c trabajadores50.c cliente49.py fallos51.py fallos51.h
python3 fallos51.py --fuentes . --evidencia evidencia51evidencia51 debe ser un directorio nuevo. Se conservan las tres fuentes base, la cabecera, doce variantes, sus binarios, logs de compilación, manifiesto y evidencias por caso. Para repetir, elige otro directorio, por ejemplo evidencia51_segunda.
El conjunto ejecuta quince casos: siete del servidor —incluido el control negativo— y ocho de trabajadores. Imprime OK solo cuando el oráculo del caso y la comprobación de nombres pasan sin rescate. Cualquier FALLO hace terminar el banco con retorno no cero.
python3 -m json.tool evidencia51/resultados.json
python3 -m json.tool evidencia51/manifiesto.json
cat evidencia51/50_caida.stderr
cat evidencia51/50_caida.proceso.json
cat evidencia51/49_gracia.stderrLos errores de preparación se guardan en preparacion_error.txt. Si falta una interfaz, un ancla cambió o GCC rechazó la variante, no se declara que las pruebas funcionales pasaron. Los logs permiten revisar qué se intentó compilar y con qué argumentos.
Una ejecución repetida comprueba reproducibilidad en ese entorno, no validez universal de todos los límites temporales. Conserva versión de Python, sistema y hashes del manifiesto cuando compares resultados de equipos diferentes.
10. Fragmentación, truncamiento y clientes incompletos
El caso fragmentos usa el cliente del tema 49 con envíos de hasta tres bytes: una trama vacía, un cuerpo que contiene NUL y un cuerpo máximo. El caso io limita las operaciones reales del servidor a un byte y agrega EINTR, por lo que no depende de cómo el núcleo agrupe escrituras del cliente.
Los mensajes inválidos se envían realmente: una cabecera de dos bytes seguida de EOF, un cuerpo corto, longitud 4097 y longitud UINT32_MAX. El servidor debe cerrar esa sesión sin reservar el cuerpo excesivo. Después de cada una se verifica una consulta válida en otra conexión.
Una lectura positiva corta no es truncamiento. Truncamiento es llegar a EOF antes de reunir los bytes prometidos. Por otro lado, una cabecera con longitud cero es una petición completa válida y debe producir su eco de cuatro bytes.
Para demostrar aislamiento, una conexión obtiene primero un eco que confirma su admisión y luego deja incompleta la siguiente cabecera. Se consulta desde otra conexión mientras la primera permanece abierta. Así el ensayo distingue un bucle no bloqueante de uno que queda esperando a ese cliente.
El caso de vida usa una copia con 250 ms de duración máxima por sesión. Ese valor es parte de la variante, no una modificación del proyecto base. Se verifica cierre de la sesión vencida y conservación del servicio para otra consulta.
11. Clientes lentos y contrapresión comprobada
El cliente de presión prepara 128 tramas máximas y comienza a enviarlas sin leer. La variante reduce SO_SNDBUF en el conectado del servidor. El cliente también es no bloqueante: si su propio envío deja de progresar, el controlador sigue observando la condición del servidor.
En /proc/PID/fdinfo del epoll se busca el token de la primera sesión, generación uno e índice cero. La condición exige EPOLLOUT presente y EPOLLIN y EPOLLRDHUP retirados. Ese estado corresponde a una salida que necesita capacidad mientras se pausó la entrada.
No se interpreta una máscara de otra conexión ni los tokens especiales de escucha y control. Los descriptores enteros pueden reutilizarse; el token de aplicación pertenece al contrato del tema 49.
| Después de observar presión | Acción del controlador | Resultado exigido |
|---|---|---|
| Otro cliente. | Realizar una consulta breve independiente. | Progreso mientras el primero no lee. |
| Recuperación. | Enviar lo que falta y leer simultáneamente. | Eco completo y ordenado de las 128 tramas, seguido de EOF. |
| Gracia agotada. | Solicitar parada y seguir sin leer. | Retorno uno y evidencia de gracia agotada, sin rescate. |
La variante de presión reduce la gracia a 150 ms para acotar el caso de abandono. En recuperación, la presión se libera antes de solicitar parada, de modo que el mismo binario puede cerrar normalmente.
Los buffers del núcleo y el tiempo de planificación cambian entre sistemas. El banco espera la condición con plazo y falla si no puede demostrarla. No transforma «no se reprodujo» en «el comportamiento es correcto».
12. Trabajadores detenidos, caída y cancelación
La variante pool_pausa ejecuta SIGSTOP después de publicar preparado y antes de recibir tareas. Ambos hijos siguen siendo procesos del supervisor. El controlador espera sus estados T y conserva pidfds antes de actuar.
En caida, envía SIGKILL a un trabajador por su pidfd. El supervisor debe observar el fallo, detener al otro y recoger a ambos. En cancelacion, se envía SIGTERM al supervisor mientras los trabajadores siguen detenidos. El padre no puede depender de una terminación cooperativa de esos hijos y debe completar su limpieza de error.
En plazo se utiliza la misma pausa con un límite interno de 300 ms. El controlador no manda una señal para iniciar la salida: exige que el proyecto detecte su propio vencimiento y termine sin publicar CSV.
Los pidfds se cierran siempre después del ensayo. Una referencia estable evita señalar un PID que se reutilizó, pero no recoge al proceso. La ausencia de la identidad original se comprueba después de la salida del supervisor.
Los fallos de segundo fork y quinto sem_init ejercitan el arranque parcial. El primero ya tiene un hijo propio que debe recoger; el segundo todavía no creó trabajadores, pero tiene objetos y algunos semáforos inicializados. En ninguno debe aparecer salida de éxito.
13. Distinguir salida, recogida y retirada
| Hecho | Qué demuestra | Qué falta |
|---|---|---|
| Se pidió SIGTERM. | El controlador solicitó una acción. | Que se atendió y terminó. |
| El proceso dejó de ejecutar. | Terminación o estado observado. | Recogida y liberación de referencias. |
| Popen obtuvo retorno. | Se consumió el estado del hijo directo. | Que el supervisor recogió sus propios hijos. |
| Desapareció un nombre. | Ya no se abre mediante ese nombre. | Que no quedan mapeos o descriptores abiertos. |
| El banco mató el grupo. | Aplicó su rescate. | Limpieza correcta del programa: ese ensayo no pasa. |
Los nombres POSIX se comprueban mediante shm_open o mq_open sin O_CREAT. Si la apertura tiene éxito, se cierra esa nueva referencia y se informa que el nombre sigue publicado. Si falla, solo ENOENT demuestra la ausencia esperada; un error de permisos no se interpreta como limpieza.
La semántica de nombres y referencias de sockets Unix se detalla en unix(7). Para los objetos del proyecto 50 se preserva la distinción entre retirar el nombre y cerrar la última referencia heredada.
El banco no destruye automáticamente un nombre residual para que la comprobación siguiente pase. El propietario y la ruta quedan en la evidencia. Si el programa tuviera un defecto de limpieza, primero se debe documentar el hallazgo y después retirar únicamente sus recursos identificados bajo una acción de mantenimiento separada.
Los hijos del caso detenido se siguen por identidad de inicio. En los casos rápidos se contrasta que no persista un proceso en el grupo y sesión originales. No se envían señales basándose en una lista global de nombres ni en un PID ilustrativo copiado de otra corrida.
14. Leer evidencias y clasificar resultados
| Archivo | Contenido | Uso |
|---|---|---|
| manifiesto.json. | Hashes, entorno y comandos de compilación. | Identificar qué fuentes y variantes se probaron. |
| base_*.c y base_cliente49.py. | Copias exactas de entradas. | Conservar la versión aun si después cambia el curso. |
| Variante .c y .gcc.log. | Código generado y diagnóstico del compilador. | Revisar el punto real de inyección. |
| Caso .stdout y .stderr. | Captura acotada de ambos flujos. | Examinar anuncios, CSV y errores. |
| Caso .proceso.json. | Argumentos, PID, retorno, rescate y captura. | Separar resultado del programa e intervención del banco. |
| resultados.json. | Dictamen por caso, error y duración observada. | Revisar el conjunto sin perder fallos individuales. |
La duración de un caso es diagnóstica. Incluye consultas, sincronización, observaciones y limpieza; no es un benchmark del mecanismo IPC. La compilación también usa límites externos y logs propios.
Un caso esperado de rechazo tiene retorno uno y pasa si rechaza exactamente el comportamiento inyectado, no emite un resultado de éxito y limpia. Un caso con rescate falla aunque los procesos desaparezcan después de SIGKILL.
Si no se observó la precondición, la evidencia no permite atribuir el resultado al punto previsto. El banco lo registra como caso fallido con esa causa; en un informe puede clasificarse como no concluyente hasta resolver entorno, sincronización o variante.
Los resultados que quedan antes de una interrupción representan un prefijo del conjunto. La existencia de resultados.json no prueba que se ejecutaron los quince casos: comprueba cantidad, nombres, dictámenes y retorno final.
15. Simular la evaluación de un ensayo
El evaluador separa observaciones que suelen mezclarse. Una salida cero con recursos residuales falla. Un rechazo previsto con salida uno puede pasar. Si hubo rescate o venció el controlador, la limpieza posterior no convierte el ensayo en correcto.
Dictamen—
Resultado y retorno esperados—
Motivo—
Siguiente comprobación—
—
«Resultado de aplicación» no incluye anuncios de preparación. Por ejemplo, P50 listo puede aparecer en stderr y aun así el rechazo correcto exige que no exista CSV de éxito en stdout. El evaluador es conceptual y no inspecciona procesos del equipo.
16. Comprobar que la prueba detecta un defecto
Un banco que siempre imprime OK puede tener un oráculo vacío. El control negativo cambia un byte del cuerpo antes de formar el eco. El cliente debe detectar la diferencia y lanzar ValueError; solo entonces el caso de control negativo pasa.
No se modifica la cabecera ni se termina el servidor para que el cliente falle por otra causa. El defecto es de contenido, y el ensayo espera su detección específica. Un timeout en ese caso no sustituye haber comprobado la corrupción.
Se detiene el servidor defectuoso normalmente después de comprobar la detección y se revisan sus nombres. Esto separa dos preguntas: el oráculo reconoce datos incorrectos y el controlador no deja un proceso vivo al terminar el control.
Otros controles útiles serían un verificador que recibe un ID duplicado, un resultado con generación antigua y una respuesta válida seguida de bytes extra. Cada uno debe tener una razón de rechazo propia.
También debe probarse el controlador: un programa que llena stdout y stderr, otro que excede la captura y uno que termina dejando un descendiente con una tubería abierta. Son pruebas del banco, distintas de los quince ensayos de los proyectos incluidos aquí.
17. Ampliar cobertura sin perder reproducibilidad
Agrega cada caso con una hipótesis y un punto de inyección revisables. Conserva una variante y un dictamen por caso, y usa semillas registradas cuando introduzcas secuencias aleatorias.
- Escribir qué garantía podría romperse y cuál sería su evidencia.
- Elegir una condición de sincronización que confirme la fase.
- Inyectar un único cambio semántico controlado.
- Comprobar resultado y progreso de participantes no afectados.
- Verificar retorno, hijos, referencias y nombres bajo propiedad.
- Conservar la versión exacta y repetir el caso aislado antes de incorporarlo al conjunto.
Para generaciones antiguas del servidor, puede invocarse su despachador con un token guardado después de reutilizar la ranura. Así se comprueba una transición difícil sin esperar una carrera particular del núcleo. Es diferente de probar la planificación real de epoll y ambas evidencias deben distinguirse.
Para publicaciones del proyecto 50, cambia el campo antes de sem_post correspondiente. Si se altera después, podrías crear una carrera que no corresponde al fallo previsto y volver no determinista el ensayo.
Los sanitizadores pueden detectar accesos fuera de rango y otros defectos durante casos funcionales, con alcance y plataforma documentados. No reemplazan la comprobación de protocolo, proceso recogido o nombre retirado.
La repetición ayuda a encontrar intercalados, pero no demuestra ausencia de carreras. Conserva la revisión de invariantes y el análisis del ciclo de recursos junto a los ensayos ejecutables.
18. Revisar el banco antes de confiar en él
| Riesgo del propio banco | Revisión necesaria |
|---|---|
| Capturar un flujo y olvidar el otro. | Drenar ambos y limitar memoria. |
| Confundir rescate con limpieza. | Registrar intervención y fallar el dictamen. |
| Señalar un PID ajeno. | Conservar identidad, topología y referencias propias. |
| Probar una fuente distinta de la que se cree. | Copias base, hashes y anclas exactas. |
| Borrar evidencia al repetir. | Directorio nuevo y archivos por caso. |
| Ignorar EOF retenido por un descendiente. | Esperar proceso y cierre de capturas con plazo. |
| Declarar limpieza por error de permisos. | Exigir la evidencia concreta de ausencia. |
| Probar solo entradas que siempre pasan. | Control negativo deliberado y razón específica de rechazo. |
El banco conoce la topología y los mensajes de estas versiones. No es una herramienta para ejecutar binarios arbitrarios o administrar todo el equipo. Si una versión cambia protocolo, procesos o forma de publicación, se actualizan sus oráculos y su modelo de aislamiento.
Un rescate puede terminar el grupo sin ejecutar finalizadores del programa. Si quedan nombres, se informa esa evidencia en lugar de atribuir al proyecto una limpieza que no ocurrió. Para procesos en estados no interrumpibles, el controlador puede no completar la recogida dentro del límite: eso también se registra como problema.
No uses estas duraciones como comparación de rendimiento. Las variantes agregan señales, operaciones de un byte, consultas a /proc y límites reducidos. La medición sin instrumentación pertenece a otro experimento con el mismo contrato funcional.
19. Resumen, repaso y práctica
Probar bajo fallos exige observar primero la fase, inyectar una semántica precisa y comprobar más que el retorno. El conjunto conserva evidencias, controla sus procesos y distingue rechazo esperado, falta de precondición, timeout, residuo y rescate. El control negativo comprueba que el oráculo no acepta cualquier salida.
- Precondición: no atribuir el resultado a una fase que no se observó.
- Inyección: no declarar progreso que la operación real no hizo.
- Oráculo: identidad, bytes, orden y valor bajo el contrato del caso.
- Limpieza: distinguir nombres, referencias, terminación y recogida.
- Evidencia: fuentes exactas, comandos, capturas y rescate visible.
Preguntas de repaso
1. ¿Un retorno cero basta para pasar?
No. Se requieren precondición, resultado válido y limpieza, dentro del plazo y sin rescate.
2. ¿Puede pasar un caso con retorno uno?
Sí, cuando ese es el rechazo esperado y se cumplen las otras observaciones del contrato.
3. ¿Por qué no usar una pausa fija para sincronizar?
No demuestra que el programa alcanzó la fase prevista. Se espera una condición con un límite propio.
4. ¿Cómo se fuerza una transferencia corta real?
Se reduce el tamaño de la llamada efectiva y se devuelve su resultado real. No se inventan bytes transferidos.
5. ¿Por qué EAGAIN debe inyectarse antes de mq_send?
Si el mensaje ya se envió, simular que no se aceptó provocaría duplicados y cambiaría el contrato del fallo.
6. ¿Qué prueba la pausa de lectura observada?
Que la sesión tiene salida pendiente y retiró intereses de entrada por capacidad, bajo el token correcto.
7. ¿Qué agrega leer y enviar simultáneamente?
Permite liberar contrapresión sin bloquear ambos extremos esperando capacidad en direcciones opuestas.
8. ¿Para qué se usan pidfds?
Para mantener una referencia estable al trabajador autorizado que se va a señalar. No sustituyen la comprobación de pertenencia ni su recogida.
9. ¿Un hijo detenido responde normalmente a SIGTERM?
Puede no ejecutar acciones cooperativas mientras está detenido. El supervisor de error debe completar su política y recogerlo.
10. ¿La ausencia del nombre de memoria demuestra que no hay mapeo?
No. Un mapeo heredado puede seguir vivo después de retirar el nombre.
11. ¿Qué error de apertura demuestra ausencia en estas comprobaciones?
ENOENT bajo el nombre concreto. EACCES u otro error no se convierte en evidencia de limpieza.
12. ¿El controlador recoge directamente a los trabajadores del supervisor?
No en este diseño. Son hijos del supervisor; se comprueba su desaparición y se exige que el supervisor complete su política.
13. ¿Qué significa rescate en un dictamen?
El controlador tuvo que intervenir para terminar el conjunto. El caso falla aunque después no queden procesos ejecutándose.
14. ¿Por qué incluir un servidor deliberadamente corrupto?
Para verificar que el cliente detecta un defecto de contenido real y que el banco no imprime éxito sin evaluar datos.
15. ¿Quince casos correctos prueban ausencia de todos los defectos?
No. Aportan evidencia de esos contratos y variantes. Se conserva revisión de invariantes y se amplía cobertura cuando cambian requisitos o implementación.
Para practicar y ampliar
- Escribe una ficha de precondición, inyección, oráculo y limpieza para cada caso.
- Ejecuta el banco dos veces en directorios diferentes y compara hashes y dictámenes.
- Introduce una longitud válida seguida de bytes extra y define el resultado esperado.
- Agrega una inyección controlada de token antiguo al despachador del servidor.
- Corrompe ID, generación y PID de un resultado antes de terminado.
- Comprueba que una captura excesiva falla y conserva solo su prefijo acotado.
- Haz que un programa de prueba escriba en ambos flujos y verifica que el banco no se bloquea.
- Prueba un descendiente que conserva stdout abierto tras salir su padre.
- Agrega un control negativo para un ID duplicado en CSV.
- Registra una semilla y reproduce una secuencia aleatoria de fragmentos.
- Distingue en un informe fallos funcionales, de precondición, de entorno y de limpieza.
- Explica qué cambiaría al ejecutar binarios que abandonan su grupo de procesos.
El tema 52 cierra el curso y prepara el puente a la programación de redes: repasar decisiones de IPC y trasladar framing, límites, identidad y pruebas al estudio de TCP y UDP.