Couche liaison

La couche physique (chapitre 3) achemine des bits, mais bruts et faillibles : elle ne dit à qui ils sont destinés sur le réseau local, ni ne signale s'ils sont arrivés intacts. La couche liaison répond à ces deux manques. Elle regroupe les bits en trames, donne à chaque machine une adresse locale, détecte les erreurs de transmission, et organise le partage du médium quand plusieurs machines veulent parler en même temps.

C'est la couche du réseau local : elle gère la communication entre machines d'un même lien — votre PC et le commutateur de la salle, votre téléphone et la borne Wi-Fi. Le passage au monde, d'un réseau à l'autre, sera l'affaire de la couche réseau (chapitre 5).

La trame et l'adresse MAC

L'unité de la couche liaison est la trame : un bloc de bits structuré, avec un en-tête, les données, et un contrôle d'erreur en fin. C'est l'enveloppe dans laquelle voyage le paquet de la couche supérieure (encapsulation, chapitre 2).

Chaque interface réseau possède une adresse MAC (Media Access Control) : un identifiant de 48 bits, écrit en hexadécimal comme a4:83:e7:2c:1f:90, gravé par le fabricant. Deux propriétés importantes :

• elle est censée être unique au monde — les premiers octets identifient le fabricant ;
• elle est plate et locale : elle ne porte aucune information de localisation. Elle désigne une carte réseau, pas un endroit dans le réseau.

C'est cette dernière propriété qui explique pourquoi la MAC ne suffit pas et pourquoi il faudra l'adresse IP au chapitre 5. On peut retrouver une machine par sa MAC sur le réseau local, mais pas la router à travers le monde : rien, dans une MAC, ne dit de quel côté de la planète elle se trouve. La MAC est une adresse de voisinage ; l'IP sera une adresse de destination globale. Retenez ce couple, il structure tout le reste du cours.

Détecter les erreurs : parité et CRC

Le bruit de la couche physique (chapitre 3) rend les erreurs de transmission inévitables. La couche liaison les détecte grâce à un code de contrôle ajouté à la trame : l'émetteur le calcule sur les données, le récepteur le recalcule et compare. S'ils diffèrent, la trame est altérée — et on la jette.

Deux mécanismes, d'inégale robustesse :

• La parité ajoute un bit qui rend pair (ou impair) le nombre de 1. Simple, mais faible : elle ne détecte qu'un nombre impair d'erreurs — deux bits inversés lui échappent.
• Le CRC (contrôle de redondance cyclique) est celui qu'emploie réellement Ethernet. Fondé sur une division polynomiale, il détecte quasiment toutes les erreurs réalistes — toutes les rafales courtes, la grande majorité des autres. C'est le standard.

Un point de vocabulaire capital, qui reviendra au chapitre 7 : la couche liaison détecte les erreurs, elle ne les corrige pas. Une trame erronée est simplement écartée. La rattraper — la retransmettre — n'est pas son rôle ; ce sera celui de TCP, à la couche transport. Détecter et corriger sont deux fonctions distinctes, situées à deux couches distinctes.

Ethernet et l'accès au médium : CSMA/CD

Ethernet est la technologie de réseau local filaire dominante. Historiquement, toutes les machines partageaient un même câble (topologie en bus, chapitre 1) — d'où un problème : si deux machines émettent en même temps, les signaux se mélangent, c'est une collision, et les deux trames sont perdues.

Ethernet le résout par CSMA/CD (Carrier Sense Multiple Access with Collision Detection), un protocole dont le nom décrit l'algorithme :

1. Écouter avant d'émettre (carrier sense) : si le médium est occupé, attendre.
2. Émettre si le médium est libre — mais continuer d'écouter.
3. Détecter une collision (collision detection) : si deux machines ont émis quasi simultanément.
4. En cas de collision, arrêter, attendre un délai aléatoire, puis réessayer.

Le délai aléatoire est la clé : sans lui, les deux machines réessaieraient en même temps et entreraient à nouveau en collision indéfiniment. Le hasard désynchronise les tentatives.

CSMA/CD appartient largement à l'histoire, et il faut comprendre pourquoi : l'Ethernet moderne est commuté (topologie en étoile autour d'un commutateur), et chaque machine a son propre lien dédié en duplex intégral. Il n'y a plus de collisions, donc plus besoin de CSMA/CD. Le protocole reste au programme parce qu'il éclaire la nature d'un médium partagé — et parce que le Wi-Fi, où le partage est inévitable, emploie un mécanisme cousin.

Le commutateur et sa table

Le commutateur (switch) est l'équipement central du réseau local moderne, et l'exemple type de ce qu'apporte la couche 2 par rapport à la couche 1. Là où le concentrateur (chapitre 3) recopiait bêtement tout sur tous les ports, le commutateur lit les adresses MAC et n'envoie chaque trame qu'au bon port.

Sa force est qu'il apprend tout seul. Il tient une table de commutation (MAC → port), qu'il remplit en observant les trames : quand une trame arrive d'une MAC sur un port, il note « cette MAC est joignable par ce port ». Ensuite :

• si la destination est connue dans la table, il envoie sur son port uniquement — envoi ciblé ;
• si elle est inconnue (ou s'il s'agit d'une diffusion), il inonde : il envoie sur tous les ports sauf celui d'entrée — le seul cas où il ressemble encore à un hub.

Le bénéfice est double : le trafic inutile disparaît (chaque machine ne voit que ce qui la concerne), et les liens ne sont plus partagés (plus de collisions). L'exercice vous fera coder cette table qui se remplit d'elle-même — l'auto-apprentissage est l'idée à emporter.

ARP : du monde IP au monde MAC

Il manque un maillon, et il est essentiel. Les applications et la couche réseau raisonnent en adresses IP (chapitre 5) ; mais pour livrer une trame sur le réseau local, il faut l'adresse MAC du destinataire. Comment passer de l'une à l'autre ?

C'est le rôle d'ARP (Address Resolution Protocol). Pour joindre l'IP 192.168.1.10 sur son réseau local, une machine diffuse une question à tout le monde : « qui a l'IP 192.168.1.10 ? donne-moi ta MAC ». La machine concernée répond avec sa MAC, et l'émetteur met en cache la correspondance pour ne pas redemander à chaque trame.

ARP est le pont entre la couche 3 (IP, global) et la couche 2 (MAC, local) : il traduit une adresse de destination globale en adresse de voisinage. C'est un rouage discret mais permanent — et son absence d'authentification en fait une cible d'attaque (l'usurpation ARP, que le cours de cybersécurité de L3 reprendra). Retenez-le comme la charnière entre les deux mondes d'adressage.

Un mot sur le Wi-Fi

Le Wi-Fi (norme 802.11) est la couche liaison du sans-fil. Il partage l'esprit d'Ethernet — trames, adresses MAC — mais avec une contrainte que le filaire commuté a supprimée : le médium est intrinsèquement partagé. Toutes les machines à portée émettent sur les mêmes ondes.

Il ne peut donc pas revenir à un lien dédié, et il emploie un cousin de CSMA/CD : CSMA/CA (Collision Avoidance). La différence tient dans le dernier sigle — sur un lien radio, une machine ne peut pas toujours détecter une collision pendant qu'elle émet (elle n'entend pas les autres). Elle cherche donc à les éviter en amont, par de l'écoute et des délais d'attente. Le Wi-Fi ajoute aussi le chiffrement (WPA2, WPA3) : puisque n'importe qui à portée capte les trames, la confidentialité doit être assurée par la cryptographie — un sujet que le chapitre 8 effleurera et que le cours de cybérsécurité approfondira.

À vous

L'exercice réunit les deux idées maîtresses de la couche liaison. D'abord, la table du commutateur : vous la voyez se remplir toute seule à mesure que les trames passent, et le commutateur cesser d'inonder dès qu'il connaît une destination — c'est ce qui le distingue du hub. Ensuite, la détection d'erreur : vous calculez un contrôle à l'émission, le recalculez à la réception, et repérez une trame altérée.

Gardez en tête la nuance que le TP met en évidence : on détecte ici, on ne corrige pas — et notre parité est bien plus faible que le CRC réel, même si le principe est identique.

// ── Partie A : la table de commutation qui s'apprend ────────────────────────
// Un commutateur relie des machines à des ports. Contrairement au hub (qui
// recopie partout), il APPREND quelle MAC est sur quel port en observant les
// trames qui passent, et n'envoie ensuite qu'au bon port.

const table = {};  // MAC source -> port (la table se remplit toute seule)

// À VOUS : compléter apprendre() et decider().
function traiter(macSrc, macDst, portEntree) {
  // 1. apprendre : la source macSrc est joignable par portEntree
  // à compléter : table[macSrc] = portEntree

  // 2. décider : si on connaît macDst, envoyer sur SON port ;
  //    sinon, INONDER (envoyer sur tous les ports sauf celui d'entrée) —
  //    c'est le seul cas où le commutateur se comporte comme un hub.
  if (table[macDst] !== undefined) {
    return "port " + table[macDst];          // envoi ciblé
  }
  return "INONDATION (dst inconnue)";        // apprentissage en cours
}

console.log("A -> B (A sur port 1) :", traiter("A", "B", 1));  // B inconnu -> inondation
console.log("B -> A (B sur port 2) :", traiter("B", "A", 2));  // A connu -> ciblé
console.log("A -> B (A sur port 1) :", traiter("A", "B", 1));  // B connu -> ciblé
console.log("table apprise :", JSON.stringify(table));

// ── Partie B : détection d'erreur (esprit du CRC) ───────────────────────────
// À l'émission, on calcule un contrôle sur la trame ; on l'envoie avec. À la
// réception, on recalcule : s'il diffère, la trame a été ALTÉRÉE (bruit,
// chapitre 3) et on la JETTE. Ici, un contrôle simple : parité des bits à 1.
function controle(trame) {
  let uns = 0;
  for (const c of trame) if (c === "1") uns++;
  return uns % 2;                 // 0 si nombre pair de 1, 1 sinon
}

// À VOUS : recevoir() doit renvoyer "OK" ou "ERREUR détectée".
function recevoir(trame, controleRecu) {
  // à compléter : recalculer le contrôle et comparer
  return "?";
}

const trame = "10110100";
const c = controle(trame);
console.log("");
console.log("émission : trame =", trame, " contrôle =", c);
console.log("réception intacte  :", recevoir(trame, c));           // OK
console.log("réception altérée  :", recevoir("10110000", c));      // un bit a changé

function traiter(macSrc, macDst, portEntree) {
  table[macSrc] = portEntree;                 // APPRENTISSAGE
  if (table[macDst] !== undefined) return "port " + table[macDst];
  return "INONDATION (dst inconnue)";
}
// A -> B : B inconnu -> INONDATION, mais on apprend « A est sur le port 1 ».
// B -> A : A désormais connu -> envoi CIBLÉ sur le port 1 ; on apprend B/port 2.
// A -> B : B connu -> envoi ciblé. La table s'est remplie SEULE, par
// observation du trafic. C'est l'auto-apprentissage du commutateur.

function recevoir(trame, controleRecu) {
  return controle(trame) === controleRecu ? "OK" : "ERREUR détectée";
}
// Trame intacte : contrôle recalculé = contrôle reçu -> OK.
// Trame "10110000" (un 1 devenu 0) : parité changée -> ERREUR détectée, on jette.

// ── Ce que le TP enseigne ───────────────────────────────────────────────────
//
// 1. Le COMMUTATEUR n'est pas un hub. Il apprend, par observation, la
//    correspondance MAC -> port, et n'envoie ensuite qu'au bon port. Il
//    n'inonde que tant qu'il ne connaît pas la destination (et pour les
//    diffusions). D'où : moins de trafic inutile, et les machines ne se
//    disputent plus le médium. C'est ce que « monter en couche 2 » apporte
//    par rapport à la couche 1.
//
// 2. La DÉTECTION D'ERREUR répond au bruit du chapitre 3. On envoie un
//    contrôle calculé sur la trame ; le récepteur le recalcule et compare.
//    S'ils diffèrent, la trame a été altérée : on la JETTE (on ne corrige
//    pas — corriger, ce sera le rôle de TCP au chapitre 7, par
//    retransmission).
//
// 3. Notre parité ne détecte qu'un nombre IMPAIR de bits erronés — deux bits
//    inversés lui échappent. Le vrai CRC (contrôle de redondance cyclique)
//    d'Ethernet est bien plus robuste : il détecte quasiment toutes les
//    erreurs réalistes. Le principe — calculer, envoyer, recalculer,
//    comparer — est exactement le même.

Ce que la suite en fait

Vous savez maintenant faire communiquer des machines sur un même réseau local : trames, adresses MAC, détection d'erreurs, commutateur, ARP. Mais l'adresse MAC est plate et locale — elle ne permet pas de trouver une machine à l'autre bout du monde.

C'est exactement le problème que résout la couche réseau, le cœur du cours. Le chapitre 5 introduit l'adresse IP — une adresse globale et structurée, qui porte une information de localisation — et le découpage en sous-réseaux, l'automatisme de calcul le plus important de l'année. Le couple MAC locale / IP globale, posé ici, en est la clé.

À retenir