Mostrando el Markdown sin formato: no se pudo cargar el visor.
## Objetivo
Escribes en Python un pequeño servidor eco del Transmission Control Protocol (TCP) y otro del User Datagram Protocol (UDP), hablas con ellos con tus propios clientes y con `nc`, y observas cómo cambian de estado los sockets con `ss` (o `netstat`). Después provocas los dos fallos clásicos, «connection refused» y «connection timed out», y ves por qué uno tarda milisegundos y el otro tarda lo que tú le dejes. Todo se ejecuta en tu propio ordenador, en `127.0.0.1`.
## Objetivos
- Explicar cómo un puerto en escucha y un puerto efímero de cliente identifican juntos una conexión.
- Comparar TCP y UDP ejecutando ambos en el mismo número de puerto y viendo lo distinto que se comportan.
- Observar una conexión TCP pasar de ESTABLISHED a TIME-WAIT y, opcionalmente, capturar el acuerdo de tres vías y el cierre con `tcpdump`.
- Identificar sockets en escucha y estados de conexión (LISTEN, ESTAB, TIME-WAIT, UNCONN) con `ss` o `netstat`.
- Reproducir y explicar «connection refused» frente a «connection timed out».
## Requisitos previos
- Un ordenador con Linux (con `ss` de iproute2), macOS o Windows 10/11.
- Python 3.10 o posterior, solo biblioteca estándar. Este laboratorio se probó con Python 3.14.7 y 3.11.8. Comprueba el tuyo con `python3 --version` (en Windows: `py --version`).
- `nc` (netcat), opcional pero recomendado. Linux: paquete `netcat-openbsd` (Debian, Ubuntu) o `nmap-ncat` (Fedora, RHEL). macOS: incluido. Windows: no incluido; usa los clientes de Python y `Test-NetConnection` en su lugar. Las salidas de abajo proceden de OpenBSD netcat 1.226.
- Tres ventanas de terminal: una para cada servidor y otra para tus comandos.
- Opcional, solo para el Paso 10: `tcpdump` y permisos de administrador (`sudo`) en Linux o macOS.
- [Lección: Capa de transporte: TCP, UDP y puertos](lesson.es.md) de este módulo.
> [!WARNING]
> Ejecuta todos los comandos de este laboratorio **solo contra tu propio ordenador**: `127.0.0.1` y la dirección de documentación `192.0.2.1` (RFC 5737), que nunca se asigna a un equipo real. No apuntes `nc -z`, `probe.py` ni ninguna otra prueba de conexión a sistemas que no sean tuyos o que no estés explícitamente autorizado a probar: sondear los puertos de otras personas es escaneo de puertos, lo cual puede ser ilegal e incumple los términos de servicio de la mayoría de los proveedores. Los servidores de este laboratorio escuchan solo en `127.0.0.1`, así que nada de tu red puede alcanzarlos.
## Arquitectura
<figure class="diagram" style="--dg-w: 980px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 980 480" width="980" height="480" role="img" aria-labelledby="tcp-lab-architecture-es-title tcp-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="tcp-lab-architecture-es-title">Arquitectura del laboratorio: sockets TCP y UDP en tu propio ordenador</title>
<desc id="tcp-lab-architecture-es-desc">Todo se ejecuta en tu ordenador a través de la interfaz de loopback, 127.0.0.1. Los clientes tcp_client.py, udp_client.py, nc y probe.py usan puertos de origen efímeros. Hablan con un servidor eco TCP en 127.0.0.1 puerto 9000, un servidor eco UDP en 127.0.0.1 puerto 9000 y el puerto 9001, donde nada escucha, que responde a TCP con RST y a UDP con un mensaje ICMP de puerto inalcanzable. Observas con ss -tan, ss -uln y, opcionalmente con sudo, tcpdump -i lo. Una sonda va a la dirección de documentación 192.0.2.1 puerto 80, que nunca responde, así que la conexión agota el tiempo de espera.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="979" height="479" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="700" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Tu ordenador · interfaz de loopback (lo) · 127.0.0.1</text></g>
<rect class="dg-card" x="44" y="64" width="200" height="330" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 80) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="102" y="101" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Clientes</text>
<text x="62" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">tcp_client.py</text>
<text x="62" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">udp_client.py</text>
<text x="62" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nc</text>
<text x="62" y="192" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">probe.py</text>
<text x="62" y="230" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="500">origen: un puerto efímero</text>
<g class="dg-l4"><rect class="dg-tint" x="62" y="244" width="132" height="26" rx="13" fill="#f9ece7" stroke="#e4aa92" stroke-width="1.2"/><text x="128" y="261.5" font-size="12" class="dg-ink" fill="#c2410c" font-weight="700" text-anchor="middle">127.0.0.1:50980</text></g>
<rect class="dg-card" x="440" y="64" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(456 80) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l4"><text x="498" y="101" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">Servidor eco TCP</text></g>
<text x="458" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9000/tcp</text>
<g class="dg-l4"><path class="dg-stroke" d="M248 110H434" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M427 104l8 6-8 6" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="323.34" y="98" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="342" y="114.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">TCP</text></g>
<rect class="dg-card" x="440" y="176" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(456 192) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l1"><text x="498" y="213" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Servidor eco UDP</text></g>
<text x="458" y="244" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9000/udp</text>
<g class="dg-l1"><path class="dg-stroke" d="M248 222H434" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M427 216l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="323.34" y="210" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="342" y="226.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">UDP</text></g>
<rect class="dg-card" x="440" y="288" width="260" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(456 304) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="498" y="325" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">Nada escuchando</text></g>
<text x="458" y="356" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9001</text>
<text x="458" y="376" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">TCP: RST · UDP: ICMP inalcanzable</text>
<g class="dg-warn"><path class="dg-stroke" d="M248 334H434" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M427 328l8 6-8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="304.02" y="322" width="75.96" height="24" rx="12" fill="#ffffff"/><text x="342" y="338.5" font-size="11.5" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">TCP / UDP</text></g>
<rect class="dg-card" x="750" y="64" width="210" height="170" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(766 80) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g>
<text x="808" y="101" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Observa con</text>
<text x="768" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">ss -tan</text>
<text x="768" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">ss -uln</text>
<text x="768" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">tcpdump -i lo</text>
<text x="768" y="192" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">(opcional, requiere sudo)</text>
<rect class="dg-card" x="750" y="270" width="210" height="140" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(766 286) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="808" y="307" font-size="14" class="dg-text" fill="#17171c" font-weight="700">192.0.2.1:80</text>
<text x="768" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Dirección de documentación</text>
<text x="768" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sin respuesta → timeout</text>
<g class="dg-warn"><path class="dg-stroke" d="M144 394V450H855V416" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M849 423l6-8 6 8" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="400.84" y="438" width="198.32" height="24" rx="12" fill="#ffffff"/><text x="500" y="454.5" font-size="11.5" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">SYN, sin respuesta → timeout</text></g>
</svg></figure>
*Figura 1. Dos servidores comparten el número de puerto 9000, uno para TCP y otro para UDP. El puerto 9001 no tiene servidor, y `192.0.2.1` nunca responde.*
## Pasos
### Paso 1 — Crea una carpeta de trabajo
Vas a escribir cinco scripts pequeños. Guárdalos en una sola carpeta para que la limpieza sea un único comando.
Linux y macOS:
```bash
mkdir -p ~/tcp-lab && cd ~/tcp-lab
```
Windows (PowerShell):
```powershell
New-Item -ItemType Directory -Force "$HOME\tcp-lab"; Set-Location "$HOME\tcp-lab"
```
Usa esta carpeta en las tres terminales. En Windows, escribe `py` donde este laboratorio dice `python3`.
### Paso 2 — Mira antes de tocar nada
Antes de arrancar tus propios servidores, comprueba en qué escucha ya tu ordenador y qué rango usa para los puertos efímeros.
**Linux:**
```bash
ss -tuln
cat /proc/sys/net/ipv4/ip_local_port_range
```
Salida esperada (abreviada; tu lista será distinta):
```text
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
udp UNCONN 0 0 127.0.0.53%lo:53 0.0.0.0:*
udp UNCONN 0 0 127.0.0.1:323 0.0.0.0:*
udp UNCONN 0 0 0.0.0.0:5353 0.0.0.0:*
tcp LISTEN 0 4096 127.0.0.53%lo:53 0.0.0.0:*
tcp LISTEN 0 4096 127.0.0.1:631 0.0.0.0:*
32768 60999
```
En un escritorio típico verás un resolvedor local del Domain Name System (DNS) en el puerto 53 (aquí `systemd-resolved`, en `127.0.0.53`), el servicio horario en UDP 323, el DNS multicast en UDP 5353 y un servicio de impresión en TCP 631. La mayoría escuchan solo en direcciones de loopback. La última línea es el rango de puertos efímeros: Linux usa por defecto 32768–60999, no el rango 49152–65535 de la RFC 6335.
**macOS:**
```bash
netstat -an -p tcp | grep LISTEN
sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last
```
**Windows (PowerShell):**
```powershell
Get-NetTCPConnection -State Listen | Sort-Object LocalPort | Select-Object LocalAddress, LocalPort, OwningProcess
netsh int ipv4 show dynamicport tcp
```
En macOS y Windows el rango dinámico por defecto es 49152–65535.
> [!NOTE]
> Los comandos de macOS y Windows no se ejecutaron para esta guía, así que no se muestra su salida; las columnas se explican solas. El puerto 9000 debe estar libre para este laboratorio. Si algo ya escucha en él, cambia `PORT` en todos los scripts por otro puerto libre por encima de 1024, como 9500.
### Paso 3 — Escribe y arranca el servidor eco TCP
Un servidor necesita un puerto fijo y conocido para que los clientes lo encuentren. Este escucha en `127.0.0.1:9000` y devuelve cada byte que recibe. Guárdalo como `tcp_server.py`:
```python
"""TCP echo server: accepts connections on 127.0.0.1:9000 and sends back every byte it receives."""
import socket
import sys
HOST, PORT = "127.0.0.1", 9000
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as srv:
if sys.platform != "win32":
# Allow a restart while old connections are still in TIME-WAIT.
# (On Windows this option means something else, so it is skipped there.)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind((HOST, PORT))
srv.listen()
print(f"TCP echo server listening on {HOST}:{PORT}", flush=True)
try:
while True:
conn, peer = srv.accept() # blocks until a handshake completes
with conn:
print(f"connection from {peer[0]}:{peer[1]}", flush=True)
while data := conn.recv(1024): # b"" means the client sent FIN
conn.sendall(data)
print(f"{peer[0]}:{peer[1]} closed the connection", flush=True)
except KeyboardInterrupt:
print("server stopped")
```
- `SOCK_STREAM` pide TCP. `bind()` reclama la dirección y el puerto; `listen()` convierte el socket en un socket en escucha.
- `accept()` solo devuelve el control cuando un cliente ha completado el acuerdo de tres vías. El sistema operativo hizo el acuerdo; tu programa solo recoge el resultado.
- `recv()` devuelve un resultado vacío cuando el cliente ha enviado FIN. Así es como un programa TCP se entera de que el otro extremo cerró.
En la **terminal 1**, arráncalo y déjalo en ejecución:
```bash
python3 tcp_server.py
```
Salida esperada:
```text
TCP echo server listening on 127.0.0.1:9000
```
### Paso 4 — Encuentra el socket en escucha
En la **terminal 3** (tu terminal de comandos), pregunta al sistema operativo quién escucha en el puerto 9000. El filtro `'sport = :9000'` (puerto de origen, que en un socket en escucha es el puerto local) mantiene la salida corta.
**Linux:**
```bash
ss -tlnp 'sport = :9000'
```
Salida esperada (tu ID de proceso será distinto):
```text
State Recv-Q Send-Q Local Address:Port Peer Address:PortProcess
LISTEN 0 128 127.0.0.1:9000 0.0.0.0:* users:(("python3",pid=4242,fd=3))
```
- `LISTEN` en `127.0.0.1:9000`: solo los programas de este ordenador pueden conectarse.
- `Peer Address:Port` es `0.0.0.0:*` porque un socket en escucha aún no tiene par.
- `Send-Q 128` es el backlog: cuántos acuerdos terminados pueden esperar a `accept()`.
- `users:(("python3",pid=…))` es el proceso propietario. Lo ves sin `sudo` porque el socket es tuyo.
**macOS:** `lsof -nP -iTCP:9000 -sTCP:LISTEN`. **Windows (PowerShell):** `Get-NetTCPConnection -LocalPort 9000`.
### Paso 5 — Conecta y observa la conexión
Ahora necesitas un cliente. Se conecta, imprime su propia dirección y puerto y los del servidor, envía un mensaje y lee el eco. Un argumento opcional mantiene la conexión abierta unos segundos para que puedas inspeccionarla. Guárdalo como `tcp_client.py`:
```python
"""TCP client: connects to the echo server, sends one message, prints the reply."""
import socket
import sys
import time
HOST, PORT = "127.0.0.1", 9000
HOLD = int(sys.argv[1]) if len(sys.argv) > 1 else 0 # seconds to keep the connection open
with socket.create_connection((HOST, PORT), timeout=5) as sock:
local, remote = sock.getsockname(), sock.getpeername()
print(f"connected: {local[0]}:{local[1]} -> {remote[0]}:{remote[1]}")
sock.sendall(b"hello over TCP")
print("reply:", sock.recv(1024).decode())
time.sleep(HOLD)
print("closed")
```
Fíjate en que el cliente nunca elige su propio puerto: `create_connection()` deja que el sistema operativo elija uno efímero.
En la terminal 3, ejecuta el cliente en segundo plano con una espera de 15 segundos y lista enseguida los sockets TCP del puerto 9000. En Linux:
```bash
python3 tcp_client.py 15 &
ss -tan '( sport = :9000 or dport = :9000 )'
```
Salida esperada (tu puerto efímero será distinto; las líneas del cliente pueden aparecer antes o después de la tabla):
```text
connected: 127.0.0.1:36784 -> 127.0.0.1:9000
reply: hello over TCP
State Recv-Q Send-Q Local Address:Port Peer Address:Port
LISTEN 0 128 127.0.0.1:9000 0.0.0.0:*
ESTAB 0 0 127.0.0.1:36784 127.0.0.1:9000
ESTAB 0 0 127.0.0.1:9000 127.0.0.1:36784
```
Lee las tres líneas:
- El socket `LISTEN` sigue ahí: continúa esperando al *siguiente* cliente.
- La conexión aparece **dos veces**, una desde cada extremo, porque ambos extremos están en tu ordenador. El lado del cliente es `127.0.0.1:36784 → 127.0.0.1:9000`; el lado del servidor es la imagen especular.
- `36784` está en el rango efímero del Paso 2. Ejecuta el cliente otra vez y obtendrás un puerto distinto.
En la terminal 1, el servidor registró la conexión:
```text
connection from 127.0.0.1:36784
```
En macOS, ejecuta el cliente igual y usa `netstat -an -p tcp | grep 9000`. En Windows, lanza `py tcp_client.py 15` en una terminal adicional y ejecuta `Get-NetTCPConnection -LocalPort 9000; Get-NetTCPConnection -RemotePort 9000` en la terminal 3 dentro de esos 15 segundos.
### Paso 6 — Observa TIME-WAIT
Espera a que el cliente imprima `closed` (15 segundos) y mira de nuevo:
```bash
ss -tan '( sport = :9000 or dport = :9000 )'
ss -tano state time-wait '( sport = :9000 or dport = :9000 )'
```
Salida esperada:
```text
State Recv-Q Send-Q Local Address:Port Peer Address:Port
LISTEN 0 128 127.0.0.1:9000 0.0.0.0:*
TIME-WAIT 0 0 127.0.0.1:36784 127.0.0.1:9000
Recv-Q Send-Q Local Address:Port Peer Address:Port
0 0 127.0.0.1:36784 127.0.0.1:9000 timer:(timewait,58sec,0)
```
- Solo queda una línea de la conexión antigua, y está en el puerto del **cliente**. El cliente cerró primero (terminó su bloque `with`), así que el cliente es el extremo que espera en TIME-WAIT. El lado del servidor pasó directamente a CLOSED tras confirmarse su propio FIN.
- `-o` muestra temporizadores: `timewait,58sec` cuenta hacia atrás desde 60 segundos, el tiempo fijo de TIME-WAIT en Linux. Ejecuta el comando otra vez pasado un minuto: la línea ha desaparecido.
El servidor registró el cierre en la terminal 1:
```text
127.0.0.1:36784 closed the connection
```
En macOS y Windows, `netstat -an -p tcp | grep 9000` (macOS) o `netstat -an -p tcp | findstr 9000` (Windows) muestra la misma conexión como `TIME_WAIT`. Sus temporizadores son distintos de los de Linux.
### Paso 7 — Habla con el servidor con netcat
Tu cliente no es especial: cualquier programa TCP puede hablar con el servidor. Netcat (`nc`) se conecta y luego copia tu teclado al socket y el socket a tu pantalla.
```bash
nc 127.0.0.1 9000
```
Escribe `hello from nc` y pulsa Intro. El servidor lo devuelve:
```text
hello from nc
hello from nc
```
La primera línea es lo que escribiste, la segunda es el eco. Pulsa **Ctrl+C** para salir. La terminal 1 registra la conexión y el cierre, cada uno con un nuevo puerto efímero.
> [!NOTE]
> Hay varias implementaciones de netcat con opciones y mensajes ligeramente distintos: OpenBSD netcat (Debian, Ubuntu y la base del `nc` de macOS), `ncat` de Nmap (Fedora, RHEL) y el antiguo netcat «tradicional». El básico `nc <host> <puerto>` funciona en todos. En Windows, sáltate los comandos `nc` y usa los clientes de Python.
### Paso 8 — Añade un servidor UDP en el mismo número de puerto
TCP y UDP tienen espacios de puertos separados, así que un servidor UDP también puede usar el puerto 9000. Guarda esto como `udp_server.py`:
```python
"""UDP echo server: receives datagrams on 127.0.0.1:9000 and sends each one back."""
import socket
HOST, PORT = "127.0.0.1", 9000
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as srv:
srv.bind((HOST, PORT))
print(f"UDP echo server listening on {HOST}:{PORT}", flush=True)
try:
while True:
data, peer = srv.recvfrom(2048) # no accept(): every datagram stands alone
print(f"datagram from {peer[0]}:{peer[1]}: {data.decode(errors='replace')}", flush=True)
srv.sendto(data, peer)
except KeyboardInterrupt:
print("server stopped")
```
Compáralo con el servidor TCP: `SOCK_DGRAM` en lugar de `SOCK_STREAM`, sin `listen()`, sin `accept()` y sin objeto de conexión. Cada datagrama llega con la dirección de su remitente, y la respuesta vuelve a esa dirección.
En la **terminal 2**, arráncalo:
```bash
python3 udp_server.py
```
```text
UDP echo server listening on 127.0.0.1:9000
```
En la terminal 3, lista juntos los sockets TCP y UDP del puerto 9000:
```bash
ss -tuln 'sport = :9000'
```
Salida esperada:
```text
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
udp UNCONN 0 0 127.0.0.1:9000 0.0.0.0:*
tcp LISTEN 0 128 127.0.0.1:9000 0.0.0.0:*
```
Dos sockets, misma dirección, mismo número de puerto, distinto protocolo. El UDP está en `UNCONN` (sin conectar), no en `LISTEN`: UDP no tiene conexiones que esperar.
Ahora el cliente. Guárdalo como `udp_client.py`:
```python
"""UDP client: sends one datagram to 127.0.0.1 and waits up to 2 seconds for an answer."""
import socket
import sys
HOST = "127.0.0.1"
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 9000
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
sock.settimeout(2)
sock.connect((HOST, PORT)) # for UDP, connect() only sets the default destination: nothing is sent
local = sock.getsockname()
print(f"sending from {local[0]}:{local[1]} to {HOST}:{PORT}")
sock.send(b"hello over UDP")
try:
print("reply:", sock.recv(2048).decode())
except TimeoutError:
print("no reply within 2 s (lost, filtered, or nobody listening)")
except ConnectionError:
print("error: port unreachable (an ICMP message said nobody is listening)")
```
Ejecútalo:
```bash
python3 udp_client.py
```
Salida esperada:
```text
sending from 127.0.0.1:40760 to 127.0.0.1:9000
reply: hello over UDP
```
La terminal 2 muestra `datagram from 127.0.0.1:40760: hello over UDP`. Después prueba netcat en modo UDP (`-u`), escribe una línea, lee el eco y pulsa Ctrl+C:
```bash
nc -u 127.0.0.1 9000
```
Ejecuta de nuevo `ss -tan '( sport = :9000 or dport = :9000 )'` y `ss -uan 'sport = :9000'` después del cliente UDP: no hay ESTAB ni TIME-WAIT para UDP. No se estableció nada, así que no hay nada que desmontar.
### Paso 9 — Connection refused frente a connection timed out
Esta es la habilidad de diagnóstico de la lección. Vas a hacer que una conexión falle de tres maneras y a cronometrar cada una. Guarda esto como `probe.py`:
```python
"""Try a TCP connection and report how it ended and how long it took."""
import socket
import sys
import time
host, port = sys.argv[1], int(sys.argv[2])
timeout = float(sys.argv[3]) if len(sys.argv) > 3 else 3
start = time.monotonic()
try:
with socket.create_connection((host, port), timeout=timeout):
result = "open: handshake completed"
except ConnectionRefusedError:
result = "refused: the host answered with RST"
except TimeoutError:
result = "timed out: no answer at all"
except OSError as exc:
result = f"error: {exc.strerror}"
print(f"{host}:{port} -> {result} after {time.monotonic() - start:.2f} s")
```
Sondea el puerto abierto, un puerto cerrado de tu propio equipo y la dirección de documentación `192.0.2.1`, que nunca se asigna a nadie:
```bash
python3 probe.py 127.0.0.1 9000
python3 probe.py 127.0.0.1 9001
python3 probe.py 192.0.2.1 80 3
```
Salida esperada:
```text
127.0.0.1:9000 -> open: handshake completed after 0.01 s
127.0.0.1:9001 -> refused: the host answered with RST after 0.01 s
192.0.2.1:80 -> timed out: no answer at all after 3.01 s
```
- **Puerto 9000:** el acuerdo se completa. La terminal 1 registra una conexión.
- **Puerto 9001:** tu ordenador recibió el SYN, no encontró ningún socket en escucha y respondió RST al instante: *connection refused*.
- **`192.0.2.1`:** el SYN sale de tu ordenador y nadie responde nunca, así que el cliente espera todo el timeout que le diste (3 s): *timed out*. Sin timeout, Linux sigue reintentando el SYN durante algo más de dos minutos antes de rendirse.
`<timeout>`, el tercer argumento opcional, es el número de segundos de espera. Prueba `python3 probe.py 192.0.2.1 80 10` y el resultado llega a los 10 segundos: el retraso lo fija el *cliente*, no la red.
Las mismas pruebas con netcat (`-v` detallado, `-z` conectar sin enviar datos, `-w 3` timeout):
```bash
nc -vz 127.0.0.1 9000
nc -vz 127.0.0.1 9001
nc -vz -w 3 192.0.2.1 80
```
```text
Connection to 127.0.0.1 9000 port [tcp/*] succeeded!
nc: connect to 127.0.0.1 port 9001 (tcp) failed: Connection refused
nc: connect to 192.0.2.1 port 80 (tcp) timed out: Operation in progress
```
El texto entre corchetes puede mostrar un nombre de servicio de la lista de servicios de tu sistema en lugar de `*`. En Windows (PowerShell), la comprobación equivalente es `Test-NetConnection -ComputerName 127.0.0.1 -Port 9001`, que informa `TcpTestSucceeded : False` en ambos tipos de fallo; usa `probe.py` para ver la diferencia.
Por último, UDP a un puerto cerrado:
```bash
python3 udp_client.py 9001
```
```text
sending from 127.0.0.1:56778 to 127.0.0.1:9001
error: port unreachable (an ICMP message said nobody is listening)
```
Tu ordenador respondió al datagrama con un mensaje de «puerto inalcanzable» del Internet Control Message Protocol (ICMP) y, como el cliente usó `connect()`, el sistema operativo lo comunicó como un error. En una red real ese mensaje ICMP suele estar filtrado, y el cliente simplemente imprimiría `no reply within 2 s`: con UDP, «cerrado» y «perdido» pueden verse idénticos.
> [!NOTE]
> Los tiempos y mensajes varían según el sistema operativo. En Windows, una conexión rechazada puede tardar unos dos segundos, porque el cliente reintenta un par de veces tras el RST, y el error UDP puede comunicarse como un *reset* de conexión; el script captura ambos. Tu red también puede responder rápido para `192.0.2.1` con «No route to host» o «Network is unreachable» (el script imprime `error: …`) si no tiene ruta para ese rango. Es un tercer tipo de fallo, procedente de la capa de red y no del destino.
### Paso 10 (opcional) — Captura el acuerdo de tres vías con tcpdump
Este paso necesita permisos de administrador. Sáltalo si no los tienes; la salida de abajo muestra lo que verías.
En la terminal 3, inicia una captura en la interfaz de loopback (`lo` en Linux, `lo0` en macOS). `-n` muestra números en lugar de nombres:
```bash
sudo tcpdump -i lo -n 'tcp port 9000 or tcp port 9001 or icmp'
```
En una terminal adicional, ejecuta una vez el cliente y sondea una vez el puerto cerrado:
```bash
python3 tcp_client.py
python3 probe.py 127.0.0.1 9001
python3 udp_client.py 9001
```
Detén la captura con Ctrl+C. Salida esperada (marcas de tiempo y opciones TCP abreviadas; tus puertos, números de secuencia y ventanas serán distintos):
```text
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [S], seq 646296056, win 65495, options [mss 65495,…], length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [S.], seq 1082532584, ack 646296057, win 65483, options [mss 65495,…], length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 1, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [P.], seq 1:15, ack 1, win 64, length 14
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [.], ack 15, win 64, length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [P.], seq 1:15, ack 15, win 64, length 14
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 15, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [F.], seq 15, ack 15, win 64, length 0
IP 127.0.0.1.9000 > 127.0.0.1.37246: Flags [F.], seq 15, ack 16, win 64, length 0
IP 127.0.0.1.37246 > 127.0.0.1.9000: Flags [.], ack 16, win 64, length 0
IP 127.0.0.1.34924 > 127.0.0.1.9001: Flags [S], seq 1486054817, win 65495, options [mss 65495,…], length 0
IP 127.0.0.1.9001 > 127.0.0.1.34924: Flags [R.], seq 0, ack 1486054818, win 0, length 0
IP 127.0.0.1 > 127.0.0.1: ICMP 127.0.0.1 udp port 9001 unreachable, length 50
```
Relaciónalo con la lección:
- Líneas 1–3: el acuerdo de tres vías, `[S]`, `[S.]`, `[.]`. Los números de secuencia iniciales (ISN) son aleatorios; el SYN-ACK confirma el ISN del cliente + 1. Desde la línea 3, `tcpdump` imprime los números de secuencia relativos al ISN.
- Líneas 4–7: `hello over TCP` son 14 bytes (`seq 1:15`, `length 14`), confirmados con `ack 15`, luego devueltos como eco y confirmados del mismo modo.
- Líneas 8–10: el cierre. El FIN del cliente, luego el FIN del servidor combinado con el ACK del FIN del cliente (`ack 16`: un FIN cuenta como un byte), luego el ACK final del cliente. Combinar dos pasos en un segmento es habitual, por lo que a menudo ves tres segmentos de cierre en lugar de cuatro.
- Líneas 11–12: un SYN al puerto cerrado 9001, respondido con `[R.]` (RST, ACK). Eso es «connection refused» en la red.
- Línea 13: el mensaje ICMP de puerto inalcanzable para el datagrama UDP al 9001.
- El tamaño máximo de segmento (MSS) de 65495 y las ventanas grandes son típicos del loopback, cuya unidad máxima de transmisión (MTU) es 65536. En Ethernet verías `mss 1460`.
> [!NOTE]
> Esta captura se grabó con `tcpdump` en Linux. Un SYN a `192.0.2.1` aparecería como la misma línea `[S]` repetida unas cuantas veces con intervalos crecientes y sin respuesta, que es el aspecto de un timeout en la red. Para verlo, captura en tu interfaz principal (por ejemplo `eth0`, `en0` o el nombre que indique `ip route show default`) en lugar de en loopback.
## Verificación
Has completado el laboratorio si puedes responder «sí» a cada comprobación:
| Comprobación | Cómo confirmarlo |
|---|---|
| El servidor TCP escucha en `127.0.0.1:9000` | `ss -tlnp 'sport = :9000'` muestra `LISTEN` y tu proceso `python3` |
| Viste una conexión desde ambos extremos | El Paso 5 muestra dos líneas `ESTAB` que se reflejan, con un puerto efímero de tu rango del Paso 2 |
| Viste TIME-WAIT en el extremo que cerró primero | El Paso 6 muestra `TIME-WAIT` solo en el puerto efímero del cliente, con un temporizador de como máximo 60 s en Linux |
| TCP y UDP comparten el número de puerto 9000 | `ss -tuln 'sport = :9000'` muestra una línea `tcp LISTEN` y otra `udp UNCONN` |
| Sabes distinguir refused de timed out | `probe.py` informa `refused` en unos 0,01 s para el puerto 9001 y `timed out` tras el timeout que elegiste para `192.0.2.1` |
## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `OSError: [Errno 98] Address already in use` (Linux), `[Errno 48]` (macOS) o `[WinError 10048]` (Windows) al arrancar un servidor | Otra copia del servidor sigue en ejecución, o algo más usa el puerto 9000 | Encuéntralo con `ss -tulnp 'sport = :9000'` (Linux), `lsof -nP -i :9000` (macOS) o `Get-NetTCPConnection -LocalPort 9000` (Windows); páralo o cambia `PORT` en todos los scripts |
| `ConnectionRefusedError: [Errno 111] Connection refused` en `tcp_client.py` | El servidor TCP no está en marcha, o escucha en otro puerto | Revisa la terminal 1; arranca de nuevo `python3 tcp_server.py` |
| `udp_client.py` imprime `no reply within 2 s` aunque el servidor UDP debería estar en marcha | El servidor UDP no está en marcha, o un cortafuegos local descarta el UDP de loopback | Revisa la terminal 2 y `ss -uln 'sport = :9000'` |
| `nc: command not found` | Netcat no está instalado | Instala `netcat-openbsd` o `nmap-ncat`, o sáltate los comandos `nc`; los clientes de Python hacen el mismo trabajo |
| `probe.py 192.0.2.1 80` imprime de inmediato `error: No route to host` o `Network is unreachable` | Tu sistema o red no tiene ruta para `192.0.2.0/24`, o un router responde con ICMP | No pasa nada: es un fallo de la capa de red, no un timeout. Compáralo con la lista de errores de la lección |
| Las líneas `ESTAB` no aparecen en el Paso 5 | Pasaron más de 15 s antes de ejecutar `ss`, o el cliente falló | Ejecuta los dos comandos juntos como se muestra, o aumenta la espera: `python3 tcp_client.py 30 &` |
| `tcpdump: lo: No such device exists` | En macOS la interfaz de loopback es `lo0` | Usa `sudo tcpdump -i lo0 -n …` |
## Reto (opcional)
1. Cambia `tcp_server.py` para que sea el **servidor** quien cierre la conexión justo después de enviar el eco (sal del bucle tras el primer `sendall()`). ¿Qué extremo muestra ahora TIME-WAIT? Después elimina la línea `SO_REUSEADDR`, ejecuta un cliente, para el servidor y vuelve a arrancarlo en menos de un minuto. ¿Qué ocurre y por qué casi todo servidor real establece `SO_REUSEADDR`?
2. Haz que el servidor escuche en `0.0.0.0` en lugar de `127.0.0.1` y comprueba la diferencia con `ss -tln`. ¿Es ahora accesible desde otro dispositivo de tu red? ¿Lo permite el cortafuegos de tu equipo? Vuelve a ponerlo como estaba cuando termines.
3. Abre diez conexiones a la vez (por ejemplo, `for i in $(seq 10); do python3 tcp_client.py 20 & done`) y cuéntalas con `ss -tan '( dport = :9000 )' | wc -l`. ¿Qué parte de la 4-tupla difiere entre ellas?
4. Envía un mensaje de 5000 bytes con `tcp_client.py` y léelo con un único `recv(1024)`. ¿Qué llega? ¿Qué te dice eso de TCP como flujo de bytes, y cómo diseñarías un formato de mensaje encima de él?
## Limpieza
Para los dos servidores: pulsa **Ctrl+C** en la terminal 1 y en la terminal 2. Cada uno imprime `server stopped`. Cierra las sesiones de `nc` con Ctrl+C y detén `tcpdump` si sigue en ejecución.
Comprueba que no queda nada en el puerto 9000 (Linux):
```bash
ss -tuln 'sport = :9000'
```
```text
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
```
Solo la línea de cabecera significa que ambos servidores han desaparecido. Si algún servidor sigue en ejecución (por ejemplo, cerraste su terminal), páralo con `pkill -f tcp_server.py; pkill -f udp_server.py` en Linux o macOS, o con `Get-Process python*` y `Stop-Process -Id <pid>` en Windows. `<pid>` es el ID de proceso que muestran `ss -tulnp` o `Get-NetTCPConnection` (columna `OwningProcess`).
Elimina la carpeta y los cinco scripts.
Linux y macOS:
```bash
cd ~ && rm -r ~/tcp-lab
```
Windows (PowerShell):
```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\tcp-lab"
```
Las entradas TIME-WAIT desaparecen solas en cosa de un minuto. No se cambió ningún ajuste del sistema, así que no hay nada más que deshacer.
## Qué has aprendido
- Un servidor enlaza un puerto fijo y escucha; cada cliente recibe del sistema operativo un puerto efímero, y la 4-tupla nombra la conexión. En una sola máquina ves cada conexión dos veces, una desde cada extremo.
- TCP y UDP tienen espacios de puertos separados. TCP muestra LISTEN, ESTAB y TIME-WAIT; UDP solo UNCONN, porque no hay conexiones.
- El extremo que cierra primero mantiene el TIME-WAIT (60 s en Linux). Es normal y desaparece solo.
- «Connection refused» es una respuesta (RST) y llega en milisegundos. «Connection timed out» es silencio, y lo que tarda depende del timeout del cliente.
- `ss` (o `netstat`, `lsof`, `Get-NetTCPConnection`) y, con permisos de administrador, `tcpdump` te muestran exactamente lo que está haciendo la capa de transporte.