CloudAcademia
FR

Réseaux · Module 08 · Couche transport : TCP, UDP et ports

Lab : sockets TCP et UDP sur votre propre machine

Lab60 minDébutantMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Vous écrivez en Python un petit serveur d'écho Transmission Control Protocol (TCP) et un serveur d'écho User Datagram Protocol (UDP), vous leur parlez avec vos propres clients et avec `nc`, et vous observez les changements d'état des sockets avec `ss` (ou `netstat`). Vous provoquez ensuite les deux échecs classiques, « connection refused » et « connection timed out », et vous voyez pourquoi l'un prend quelques millisecondes et l'autre autant de temps que vous le lui laissez. Tout s'exécute sur votre propre ordinateur, sur `127.0.0.1`.

## Objectifs
- Expliquer comment un port en écoute et un port éphémère de client identifient ensemble une connexion.
- Comparer TCP et UDP en les exécutant sur le même numéro de port et en constatant à quel point ils se comportent différemment.
- Observer une connexion TCP passer d'ESTABLISHED à TIME-WAIT et, en option, capturer la poignée de main et la fermeture avec `tcpdump`.
- Identifier les sockets en écoute et les états de connexion (LISTEN, ESTAB, TIME-WAIT, UNCONN) avec `ss` ou `netstat`.
- Reproduire et expliquer « connection refused » par rapport à « connection timed out ».

## Prérequis
- Un ordinateur sous Linux (avec `ss` d'iproute2), macOS ou Windows 10/11.
- Python 3.10 ou ultérieur, bibliothèque standard uniquement. Ce lab a été testé avec Python 3.14.7 et 3.11.8. Vérifiez le vôtre avec `python3 --version` (sous Windows : `py --version`).
- `nc` (netcat), facultatif mais recommandé. Linux : paquet `netcat-openbsd` (Debian, Ubuntu) ou `nmap-ncat` (Fedora, RHEL). macOS : intégré. Windows : non intégré ; utilisez plutôt les clients Python et `Test-NetConnection`. Les sorties ci-dessous proviennent d'OpenBSD netcat 1.226.
- Trois fenêtres de terminal : une pour chaque serveur et une pour vos commandes.
- Facultatif, pour l'Étape 10 uniquement : `tcpdump` et des droits d'administrateur (`sudo`) sous Linux ou macOS.
- [Leçon : Couche transport : TCP, UDP et ports](lesson.fr.md) de ce module.

> [!WARNING]
> Exécutez chaque commande de ce lab **uniquement contre votre propre ordinateur** : `127.0.0.1` et l'adresse de documentation `192.0.2.1` (RFC 5737), qui n'est jamais attribuée à un hôte réel. Ne dirigez pas `nc -z`, `probe.py` ni aucun autre test de connexion vers des systèmes qui ne vous appartiennent pas ou que vous n'êtes pas explicitement autorisé à tester : sonder les ports d'autrui, c'est du balayage de ports, ce qui peut être illégal et enfreint les conditions d'utilisation de la plupart des fournisseurs. Les serveurs de ce lab n'écoutent que sur `127.0.0.1`, donc rien sur votre réseau ne peut les atteindre.

## Architecture
<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-fr-title tcp-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="tcp-lab-architecture-fr-title">Architecture du lab : sockets TCP et UDP sur votre propre ordinateur</title>
<desc id="tcp-lab-architecture-fr-desc">Tout s&#x27;exécute sur votre ordinateur via l&#x27;interface de boucle, 127.0.0.1. Les clients tcp_client.py, udp_client.py, nc et probe.py utilisent des ports source éphémères. Ils dialoguent avec un serveur d&#x27;écho TCP sur 127.0.0.1 port 9000, un serveur d&#x27;écho UDP sur 127.0.0.1 port 9000 et le port 9001, où rien n&#x27;écoute, qui répond à TCP par RST et à UDP par un message ICMP de port inaccessible. Vous observez avec ss -tan, ss -uln et, en option avec sudo, tcpdump -i lo. Une sonde part vers l&#x27;adresse de documentation 192.0.2.1 port 80, qui ne répond jamais : la connexion expire.</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">Votre ordinateur · interface de boucle (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">Clients</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">source : un port éphémère</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">Serveur d&#x27;écho 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">Serveur d&#x27;écho 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">Rien n&#x27;écoute</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 inaccessible</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">Observer avec</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">(facultatif, nécessite 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">Adresse de documentation</text>
<text x="768" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">pas de réponse → 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="397.62" y="438" width="204.76" 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, pas de réponse → timeout</text></g>
</svg></figure>

*Figure 1. Deux serveurs partagent le numéro de port 9000, l'un pour TCP, l'autre pour UDP. Le port 9001 n'a pas de serveur, et `192.0.2.1` ne répond jamais.*

## Étapes

### Étape 1 — Créez un dossier de travail
Vous allez écrire cinq petits scripts. Gardez-les dans un seul dossier pour que le nettoyage tienne en une commande.

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

Utilisez ce dossier dans les trois terminaux. Sous Windows, tapez `py` partout où ce lab dit `python3`.

### Étape 2 — Regardez avant de toucher à quoi que ce soit
Avant de démarrer vos propres serveurs, regardez ce que votre ordinateur écoute déjà et quelle plage il utilise pour les ports éphémères.

**Linux :**

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

Sortie attendue (abrégée ; votre liste sera différente) :

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

Sur un poste de travail typique, vous verrez un résolveur local du Domain Name System (DNS) sur le port 53 (ici `systemd-resolved`, sur `127.0.0.53`), le service d'heure sur UDP 323, le DNS multicast sur UDP 5353 et un service d'impression sur TCP 631. La plupart n'écoutent que sur des adresses de boucle locale. La dernière ligne est la plage de ports éphémères : Linux utilise par défaut 32768–60999, pas la plage 49152–65535 de la RFC 6335.

**macOS :**

```bash
netstat -an -p tcp | grep LISTEN
sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last
```

**Windows (PowerShell) :**

```powershell
Get-NetTCPConnection -State Listen | Sort-Object LocalPort | Select-Object LocalAddress, LocalPort, OwningProcess
netsh int ipv4 show dynamicport tcp
```

Sous macOS et Windows, la plage dynamique par défaut est 49152–65535.

> [!NOTE]
> Les commandes macOS et Windows n'ont pas été exécutées pour ce guide, leur sortie n'est donc pas montrée ; les colonnes se passent d'explication. Le port 9000 doit être libre pour ce lab. Si quelque chose y écoute déjà, remplacez `PORT` dans chaque script par un autre port libre supérieur à 1024, comme 9500.

### Étape 3 — Écrivez et démarrez le serveur d'écho TCP
Un serveur a besoin d'un port fixe et connu pour que les clients le trouvent. Celui-ci écoute sur `127.0.0.1:9000` et renvoie chaque octet reçu. Enregistrez-le sous `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` demande TCP. `bind()` réserve l'adresse et le port ; `listen()` transforme le socket en socket en écoute.
- `accept()` ne rend la main qu'une fois qu'un client a terminé la poignée de main en trois temps. C'est le système d'exploitation qui a fait la poignée de main ; votre programme ne fait que récupérer le résultat.
- `recv()` renvoie un résultat vide quand le client a envoyé FIN. C'est ainsi qu'un programme TCP apprend que l'autre côté a fermé.

Dans le **terminal 1**, démarrez-le et laissez-le tourner :

```bash
python3 tcp_server.py
```

Sortie attendue :

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

### Étape 4 — Trouvez le socket en écoute
Dans le **terminal 3** (votre terminal de commandes), demandez au système d'exploitation qui écoute sur le port 9000. Le filtre `'sport = :9000'` (port source, qui pour un socket en écoute est le port local) garde la sortie courte.

**Linux :**

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

Sortie attendue (votre identifiant de processus sera différent) :

```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` sur `127.0.0.1:9000` : seuls les programmes de cet ordinateur peuvent se connecter.
- `Peer Address:Port` vaut `0.0.0.0:*` parce qu'un socket en écoute n'a pas encore de pair.
- `Send-Q 128` est le backlog : combien de poignées de main terminées peuvent attendre `accept()`.
- `users:(("python3",pid=…))` est le processus propriétaire. Vous le voyez sans `sudo` parce que le socket est à vous.

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

### Étape 5 — Connectez-vous et observez la connexion
Il vous faut maintenant un client. Il se connecte, affiche sa propre adresse et son port ainsi que ceux du serveur, envoie un message et lit l'écho. Un argument facultatif maintient la connexion ouverte quelques secondes pour que vous puissiez l'inspecter. Enregistrez-le sous `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")
```

Remarquez que le client ne choisit jamais son propre port : `create_connection()` laisse le système d'exploitation en choisir un éphémère.

Dans le terminal 3, lancez le client en arrière-plan avec une attente de 15 secondes, puis listez aussitôt les sockets TCP du port 9000. Sous Linux :

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

Sortie attendue (votre port éphémère sera différent ; les lignes du client peuvent apparaître avant ou après le tableau) :

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

Lisez les trois lignes :
- Le socket `LISTEN` est toujours là : il continue d'attendre le *prochain* client.
- La connexion apparaît **deux fois**, une fois depuis chaque extrémité, parce que les deux extrémités se trouvent sur votre ordinateur. Le côté client est `127.0.0.1:36784 → 127.0.0.1:9000` ; le côté serveur en est l'image miroir.
- `36784` se situe dans la plage éphémère de l'Étape 2. Relancez le client et vous obtenez un autre port.

Dans le terminal 1, le serveur a journalisé la connexion :

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

Sous macOS, lancez le client de la même façon et utilisez `netstat -an -p tcp | grep 9000`. Sous Windows, démarrez `py tcp_client.py 15` dans un terminal supplémentaire et exécutez `Get-NetTCPConnection -LocalPort 9000; Get-NetTCPConnection -RemotePort 9000` dans le terminal 3 dans les 15 secondes.

### Étape 6 — Observez TIME-WAIT
Attendez que le client affiche `closed` (15 secondes), puis regardez de nouveau :

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

Sortie attendue :

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

- Il ne reste qu'une ligne pour l'ancienne connexion, et elle est sur le port du **client**. Le client a fermé en premier (son bloc `with` s'est terminé) : c'est donc le client qui attend en TIME-WAIT. Le côté serveur est passé directement à CLOSED après l'acquittement de son propre FIN.
- `-o` affiche les temporisations : `timewait,58sec` décompte à partir de 60 secondes, la durée fixe de TIME-WAIT sous Linux. Relancez la commande au bout d'une minute : la ligne a disparu.

Le serveur a journalisé la fermeture dans le terminal 1 :

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

Sous macOS et Windows, `netstat -an -p tcp | grep 9000` (macOS) ou `netstat -an -p tcp | findstr 9000` (Windows) montre la même connexion en `TIME_WAIT`. Leurs temporisations diffèrent de celles de Linux.

### Étape 7 — Parlez au serveur avec netcat
Votre client n'a rien de spécial : n'importe quel programme TCP peut parler au serveur. Netcat (`nc`) se connecte puis recopie votre clavier vers le socket et le socket vers votre écran.

```bash
nc 127.0.0.1 9000
```

Tapez `hello from nc` et appuyez sur Entrée. Le serveur le renvoie :

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

La première ligne est ce que vous avez tapé, la seconde est l'écho. Appuyez sur **Ctrl+C** pour quitter. Le terminal 1 journalise la connexion et la fermeture, chacune avec un nouveau port éphémère.

> [!NOTE]
> Il existe plusieurs implémentations de netcat aux options et messages légèrement différents : OpenBSD netcat (Debian, Ubuntu, et la base du `nc` de macOS), `ncat` de Nmap (Fedora, RHEL) et l'ancien netcat « traditionnel ». La forme de base `nc <hôte> <port>` fonctionne dans toutes. Sous Windows, ignorez les commandes `nc` et utilisez les clients Python.

### Étape 8 — Ajoutez un serveur UDP sur le même numéro de port
TCP et UDP ont des espaces de ports séparés ; un serveur UDP peut donc utiliser lui aussi le port 9000. Enregistrez ceci sous `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")
```

Comparez-le au serveur TCP : `SOCK_DGRAM` au lieu de `SOCK_STREAM`, pas de `listen()`, pas de `accept()` et pas d'objet de connexion. Chaque datagramme arrive avec l'adresse de son expéditeur, et la réponse repart vers cette adresse.

Dans le **terminal 2**, démarrez-le :

```bash
python3 udp_server.py
```

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

Dans le terminal 3, listez ensemble les sockets TCP et UDP du port 9000 :

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

Sortie attendue :

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

Deux sockets, même adresse, même numéro de port, protocoles différents. Le socket UDP est en `UNCONN` (non connecté), pas en `LISTEN` : UDP n'a pas de connexions à attendre.

Passons au client. Enregistrez-le sous `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)")
```

Exécutez-le :

```bash
python3 udp_client.py
```

Sortie attendue :

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

Le terminal 2 affiche `datagram from 127.0.0.1:40760: hello over UDP`. Essayez ensuite netcat en mode UDP (`-u`), tapez une ligne, lisez l'écho et appuyez sur Ctrl+C :

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

Relancez `ss -tan '( sport = :9000 or dport = :9000 )'` et `ss -uan 'sport = :9000'` après le client UDP : il n'y a ni ESTAB ni TIME-WAIT pour UDP. Rien n'a été établi, donc rien n'a à être démonté.

### Étape 9 — Connection refused ou connection timed out
C'est la compétence de dépannage de la leçon. Vous allez faire échouer une connexion de trois façons et chronométrer chacune. Enregistrez ceci sous `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")
```

Sondez le port ouvert, un port fermé de votre propre machine et l'adresse de documentation `192.0.2.1`, qui n'est attribuée à personne :

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

Sortie attendue :

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

- **Port 9000 :** la poignée de main aboutit. Le terminal 1 journalise une connexion.
- **Port 9001 :** votre ordinateur a reçu le SYN, n'a trouvé aucun socket en écoute et a répondu RST aussitôt : *connection refused*.
- **`192.0.2.1` :** le SYN quitte votre ordinateur et personne ne répond jamais ; le client attend donc tout le délai que vous lui avez donné (3 s) : *timed out*. Sans délai, Linux continue à réessayer le SYN pendant un peu plus de deux minutes avant d'abandonner.

`<timeout>`, le troisième argument facultatif, est le nombre de secondes d'attente. Essayez `python3 probe.py 192.0.2.1 80 10` et le résultat arrive au bout de 10 secondes : le délai est fixé par le *client*, pas par le réseau.

Les mêmes tests avec netcat (`-v` bavard, `-z` se connecter sans envoyer de données, `-w 3` délai) :

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

Le texte entre crochets peut afficher un nom de service issu de la liste des services de votre système au lieu de `*`. Sous Windows (PowerShell), la vérification équivalente est `Test-NetConnection -ComputerName 127.0.0.1 -Port 9001`, qui indique `TcpTestSucceeded : False` pour les deux types d'échec ; utilisez `probe.py` pour voir la différence.

Enfin, UDP vers un port fermé :

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

Votre ordinateur a répondu au datagramme par un message « port unreachable » de l'Internet Control Message Protocol (ICMP) et, comme le client a utilisé `connect()`, le système d'exploitation l'a signalé comme une erreur. Sur un vrai réseau, ce message ICMP est souvent filtré, et le client afficherait simplement `no reply within 2 s` : avec UDP, « fermé » et « perdu » peuvent avoir exactement le même aspect.

> [!NOTE]
> Les durées et les messages varient selon le système d'exploitation. Sous Windows, une connexion refusée peut prendre environ deux secondes, car le client réessaie une ou deux fois après le RST, et l'erreur UDP peut être signalée comme une *réinitialisation* de connexion ; le script intercepte les deux. Votre réseau peut aussi répondre rapidement pour `192.0.2.1` par « No route to host » ou « Network is unreachable » (le script affiche `error: …`) s'il n'a pas de route pour cette plage. C'est un troisième type d'échec, venant de la couche réseau plutôt que de la cible.

### Étape 10 (facultative) — Capturez la poignée de main avec tcpdump
Cette étape nécessite des droits d'administrateur. Passez-la si vous n'en avez pas ; la sortie ci-dessous montre ce que vous verriez.

Dans le terminal 3, démarrez une capture sur l'interface de boucle locale (`lo` sous Linux, `lo0` sous macOS). `-n` affiche des nombres au lieu de noms :

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

Dans un terminal supplémentaire, lancez le client une fois et sondez une fois le port fermé :

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

Arrêtez la capture avec Ctrl+C. Sortie attendue (horodatages et options TCP abrégés ; vos ports, numéros de séquence et fenêtres seront différents) :

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

Rapprochez-la de la leçon :
- Lignes 1–3 : la poignée de main en trois temps, `[S]`, `[S.]`, `[.]`. Les numéros de séquence initiaux (ISN) sont aléatoires ; le SYN-ACK acquitte l'ISN du client + 1. À partir de la ligne 3, `tcpdump` affiche les numéros de séquence relatifs à l'ISN.
- Lignes 4–7 : `hello over TCP` fait 14 octets (`seq 1:15`, `length 14`), acquittés par `ack 15`, puis renvoyés en écho et acquittés de la même façon.
- Lignes 8–10 : la fermeture. Le FIN du client, puis le FIN du serveur combiné à l'ACK du FIN du client (`ack 16` : un FIN compte pour un octet), puis l'ACK final du client. Combiner deux étapes dans un même segment est fréquent, d'où les trois segments de fermeture que l'on voit souvent au lieu de quatre.
- Lignes 11–12 : un SYN vers le port fermé 9001, auquel répond `[R.]` (RST, ACK). C'est « connection refused » sur le réseau.
- Ligne 13 : le message ICMP port unreachable pour le datagramme UDP vers 9001.
- La taille maximale de segment (MSS) de 65495 et les grandes fenêtres sont typiques de la boucle locale, dont l'unité maximale de transmission (MTU) est de 65536. Sur Ethernet, vous verriez `mss 1460`.

> [!NOTE]
> Cette capture a été enregistrée avec `tcpdump` sous Linux. Un SYN vers `192.0.2.1` apparaîtrait comme la même ligne `[S]` répétée quelques fois avec des intervalles croissants et sans réponse, ce qui est l'aspect d'un timeout sur le réseau. Pour le voir, capturez sur votre interface principale (par exemple `eth0`, `en0` ou le nom indiqué par `ip route show default`) plutôt que sur la boucle locale.

## Vérification
Vous avez terminé le lab si vous pouvez répondre « oui » à chaque contrôle :

| Contrôle | Comment le confirmer |
|---|---|
| Le serveur TCP écoute sur `127.0.0.1:9000` | `ss -tlnp 'sport = :9000'` affiche `LISTEN` et votre processus `python3` |
| Vous avez vu une connexion depuis les deux extrémités | L'Étape 5 montre deux lignes `ESTAB` en miroir, avec un port éphémère de votre plage de l'Étape 2 |
| Vous avez vu TIME-WAIT du côté qui a fermé en premier | L'Étape 6 montre `TIME-WAIT` uniquement sur le port éphémère du client, avec une temporisation d'au plus 60 s sous Linux |
| TCP et UDP partagent le numéro de port 9000 | `ss -tuln 'sport = :9000'` affiche une ligne `tcp LISTEN` et une ligne `udp UNCONN` |
| Vous savez distinguer refused de timed out | `probe.py` indique `refused` en environ 0,01 s pour le port 9001 et `timed out` après le délai choisi pour `192.0.2.1` |

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `OSError: [Errno 98] Address already in use` (Linux), `[Errno 48]` (macOS) ou `[WinError 10048]` (Windows) au démarrage d'un serveur | Une autre copie du serveur tourne encore, ou autre chose utilise le port 9000 | Trouvez-la avec `ss -tulnp 'sport = :9000'` (Linux), `lsof -nP -i :9000` (macOS) ou `Get-NetTCPConnection -LocalPort 9000` (Windows) ; arrêtez-la, ou changez `PORT` dans tous les scripts |
| `ConnectionRefusedError: [Errno 111] Connection refused` depuis `tcp_client.py` | Le serveur TCP ne tourne pas, ou écoute sur un autre port | Vérifiez le terminal 1 ; relancez `python3 tcp_server.py` |
| `udp_client.py` affiche `no reply within 2 s` alors que le serveur UDP devrait tourner | Le serveur UDP ne tourne pas, ou un pare-feu local bloque l'UDP de boucle locale | Vérifiez le terminal 2 et `ss -uln 'sport = :9000'` |
| `nc: command not found` | Netcat n'est pas installé | Installez `netcat-openbsd` ou `nmap-ncat`, ou ignorez les commandes `nc` ; les clients Python font le même travail |
| `probe.py 192.0.2.1 80` affiche immédiatement `error: No route to host` ou `Network is unreachable` | Votre système ou votre réseau n'a pas de route pour `192.0.2.0/24`, ou un routeur répond par un ICMP | Pas de souci : c'est un échec de la couche réseau, pas un timeout. Comparez avec la liste d'erreurs de la leçon |
| Les lignes `ESTAB` n'apparaissent pas à l'Étape 5 | Plus de 15 s se sont écoulées avant l'exécution de `ss`, ou le client a échoué | Exécutez les deux commandes ensemble comme indiqué, ou augmentez l'attente : `python3 tcp_client.py 30 &` |
| `tcpdump: lo: No such device exists` | Sous macOS, l'interface de boucle locale est `lo0` | Utilisez `sudo tcpdump -i lo0 -n …` |

## Défi (facultatif)
1. Modifiez `tcp_server.py` pour que ce soit le **serveur** qui ferme la connexion juste après avoir envoyé l'écho (sortez de la boucle après le premier `sendall()`). Quel côté affiche maintenant TIME-WAIT ? Supprimez ensuite la ligne `SO_REUSEADDR`, lancez un client, arrêtez le serveur et redémarrez-le en moins d'une minute. Que se passe-t-il, et pourquoi presque tous les vrais serveurs définissent-ils `SO_REUSEADDR` ?
2. Faites écouter le serveur sur `0.0.0.0` au lieu de `127.0.0.1` et constatez la différence avec `ss -tln`. Est-il maintenant joignable depuis un autre appareil de votre réseau ? Le pare-feu de votre hôte l'autorise-t-il ? Remettez-le comme avant quand vous avez fini.
3. Ouvrez dix connexions à la fois (par exemple `for i in $(seq 10); do python3 tcp_client.py 20 & done`) et comptez-les avec `ss -tan '( dport = :9000 )' | wc -l`. Quelle partie du 4-uplet diffère entre elles ?
4. Envoyez un message de 5 000 octets avec `tcp_client.py` et lisez-le avec un seul `recv(1024)`. Que reçoit-on ? Qu'est-ce que cela vous apprend sur TCP comme flux d'octets, et comment concevriez-vous un format de message par-dessus ?

## Nettoyage
Arrêtez les deux serveurs : appuyez sur **Ctrl+C** dans le terminal 1 et dans le terminal 2. Chacun affiche `server stopped`. Fermez les sessions `nc` avec Ctrl+C et arrêtez `tcpdump` s'il tourne encore.

Vérifiez qu'il ne reste rien sur le port 9000 (Linux) :

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

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

Seule la ligne d'en-tête signifie que les deux serveurs ont disparu. Si un serveur tourne encore (par exemple, vous avez fermé son terminal), arrêtez-le avec `pkill -f tcp_server.py; pkill -f udp_server.py` sous Linux ou macOS, ou avec `Get-Process python*` et `Stop-Process -Id <pid>` sous Windows. `<pid>` est l'identifiant de processus affiché par `ss -tulnp` ou `Get-NetTCPConnection` (colonne `OwningProcess`).

Supprimez le dossier et les cinq scripts.

Linux et macOS :

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

Windows (PowerShell) :

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

Les entrées TIME-WAIT disparaissent d'elles-mêmes en une minute environ. Aucun paramètre système n'a été modifié, il n'y a donc rien d'autre à annuler.

## Ce que vous avez appris
- Un serveur lie un port fixe et écoute ; chaque client reçoit du système d'exploitation un port éphémère, et le 4-uplet désigne la connexion. Sur une seule machine, vous voyez chaque connexion deux fois, une fois depuis chaque extrémité.
- TCP et UDP ont des espaces de ports séparés. TCP affiche LISTEN, ESTAB et TIME-WAIT ; UDP seulement UNCONN, car il n'y a pas de connexions.
- Le côté qui ferme en premier détient le TIME-WAIT (60 s sous Linux). C'est normal et cela disparaît tout seul.
- « Connection refused » est une réponse (RST) et arrive en quelques millisecondes. « Connection timed out » est le silence, et sa durée dépend du délai du client.
- `ss` (ou `netstat`, `lsof`, `Get-NetTCPConnection`) et, avec des droits d'administrateur, `tcpdump` vous montrent exactement ce que fait la couche transport.