Corrigé bac NSI 2025 Métropole jour 1 — Exercice 3 : Réseau CaféNet : adressage IPv4, routage RIP et OSPF, table de routage en ABR

Partie A

1. Le réseau du café 1 est le réseau 192.168.20.0 de masque 255.255.255.0 : les trois premiers octets 192.168.20 sont imposés à toute machine du réseau, et seul le dernier octet, codé sur 8 bits, distingue les machines.

• [–] (a) 192.168.20.2 : valide. Elle appartient bien au réseau du café 1, son dernier octet est compris entre 1 et 254, et elle est encore libre (le routeur 2 occupe .1, les deux bornes existantes .10 et .11).
• [–] (b) 192.168.20.157 : valide, pour les mêmes raisons.
• [–] (c) 192.168.20.261 : impossible. Un octet est codé sur 8 bits, donc compris entre 0 et $2^8-1=255$ : 261 ne s'écrit pas sur un octet.
• [–] (d) 192.168.24.10 : le troisième octet vaut 24 et non 20. Cette adresse appartient à un autre réseau ; la borne ne pourrait pas dialoguer avec les machines du café 1 sans passer par un routeur.

Les deux adresses valides sont donc (a) et (b).

2. L'adresse de diffusion est la dernière adresse du réseau local, c'est-à-dire celle dont tous les bits de la partie machine valent 1 : le dernier octet vaut $11111111_2=255$. L'adresse de diffusion du café 1 est 192.168.20.255.

3. Le dernier octet offre $2^8=256$ combinaisons, mais deux sont réservées : 192.168.20.0 (adresse du réseau) et 192.168.20.255 (adresse de diffusion). Il reste $256-2=254$ adresses attribuables. Sont déjà attribuées : 192.168.20.1 (interface du routeur 2), 192.168.20.10 et 192.168.20.11 (les deux bornes), plus la nouvelle borne, soit 4 adresses. Les switchs, eux, n'ont pas d'adresse IP et ne comptent pas. On peut donc encore connecter $254-4=250$ machines.

4. Il faut que le réseau contienne au moins 8 adresses, adresse du réseau et adresse de diffusion comprises. Or $8=2^3$ : il faut au moins 3 bits pour la partie machine, donc au plus $32-3=29$ bits pour le masque. La longueur maximale du masque est 29 bits, soit 255.255.255.248 en notation décimale. Un masque de 30 bits ne laisserait que $2^2=4$ adresses, ce qui est insuffisant. En passant de 24 à 29 bits, on libère les $256-8=248$ autres adresses pour d'autres sous-réseaux.

Partie B

5. On raisonne à partir de la Figure 1, en comptant les transferts de routeur à routeur.

192.168.30.0 est le réseau du café 2, relié au routeur 3 : depuis le routeur 2, on sort par l'interface 172.16.4.1 vers le routeur 3 (172.16.4.2), soit 1 saut. L'autre chemin, par le routeur 1 puis le routeur 3, coûterait 2 sauts : RIP retient le plus court.

172.16.1.0 est le réseau qui relie le routeur 4 au routeur 1 : le routeur 1 y possède l'interface 172.16.1.2, il suffit donc de l'atteindre. On sort par 172.16.3.1 vers le routeur 1 (172.16.3.2), soit 1 saut ; en passant par le routeur 3 puis le routeur 4, il en faudrait 2.

6. La réponse attendue est le réseau 192.168.10.0 (le siège social, relié au routeur 4) : il est atteignable de deux façons de même coût : par le routeur 1 puis le routeur 4 (2 sauts, comme l'indique la table), ou par le routeur 3 puis le routeur 4 (2 sauts également). La ligne pourrait donc s'écrire :

Ce que le correcteur attend : le nombre de sauts, lui, ne change pas (les deux routes ont le même coût au sens de RIP) ; seuls l'interface de sortie et le prochain routeur changent. Honnêteté du corrigé : le réseau 172.16.0.0, qui relie les routeurs 1 et 3, est en réalité dans la même situation : il est à 1 saut par le routeur 3 (172.16.4.1 / 172.16.4.2, comme dans la table) comme par le routeur 1 (172.16.3.1 / 172.16.3.2) ; l'énoncé n'en attend qu'un, et 192.168.10.0 est celui dont les deux routes empruntent des chemins vraiment distincts. Une copie qui cite 172.16.0.0 en le justifiant ne dit rien de faux. Ce sont les deux cycles du graphe des routeurs qui créent cette ambiguïté ; RIP ne la tranche pas, le routeur conserve la première route apprise.

7. Internet est relié au routeur 1, dont l'interface porte l'adresse 203.0.113.1. Depuis le routeur 2, tout paquet dont la destination n'est pas dans la table doit donc partir vers le routeur 1 :

L'interface de sortie est celle du routeur 2 sur cette liaison, et le prochain routeur est l'adresse de l'interface du routeur 1 sur la même liaison. Cette ligne, la route par défaut, est examinée en dernier : elle ne sert que si aucune autre ne correspond.

Partie C

8. On applique $\text{couˆt}=10^9/\text{deˊbit}$ :

Le coût de Fast Ethernet vaut 10, celui de la fibre optique vaut 1. Plus le débit est grand, plus le coût est petit : OSPF préfère les liaisons rapides.

9. La Figure 2 donne le type de chaque liaison, donc son coût : routeur 4 – routeur 3 en fibre (coût 1) ; routeur 4 – routeur 1 en Ethernet (100) ; routeur 1 – routeur 3 en Ethernet (100) ; routeur 1 – routeur 2 en Fast Ethernet (10) ; routeur 3 – routeur 2 en Fast Ethernet (10). On énumère les chemins du routeur 1 au routeur 4 :

La route de coût minimal est routeur 1 $\to$ routeur 2 $\to$ routeur 3 $\to$ routeur 4, de coût 21.

Ce que le correcteur attend : la route la plus courte en nombre de sauts (la liaison directe, 1 saut) n'est pas la moins coûteuse au sens d'OSPF. Traverser trois liaisons rapides coûte 21, quand une seule liaison Ethernet lente coûte 100. C'est toute la différence entre RIP, qui compte les routeurs traversés, et OSPF, qui tient compte du débit. La Figure 2 échange par ailleurs les étiquettes des deux cafés par rapport à la Figure 1 ; cela ne change rien au calcul, qui ne porte que sur les liaisons entre routeurs.

Partie D

10. On convertit chaque octet en binaire sur 8 bits : $192=128+64=11000000_2$, $168=128+32+8=10101000_2$, $20=16+4=00010100_2$, $12=8+4=00001100_2$.

>>> ip_bin('192.168.20.12')
'11000000.10101000.00010100.00001100'

La chaîne compte bien 35 caractères : 32 chiffres binaires et 3 points.

11. La boucle for examine les 35 caractères. Le premier caractère où les deux chaînes diffèrent déclenche immédiatement un return (ligne 4 si ip_1[i] est le plus petit, ligne 6 sinon) et la fonction s'arrête. La ligne 7 n'est donc atteinte que si la boucle est allée jusqu'au bout sans jamais trouver de différence : les deux chaînes sont identiques, c'est-à-dire que les deux paramètres désignent la même adresse IP. Les points occupent les mêmes positions dans les deux chaînes et ne peuvent jamais créer d'écart.

12. Une adresse ne se précède pas elle-même : le cas de la ligne 7 doit donc renvoyer False, comme le cas où la première adresse est la plus grande.

def precede(ip_1, ip_2):
    for i in range(35):
        if ip_1[i] < ip_2[i]:
            return True
        elif ip_1[i] > ip_2[i]:
            return False
    return False

Vérification sur l'exemple du sujet : avec a et b, les 23 premiers caractères coïncident ; au vingt-quatrième (le sixième bit du troisième octet) on a a[23] = '0' et b[23] = '1', donc '0' < '1' et la fonction renvoie True. Elle renvoie False pour precede(b, a) et pour precede(a, a). La comparaison < porte ici sur des caractères : elle compare leurs codes, et '0' < '1', ce qui donne bien l'ordre des bits.

13. Un attribut : adresse_ip (on accepte aussi interface, passerelle, cout, gauche, droite). Une méthode : est_vide (on accepte aussi __init__, modifie, rechercher, inserer). Un attribut est une donnée portée par chaque instance, accessible par self ; une méthode est une fonction définie dans la classe, dont le premier paramètre est self.

14. Par convention, l'arbre est vide lorsque son adresse IP est la chaîne vide :

    def est_vide(self):
        return self.adresse_ip == ''

On renvoie directement le booléen de la comparaison ; attention à l'opérateur de comparaison == et non à l'affectation =.

15. Une table de routage est consultée à chaque paquet transmis : la vitesse de recherche est décisive. Rangée dans une liste, la table impose une recherche séquentielle, donc $n$ comparaisons dans le pire des cas pour $n$ lignes : un coût linéaire. Dans un arbre binaire de recherche, chaque comparaison avec la racine élimine d'un coup tout un sous-arbre : on descend d'un niveau à chaque étape, et le nombre de comparaisons est majoré par la hauteur de l'arbre. Si l'arbre est équilibré, cette hauteur est de l'ordre de ${\log }_{2}n$ : le coût est logarithmique. Pour une table de 1 000 lignes, cela fait une dizaine de comparaisons au lieu d'un millier. De plus, le parcours infixe de l'arbre rend les adresses déjà triées, et l'insertion d'une nouvelle ligne ne demande aucun décalage. Réserve à signaler : l'avantage disparaît si l'arbre dégénère en peigne (adresses insérées déjà triées) : la recherche redevient linéaire.

16. Les quatre affectations sont communes aux deux cas : on les sort du test. Seule la création des deux sous-arbres vides est propre au cas où le nœud était vide. Il faut donc mémoriser la réponse de est_vide() avant de modifier adresse_ip :

    def modifie(self, adresse_ip,
                interface, passerelle,
                cout):
        etait_vide = self.est_vide()
        self.adresse_ip = adresse_ip
        self.interface  = interface
        self.passerelle = passerelle
        self.cout       = cout
        if etait_vide:
            self.gauche = Abr('','','',0)
            self.droite = Abr('','','',0)

Ce que le correcteur attend : si l'on garde if self.est_vide(): après les affectations, le test est toujours faux, puisque self.adresse_ip vient de recevoir une adresse non vide : les sous-arbres ne sont jamais créés et l'insertion suivante échoue sur AttributeError: 'Abr' object has no attribute 'gauche'. C'est le piège de la question.

17. L'arbre est ordonné par la relation precede, qui attend des adresses binaires : il faut donc convertir les deux adresses avec ip_bin avant de les comparer. Si l'adresse cherchée précède celle du nœud, elle ne peut se trouver que dans le sous-arbre gauche :

    def rechercher(self, adresse_ip):
        if self.est_vide() or adresse_ip==self.adresse_ip:
            return self
        elif precede(ip_bin(adresse_ip), ip_bin(self.adresse_ip)):
            return self.gauche.rechercher(adresse_ip)
        else:
            return self.droite.rechercher(adresse_ip)

Le cas d'arrêt de cette fonction récursive est double : ou bien l'adresse est trouvée, ou bien on aboutit à un arbre vide, qui est précisément l'emplacement où inserer viendra écrire la nouvelle ligne par un appel à modifie.

Vérification : en insérant dans un arbre vide les huit lignes de la table du routeur 2 (avec les deux lignes complétées à la question 5), le parcours infixe rend les adresses dans l'ordre croissant, 172.16.0.0, 172.16.1.0, 172.16.2.0, 172.16.3.0, 172.16.4.0, 192.168.10.0, 192.168.20.0, 192.168.30.0 : la propriété de l'arbre binaire de recherche est bien respectée. Un inserer portant sur une adresse déjà présente met la ligne à jour sans créer de doublon, puisque rechercher retourne le nœud existant.