Ce document, conçu pour les étudiants de L3 en Réseaux & Télécommunications de l'Université Paris 5 - René Descartes, constitue le TD n°8 et aborde des concepts fondamentaux de l'interconnexion des réseaux IP.
Il couvre les notions suivantes :
- La fragmentation des paquets IP et ses implications sur la transmission.
- Les mécanismes de routage IP, incluant l'algorithme Bellman-Ford et le protocole RIP.
- Les principes de la commutation de paquets IP, notamment la commutation de circuits virtuels.
Chaque section propose des exercices détaillés accompagnés de leurs corrections, favorisant une compréhension approfondie de ces thématiques essentielles.
Réseaux Informatiques : L3 reseaux et telecommunications ip fragmentation routage c
Télécharger PDFFragmentation des paquets IP
Scénario de fragmentation et champs IP
Soit un réseau constitué de 5 routeurs IP (R1 ... R5) et de trois stations A, B et C qui doivent communiquer. Chaque liaison entre hôtes (station ou routeur) est étiquetée par son MTU (Maximum Transmission Unit). Le MTU définit la taille maximale d’un paquet IP qui peut être véhiculé dans les trames d’un réseau physique particulier. Ce paramètre est rattaché à une interface réseau de l'hôte (de numéro pi et d’adresse IP de classe B) pour fragmenter les données avant leur transmission sur la liaison. On suppose que A doit émettre 1520 octets de données vers B.
Décrivez les fragmentations réalisées pour la transmission d’un paquet IP émis par A à destination de B, en supposant que le routeur R1 transmet alternativement les trames qu’il reçoit vers R2-R3 puis vers R4-R5. Précisez pour chaque fragment de paquet, les valeurs des champs (Identification, More Fragment Flag, Offset). On supposera que la valeur initiale de l’Identifiant du paquet est 71.
Justification de la défragmentation au niveau du destinataire
La régénération des paquets fragmentés n’a lieu que sur la station destinataire et non sur les routeurs pour plusieurs raisons. Certains routeurs ne voient pas passer la totalité des fragments d’un paquet IP, ils ne peuvent donc pas reconstruire le datagramme original. De plus, l’opération de défragmentation nécessite de la mémoire et du calcul. La philosophie d’IP est de simplifier les fonctions dans le réseau (c'est-à-dire exécutées par les routeurs) et de repousser les traitements complexes (contrôle de flux, contrôles d’erreurs, chiffrement, défragmentation, etc.) aux extrémités du réseau (c'est-à-dire exécutés par les stations).
Mécanisme de découverte du Path-MTU
Afin d’éviter la fragmentation, la notion de Path-MTU (MTU sur un chemin) a été introduite. Il représente la valeur minimale des MTU des réseaux traversés. Une solution, proposée par exemple dans IPv6, est de placer le bit « Don’t fragment » à la valeur 1 dans l’en-tête des paquets IP émis vers la destination (champ FLAG). Si le paquet arrive sur un routeur qui doit le fragmenter parce que le MTU de l’interface de sortie est trop petit, alors il sera détruit et le routeur enverra un message ICMP (Destination Unreachable) à la station émettrice. Une extension du protocole ICMP pour IPv6 (ICMPv6) propose d’indiquer dans ce message d’erreur ICMP la taille du MTU requis. Dans la pratique, seules les stations en IPv6 exploitent cette extension. Les émetteurs IPv4 choisissent de réduire la taille des paquets émis arbitrairement et à l’aveugle, jusqu’à trouver une taille de paquet qui est inférieure ou égale à la valeur Path-MTU.
Routage des paquets IP
Longueur maximale d'une route et durée de vie (TTL)
La route la plus longue traverse au maximum 16 routeurs dans un réseau IP utilisant le protocole de routage RIP. Les paquets IP transmis par une source sont initialisés avec le champ TTL (Time To Live) égal à 16. À chaque passage dans un routeur, le champ TTL du paquet est décrémenté de 1. Lorsqu’un paquet arrive dans un routeur avec une valeur TTL égale à 1, le routeur détruit ce paquet, limitant les routes à 16 nœuds traversés au maximum.
Tables de routage initiales (T=0)
On supposera que le réseau vient d'être mis en service par l’administrateur et que chaque routeur n'a qu'une connaissance locale de la topologie du réseau (il ne connaît que ses routeurs voisins et ses sous-réseaux voisins). Voici les tables de routage initiales des différents routeurs telles que configurées par l’administrateur :
| Réseau de destination | Prochain saut | Interface | Métrique (HC) |
|---|---|---|---|
| R1 | |||
| 10.0.0.0 | direct | P2 | 0 |
| 20.0.0.0 | direct | P3 | 0 |
| 90.0.0.0 | direct | P1 | 0 |
| R2 | |||
| 10.0.0.0 | direct | P1 | 0 |
| 30.0.0.0 | direct | P3 | 0 |
| 70.0.0.0 | direct | P2 | 0 |
| R3 | |||
| 50.0.0.0 | direct | P3 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
| 70.0.0.0 | direct | P1 | 0 |
| R4 | |||
| 20.0.0.0 | direct | P1 | 0 |
| 40.0.0.0 | direct | P2 | 0 |
| 90.0.0.0 | direct | P3 | 0 |
| R5 | |||
| 30.0.0.0 | direct | P3 | 0 |
| 40.0.0.0 | direct | P1 | 0 |
| 50.0.0.0 | direct | P4 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
Évolution des tables de routage (Bellman-Ford)
On considèrera la séquence d'échange de vecteurs de distance suivante:
| Instant | Événement |
|---|---|
| T1 | R2, R4 reçoivent VR1 (vecteur de distance de R1) |
| T2 | R1, R3, R5 reçoivent VR2 |
| T3 | R1, R5 reçoivent VR4 |
| T4 | R2, R4 reçoivent VR1 puis VR5 |
| T5 | R2, R5 reçoivent VR3 |
| T6 | R1 reçoit VR2 |
| T7 | R3, R4 reçoivent VR5 |
Voici les tables de routage de chaque routeur, obtenues une fois que l'algorithme de routage a convergé.
| Réseau de destination | Prochain saut | Interface | Métrique |
|---|---|---|---|
| R2 (après T1, puis T4, puis T5) | |||
| 10.0.0.0 | direct | P1 | 0 |
| 30.0.0.0 | direct | P3 | 0 |
| 70.0.0.0 | direct | P2 | 0 |
| 80.0.0.0 | 10.0.0.1 | P1 | 1 |
| 20.0.0.0 | 10.0.0.1 | P1 | 1 |
| 40.0.0.0 | 10.0.0.1 | P1 | 2 |
| 90.0.0.0 | 10.0.0.1 | P1 | 2 |
| 40.0.0.0 | 30.0.0.1 | P3 | 1 |
| 50.0.0.0 | 30.0.0.1 | P3 | 1 |
| 60.0.0.0 | 30.0.0.1 | P3 | 1 |
| R4 (après T1, puis T3, puis T4, puis T7) | |||
| 20.0.0.0 | direct | P1 | 0 |
| 40.0.0.0 | direct | P2 | 0 |
| 90.0.0.0 | direct | P3 | 0 |
| 10.0.0.0 | 20.0.0.1 | P1 | 1 |
| 80.0.0.0 | 20.0.0.1 | P1 | 1 |
| 30.0.0.0 | 20.0.0.1 | P1 | 2 |
| 70.0.0.0 | 20.0.0.1 | P1 | 2 |
| 30.0.0.0 | 40.0.0.2 | P2 | 1 |
| 50.0.0.0 | 40.0.0.2 | P2 | 1 |
| 60.0.0.0 | 40.0.0.2 | P2 | 1 |
| R1 (après T2, puis T3, puis T6) | |||
| 10.0.0.0 | direct | P2 | 0 |
| 20.0.0.0 | direct | P3 | 0 |
| 80.0.0.0 | direct | P1 | 0 |
| 30.0.0.0 | 10.0.0.2 | P2 | 1 |
| 70.0.0.0 | 10.0.0.2 | P2 | 1 |
| 40.0.0.0 | 20.0.0.2 | P3 | 1 |
| 90.0.0.0 | 20.0.0.2 | P3 | 1 |
| 50.0.0.0 | 10.0.0.2 | P2 | 2 |
| 60.0.0.0 | 10.0.0.2 | P2 | 2 |
| R3 (après T2, puis T5, puis T7) | |||
| 50.0.0.0 | direct | P3 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
| 70.0.0.0 | direct | P1 | 0 |
| 10.0.0.0 | 70.0.0.1 | P1 | 1 |
| 20.0.0.0 | 70.0.0.1 | P1 | 2 |
| 30.0.0.0 | 70.0.0.1 | P1 | 1 |
| 80.0.0.0 | 70.0.0.1 | P1 | 2 |
| 40.0.0.0 | 50.0.0.1 | P3 | 1 |
| 90.0.0.0 | 50.0.0.1 | P3 | 2 |
| R5 (après T2, puis T3, puis T4, puis T5, puis T7) | |||
| 30.0.0.0 | direct | P3 | 0 |
| 40.0.0.0 | direct | P1 | 0 |
| 50.0.0.0 | direct | P4 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
| 10.0.0.0 | 30.0.0.2 | P3 | 1 |
| 70.0.0.0 | 30.0.0.2 | P3 | 1 |
| 20.0.0.0 | 30.0.0.2 | P3 | 2 |
| 80.0.0.0 | 40.0.0.1 | P1 | 1 |
| 90.0.0.0 | 40.0.0.1 | P1 | 1 |
La route vers 80.0.0.0 reçue de R4 (via son interface d’adresse 40.0.0.1) est plus courte que celle enregistrée dans la table de R5. Par conséquent, celle-ci remplace l’ancienne avec un coût de 1 (nombre de sauts pour atteindre le réseau 80.0.0.0).
Pas de modification des tables de R2 et R5 à T5.
Pas de changement de la table de R4 à T7.
À la fin des 7 étapes, les tables de routage sont les suivantes :
| Réseau de destination | Prochain saut | Interface | Métrique |
|---|---|---|---|
| R1 | |||
| 10.0.0.0 | direct | P2 | 0 |
| 20.0.0.0 | direct | P3 | 0 |
| 30.0.0.0 | 10.0.0.2 | P2 | 1 |
| 40.0.0.0 | 20.0.0.2 | P3 | 1 |
| 50.0.0.0 | 10.0.0.2 | P2 | 2 |
| 60.0.0.0 | 10.0.0.2 | P2 | 2 |
| 70.0.0.0 | 10.0.0.2 | P2 | 1 |
| 80.0.0.0 | direct | P1 | 0 |
| 90.0.0.0 | 20.0.0.2 | P3 | 1 |
| R2 | |||
| 10.0.0.0 | direct | P1 | 0 |
| 20.0.0.0 | 10.0.0.1 | P1 | 1 |
| 30.0.0.0 | direct | P3 | 0 |
| 40.0.0.0 | 30.0.0.1 | P3 | 1 |
| 50.0.0.0 | 30.0.0.1 | P3 | 1 |
| 60.0.0.0 | 30.0.0.1 | P3 | 1 |
| 70.0.0.0 | direct | P2 | 0 |
| 80.0.0.0 | 10.0.0.1 | P1 | 1 |
| 90.0.0.0 | 10.0.0.1 | P1 | 2 |
| R3 | |||
| 10.0.0.0 | 70.0.0.1 | P1 | 1 |
| 20.0.0.0 | 70.0.0.1 | P1 | 2 |
| 30.0.0.0 | 70.0.0.1 | P1 | 1 |
| 40.0.0.0 | 50.0.0.1 | P3 | 1 |
| 50.0.0.0 | direct | P3 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
| 70.0.0.0 | direct | P1 | 0 |
| 80.0.0.0 | 70.0.0.1 | P1 | 2 |
| 90.0.0.0 | 50.0.0.1 | P3 | 2 |
| R4 | |||
| 10.0.0.0 | 20.0.0.1 | P1 | 1 |
| 20.0.0.0 | direct | P1 | 0 |
| 30.0.0.0 | 40.0.0.2 | P2 | 1 |
| 40.0.0.0 | direct | P2 | 0 |
| 50.0.0.0 | 40.0.0.2 | P2 | 1 |
| 60.0.0.0 | 40.0.0.2 | P2 | 1 |
| 70.0.0.0 | 20.0.0.1 | P1 | 2 |
| 80.0.0.0 | 20.0.0.1 | P1 | 1 |
| 90.0.0.0 | direct | P3 | 0 |
| R5 | |||
| 10.0.0.0 | 30.0.0.2 | P3 | 1 |
| 20.0.0.0 | 30.0.0.2 | P3 | 2 |
| 30.0.0.0 | direct | P3 | 0 |
| 40.0.0.0 | direct | P1 | 0 |
| 50.0.0.0 | direct | P4 | 0 |
| 60.0.0.0 | direct | P2 | 0 |
| 70.0.0.0 | 30.0.0.2 | P3 | 1 |
| 80.0.0.0 | 40.0.0.1 | P1 | 1 |
| 90.0.0.0 | 40.0.0.1 | P1 | 1 |
Invalidation et suppression des routes RIP
Toutes les 30 secondes, le daemon RIP (routed) qui s’exécute sur le routeur, transmet sur le port 520 (UDP) sa table de routage vers tous ses routeurs voisins, sous la forme de paquets IP broadcast (255.255.255.255). Si un routeur voisin ne répond pas au bout de 180 secondes (3 minutes), toutes les routes passant par ce routeur sont invalidées avec un coût mis à 16 (infini). Ces routes sont conservées durant encore 120 secondes (2 minutes), puis supprimées de la table si aucun paquet RIP n’est reçu de ce routeur.
Travaux pratiques : RIP (Routing Information Protocol)
Visualisation de la table de routage avec 'route'
La commande
route, tout comme
ifconfig, sert à la fois à connaître l'état de la table de routage de l'hôte et à configurer de nouvelles routes statiques au besoin.
Exemple de table de routage sous Windows avec la commande système (
C:\route print)
| Description | Réseau de destination | Masque de réseau | Passerelle | Interface | Métrique |
|---|---|---|---|---|---|
| Itinéraire par défaut | 0.0.0.0 | 0.0.0.0 | 10.0.0.1 | 10.0.0.169 | 1 |
| Réseau de bouclage | 127.0.0.0 | 255.0.0.0 | 127.0.0.1 | 127.0.0.1 | 1 |
| Réseau local | 10.0.0.0 | 255.0.0.0 | 10.0.0.169 | 10.0.0.169 | 1 |
| Adresse IP locale | 10.0.0.169 | 255.255.255.255 | 127.0.0.1 | 127.0.0.1 | 1 |
| Adresses multicast | 224.0.0.0 | 240.0.0.0 | 10.0.0.169 | 10.0.0.169 | 1 |
| Adresse de diffusion limitée | 255.255.255.255 | 255.255.255.255 | 10.0.0.169 | 10.0.0.169 | 1 |
Exemple de table de routage sous Linux/UNIX avec la commande système (
route -n)
| Destination | Gateway | Genmask | Flags | Metric | Ref | Use | Iface |
|---|---|---|---|---|---|---|---|
| 192.168.1.0 | 0.0.0.0 | 255.255.255.0 | U | 0 | 0 | 0 | eth0 |
| 0.0.0.0 | 192.168.1.1 | 0.0.0.0 | UG | 0 | 0 | 0 | eth0 |
Ajout de route statique et analyse Wireshark
Sur le serveur, ajoutez une route vers le client au moyen de la commande ci-dessous, et visualisez la nouvelle table:
route add -net 192.168.119.0 netmask 255.255.255.0 vmnet1
Lancez l’analyseur de protocole Wireshark sur le serveur. Puis lancez le daemon RIP « routed » sur le serveur grâce à la commande ci-dessous. Analysez les paquets RIP transmis par le serveur:
[prof@machine] $/etc/init.d/routed start
Commutation de paquets IP
Pour accélérer les transferts de flux multimédia (téléphonie, audio et vidéo) entre les stations du réseau, on décide de combiner le routage IP avec la commutation de circuit virtuel. Ces nouveaux équipements, appelés commutateurs IP, sont capables d’établir et de gérer des circuits virtuels entre les stations en insérant un nouveau champ appelé Label ou étiquette devant chaque en-tête des paquets IP émis vers la destination. On supposera aussi qu’un paquet d’appel (setup) est transmis avant les données multimédia pour initialiser le circuit virtuel. Ce paquet d’appel est acquitté par la destination et est routé au moyen des tables de routage RIP précédemment calculées.
Méthodes de commutation
Les différentes méthodes de commutation sont :
- Commutation de circuit
- Commutation de message
- Commutation de paquet
- Commutation de cellule
Définition de la commutation de circuit virtuel
Une communication par commutation de circuit virtuel est fondée sur la négociation et la construction d'un chemin unique d'une machine A à une machine B, lors de l'établissement d'une séquence de dialogue entre ces deux machines. Le chemin ainsi créé perdure jusqu'à la clôture de la séquence de dialogue qu'il sous-tend. Ce chemin physique étant partagé entre plusieurs communications, il est appelé chemin logique ou circuit virtuel, d'où le nom de cette méthode de communication.
Avantages de la commutation de circuit virtuel
Les avantages d’utiliser un service de transfert de données par commutation de circuit virtuel, plutôt qu’un service en mode datagramme, sont :
- le séquencement des données reçues ;
- la négociation préalable des ressources de communication (mémoire, bande passante, CPU, fenêtre de contrôle de flux, temporisateurs, ...) nécessaires au bon transfert des données ;
- la vérification de la disponibilité des machines communicantes ;
- la minimisation du délai de traitement (temps de service) des paquets dans chaque nœud.
Calcul des tables de commutation de labels (MPLS)
On supposera que 2 circuits virtuels CV1 et CV2 sont établis entre A et B, et un 3ème CV (CV3) est établi entre C et B. Les CV sont activés dans l’ordre chronologique suivant : CV1, CV3, puis CV2. Voici les tables de commutation des labels des commutateurs appartenant aux circuits virtuels :
Initialisation du circuit virtuel CV1
L’initialisation du circuit virtuel CV1 est réalisée par l’envoi d’un premier paquet d’appel (call setup) par la machine A vers la destination B.
- Dans chaque nœud traversé, l’adresse IP de la machine destination B contenue dans ce paquet d’appel est analysée pour identifier la route à suivre.
- À la réception de ce paquet d’appel, les nœuds traversés consultent leur table de routage IP, identifient le prochain nœud vers la destination, allouent un numéro de circuit virtuel (appelé étiquette ou label) à cet échange et mettent à jour leur table de commutation de circuit.
- Les variables suivantes sont enregistrées dans la table de commutation : le numéro de port d’entrée, le numéro de CV en entrée, le numéro de port de sortie. La dernière variable de la table, à savoir le « numéro de CV de sortie », sera déterminée par le nœud suivant et communiquée au nœud pour assurer son unicité et permettre le bon démultiplexage des paquets associés à chaque dialogue.
- Ce premier paquet d’appel est ainsi routé jusqu’à la destination et donnera lieu à un acquittement.
Procédure d'initialisation du circuit virtuel CV1 :
- Comme R1 est la passerelle par défaut de A, A transmet un message d’appel à R1 en précisant l’adresse IP de la machine B destinataire.
- La table de routage de R1 indique que pour atteindre la machine B d’adresse 60.0.0.3 appartenant au sous-réseau 60.0.0.0, il faut transiter via l’interface d’adresse 10.0.0.2, qui appartient au nœud R2. Pour atteindre le prochain nœud R2, il faut sortir de R1 par son port n° P2.
- R1 alloue le premier numéro de circuit virtuel disponible, à savoir 1, et le communique à la machine A.
- R1 initialise sa table de commutation avec le vecteur (numéro de circuit virtuel en entrée = 1, numéro de port d’entrée = P1 ; numéro de port de sortie = P2, numéro de CV en sortie = à déterminer par le prochain nœud R2).
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R1 (initialisation CV1) | |||
| 1 | P1 | P2 | ? |
- R1 transmet le paquet d’appel au prochain nœud R2. R2 attribue le premier numéro de CV disponible à cette connexion et le transmet au nœud R1. R1 finalise l’initialisation de sa table de commutation.
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R1 (finalisation CV1) | |||
| 1 | P1 | P2 | 1 |
R2 effectue les mêmes opérations que R1. La table de routage de R2 indique que pour atteindre la machine B d’adresse 60.0.0.3, il faut passer par le prochain nœud R5 en sortant par le port P3. La table de commutation de R2 est alors initialisée comme suit :
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R2 (initialisation CV1) | |||
| 1 | P3 | P3 | 1 |
R5 effectue les mêmes opérations que R1 et R2. La table de routage de R5 indique que le sous-réseau de B est directement raccordé au nœud via le port P2. La table de commutation de R5 est alors initialisée comme suit :
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R5 (initialisation CV1) | |||
| 1 | P3 | P2 | 1 |
Initialisation du circuit virtuel CV3
La procédure d’initialisation est identique à celle suivie pour le CV1 et permet d’identifier les nœuds traversés par le CV3 entre les machines C et B, soit R4 et R5. Les tables de commutation de R4 et R5 sont mises à jour comme suit. Sachant que pour R5, le premier « numéro de CV de sortie » disponible est alors 2.
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R4 (initialisation CV3) | |||
| 1 | P3 | P2 | 1 |
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R5 (mise à jour CV1 + CV3) | |||
| 1 | P3 | P2 | 1 |
| 1 | P1 | P2 | 2 |
Initialisation du circuit virtuel CV2
Comme pour le CV1, le CV2 traverse les nœuds R1 puis R2 puis R5. Leurs tables de commutation sont initialisées comme suit :
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R1 (mise à jour CV1 + CV2) | |||
| 1 | P1 | P2 | 1 |
| 2 | P1 | P2 | 2 |
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R2 (mise à jour CV1 + CV2) | |||
| 1 | P3 | P3 | 1 |
| 2 | P3 | P3 | 2 |
| Label Entrée | Interface Entrée | Interface Sortie | Label Sortie |
|---|---|---|---|
| R5 (mise à jour CV1 + CV3 + CV2) | |||
| 1 | P3 | P2 | 1 |
| 1 | P1 | P2 | 2 |
| 2 | P3 | P2 | 3 |
Foire aux questions (FAQ)
Qu'est-ce que le MTU dans un réseau IP ?
Le MTU (Maximum Transmission Unit) définit la taille maximale, en octets, qu'un paquet IP peut avoir pour être transporté dans les trames d’un réseau physique spécifique sans être fragmenté. Chaque interface réseau a son propre MTU.
Pourquoi les routeurs ne défragmentent-ils pas les paquets IP ?
Les routeurs ne défragmentent pas les paquets IP car cela nécessiterait des ressources importantes (mémoire et CPU) et ne garantit pas qu'un routeur verrait tous les fragments d'un même paquet. La défragmentation est reléguée aux stations finales pour simplifier les fonctions du réseau et optimiser les performances des routeurs.
Quel est le rôle du champ TTL dans les paquets IP ?
Le champ TTL (Time To Live) est utilisé pour éviter que les paquets IP ne tournent indéfiniment en boucle dans un réseau. Il est initialisé avec une valeur (par exemple 16 pour RIP) et décrémenté par chaque routeur traversé. Si le TTL atteint 1, le routeur détruit le paquet, empêchant ainsi les boucles infinies.