Corrigé bac NSI 2026 Métropole jour 2 — Exercice 1 : Réseau d'entreprise : adressage IPv4, routage RIP et OSPF, classe Routage

Adressage du site C (questions 1 à 3).

1. L'adresse 172.16.2.1 /16 a une partie fixe de $S=16$ bits, soit exactement les deux premiers octets (le masque de sous-réseau est 255.255.0.0). L'adresse du réseau local s'obtient en conservant cette partie fixe et en mettant à 0 les $32-16=16$ bits restants, c'est-à-dire les deux derniers octets :

$$\text{172.16.2.1}⟶\underset{\text{partie fixe conserveˊe}}{\underbrace{\text{10101100.00010000}}}.\underset{\text{16 bits aˋ 0}}{\underbrace{\text{00000000.00000000}}}=\text{172.16.0.0}$$

L'adresse du réseau local du site C est donc 172.16.0.0 (notée 172.16.0.0/16).

2. L'adresse de diffusion se construit de la même façon, mais en mettant à 1 les 16 bits de la partie machine : chaque octet 11111111 vaut 255, d'où l'adresse de diffusion 172.16.255.255. Un paquet envoyé à cette adresse est reçu par toutes les machines du réseau local.

3. La partie propre à la machine compte $32-16=16$ bits, ce qui donne $2^{16}=65536$ adresses possibles. Deux d'entre elles sont réservées (l'adresse du réseau 172.16.0.0 et l'adresse de diffusion 172.16.255.255) et ne peuvent pas être attribuées à une machine. Le nombre maximal de machines est donc

$$2^{16}-2=65536-2=65534.$$

Ce que le correcteur attend : le « $-2$ » explicitement justifié par les deux adresses réservées ; répondre $65536$ est une erreur classique.

Routage RIP (questions 4 à 6).

4. Avec RIP, chaque routeur retient, pour chaque destination, la route ayant le moins de sauts. Sur la figure, R1 possède deux voisins directs, R3 et R4 (liaisons R1-R3 et R1-R4) : ils sont à 1 saut, et le routeur « par lequel on passe » (le prochain saut) est alors la destination elle-même, jointe par la liaison directe ; on peut aussi écrire « liaison directe » dans la colonne. Le routeur R2 est voisin de R3 (liaison R2-R3), donc atteignable en 2 sauts par R3, alors que le chemin par R4 (R1-R4-R5-R2) demande 3 sauts. De même R5 est voisin de R4 (liaison R5-R4), donc atteignable en 2 sauts par R4, alors que le chemin R1-R3-R2-R5 demande 3 sauts.

5. PC A01 est relié au Switch A, lui-même relié à R1 ; PC B01 est relié au Switch B, relié à R2. D'après la table de routage précédente, R1 envoie vers R2 en passant par R3 (2 sauts). Le paquet suit donc le chemin

$$\text{PC A01}\to \text{Switch A}\to \text{R1}\to \text{R3}\to \text{R2}\to \text{Switch B}\to \text{PC B01},$$

soit, entre routeurs, la route ['R1','R3','R2']. Les commutateurs (switchs) ne comptent pas comme des sauts : seuls les routeurs traversés sont comptés.

6. Si R3 tombe en panne, les liaisons R1-R3, R3-R2 et R3-R4 disparaissent. Le seul chemin restant de R1 vers R2 passe par R4 puis R5 : $\text{R1}\to \text{R4}\to \text{R5}\to \text{R2}$, soit 3 sauts. Après convergence du protocole, la ligne « R2 » de la table de R1 devient « passe par R4, 3 sauts ». C'est l'intérêt des réseaux maillés : la commutation de paquets permet de réacheminer les paquets par une autre route lorsqu'un équipement tombe.

Routage OSPF (questions 7 et 8).

7. On applique la formule $\text{Couˆt}=10^8/\text{Deˊbit}$ :

Plus la liaison est rapide, plus son coût est faible : OSPF privilégie les liens rapides.

8. OSPF choisit le chemin dont la somme des coûts des liaisons est minimale. Les chemins possibles de R1 à R4 (sans repasser deux fois par le même routeur) sont :

• R1-R4 en direct (Ethernet) : coût $10$ ;
• R1-R3-R4 (Fibre puis Fast Ethernet) : coût $0,1+1=1,1$ ;
• R1-R3-R2-R5-R4 (Fibre, Ethernet, Fast Ethernet, Fast Ethernet) : coût $0,1+10+1+1=12,1$.

Le minimum est $1,1$ : OSPF choisit le chemin $\text{R1}\to \text{R3}\to \text{R4}$. On remarque que RIP aurait choisi la liaison directe R1-R4 (1 saut contre 2), pourtant dix fois plus lente : c'est précisément la différence entre les deux protocoles, RIP compte les sauts, OSPF tient compte du débit.

Programmation orientée objet (questions 9 à 11).

9. La fonction ajouter_route ajoute la route à liste_routes de façon inconditionnelle : aucune instruction ne compare la longueur de la liste, len(liste_routes), à la constante MAX_ROUTES. Cette constante est déclarée mais jamais utilisée. Cinq appels, puis un sixième, puis un septième, allongent la liste sans limite : après 7 appels de ajouter_route, len(liste_routes) vaut 7, supérieur à MAX_ROUTES. De plus, liste_routes est une variable globale : n'importe quelle partie du programme peut écrire directement liste_routes.append(...) sans passer par la fonction, ce qu'aucun contrôle ne peut empêcher. C'est ce défaut d'encapsulation que la classe Routage va corriger, en regroupant la liste et sa capacité dans un même objet et en réservant l'ajout à une méthode qui vérifie la contrainte.

10. La ligne 3 mémorise la capacité reçue en paramètre dans l'attribut self.capacite (la valeur par défaut 5 est fournie par la signature capacite = 5). La ligne 7 teste que la capacité n'est pas atteinte, la ligne 8 ajoute la route, la ligne 10 affiche le message d'erreur.

class Routage:
    def __init__(self, capacite = 5):
        self.capacite = capacite
        self.routes = []

    def ajouter(self, route):
        if len(self.routes) < self.capacite:
            self.routes.append(route)
        else:
            print("Erreur : capacité maximale atteinte, route non ajoutée")

Vérification exécutée : r = Routage() donne r.capacite égal à 5 et r.routes égal à [] ; avec r2 = Routage(2), trois appels successifs de r2.ajouter(['R1','R3']) ajoutent les deux premières routes et le troisième affiche le message d'erreur, r2.routes restant de longueur 2.

Ce que le correcteur attend : la condition stricte len(self.routes) < self.capacite (avec <=, on accepterait une route de trop) et l'usage de self. devant chaque attribut.

11. Pour chaque route de la liste routes, on affiche ses routeurs un par ligne, puis une ligne de séparation formée de trois tirets :

    def afficher(self):
        for route in self.routes:
            for routeur in route:
                print(routeur)
            print("---")

Cette méthode s'écrit à l'intérieur de la classe, au même niveau d'indentation que ajouter. Exécutée après r.ajouter(['R1','R3','R2']) et r.ajouter(['R1','R4','R5','R2']), l'appel r.afficher() produit exactement l'affichage demandé : R1, R3, R2, la ligne de trois tirets, puis R1, R4, R5, R2 et une nouvelle ligne de trois tirets, chaque élément sur sa propre ligne. Si la liste routes est vide, la méthode n'affiche rien, ce qui est le comportement attendu.