---
title: "Laboratorio: socket TCP e UDP sul tuo computer"
domain: networking
level: beginner
duration: "60 min"
cost: "gratuito"
environment: "il tuo computer (Linux, macOS o Windows) con Python 3; tutto gira sull'interfaccia di loopback"
lang: it
source_hash: 64c2dda423c2
---

# Laboratorio: socket TCP e UDP sul tuo computer

## 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
![Architettura del laboratorio. Tutto gira sul tuo computer attraverso l'interfaccia di loopback lo, 127.0.0.1. I client tcp_client.py, udp_client.py, nc e probe.py usano una porta di origine effimera come 127.0.0.1:50980. Si connettono via TCP a un server echo TCP su 127.0.0.1:9000/tcp, via UDP a un server echo UDP su 127.0.0.1:9000/udp, e a 127.0.0.1:9001 dove nulla è in ascolto, che risponde a TCP con RST e a UDP con ICMP di porta irraggiungibile. Osservi con ss -tan, ss -uln e, facoltativamente con sudo, tcpdump -i lo. Una sonda invia un SYN all'indirizzo di documentazione 192.0.2.1:80, che non risponde mai, quindi va in timeout](../../../assets/diagrams/tcp-lab-architecture.it.svg)

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