---
title: "Laboratorio: costruire uno switch con VLAN usando i namespace Linux"
domain: networking
level: beginner
duration: "60 min"
cost: "gratuito"
environment: "macchina Linux locale o VM con sudo (network namespace, bridge Linux)"
lang: it
source_hash: 14b155c590c5
---

# Laboratorio: costruire uno switch con VLAN usando i namespace Linux

## Obiettivo
Costruisci una piccola rete commutata su una sola macchina Linux: un bridge Linux con VLAN fa da switch e i network namespace fanno da tre PC e un router. Vedi lo switch imparare gli indirizzi MAC e inondare i frame sconosciuti, dividi i PC in due VLAN, trasporti entrambe le VLAN su un trunk, vedi i tag 802.1Q in una cattura e instradi tra le VLAN con un router-on-a-stick.

## Obiettivi
- Osservare l'apprendimento degli indirizzi MAC e l'inondazione nel forwarding database di uno switch.
- Configurare porte access in due VLAN e mostrare che host in VLAN diverse non possono raggiungersi al livello 2, nemmeno nella stessa subnet.
- Configurare una porta trunk che trasporta le VLAN 10 e 20 con tag e leggere i tag 802.1Q in una cattura di pacchetti.
- Instradare tra le VLAN con un router-on-a-stick costruito con sottointerfacce VLAN.

## Prerequisiti
- Una macchina Linux o VM dove puoi usare `sudo`. Va bene qualsiasi distribuzione attuale (testato su Fedora con Linux 6.x).
- iproute2 5.0 o successivo, che fornisce i comandi `ip` e `bridge` (testato con 6.17). Controlla con `ip -V`.
- tcpdump 4.9 o successivo (testato con 4.99.6). Installalo con il gestore di pacchetti se `tcpdump --version` fallisce, ad esempio `sudo dnf install tcpdump` o `sudo apt install tcpdump`.
- Due finestre di terminale: eseguirai le catture nella seconda.
- La [lezione](lesson.it.md) di questo modulo, in particolare l'apprendimento delle MAC, le porte access e trunk e il router-on-a-stick.

> [!WARNING]
> Esegui questo laboratorio solo sulla tua macchina o su una VM che controlli, meglio una VM di prova che un server di produzione. Tutto avviene dentro nuovi network namespace, quindi le tue interfacce, i tuoi indirizzi e le tue route reali non vengono toccati. Il laboratorio usa l'intervallo privato `192.168.0.0/16` (RFC 1918) dentro i namespace; anche se la tua rete domestica usa gli stessi indirizzi, non c'è conflitto, perché i namespace ne sono isolati. Esegui sempre la sezione [Pulizia](#pulizia) alla fine.

## Architettura
Un **network namespace** è una copia separata dello stack di rete di Linux, con proprie interfacce, indirizzi e tabella di routing. Ne crei cinque. Uno, `sw1`, contiene lo switch: un bridge Linux chiamato `br0` con il filtraggio VLAN attivo. Gli altri sono host. Ogni host è collegato a una porta del bridge con una **coppia veth**, un cavo Ethernet virtuale le cui due estremità possono stare in namespace diversi.

![Architettura del laboratorio: il namespace sw1 contiene br0, un bridge Linux con vlan_filtering 1. Il namespace pc1 (eth0, 00:00:5e:00:53:01, 192.168.10.11/24) si collega alla porta p1, una porta access nella VLAN 10. Il namespace pc2 (eth0, 00:00:5e:00:53:02, 192.168.20.12/24) si collega a p2, una porta access nella VLAN 20. Il namespace pc3 (eth0, 00:00:5e:00:53:03, 192.168.10.13/24) si collega a p3, una porta access nella VLAN 10. Il namespace r1 (eth0, 00:00:5e:00:53:fe) si collega a p4, un trunk con tag delle VLAN 10 e 20, e instrada tra di esse con le sottointerfacce eth0.10 (192.168.10.1/24) e eth0.20 (192.168.20.1/24)](../../../assets/diagrams/vlan-lab-architecture.it.svg)

*Figura 1. Il laboratorio finito. I collegamenti blu sono la VLAN 10, quelli arancioni la VLAN 20 e il trunk verde le trasporta entrambe. pc2 parte in `192.168.10.0/24` e passa a `192.168.20.0/24` nel Passo 8.*

Gli host usano indirizzi MAC dal blocco di documentazione della RFC 7042 (`00:00:5e:00:53:xx`), così gli output che vedi corrispondono a questa guida.

| Namespace | Ruolo | Interfaccia | MAC | Indirizzo IP (finale) | Porta del bridge |
|---|---|---|---|---|---|
| `pc1` | Host, VLAN 10 | `eth0` | `00:00:5e:00:53:01` | `192.168.10.11/24` | `p1`, access VLAN 10 |
| `pc2` | Host, VLAN 20 | `eth0` | `00:00:5e:00:53:02` | `192.168.20.12/24` | `p2`, access VLAN 20 |
| `pc3` | Host, VLAN 10 | `eth0` | `00:00:5e:00:53:03` | `192.168.10.13/24` | `p3`, access VLAN 10 |
| `r1` | Router-on-a-stick | `eth0`, `eth0.10`, `eth0.20` | `00:00:5e:00:53:fe` | `192.168.10.1/24`, `192.168.20.1/24` | `p4`, trunk 10, 20 |
| `sw1` | Switch | `br0`, `p1`–`p4` | casuale | nessuno | — |

## Passaggi

> [!NOTE]
> Esegui ogni comando nel primo terminale, a meno che il passo dica "terminale 2". Gli output mostrati provengono da iproute2 6.17, tcpdump 4.99.6 e iputils 20250605. Timestamp, tempi e numeri di indice delle interfacce (come `@if4`) saranno diversi sulla tua macchina. Una localizzazione diversa dall'inglese traduce alcuni messaggi: avvia entrambi i terminali con `export LC_ALL=C` per ottenere le stesse parole di questa guida.

### Passo 1 — Controlla gli strumenti
Assicurati che i comandi esistano e siano abbastanza recenti prima di costruire qualsiasi cosa.

```bash
ip -V
bridge -V
tcpdump --version
```

Output atteso (le tue versioni possono essere più recenti):
```text
ip utility, iproute2-6.17.0, libbpf 1.6.3
bridge utility, 6.17.0
tcpdump version 4.99.6
libpcap version 1.10.7 (64-bit time_t, with TPACKET_V3)
...
```

### Passo 2 — Crea i namespace
Ogni namespace è un dispositivo della tua rete: uno switch, tre PC e un router. Disattivi anche IPv6 al loro interno. Non serve perché le VLAN funzionino, ma impedisce agli host di inviare messaggi di discovery IPv6, così la tabella MAC e le catture mostrano solo il traffico che generi tu.

```bash
for ns in sw1 pc1 pc2 pc3 r1; do
  sudo ip netns add $ns
  sudo ip netns exec $ns sysctl -qw net.ipv6.conf.all.disable_ipv6=1 net.ipv6.conf.default.disable_ipv6=1
done
ip netns list
```

Output atteso:
```text
r1
pc3
pc2
pc1
sw1
```

### Passo 3 — Crea lo switch
Un **bridge** Linux è uno switch software: impara gli indirizzi MAC e inoltra i frame esattamente come descrive la lezione. Con `vlan_filtering 1`, tiene traccia anche delle VLAN per porta, come uno switch gestito. Lo crei dentro `sw1` con l'opzione `-n sw1`, che esegue un comando `ip` o `bridge` in quel namespace.

```bash
sudo ip -n sw1 link add br0 type bridge vlan_filtering 1
sudo ip -n sw1 link set br0 up
sudo ip -n sw1 -d link show br0 | grep -o -E 'vlan_filtering [0-9]+|ageing_time [0-9]+'
sudo bridge -n sw1 vlan show
```

Output atteso:
```text
ageing_time 30000
vlan_filtering 1
port              vlan-id  
br0               1 PVID Egress Untagged
```

- `ageing_time 30000` è il tempo di scadenza della tabella MAC in centesimi di secondo: 300 secondi, il valore predefinito comune visto nella lezione.
- `bridge vlan show` elenca le VLAN di ogni porta. Per ora esiste solo `br0` stesso, nella VLAN 1. **PVID** (port VLAN ID) è la VLAN a cui si uniscono i frame senza tag in ingresso, e **Egress Untagged** significa che i frame di quella VLAN escono dalla porta senza tag. Insieme, fanno di una porta una porta access per quella VLAN.

### Passo 4 — Collega tre PC
Ora colleghi i PC allo switch. Per ogni PC, un comando crea una coppia veth: l'estremità chiamata `p1` (o `p2`, `p3`) resta in `sw1` e quella chiamata `eth0` va nel namespace del PC. Poi imposti l'indirizzo MAC del PC, colleghi l'estremità dello switch a `br0` e attivi entrambe le estremità. All'inizio, i tre PC condividono una subnet, `192.168.10.0/24`.

```bash
for i in 1 2 3; do
  sudo ip -n sw1 link add p$i type veth peer name eth0 netns pc$i
  sudo ip -n pc$i link set eth0 address 00:00:5e:00:53:0$i
  sudo ip -n sw1 link set p$i master br0
  sudo ip -n sw1 link set p$i up
  sudo ip -n pc$i link set eth0 up
done
sudo ip -n pc1 addr add 192.168.10.11/24 dev eth0
sudo ip -n pc2 addr add 192.168.10.12/24 dev eth0
sudo ip -n pc3 addr add 192.168.10.13/24 dev eth0
sudo bridge -n sw1 vlan show
sudo ip -n pc2 -br addr
```

Output atteso:
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                1 PVID Egress Untagged
p2                1 PVID Egress Untagged
p3                1 PVID Egress Untagged
lo               DOWN           
eth0@if4         UP             192.168.10.12/24 
```

Ogni nuova porta si unisce alla VLAN 1 come porta access, proprio come un nuovo switch hardware. I tre PC sono in un unico dominio di broadcast.


### Passo 5 — Guarda lo switch imparare e inondare
Per prima cosa, guarda il **forwarding database** (FDB) dello switch, il nome che Linux dà alla tabella degli indirizzi MAC. La parola chiave `dynamic` mostra solo le voci apprese e nasconde quelle permanenti del bridge stesso.

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Output atteso: niente. Nessun PC ha ancora inviato un frame, quindi lo switch non ha imparato nulla.

> [!TIP]
> Se il tuo comando `bridge` non accetta `dynamic`, esegui invece `sudo bridge -n sw1 fdb show br br0 | grep -v permanent`.

Ora avvia una cattura su pc3, che non partecipa alla conversazione che stai per iniziare. Nel **terminale 2**:

```bash
sudo ip netns exec pc3 tcpdump -e -n -i eth0 arp or icmp
```

`ip netns exec pc3` esegue tcpdump dentro pc3. `-e` stampa le MAC di ogni frame, `-n` disattiva la risoluzione dei nomi e `arp or icmp` mostra solo il traffico ARP e ping.

Nel **terminale 1**, fai ping a pc2 da pc1:

```bash
sudo ip netns exec pc1 ping -c 2 192.168.10.12
```

Output atteso (i tempi variano):
```text
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.
64 bytes from 192.168.10.12: icmp_seq=1 ttl=64 time=0.054 ms
64 bytes from 192.168.10.12: icmp_seq=2 ttl=64 time=0.056 ms

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1037ms
rtt min/avg/max/mdev = 0.054/0.055/0.056/0.001 ms
```

Ferma la cattura nel terminale 2 con Ctrl+C. Output atteso nel terminale 2:
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:36.485926 00:00:5e:00:53:01 > Broadcast, ethertype ARP (0x0806), length 42: Request who-has 192.168.10.12 tell 192.168.10.11, length 28
^C
1 packet captured
1 packet received by filter
0 packets dropped by kernel
```

pc3 ha visto esattamente un frame: la richiesta ARP di pc1, inviata all'indirizzo di broadcast e quindi inondata da ogni porta. **Non** ha visto la risposta ARP né i quattro pacchetti ping. Quando pc2 ha risposto, lo switch conosceva già la porta di pc1 (appresa dall'origine della richiesta ARP), quindi ha inoltrato la risposta solo a `p1` e da essa ha imparato la porta di pc2.

Controlla di nuovo la tabella:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Output atteso:
```text
00:00:5e:00:53:01 dev p1 vlan 1 master br0 
00:00:5e:00:53:02 dev p2 vlan 1 master br0 
```

Lo switch ha imparato pc1 su `p1` e pc2 su `p2`, entrambi nella VLAN 1. pc3 non ha inviato nulla, quindi non è ancora nella tabella.

### Passo 6 — Dividi i PC in due VLAN
Ora fai di `p1` e `p3` porte access nella VLAN 10 e di `p2` una porta access nella VLAN 20. `pvid untagged` rende la VLAN la VLAN access della porta. Poi rimuovi la VLAN 1 dalle tre porte, così ogni porta appartiene esattamente a una VLAN.

```bash
sudo bridge -n sw1 vlan add dev p1 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p3 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p2 vid 20 pvid untagged
sudo bridge -n sw1 vlan del dev p1 vid 1
sudo bridge -n sw1 vlan del dev p2 vid 1
sudo bridge -n sw1 vlan del dev p3 vid 1
sudo bridge -n sw1 vlan show
```

Output atteso:
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                10 PVID Egress Untagged
p2                20 PVID Egress Untagged
p3                10 PVID Egress Untagged
```

pc2 ha ancora l'indirizzo `192.168.10.12/24`, nella stessa subnet di pc1. Svuota la cache ARP di pc1, così deve chiedere di nuovo, poi fai ping a pc3 (stessa VLAN) e a pc2 (altra VLAN):

```bash
sudo ip -n pc1 neigh flush all
sudo ip netns exec pc1 ping -c 2 192.168.10.13
sudo ip netns exec pc1 ping -c 2 192.168.10.12
sudo ip -n pc1 neigh show
```

Output atteso (i tempi variano):
```text
PING 192.168.10.13 (192.168.10.13) 56(84) bytes of data.
64 bytes from 192.168.10.13: icmp_seq=1 ttl=64 time=0.038 ms
64 bytes from 192.168.10.13: icmp_seq=2 ttl=64 time=0.051 ms

--- 192.168.10.13 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1009ms
rtt min/avg/max/mdev = 0.038/0.044/0.051/0.006 ms
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1019ms

192.168.10.12 dev eth0 FAILED 
192.168.10.13 dev eth0 lladdr 00:00:5e:00:53:03 REACHABLE 
```

pc1 e pc2 hanno indirizzi nella stessa subnet, eppure pc1 non riesce nemmeno a risolvere l'indirizzo MAC di pc2: la voce ARP è `FAILED`. Lo switch tiene il broadcast di pc1 dentro la VLAN 10, quindi non raggiunge mai la porta di pc2. È il confine della VLAN al lavoro. Stessa subnet o no, VLAN diverse sono domini di broadcast diversi.

Guarda la tabella ancora una volta:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Output atteso:
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
```

Le voci ora riportano la VLAN: lo switch mantiene una tabella per VLAN. Rimuovere la VLAN 1 dalle porte ha eliminato anche le loro vecchie voci della VLAN 1. La riga di pc2 nella VLAN 20 compare solo dopo che pc2 ha inviato un frame nella sua nuova VLAN (ad esempio una sonda ARP); se manca sulla tua macchina, va bene.

### Passo 7 — Aggiungi una porta trunk per il router
Il router deve raggiungere entrambe le VLAN con un solo cavo, quindi la sua porta sullo switch è un trunk. Aggiungi una quarta coppia veth: `p4` nello switch, `eth0` in `r1`. Poi rendi `p4` un membro con tag delle VLAN 10 e 20. Senza le parole chiave `pvid untagged`, i frame di queste VLAN escono da `p4` con un tag 802.1Q. Rimuovere la VLAN 1 significa che `p4` non ha VLAN nativa: i frame senza tag che arrivano su di essa vengono scartati.

```bash
sudo ip -n sw1 link add p4 type veth peer name eth0 netns r1
sudo ip -n r1 link set eth0 address 00:00:5e:00:53:fe
sudo ip -n sw1 link set p4 master br0
sudo ip -n sw1 link set p4 up
sudo bridge -n sw1 vlan add dev p4 vid 10
sudo bridge -n sw1 vlan add dev p4 vid 20
sudo bridge -n sw1 vlan del dev p4 vid 1
sudo bridge -n sw1 vlan show dev p4
```

Output atteso:
```text
port              vlan-id  
p4                10
                  20
```

Niente `PVID` e niente `Egress Untagged`: `p4` trasporta entrambe le VLAN, con tag. Questo è un trunk.


### Passo 8 — Configura il router-on-a-stick
In `r1`, crei una **sottointerfaccia VLAN** per VLAN sopra `eth0`. `eth0.10` invia e riceve frame con tag VLAN 10, ed `eth0.20` frame con tag VLAN 20. Ciascuna riceve l'indirizzo gateway della propria VLAN. Attivare l'IP forwarding fa sì che `r1` instradi tra di esse.

```bash
sudo ip -n r1 link set eth0 up
sudo ip -n r1 link add link eth0 name eth0.10 type vlan id 10
sudo ip -n r1 link add link eth0 name eth0.20 type vlan id 20
sudo ip -n r1 addr add 192.168.10.1/24 dev eth0.10
sudo ip -n r1 addr add 192.168.20.1/24 dev eth0.20
sudo ip -n r1 link set eth0.10 up
sudo ip -n r1 link set eth0.20 up
sudo ip netns exec r1 sysctl -w net.ipv4.ip_forward=1
sudo ip -n r1 -d link show eth0.20 | grep -o 'vlan protocol [^ ]* id [0-9]*'
sudo ip -n r1 -br addr
```

Output atteso:
```text
net.ipv4.ip_forward = 1
vlan protocol 802.1Q id 20
lo               DOWN           
eth0@if6         UP             
eth0.10@eth0     UP             192.168.10.1/24 
eth0.20@eth0     UP             192.168.20.1/24 
```

`eth0` stessa non ha un indirizzo: è solo il collegamento fisico che trasporta i frame con tag.

Ora assegna a pc2 un indirizzo nella subnet della VLAN 20 e dai a ogni PC un gateway predefinito nella propria VLAN:

```bash
sudo ip -n pc2 addr flush dev eth0
sudo ip -n pc2 addr add 192.168.20.12/24 dev eth0
sudo ip -n pc1 route add default via 192.168.10.1
sudo ip -n pc3 route add default via 192.168.10.1
sudo ip -n pc2 route add default via 192.168.20.1
sudo ip -n pc1 route
```

Output atteso:
```text
default via 192.168.10.1 dev eth0 
192.168.10.0/24 dev eth0 proto kernel scope link src 192.168.10.11 
```

### Passo 9 — Guarda i tag 802.1Q sul trunk
Cattura sulla porta trunk `p4`, dentro lo switch, mentre pc1 fa ping a pc2 attraverso le VLAN. Nel **terminale 2**:

```bash
sudo ip netns exec sw1 tcpdump -e -n -i p4 -c 8 vlan
```

Il filtro `vlan` tiene solo i frame con tag, e `-c 8` si ferma dopo otto pacchetti.

Nel **terminale 1**:

```bash
sudo ip netns exec pc1 ping -c 1 192.168.20.12
```

Output atteso nel terminale 1 (i tempi variano):
```text
PING 192.168.20.12 (192.168.20.12) 56(84) bytes of data.
64 bytes from 192.168.20.12: icmp_seq=1 ttl=63 time=0.082 ms

--- 192.168.20.12 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.082/0.082/0.082/0.000 ms
```

Output atteso nel terminale 2:
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on p4, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:53.622170 00:00:5e:00:53:01 > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Request who-has 192.168.10.1 tell 192.168.10.11, length 28
22:16:53.622187 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Reply 192.168.10.1 is-at 00:00:5e:00:53:fe, length 28
22:16:53.622198 00:00:5e:00:53:01 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622204 00:00:5e:00:53:fe > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Request who-has 192.168.20.12 tell 192.168.20.1, length 28
22:16:53.622214 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Reply 192.168.20.12 is-at 00:00:5e:00:53:02, length 28
22:16:53.622216 00:00:5e:00:53:fe > 00:00:5e:00:53:02, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622224 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
22:16:53.622226 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
8 packets captured
8 packets received by filter
0 packets dropped by kernel
```

Leggilo riga per riga. È la Figura 4 della lezione, catturata dal vivo:

- `ethertype 802.1Q (0x8100)` è il TPID; `vlan 10` è il VID; `p 0` è la priorità PCP. Poi viene il vero EtherType del payload.
- **Righe 1–3, VLAN 10:** pc1 chiede la MAC del suo gateway (ARP), r1 risponde da `eth0.10` e pc1 invia il ping alla MAC di r1.
- **Righe 4–6, VLAN 20:** r1 instrada il pacchetto. Chiede la MAC di pc2 nella VLAN 20 e invia il ping sullo stesso cavo, ora con tag 20, dalla propria MAC a quella di pc2.
- **Righe 7–8:** la risposta percorre il cammino opposto.
- Il `ttl=63` del ping nel terminale 1 (invece di 64) mostra che un router ha gestito il pacchetto.

Gli indirizzi IP (`192.168.10.11 > 192.168.20.12`) non cambiano mai. Cambiano gli indirizzi MAC e il tag VLAN. pc1 e pc2 non hanno mai visto un tag: il bridge li ha aggiunti e rimossi su `p4`.

Infine, guarda la tabella dello switch:

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Output atteso:
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:fe dev p4 vlan 20 master br0 
00:00:5e:00:53:fe dev p4 vlan 10 master br0 
```

La MAC di r1 compare due volte sulla porta trunk, una per VLAN, perché ogni VLAN ha la propria tabella.

## Verifica
Hai completato il laboratorio quando sono vere tutte queste condizioni:

1. `sudo bridge -n sw1 vlan show` elenca `p1` e `p3` come `10 PVID Egress Untagged`, `p2` come `20 PVID Egress Untagged` e `p4` con `10` e `20` e senza `PVID`.
2. Stessa VLAN, diretto: `sudo ip netns exec pc1 ping -c 1 192.168.10.13` riporta `1 received`.
3. VLAN diverse, attraverso il router: `sudo ip netns exec pc1 ping -c 1 192.168.20.12` e `sudo ip netns exec pc3 ping -c 1 192.168.20.12` riportano entrambi `1 received`, con `ttl=63`.
4. Il percorso passa per r1:
   ```bash
   sudo ip netns exec pc1 tracepath -n 192.168.20.12
   ```
   Output atteso (i tempi variano; `tracepath` fa parte di iputils):
   ```text
    1?: [LOCALHOST]                      pmtu 1500
    1:  192.168.10.1                                          0.104ms 
    1:  192.168.10.1                                          0.022ms 
    2:  192.168.20.12                                         0.020ms reached
        Resume: pmtu 1500 hops 2 back 2 
   ```
5. Sai spiegare, dalla tua cattura del Passo 9, dove il tag viene aggiunto e rimosso e perché le MAC cambiano su r1.

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `RTNETLINK answers: Operation not permitted` o `mkdir /var/run/netns failed: Permission denied` | Hai eseguito un comando che modifica la rete senza `sudo`. | Anteponi `sudo` al comando. |
| `RTNETLINK answers: File exists` o `Cannot create namespace file "/var/run/netns/sw1": File exists` | Resti di un tentativo precedente. | Esegui la [Pulizia](#pulizia), poi ricomincia dal Passo 2. |
| `Cannot open network namespace "pc1": No such file or directory` | Un passo è stato saltato, o la pulizia è già stata eseguita. | Esegui `ip netns list` e ripeti i comandi di creazione mancanti. |
| I ping nella stessa VLAN falliscono dopo il Passo 6 | Una porta è ancora nella VLAN 1, o la sua VLAN non ha `pvid untagged`. | Confronta `sudo bridge -n sw1 vlan show` con il punto 1 della Verifica e correggi la porta con `bridge vlan add` / `del`. |
| I ping tra VLAN falliscono, ma i ping dentro ogni VLAN funzionano | L'IP forwarding è disattivato in r1, una sottointerfaccia è giù, un PC non ha una route predefinita, o a `p4` manca una VLAN. | Controlla `sudo ip netns exec r1 sysctl net.ipv4.ip_forward` (deve essere `1`), `sudo ip -n r1 -br addr` (entrambe le sottointerfacce `UP`), `sudo ip -n pc2 route` e `sudo bridge -n sw1 vlan show dev p4`. |
| La cattura del Passo 9 non mostra nulla | Hai catturato sull'interfaccia o sul namespace sbagliati, oppure le voci ARP erano già in cache e hai perso i primi pacchetti. | Cattura con `-i p4` dentro `sw1`, avvia tcpdump prima del ping ed esegui `sudo ip -n pc1 neigh flush all` e `sudo ip -n r1 neigh flush all` per rivedere lo scambio ARP. |
| `tcpdump: command not found` | tcpdump non è installato. | Installalo (`sudo dnf install tcpdump` o `sudo apt install tcpdump`). |
| `bridge fdb show ... dynamic` fallisce con un errore di sintassi o di utilizzo | iproute2 più vecchio senza la parola chiave `dynamic`. | Usa `sudo bridge -n sw1 fdb show br br0 \| grep -v permanent`. |

## Sfida (facoltativa)
Costruisci un loop di switching e lascia che Spanning Tree lo spezzi. Crea un secondo namespace switch `sw2` con il proprio bridge e collega `sw1` e `sw2` con **due** coppie veth. Prima di collegare il secondo cavo, attiva STP su entrambi i bridge (`ip link set br0 type bridge stp_state 1`). Aspetta circa 30 secondi (due forward delay da 15 secondi), poi usa `bridge -n sw2 link show` per trovare la porta nello stato `blocking`. Quale switch è diventato il root bridge, e perché? (Suggerimento: `ip -d link show br0` mostra `root_id` e `bridge_id`.) Cosa cambia se abbassi la priorità di `sw2` con `ip link set br0 type bridge priority 4096`?

> [!NOTE]
> Il bridge del kernel Linux implementa lo STP 802.1D classico, per questo ci vogliono circa 30 secondi. RSTP su Linux richiede un daemon separato in user space (come `mstpd`), che esula da questo laboratorio. Esegui la sfida solo dentro i namespace, mai mettendo in bridge le tue interfacce di rete reali: un loop su una rete reale può metterla fuori uso.

## Pulizia
Elimina il bridge, poi tutti i namespace. Eliminare un namespace elimina anche tutte le interfacce al suo interno, ed eliminare un'estremità di una coppia veth elimina anche l'altra, quindi non resta nessun veth.

```bash
sudo ip -n sw1 link del br0
for ns in sw1 pc1 pc2 pc3 r1; do sudo ip netns del $ns; done
sudo ip netns del sw2 2>/dev/null   # only if you did the challenge
ip netns list
```

Output atteso: `ip netns list` non stampa nulla (o almeno non elenca `sw1`, `sw2`, `pc1`, `pc2`, `pc3` o `r1`).

Nient'altro è stato modificato sulla tua macchina: le impostazioni IPv6 e di IP forwarding che hai cambiato vivevano dentro i namespace e sono scomparse con essi.

## Cosa hai imparato
- Uno switch impara gli indirizzi MAC dall'origine di ogni frame, inonda i broadcast e inoltra l'unicast noto a una sola porta, quindi gli altri host non lo vedono mai.
- Le VLAN dividono uno switch in domini di broadcast separati: host in VLAN diverse non possono parlare al livello 2, anche con indirizzi nella stessa subnet.
- Una porta access trasporta una VLAN senza tag; una porta trunk trasporta più VLAN con tag 802.1Q (`ethertype 802.1Q (0x8100)`, `vlan <id>`), che puoi leggere in una cattura.
- Il router-on-a-stick instrada tra VLAN su un solo trunk usando sottointerfacce VLAN; ogni pacchetto instradato attraversa il trunk due volte, con una nuova intestazione MAC e un tag diverso.
- Lo switch mantiene una tabella MAC separata per VLAN, quindi la stessa MAC può comparire in più VLAN su una porta trunk.
