CloudAcademia
PT

Redes · Módulo 08 · Camada de transporte: TCP, UDP e portas

Laboratório: sockets TCP e UDP no seu próprio computador

Laboratório60 minInicianteMarkdown

A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.

## Objetivo
Escreve em Python um pequeno servidor de eco do Transmission Control Protocol (TCP) e outro do User Datagram Protocol (UDP), comunica com eles através dos seus próprios clientes e do `nc`, e observa como os sockets mudam de estado com o `ss` (ou `netstat`). Depois provoca as duas falhas clássicas, «connection refused» e «connection timed out», e vê porque é que uma demora milissegundos e a outra demora o tempo que lhe permitir. Tudo corre no seu próprio computador, em `127.0.0.1`.

## Objetivos
- Explicar como uma porta em escuta e uma porta efémera de cliente identificam em conjunto uma ligação.
- Comparar o TCP e o UDP executando ambos no mesmo número de porta e vendo como se comportam de forma diferente.
- Observar uma ligação TCP passar de ESTABLISHED a TIME-WAIT e, opcionalmente, capturar o handshake e o encerramento com o `tcpdump`.
- Identificar sockets em escuta e estados de ligação (LISTEN, ESTAB, TIME-WAIT, UNCONN) com `ss` ou `netstat`.
- Reproduzir e explicar «connection refused» versus «connection timed out».

## Pré-requisitos
- Um computador com Linux (com o `ss` do iproute2), macOS ou Windows 10/11.
- Python 3.10 ou posterior, apenas biblioteca padrão. Este laboratório foi testado com Python 3.14.7 e 3.11.8. Verifique o seu com `python3 --version` (no Windows: `py --version`).
- `nc` (netcat), opcional mas recomendado. Linux: pacote `netcat-openbsd` (Debian, Ubuntu) ou `nmap-ncat` (Fedora, RHEL). macOS: incluído. Windows: não incluído; use antes os clientes Python e o `Test-NetConnection`. Os resultados abaixo provêm do OpenBSD netcat 1.226.
- Três janelas de terminal: uma para cada servidor e outra para os seus comandos.
- Opcional, apenas para o Passo 10: `tcpdump` e permissões de administrador (`sudo`) no Linux ou macOS.
- [Lição: Camada de transporte: TCP, UDP e portas](lesson.pt.md) deste módulo.

> [!WARNING]
> Execute todos os comandos deste laboratório **apenas contra o seu próprio computador**: `127.0.0.1` e o endereço de documentação `192.0.2.1` (RFC 5737), que nunca é atribuído a um anfitrião real. Não aponte `nc -z`, `probe.py` nem qualquer outro teste de ligação a sistemas que não sejam seus ou que não esteja explicitamente autorizado a testar: sondar as portas de outras pessoas é varrimento de portas, o que pode ser ilegal e viola os termos de serviço da maioria dos fornecedores. Os servidores deste laboratório escutam apenas em `127.0.0.1`, pelo que nada na sua rede os consegue alcançar.

## Arquitetura
<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-pt-title tcp-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="tcp-lab-architecture-pt-title">Arquitetura do laboratório: sockets TCP e UDP no seu próprio computador</title>
<desc id="tcp-lab-architecture-pt-desc">Tudo corre no seu computador através da interface de loopback, 127.0.0.1. Os clientes tcp_client.py, udp_client.py, nc e probe.py usam portas de origem efémeras. Comunicam com um servidor de eco TCP em 127.0.0.1 porta 9000, um servidor de eco UDP em 127.0.0.1 porta 9000 e a porta 9001, onde nada escuta, que responde ao TCP com RST e ao UDP com uma mensagem ICMP de porta inalcançável. Observa-se com ss -tan, ss -uln e, opcionalmente com sudo, tcpdump -i lo. Uma sonda segue para o endereço de documentação 192.0.2.1 porta 80, que nunca responde, pelo que a ligação expira.</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">O seu computador · interface 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">origem: uma porta efémera</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 de 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 de 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 em escuta</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 inalcançável</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">Observar com</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, requer 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">Endereço de documentação</text>
<text x="768" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sem resposta → 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="404.06" y="438" width="191.88" 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, sem resposta → timeout</text></g>
</svg></figure>

*Figura 1. Dois servidores partilham o número de porta 9000, um para TCP e outro para UDP. A porta 9001 não tem servidor, e `192.0.2.1` nunca responde.*

## Passos

### Passo 1 — Crie uma pasta de trabalho
Vai escrever cinco scripts pequenos. Guarde-os numa só pasta para que a limpeza seja um único comando.

Linux e 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"
```

Use esta pasta nos três terminais. No Windows, escreva `py` onde este laboratório diz `python3`.

### Passo 2 — Observe antes de mexer em nada
Antes de iniciar os seus próprios servidores, veja em que é que o seu computador já escuta e que intervalo usa para as portas efémeras.

**Linux:**

```bash
ss -tuln
cat /proc/sys/net/ipv4/ip_local_port_range
```

Resultado esperado (abreviado; a sua lista será diferente):

```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
```

Num desktop típico verá um resolvedor local do Domain Name System (DNS) na porta 53 (aqui o `systemd-resolved`, em `127.0.0.53`), o serviço de hora em UDP 323, o DNS multicast em UDP 5353 e um serviço de impressão em TCP 631. A maioria escuta apenas em endereços de loopback. A última linha é o intervalo de portas efémeras: o Linux usa por predefinição 32768–60999, e não o intervalo 49152–65535 da 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
```

No macOS e no Windows o intervalo dinâmico por predefinição é 49152–65535.

> [!NOTE]
> Os comandos do macOS e do Windows não foram executados para este guia, pelo que o respetivo resultado não é mostrado; as colunas explicam-se por si. A porta 9000 tem de estar livre para este laboratório. Se algo já escutar nela, altere `PORT` em todos os scripts para outra porta livre acima de 1024, como a 9500.

### Passo 3 — Escreva e inicie o servidor de eco TCP
Um servidor precisa de uma porta fixa e conhecida para que os clientes o encontrem. Este escuta em `127.0.0.1:9000` e devolve cada byte que recebe. Guarde-o 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` pede TCP. `bind()` reclama o endereço e a porta; `listen()` transforma o socket num socket em escuta.
- `accept()` só devolve o controlo depois de um cliente ter concluído o handshake de três vias. Foi o sistema operativo que fez o handshake; o seu programa limita-se a recolher o resultado.
- `recv()` devolve um resultado vazio quando o cliente enviou FIN. É assim que um programa TCP fica a saber que o outro lado fechou.

No **terminal 1**, inicie-o e deixe-o em execução:

```bash
python3 tcp_server.py
```

Resultado esperado:

```text
TCP echo server listening on 127.0.0.1:9000
```

### Passo 4 — Encontre o socket em escuta
No **terminal 3** (o seu terminal de comandos), pergunte ao sistema operativo quem escuta na porta 9000. O filtro `'sport = :9000'` (porta de origem, que num socket em escuta é a porta local) mantém o resultado curto.

**Linux:**

```bash
ss -tlnp 'sport = :9000'
```

Resultado esperado (o seu ID de processo será diferente):

```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` em `127.0.0.1:9000`: apenas os programas deste computador se podem ligar.
- `Peer Address:Port` é `0.0.0.0:*` porque um socket em escuta ainda não tem par.
- `Send-Q 128` é o backlog: quantos handshakes concluídos podem aguardar pelo `accept()`.
- `users:(("python3",pid=…))` é o processo proprietário. Vê-o sem `sudo` porque o socket é seu.

**macOS:** `lsof -nP -iTCP:9000 -sTCP:LISTEN`. **Windows (PowerShell):** `Get-NetTCPConnection -LocalPort 9000`.

### Passo 5 — Ligue-se e observe a ligação
Agora precisa de um cliente. Liga-se, imprime o seu próprio endereço e porta e os do servidor, envia uma mensagem e lê o eco. Um argumento opcional mantém a ligação aberta durante alguns segundos para a poder inspecionar. Guarde-o 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")
```

Repare que o cliente nunca escolhe a sua própria porta: o `create_connection()` deixa que o sistema operativo escolha uma efémera.

No terminal 3, execute o cliente em segundo plano com uma espera de 15 segundos e liste logo de seguida os sockets TCP da porta 9000. No Linux:

```bash
python3 tcp_client.py 15 &
ss -tan '( sport = :9000 or dport = :9000 )'
```

Resultado esperado (a sua porta efémera será diferente; as linhas do cliente podem aparecer antes ou depois da tabela):

```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
```

Leia as três linhas:
- O socket `LISTEN` continua lá: continua a aguardar o *próximo* cliente.
- A ligação aparece **duas vezes**, uma de cada extremidade, porque ambas as extremidades estão no seu computador. O lado do cliente é `127.0.0.1:36784 → 127.0.0.1:9000`; o lado do servidor é a imagem espelhada.
- `36784` está no intervalo efémero do Passo 2. Execute o cliente outra vez e obterá uma porta diferente.

No terminal 1, o servidor registou a ligação:

```text
connection from 127.0.0.1:36784
```

No macOS, execute o cliente da mesma forma e use `netstat -an -p tcp | grep 9000`. No Windows, inicie `py tcp_client.py 15` num terminal adicional e execute `Get-NetTCPConnection -LocalPort 9000; Get-NetTCPConnection -RemotePort 9000` no terminal 3 dentro desses 15 segundos.

### Passo 6 — Veja o TIME-WAIT
Aguarde até o cliente imprimir `closed` (15 segundos) e volte a olhar:

```bash
ss -tan '( sport = :9000 or dport = :9000 )'
ss -tano state time-wait '( sport = :9000 or dport = :9000 )'
```

Resultado esperado:

```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)
```

- Resta apenas uma linha da ligação antiga, e está na porta do **cliente**. O cliente fechou primeiro (o seu bloco `with` terminou), pelo que é o cliente o lado que aguarda em TIME-WAIT. O lado do servidor passou diretamente a CLOSED depois de o seu próprio FIN ser confirmado.
- `-o` mostra temporizadores: `timewait,58sec` conta decrescentemente a partir de 60 segundos, o tempo fixo de TIME-WAIT no Linux. Execute o comando outra vez passado um minuto: a linha desapareceu.

O servidor registou o encerramento no terminal 1:

```text
127.0.0.1:36784 closed the connection
```

No macOS e no Windows, `netstat -an -p tcp | grep 9000` (macOS) ou `netstat -an -p tcp | findstr 9000` (Windows) mostra a mesma ligação como `TIME_WAIT`. Os seus temporizadores são diferentes dos do Linux.

### Passo 7 — Comunique com o servidor através do netcat
O seu cliente não é especial: qualquer programa TCP pode comunicar com o servidor. O netcat (`nc`) liga-se e depois copia o seu teclado para o socket e o socket para o ecrã.

```bash
nc 127.0.0.1 9000
```

Escreva `hello from nc` e prima Enter. O servidor devolve-o:

```text
hello from nc
hello from nc
```

A primeira linha é o que escreveu, a segunda é o eco. Prima **Ctrl+C** para sair. O terminal 1 regista a ligação e o encerramento, cada um com uma nova porta efémera.

> [!NOTE]
> Existem várias implementações de netcat com opções e mensagens ligeiramente diferentes: OpenBSD netcat (Debian, Ubuntu e a base do `nc` do macOS), o `ncat` do Nmap (Fedora, RHEL) e o antigo netcat «tradicional». O básico `nc <anfitrião> <porta>` funciona em todos. No Windows, ignore os comandos `nc` e use os clientes Python.

### Passo 8 — Acrescente um servidor UDP no mesmo número de porta
O TCP e o UDP têm espaços de portas separados, pelo que um servidor UDP também pode usar a porta 9000. Guarde isto 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")
```

Compare-o com o servidor TCP: `SOCK_DGRAM` em vez de `SOCK_STREAM`, sem `listen()`, sem `accept()` e sem objeto de ligação. Cada datagrama chega com o endereço do seu remetente, e a resposta volta para esse endereço.

No **terminal 2**, inicie-o:

```bash
python3 udp_server.py
```

```text
UDP echo server listening on 127.0.0.1:9000
```

No terminal 3, liste em conjunto os sockets TCP e UDP da porta 9000:

```bash
ss -tuln 'sport = :9000'
```

Resultado esperado:

```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:*
```

Dois sockets, o mesmo endereço, o mesmo número de porta, protocolos diferentes. O UDP está em `UNCONN` (sem ligação), e não em `LISTEN`: o UDP não tem ligações à espera.

Agora o cliente. Guarde-o 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)")
```

Execute-o:

```bash
python3 udp_client.py
```

Resultado esperado:

```text
sending from 127.0.0.1:40760 to 127.0.0.1:9000
reply: hello over UDP
```

O terminal 2 mostra `datagram from 127.0.0.1:40760: hello over UDP`. Depois experimente o netcat em modo UDP (`-u`), escreva uma linha, leia o eco e prima Ctrl+C:

```bash
nc -u 127.0.0.1 9000
```

Execute outra vez `ss -tan '( sport = :9000 or dport = :9000 )'` e `ss -uan 'sport = :9000'` depois do cliente UDP: não há ESTAB nem TIME-WAIT para o UDP. Nada foi estabelecido, pelo que nada tem de ser desmontado.

### Passo 9 — Connection refused versus connection timed out
Esta é a competência de diagnóstico da lição. Vai fazer uma ligação falhar de três maneiras e cronometrar cada uma. Guarde isto 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")
```

Sonde a porta aberta, uma porta fechada do seu próprio computador e o endereço de documentação `192.0.2.1`, que nunca é atribuído a ninguém:

```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
```

Resultado esperado:

```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
```

- **Porta 9000:** o handshake conclui-se. O terminal 1 regista uma ligação.
- **Porta 9001:** o seu computador recebeu o SYN, não encontrou nenhum socket em escuta e respondeu RST de imediato: *connection refused*.
- **`192.0.2.1`:** o SYN sai do seu computador e ninguém responde, pelo que o cliente espera todo o timeout que lhe indicou (3 s): *timed out*. Sem timeout, o Linux continua a repetir o SYN durante um pouco mais de dois minutos antes de desistir.

`<timeout>`, o terceiro argumento opcional, é o número de segundos de espera. Experimente `python3 probe.py 192.0.2.1 80 10` e o resultado chega ao fim de 10 segundos: o atraso é definido pelo *cliente*, e não pela rede.

Os mesmos testes com o netcat (`-v` detalhado, `-z` ligar sem enviar dados, `-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
```

O texto entre parênteses retos pode mostrar o nome de um serviço da lista de serviços do seu sistema em vez de `*`. No Windows (PowerShell), a verificação equivalente é `Test-NetConnection -ComputerName 127.0.0.1 -Port 9001`, que indica `TcpTestSucceeded : False` para ambos os tipos de falha; use o `probe.py` para ver a diferença.

Por fim, UDP para uma porta fechada:

```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)
```

O seu computador respondeu ao datagrama com uma mensagem de «porta inalcançável» do Internet Control Message Protocol (ICMP) e, como o cliente usou `connect()`, o sistema operativo comunicou-a como um erro. Numa rede real, essa mensagem ICMP é muitas vezes filtrada, e o cliente limitar-se-ia a imprimir `no reply within 2 s`: com o UDP, «fechado» e «perdido» podem ter o mesmo aspeto.

> [!NOTE]
> Os tempos e as mensagens variam consoante o sistema operativo. No Windows, uma ligação recusada pode demorar cerca de dois segundos, porque o cliente repete algumas vezes depois do RST, e o erro UDP pode ser comunicado como um *reset* da ligação; o script apanha ambos. A sua rede também pode responder rapidamente para `192.0.2.1` com «No route to host» ou «Network is unreachable» (o script imprime `error: …`) se não tiver rota para esse intervalo. É um terceiro tipo de falha, que vem da camada de rede e não do destino.

### Passo 10 (opcional) — Capture o handshake com o tcpdump
Este passo requer permissões de administrador. Salte-o se não as tiver; o resultado abaixo mostra o que veria.

No terminal 3, inicie uma captura na interface de loopback (`lo` no Linux, `lo0` no macOS). `-n` mostra números em vez de nomes:

```bash
sudo tcpdump -i lo -n 'tcp port 9000 or tcp port 9001 or icmp'
```

Num terminal adicional, execute o cliente uma vez e sonde a porta fechada uma vez:

```bash
python3 tcp_client.py
python3 probe.py 127.0.0.1 9001
python3 udp_client.py 9001
```

Pare a captura com Ctrl+C. Resultado esperado (marcas temporais e opções TCP abreviadas; as suas portas, números de sequência e janelas serão diferentes):

```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
```

Relacione-o com a lição:
- Linhas 1–3: o handshake de três vias, `[S]`, `[S.]`, `[.]`. Os números de sequência iniciais (ISN) são aleatórios; o SYN-ACK confirma o ISN do cliente + 1. A partir da linha 3, o `tcpdump` imprime os números de sequência relativos ao ISN.
- Linhas 4–7: `hello over TCP` são 14 bytes (`seq 1:15`, `length 14`), confirmados com `ack 15`, depois devolvidos como eco e confirmados da mesma forma.
- Linhas 8–10: o encerramento. O FIN do cliente, depois o FIN do servidor combinado com o ACK do FIN do cliente (`ack 16`: um FIN conta como um byte), depois o ACK final do cliente. Combinar dois passos num só segmento é comum, pelo que muitas vezes se veem três segmentos de encerramento em vez de quatro.
- Linhas 11–12: um SYN para a porta fechada 9001, respondido com `[R.]` (RST, ACK). Isso é «connection refused» na rede.
- Linha 13: a mensagem ICMP de porta inalcançável para o datagrama UDP para a 9001.
- O tamanho máximo de segmento (MSS) de 65495 e as janelas grandes são típicos do loopback, cuja unidade máxima de transmissão (MTU) é 65536. Em Ethernet veria `mss 1460`.

> [!NOTE]
> Esta captura foi registada com o `tcpdump` no Linux. Um SYN para `192.0.2.1` apareceria como a mesma linha `[S]` repetida algumas vezes com intervalos crescentes e sem resposta, que é o aspeto de um timeout na rede. Para o ver, capture na sua interface principal (por exemplo `eth0`, `en0` ou o nome indicado por `ip route show default`) em vez de no loopback.

## Verificação
Concluiu o laboratório se puder responder «sim» a cada verificação:

| Verificação | Como confirmar |
|---|---|
| O servidor TCP escuta em `127.0.0.1:9000` | `ss -tlnp 'sport = :9000'` mostra `LISTEN` e o seu processo `python3` |
| Viu uma ligação a partir de ambas as extremidades | O Passo 5 mostra duas linhas `ESTAB` que se espelham, com uma porta efémera do seu intervalo do Passo 2 |
| Viu o TIME-WAIT no lado que fechou primeiro | O Passo 6 mostra `TIME-WAIT` apenas na porta efémera do cliente, com um temporizador de no máximo 60 s no Linux |
| O TCP e o UDP partilham o número de porta 9000 | `ss -tuln 'sport = :9000'` mostra uma linha `tcp LISTEN` e outra `udp UNCONN` |
| Sabe distinguir refused de timed out | O `probe.py` indica `refused` em cerca de 0,01 s para a porta 9001 e `timed out` após o timeout escolhido para `192.0.2.1` |

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `OSError: [Errno 98] Address already in use` (Linux), `[Errno 48]` (macOS) ou `[WinError 10048]` (Windows) ao iniciar um servidor | Outra cópia do servidor continua em execução, ou algo mais usa a porta 9000 | Encontre-o com `ss -tulnp 'sport = :9000'` (Linux), `lsof -nP -i :9000` (macOS) ou `Get-NetTCPConnection -LocalPort 9000` (Windows); pare-o ou altere `PORT` em todos os scripts |
| `ConnectionRefusedError: [Errno 111] Connection refused` no `tcp_client.py` | O servidor TCP não está em execução, ou escuta noutra porta | Verifique o terminal 1; inicie de novo `python3 tcp_server.py` |
| O `udp_client.py` imprime `no reply within 2 s` embora o servidor UDP devesse estar em execução | O servidor UDP não está em execução, ou uma firewall local descarta o UDP de loopback | Verifique o terminal 2 e `ss -uln 'sport = :9000'` |
| `nc: command not found` | O netcat não está instalado | Instale `netcat-openbsd` ou `nmap-ncat`, ou ignore os comandos `nc`; os clientes Python fazem o mesmo trabalho |
| `probe.py 192.0.2.1 80` imprime de imediato `error: No route to host` ou `Network is unreachable` | O seu sistema ou rede não tem rota para `192.0.2.0/24`, ou um router responde com ICMP | Não há problema: é uma falha da camada de rede, e não um timeout. Compare com a lista de erros da lição |
| As linhas `ESTAB` não aparecem no Passo 5 | Passaram mais de 15 s antes de o `ss` ser executado, ou o cliente falhou | Execute os dois comandos em conjunto como indicado, ou aumente a espera: `python3 tcp_client.py 30 &` |
| `tcpdump: lo: No such device exists` | No macOS a interface de loopback é `lo0` | Use `sudo tcpdump -i lo0 -n …` |

## Desafio (opcional)
1. Altere o `tcp_server.py` para que seja o **servidor** a fechar a ligação logo após enviar o eco (saia do ciclo depois do primeiro `sendall()`). Que lado mostra agora o TIME-WAIT? Depois remova a linha `SO_REUSEADDR`, execute um cliente, pare o servidor e volte a iniciá-lo em menos de um minuto. O que acontece, e porque é que quase todos os servidores reais definem `SO_REUSEADDR`?
2. Faça o servidor escutar em `0.0.0.0` em vez de `127.0.0.1` e verifique a diferença com `ss -tln`. Está agora acessível a partir de outro dispositivo da sua rede? A firewall do seu anfitrião permite-o? Reponha-o como estava quando terminar.
3. Abra dez ligações em simultâneo (por exemplo, `for i in $(seq 10); do python3 tcp_client.py 20 & done`) e conte-as com `ss -tan '( dport = :9000 )' | wc -l`. Que parte do 4-tuplo difere entre elas?
4. Envie uma mensagem de 5000 bytes com o `tcp_client.py` e leia-a com um único `recv(1024)`. O que chega? O que lhe diz isso sobre o TCP como fluxo de bytes, e como conceberia um formato de mensagem por cima dele?

## Limpeza
Pare ambos os servidores: prima **Ctrl+C** no terminal 1 e no terminal 2. Cada um imprime `server stopped`. Feche quaisquer sessões `nc` com Ctrl+C e pare o `tcpdump` se ainda estiver em execução.

Verifique que não resta nada na porta 9000 (Linux):

```bash
ss -tuln 'sport = :9000'
```

```text
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
```

Apenas a linha de cabeçalho significa que ambos os servidores desapareceram. Se algum servidor ainda estiver em execução (por exemplo, fechou o respetivo terminal), pare-o com `pkill -f tcp_server.py; pkill -f udp_server.py` no Linux ou macOS, ou com `Get-Process python*` e `Stop-Process -Id <pid>` no Windows. `<pid>` é o ID de processo mostrado por `ss -tulnp` ou `Get-NetTCPConnection` (coluna `OwningProcess`).

Remova a pasta e os cinco scripts.

Linux e macOS:

```bash
cd ~ && rm -r ~/tcp-lab
```

Windows (PowerShell):

```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\tcp-lab"
```

As entradas TIME-WAIT desaparecem por si em cerca de um minuto. Nenhuma definição do sistema foi alterada, pelo que não há mais nada a desfazer.

## O que aprendeu
- Um servidor associa-se a uma porta fixa e escuta; cada cliente recebe do sistema operativo uma porta efémera, e o 4-tuplo identifica a ligação. Numa só máquina vê cada ligação duas vezes, uma de cada extremidade.
- O TCP e o UDP têm espaços de portas separados. O TCP mostra LISTEN, ESTAB e TIME-WAIT; o UDP apenas UNCONN, porque não há ligações.
- O lado que fecha primeiro mantém o TIME-WAIT (60 s no Linux). É normal e desaparece por si.
- «Connection refused» é uma resposta (RST) e chega em milissegundos. «Connection timed out» é silêncio, e o tempo que demora depende do timeout do cliente.
- O `ss` (ou `netstat`, `lsof`, `Get-NetTCPConnection`) e, com permissões de administrador, o `tcpdump` mostram exatamente o que a camada de transporte está a fazer.