CloudAcademia
IT

Reti · Modulo 08 · Livello di trasporto: TCP, UDP e porte

Laboratorio: socket TCP e UDP sul tuo computer

Laboratorio60 minPrincipianteMarkdown

Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.

## Obiettivo
Scrivi in Python un piccolo server echo Transmission Control Protocol (TCP) e un server echo User Datagram Protocol (UDP), parli con loro usando i tuoi client e `nc`, e osservi i socket cambiare stato con `ss` (o `netstat`). Poi provochi i due fallimenti classici, «connection refused» e «connection timed out», e vedi perché uno richiede millisecondi e l'altro tutto il tempo che gli concedi. Tutto gira sul tuo computer, su `127.0.0.1`.

## Obiettivi
- Spiegare come una porta in ascolto e una porta effimera del client identificano insieme una connessione.
- Confrontare TCP e UDP eseguendoli sullo stesso numero di porta e vedendo quanto si comportano in modo diverso.
- Osservare una connessione TCP passare da ESTABLISHED a TIME-WAIT e, facoltativamente, catturare handshake e chiusura con `tcpdump`.
- Identificare i socket in ascolto e gli stati di connessione (LISTEN, ESTAB, TIME-WAIT, UNCONN) con `ss` o `netstat`.
- Riprodurre e spiegare «connection refused» rispetto a «connection timed out».

## Prerequisiti
- Un computer con Linux (con `ss` di iproute2), macOS o Windows 10/11.
- Python 3.10 o successivo, solo libreria standard. Questo laboratorio è stato provato con Python 3.14.7 e 3.11.8. Controlla il tuo con `python3 --version` (su Windows: `py --version`).
- `nc` (netcat), facoltativo ma consigliato. Linux: pacchetto `netcat-openbsd` (Debian, Ubuntu) o `nmap-ncat` (Fedora, RHEL). macOS: incluso. Windows: non incluso; usa invece i client Python e `Test-NetConnection`. Gli output qui sotto vengono da OpenBSD netcat 1.226.
- Tre finestre di terminale: una per ciascun server e una per i tuoi comandi.
- Facoltativo, solo per il Passaggio 10: `tcpdump` e privilegi di amministratore (`sudo`) su Linux o macOS.
- [Lezione: Livello di trasporto: TCP, UDP e porte](lesson.it.md) di questo modulo.

> [!WARNING]
> Esegui ogni comando di questo laboratorio **solo contro il tuo computer**: `127.0.0.1` e l'indirizzo di documentazione `192.0.2.1` (RFC 5737), che non è mai assegnato a un host reale. Non puntare `nc -z`, `probe.py` o qualsiasi altro test di connessione verso sistemi che non possiedi o che non sei esplicitamente autorizzato a testare: sondare le porte altrui è scansione delle porte, che può essere illegale e viola i termini di servizio della maggior parte dei provider. I server di questo laboratorio ascoltano solo su `127.0.0.1`, quindi nulla sulla tua rete può raggiungerli.

## Architettura
<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-it-title tcp-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="tcp-lab-architecture-it-title">Architettura del laboratorio: socket TCP e UDP sul tuo computer</title>
<desc id="tcp-lab-architecture-it-desc">Tutto gira sul tuo computer attraverso l&#x27;interfaccia di loopback, 127.0.0.1. I client tcp_client.py, udp_client.py, nc e probe.py usano porte di origine effimere. Comunicano con un server echo TCP su 127.0.0.1 porta 9000, un server echo UDP su 127.0.0.1 porta 9000 e la porta 9001, dove nulla è in ascolto, che risponde a TCP con RST e a UDP con un messaggio ICMP di porta irraggiungibile. Osservi con ss -tan, ss -uln e, facoltativamente con sudo, tcpdump -i lo. Una sonda va all&#x27;indirizzo di documentazione 192.0.2.1 porta 80, che non risponde mai, quindi la connessione scade.</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">Il tuo computer · interfaccia di 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">Client</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">origine: una porta effimera</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">Server echo 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">Server echo 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">Nessuno in ascolto</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 irraggiungibile</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">Osserva 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">(facoltativo, richiede 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">Indirizzo di documentazione</text>
<text x="768" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">nessuna risposta → 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="391.18" y="438" width="217.64" 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, nessuna risposta → timeout</text></g>
</svg></figure>

*Figura 1. Due server condividono il numero di porta 9000, uno per TCP e uno per UDP. La porta 9001 non ha server, e `192.0.2.1` non risponde mai.*

## Passaggi

### Passaggio 1 — Crea una cartella di lavoro
Scriverai cinque piccoli script. Tienili in una sola cartella così la pulizia è un unico 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"
```

Usa questa cartella in tutti e tre i terminali. Su Windows, scrivi `py` ovunque questo laboratorio dica `python3`.

### Passaggio 2 — Guarda prima di toccare qualsiasi cosa
Prima di avviare i tuoi server, guarda su cosa il tuo computer è già in ascolto e quale intervallo usa per le porte effimere.

**Linux:**

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

Output atteso (abbreviato; la tua lista sarà diversa):

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

Su un desktop tipico vedrai un resolver Domain Name System (DNS) locale sulla porta 53 (qui `systemd-resolved`, su `127.0.0.53`), il servizio orario su UDP 323, il DNS multicast su UDP 5353 e un servizio di stampa su TCP 631. La maggior parte ascolta solo su indirizzi di loopback. L'ultima riga è l'intervallo delle porte effimere: Linux usa per impostazione predefinita 32768–60999, non l'intervallo 49152–65535 della 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
```

Su macOS e Windows l'intervallo dinamico predefinito è 49152–65535.

> [!NOTE]
> I comandi per macOS e Windows non sono stati eseguiti per questa guida, quindi il loro output non è mostrato; le colonne si spiegano da sole. La porta 9000 deve essere libera per questo laboratorio. Se qualcosa vi è già in ascolto, cambia `PORT` in ogni script con un'altra porta libera superiore a 1024, come 9500.

### Passaggio 3 — Scrivi e avvia il server echo TCP
Un server ha bisogno di una porta fissa e nota perché i client lo trovino. Questo ascolta su `127.0.0.1:9000` e rimanda indietro ogni byte che riceve. Salvalo come `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` chiede TCP. `bind()` rivendica indirizzo e porta; `listen()` trasforma il socket in un socket in ascolto.
- `accept()` ritorna solo dopo che un client ha completato l'handshake a tre vie. L'handshake l'ha fatto il sistema operativo; il tuo programma raccoglie solo il risultato.
- `recv()` restituisce un risultato vuoto quando il client ha inviato FIN. È così che un programma TCP scopre che l'altro lato ha chiuso.

Nel **terminale 1**, avvialo e lascialo in esecuzione:

```bash
python3 tcp_server.py
```

Output atteso:

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

### Passaggio 4 — Trova il socket in ascolto
Nel **terminale 3** (il tuo terminale dei comandi), chiedi al sistema operativo chi ascolta sulla porta 9000. Il filtro `'sport = :9000'` (porta di origine, che per un socket in ascolto è la porta locale) mantiene l'output breve.

**Linux:**

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

Output atteso (il tuo ID di processo sarà diverso):

```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` su `127.0.0.1:9000`: solo i programmi di questo computer possono connettersi.
- `Peer Address:Port` è `0.0.0.0:*` perché un socket in ascolto non ha ancora un peer.
- `Send-Q 128` è il backlog: quanti handshake completati possono attendere `accept()`.
- `users:(("python3",pid=…))` è il processo proprietario. Lo vedi senza `sudo` perché il socket è tuo.

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

### Passaggio 5 — Connettiti e osserva la connessione
Ora ti serve un client. Si connette, stampa il proprio indirizzo e porta e quelli del server, invia un messaggio e legge l'echo. Un argomento facoltativo mantiene la connessione aperta per alcuni secondi così puoi ispezionarla. Salvalo come `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")
```

Nota che il client non sceglie mai la propria porta: `create_connection()` lascia che il sistema operativo ne scelga una effimera.

Nel terminale 3, esegui il client in background con un'attesa di 15 secondi, poi elenca subito i socket TCP sulla porta 9000. Su Linux:

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

Output atteso (la tua porta effimera sarà diversa; le righe del client possono comparire prima o dopo la tabella):

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

Leggi le tre righe:
- Il socket `LISTEN` è ancora lì: continua ad attendere il *prossimo* client.
- La connessione compare **due volte**, una da ciascuna estremità, perché entrambe le estremità sono sul tuo computer. Il lato client è `127.0.0.1:36784 → 127.0.0.1:9000`; il lato server è l'immagine speculare.
- `36784` rientra nell'intervallo effimero del Passaggio 2. Esegui di nuovo il client e otterrai una porta diversa.

Nel terminale 1, il server ha registrato la connessione:

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

Su macOS, esegui il client allo stesso modo e usa `netstat -an -p tcp | grep 9000`. Su Windows, avvia `py tcp_client.py 15` in un terminale aggiuntivo ed esegui `Get-NetTCPConnection -LocalPort 9000; Get-NetTCPConnection -RemotePort 9000` nel terminale 3 entro 15 secondi.

### Passaggio 6 — Osserva TIME-WAIT
Aspetta che il client stampi `closed` (15 secondi), poi guarda di nuovo:

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

Output atteso:

```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 solo una riga per la vecchia connessione, ed è sulla porta del **client**. Il client ha chiuso per primo (il suo blocco `with` è finito), quindi è il client il lato che attende in TIME-WAIT. Il lato server è passato direttamente a CLOSED dopo che il proprio FIN è stato confermato.
- `-o` mostra i timer: `timewait,58sec` conta alla rovescia da 60 secondi, il tempo fisso di TIME-WAIT su Linux. Esegui di nuovo il comando dopo un minuto: la riga è sparita.

Il server ha registrato la chiusura nel terminale 1:

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

Su macOS e Windows, `netstat -an -p tcp | grep 9000` (macOS) o `netstat -an -p tcp | findstr 9000` (Windows) mostra la stessa connessione come `TIME_WAIT`. I loro timer sono diversi da quelli di Linux.

### Passaggio 7 — Parla con il server usando netcat
Il tuo client non ha nulla di speciale: qualsiasi programma TCP può parlare con il server. Netcat (`nc`) si connette e poi copia la tua tastiera sul socket e il socket sul tuo schermo.

```bash
nc 127.0.0.1 9000
```

Scrivi `hello from nc` e premi Invio. Il server lo rimanda indietro:

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

La prima riga è ciò che hai scritto, la seconda è l'echo. Premi **Ctrl+C** per uscire. Il terminale 1 registra la connessione e la chiusura, ciascuna con una nuova porta effimera.

> [!NOTE]
> Esistono diverse implementazioni di netcat con opzioni e messaggi leggermente diversi: OpenBSD netcat (Debian, Ubuntu e la base di `nc` su macOS), `ncat` di Nmap (Fedora, RHEL) e il vecchio netcat «tradizionale». La forma base `nc <host> <porta>` funziona in tutte. Su Windows, salta i comandi `nc` e usa i client Python.

### Passaggio 8 — Aggiungi un server UDP sullo stesso numero di porta
TCP e UDP hanno spazi di porte separati, quindi anche un server UDP può usare la porta 9000. Salva questo come `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")
```

Confrontalo con il server TCP: `SOCK_DGRAM` invece di `SOCK_STREAM`, niente `listen()`, niente `accept()` e nessun oggetto di connessione. Ogni datagramma arriva con l'indirizzo del suo mittente, e la risposta torna a quell'indirizzo.

Nel **terminale 2**, avvialo:

```bash
python3 udp_server.py
```

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

Nel terminale 3, elenca insieme i socket TCP e UDP sulla porta 9000:

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

Output atteso:

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

Due socket, stesso indirizzo, stesso numero di porta, protocolli diversi. Quello UDP è `UNCONN` (non connesso), non `LISTEN`: UDP non ha connessioni da attendere.

Ora il client. Salvalo come `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)")
```

Eseguilo:

```bash
python3 udp_client.py
```

Output atteso:

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

Il terminale 2 mostra `datagram from 127.0.0.1:40760: hello over UDP`. Poi prova netcat in modalità UDP (`-u`), scrivi una riga, leggi l'echo e premi Ctrl+C:

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

Esegui di nuovo `ss -tan '( sport = :9000 or dport = :9000 )'` e `ss -uan 'sport = :9000'` dopo il client UDP: non c'è ESTAB né TIME-WAIT per UDP. Non è stato stabilito nulla, quindi non c'è nulla da smontare.

### Passaggio 9 — Connection refused rispetto a connection timed out
Questa è l'abilità di troubleshooting della lezione. Farai fallire una connessione in tre modi e cronometrerai ciascuno. Salva questo come `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")
```

Sonda la porta aperta, una porta chiusa sul tuo computer e l'indirizzo di documentazione `192.0.2.1`, che non è mai assegnato a nessuno:

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

Output atteso:

```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:** l'handshake si completa. Il terminale 1 registra una connessione.
- **Porta 9001:** il tuo computer ha ricevuto il SYN, non ha trovato alcun socket in ascolto e ha risposto subito RST: *connection refused*.
- **`192.0.2.1`:** il SYN lascia il tuo computer e nessuno risponde mai, quindi il client attende l'intero timeout che gli hai dato (3 s): *timed out*. Senza timeout, Linux continua a ritentare il SYN per poco più di due minuti prima di rinunciare.

`<timeout>`, il terzo argomento facoltativo, è il numero di secondi di attesa. Prova `python3 probe.py 192.0.2.1 80 10` e il risultato arriva dopo 10 secondi: il ritardo lo stabilisce il *client*, non la rete.

Gli stessi test con netcat (`-v` verboso, `-z` connettiti senza inviare dati, `-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
```

Il testo tra parentesi quadre può mostrare un nome di servizio dall'elenco dei servizi del tuo sistema invece di `*`. Su Windows (PowerShell), il controllo equivalente è `Test-NetConnection -ComputerName 127.0.0.1 -Port 9001`, che riporta `TcpTestSucceeded : False` per entrambi i tipi di fallimento; usa `probe.py` per vedere la differenza.

Infine, UDP verso una porta chiusa:

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

Il tuo computer ha risposto al datagramma con un messaggio «port unreachable» dell'Internet Control Message Protocol (ICMP) e, poiché il client ha usato `connect()`, il sistema operativo l'ha segnalato come errore. Su una rete reale quel messaggio ICMP è spesso filtrato, e il client stamperebbe semplicemente `no reply within 2 s`: con UDP, «chiusa» e «persa» possono sembrare identiche.

> [!NOTE]
> Tempi e messaggi variano a seconda del sistema operativo. Su Windows, una connessione rifiutata può richiedere circa due secondi, perché il client ritenta un paio di volte dopo l'RST, e l'errore UDP può essere segnalato come *reset* della connessione; lo script le intercetta entrambe. La tua rete può anche rispondere in fretta per `192.0.2.1` con «No route to host» o «Network is unreachable» (lo script stampa `error: …`) se non ha una route per quell'intervallo. È un terzo tipo di fallimento, che viene dal livello di rete anziché dal bersaglio.

### Passaggio 10 (facoltativo) — Cattura l'handshake con tcpdump
Questo passaggio richiede privilegi di amministratore. Saltalo se non li hai; l'output qui sotto mostra cosa vedresti.

Nel terminale 3, avvia una cattura sull'interfaccia di loopback (`lo` su Linux, `lo0` su macOS). `-n` mostra numeri invece di nomi:

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

In un terminale aggiuntivo, esegui il client una volta e sonda una volta la porta chiusa:

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

Ferma la cattura con Ctrl+C. Output atteso (timestamp e opzioni TCP abbreviati; le tue porte, i numeri di sequenza e le finestre saranno diversi):

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

Confrontalo con la lezione:
- Righe 1–3: l'handshake a tre vie, `[S]`, `[S.]`, `[.]`. I numeri di sequenza iniziali (ISN) sono casuali; il SYN-ACK conferma l'ISN del client + 1. Dalla riga 3, `tcpdump` stampa i numeri di sequenza relativi all'ISN.
- Righe 4–7: `hello over TCP` sono 14 byte (`seq 1:15`, `length 14`), confermati con `ack 15`, poi rimandati indietro come echo e confermati allo stesso modo.
- Righe 8–10: la chiusura. Il FIN del client, poi il FIN del server combinato con l'ACK del FIN del client (`ack 16`: un FIN conta come un byte), poi l'ACK finale del client. Combinare due passaggi in un solo segmento è comune, quindi spesso si vedono tre segmenti di chiusura invece di quattro.
- Righe 11–12: un SYN verso la porta chiusa 9001, a cui si risponde con `[R.]` (RST, ACK). Questo è «connection refused» sul cavo.
- Riga 13: il messaggio ICMP port unreachable per il datagramma UDP verso la 9001.
- La dimensione massima del segmento (MSS) di 65495 e le finestre grandi sono tipiche del loopback, la cui unità massima di trasmissione (MTU) è 65536. Su Ethernet vedresti `mss 1460`.

> [!NOTE]
> Questa cattura è stata registrata con `tcpdump` su Linux. Un SYN verso `192.0.2.1` comparirebbe come la stessa riga `[S]` ripetuta alcune volte con intervalli crescenti e senza risposta, che è l'aspetto di un timeout sul cavo. Per vederlo, cattura sull'interfaccia principale (per esempio `eth0`, `en0` o il nome indicato da `ip route show default`) invece che sul loopback.

## Verifica
Hai completato il laboratorio se puoi rispondere «sì» a ciascun controllo:

| Controllo | Come confermarlo |
|---|---|
| Il server TCP ascolta su `127.0.0.1:9000` | `ss -tlnp 'sport = :9000'` mostra `LISTEN` e il tuo processo `python3` |
| Hai visto una connessione da entrambe le estremità | Il Passaggio 5 mostra due righe `ESTAB` speculari, con una porta effimera nel tuo intervallo del Passaggio 2 |
| Hai visto TIME-WAIT sul lato che ha chiuso per primo | Il Passaggio 6 mostra `TIME-WAIT` solo sulla porta effimera del client, con un timer di al massimo 60 s su Linux |
| TCP e UDP condividono il numero di porta 9000 | `ss -tuln 'sport = :9000'` mostra una riga `tcp LISTEN` e una `udp UNCONN` |
| Sai distinguere refused da timed out | `probe.py` riporta `refused` in circa 0,01 s per la porta 9001 e `timed out` dopo il timeout scelto per `192.0.2.1` |

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `OSError: [Errno 98] Address already in use` (Linux), `[Errno 48]` (macOS) o `[WinError 10048]` (Windows) all'avvio di un server | Un'altra copia del server è ancora in esecuzione, oppure qualcos'altro usa la porta 9000 | Trovala con `ss -tulnp 'sport = :9000'` (Linux), `lsof -nP -i :9000` (macOS) o `Get-NetTCPConnection -LocalPort 9000` (Windows); fermala, oppure cambia `PORT` in tutti gli script |
| `ConnectionRefusedError: [Errno 111] Connection refused` da `tcp_client.py` | Il server TCP non è in esecuzione, o ascolta su un'altra porta | Controlla il terminale 1; riavvia `python3 tcp_server.py` |
| `udp_client.py` stampa `no reply within 2 s` anche se il server UDP dovrebbe essere in esecuzione | Il server UDP non è in esecuzione, o un firewall locale scarta l'UDP di loopback | Controlla il terminale 2 e `ss -uln 'sport = :9000'` |
| `nc: command not found` | Netcat non è installato | Installa `netcat-openbsd` o `nmap-ncat`, oppure salta i comandi `nc`; i client Python fanno lo stesso lavoro |
| `probe.py 192.0.2.1 80` stampa subito `error: No route to host` o `Network is unreachable` | Il tuo sistema o la tua rete non ha una route per `192.0.2.0/24`, oppure un router risponde con ICMP | Va bene: è un fallimento del livello di rete, non un timeout. Confrontalo con l'elenco di errori della lezione |
| Le righe `ESTAB` non compaiono nel Passaggio 5 | Sono passati più di 15 s prima dell'esecuzione di `ss`, oppure il client è fallito | Esegui i due comandi insieme come mostrato, oppure aumenta l'attesa: `python3 tcp_client.py 30 &` |
| `tcpdump: lo: No such device exists` | Su macOS l'interfaccia di loopback è `lo0` | Usa `sudo tcpdump -i lo0 -n …` |

## Sfida (facoltativa)
1. Modifica `tcp_server.py` in modo che sia il **server** a chiudere la connessione subito dopo aver inviato l'echo (esci dal ciclo dopo il primo `sendall()`). Quale lato mostra ora TIME-WAIT? Poi rimuovi la riga `SO_REUSEADDR`, esegui un client, ferma il server e riavvialo entro un minuto. Cosa succede, e perché quasi ogni server reale imposta `SO_REUSEADDR`?
2. Fai ascoltare il server su `0.0.0.0` invece che su `127.0.0.1` e controlla la differenza con `ss -tln`. Ora è raggiungibile da un altro dispositivo della tua rete? Il firewall del tuo host lo consente? Rimettilo com'era quando hai finito.
3. Apri dieci connessioni contemporaneamente (per esempio, `for i in $(seq 10); do python3 tcp_client.py 20 & done`) e contale con `ss -tan '( dport = :9000 )' | wc -l`. Quale parte della 4-tupla differisce tra loro?
4. Invia un messaggio da 5000 byte con `tcp_client.py` e leggilo con un solo `recv(1024)`. Cosa arriva? Cosa ti dice questo su TCP come flusso di byte, e come progetteresti un formato di messaggio sopra di esso?

## Pulizia
Ferma entrambi i server: premi **Ctrl+C** nel terminale 1 e nel terminale 2. Ciascuno stampa `server stopped`. Chiudi le sessioni `nc` con Ctrl+C e ferma `tcpdump` se è ancora in esecuzione.

Controlla che non sia rimasto nulla sulla porta 9000 (Linux):

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

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

La sola riga di intestazione significa che entrambi i server sono spariti. Se un server è ancora in esecuzione (per esempio, hai chiuso il suo terminale), fermalo con `pkill -f tcp_server.py; pkill -f udp_server.py` su Linux o macOS, oppure con `Get-Process python*` e `Stop-Process -Id <pid>` su Windows. `<pid>` è l'ID di processo mostrato da `ss -tulnp` o `Get-NetTCPConnection` (colonna `OwningProcess`).

Rimuovi la cartella e i cinque script.

Linux e macOS:

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

Windows (PowerShell):

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

Le voci TIME-WAIT spariscono da sole in circa un minuto. Nessuna impostazione di sistema è stata modificata, quindi non c'è altro da annullare.

## Cosa hai imparato
- Un server associa una porta fissa e ascolta; ogni client riceve dal sistema operativo una porta effimera, e la 4-tupla identifica la connessione. Su una sola macchina vedi ogni connessione due volte, una da ciascuna estremità.
- TCP e UDP hanno spazi di porte separati. TCP mostra LISTEN, ESTAB e TIME-WAIT; UDP solo UNCONN, perché non ci sono connessioni.
- Il lato che chiude per primo detiene TIME-WAIT (60 s su Linux). È normale e sparisce da solo.
- «Connection refused» è una risposta (RST) e arriva in millisecondi. «Connection timed out» è silenzio, e quanto dura dipende dal timeout del client.
- `ss` (o `netstat`, `lsof`, `Get-NetTCPConnection`) e, con privilegi di amministratore, `tcpdump` ti mostrano esattamente cosa sta facendo il livello di trasporto.