---
title: "Laboratorio: sockets TCP y UDP en tu propio equipo"
domain: networking
level: beginner
duration: "60 min"
cost: "gratis"
environment: "tu propio ordenador (Linux, macOS o Windows) con Python 3; todo se ejecuta en la interfaz de loopback"
lang: es
source_hash: 64c2dda423c2
---

# Laboratorio: sockets TCP y UDP en tu propio equipo

## 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
![Arquitectura del laboratorio. Todo se ejecuta en tu ordenador a través de la interfaz de loopback lo, 127.0.0.1. Los clientes tcp_client.py, udp_client.py, nc y probe.py usan un puerto de origen efímero como 127.0.0.1:50980. Se conectan por TCP a un servidor eco TCP en 127.0.0.1:9000/tcp, por UDP a un servidor eco UDP en 127.0.0.1:9000/udp, y a 127.0.0.1:9001 donde nada escucha, que responde a TCP con RST y a UDP con ICMP de puerto inalcanzable. Observas con ss -tan, ss -uln y, opcionalmente con sudo, tcpdump -i lo. Una sonda envía un SYN a la dirección de documentación 192.0.2.1:80, que nunca responde, así que agota el tiempo de espera](../../../assets/diagrams/tcp-lab-architecture.es.svg)

*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.
