Aller au contenu principal

1. Introduction

1.1. Motivation​

Le Protocole Internet (Internet Protocol) est conçu pour une utilisation dans des systèmes interconnectés de réseaux de communication informatique à commutation de paquets. Un tel système a été appelé un « catenet » [1]. Le protocole internet permet de transmettre des blocs de données appelés datagrammes (datagrams) des sources vers les destinations, où les sources et les destinations sont des hôtes identifiés par des adresses de longueur fixe. Le protocole internet fournit également la fragmentation (fragmentation) et le réassemblage (reassembly) des datagrammes longs, si nécessaire, pour la transmission à travers des réseaux à « petits paquets ».

Objectifs de conception fondamentaux​

1. Interconnexion

Réseau A ←→ Passerelle ←→ Réseau B ←→ Passerelle ←→ Réseau C
  ↓                        ↓                        ↓
Hôte 1                  Hôte 2                  Hôte 3

IP permet à différents types de réseaux de s'interconnecter

2. Livraison de datagrammes

  • Service sans connexion (connectionless)
  • Chaque datagramme routé indépendamment
  • Aucune garantie de livraison, d'ordre ou de protection contre la duplication

3. Adressage

  • Adresses de longueur fixe de 32 bits
  • Identifient de manière unique chaque hôte sur l'internet
  • Structure hiérarchique (réseau + hôte)

4. Fragmentation et réassemblage

Grand datagramme (1500 octets)
    ↓ Fragmentation
Fragment 1 (500 octets) + Fragment 2 (500 octets) + Fragment 3 (500 octets)
    ↓ Transmission à travers un réseau à petits paquets
    ↓ Réassemblage
Grand datagramme (1500 octets)

1.2. Portée​

Le protocole internet est spécifiquement limité en portée pour fournir les fonctions nécessaires à la livraison d'un paquet de bits (un datagramme internet) d'une source vers une destination sur un système interconnecté de réseaux. Il n'y a pas de mécanismes pour augmenter la fiabilité des données de bout en bout, le contrôle de flux, le séquencement ou d'autres services couramment trouvés dans les protocoles hôte à hôte. Le protocole internet peut capitaliser sur les services de ses réseaux de support pour fournir divers types et qualités de service.

Ce qu'IP ne fournit PAS​

|| Fonction | IP fournit | Fourni par | ||----------|------------|------------| || Livraison fiable | ❌ Non | TCP | || Contrôle de flux | ❌ Non | TCP | || Séquencement | ❌ Non | TCP | || Récupération d'erreur | ❌ Non | TCP | || Gestion des connexions | ❌ Non | TCP | || Contrôle de congestion | ❌ Non | TCP |

Ce qu'IP fournit​

|| Fonction | Description | ||----------|-------------| || ✅ Adressage | Adresses IP de 32 bits | || ✅ Routage | Acheminement des datagrammes | || ✅ Fragmentation/Réassemblage | Adaptation aux différents MTU | || ✅ Durée de vie | TTL empêche les boucles | || ✅ Type de service | Champ ToS | || ✅ Somme de contrôle d'en-tête | Détection des erreurs d'en-tête |

Philosophie de conception​

Principe de bout en bout (End-to-End Principle):
- Maintenir la couche IP simple
- Fonctions complexes implémentées aux points terminaux
- Le cœur du réseau ne fait que l'acheminement

Avantages:
✅ Scalabilité du réseau
✅ Support de multiples protocoles de couche supérieure
✅ Isolation du domaine de défaillance

1.3. Interfaces​

Ce protocole est appelé par des protocoles hôte à hôte dans un environnement internet. Ce protocole appelle des protocoles de réseau local pour transporter le datagramme internet vers la prochaine passerelle ou l'hôte de destination.

Interface de couche supérieure​

Exemple : TCP appelant IP

Le module TCP appellerait le module internet pour prendre un segment TCP 
(incluant l'en-tête TCP et les données utilisateur) comme la portion de 
données d'un datagramme internet. Le module TCP fournirait les adresses 
et autres paramètres dans l'en-tête internet au module internet comme 
arguments de l'appel.

Flux d'interface :

Couche Application
    ↓ Données
Couche Transport (TCP/UDP)
    ↓ Segment TCP/datagramme UDP
Couche Réseau (IP) ← Ajout de l'en-tête IP
    ↓ Datagramme IP
Couche Liaison de données (Ethernet/etc)
    ↓ Trame
Couche Physique

Interface de couche inférieure​

Exemple : IP appelant le réseau local

Dans le cas d'ARPANET, par exemple, le module internet appellerait un 
module de réseau local qui ajouterait le leader 1822 [2] au datagramme 
internet créant un message ARPANET à transmettre à l'IMP (Interface 
Message Processor). L'adresse ARPANET serait dérivée de l'adresse 
internet par l'interface de réseau local.

Exemple de protocole 1822 :

+------------------+------------------+
|| Leader 1822      | Datagramme IP    |
|| (spécifique ARPANET) | (format générique) |
+------------------+------------------+

Paramètres d'interface​

Interface d'envoi IP :

send_ip_datagram(
    source_address,      // Adresse IP source
    dest_address,        // Adresse IP destination
    protocol,            // Protocole de couche supérieure (TCP=6, UDP=17)
    tos,                 // Type de service
    ttl,                 // Durée de vie
    data,                // Données
    length,              // Longueur des données
    options              // Options IP (optionnel)
);

Interface de réception IP :

receive_ip_datagram(
    source_address,      // Adresse IP source
    dest_address,        // Adresse IP destination
    protocol,            // Protocole de couche supérieure
    data,                // Données
    length               // Longueur des données
);

1.4. Fonctionnement​

Le protocole internet implémente deux fonctions de base : l'adressage et la fragmentation.

Adressage​

Les modules internet utilisent les adresses portées dans l'en-tête internet pour transmettre les datagrammes internet vers leurs destinations. La sélection d'un chemin pour la transmission est appelée routage (routing).

Structure d'adresse :

Adresse IP de 32 bits = Portion réseau + Portion hôte

Classe A : [0][réseau 7 bits][hôte 24 bits]
Classe B : [10][réseau 14 bits][hôte 16 bits]
Classe C : [110][réseau 21 bits][hôte 8 bits]

Décision de routage :

def route_datagram(dest_ip):
    if dest_ip in local_network:
        # Livraison directe
        send_to_host(dest_ip)
    else:
        # Transmission à la passerelle
        gateway = lookup_routing_table(dest_ip)
        send_to_gateway(gateway, datagram)

Fragmentation​

Les modules internet utilisent des champs dans l'en-tête internet pour fragmenter et réassembler les datagrammes internet lorsque nécessaire pour la transmission à travers des réseaux à « petits paquets ».

Processus de fragmentation :

Datagramme original (MTU=1500):
+--------+------------------------+
|| En-tête IP |   1480 octets données  |
+--------+------------------------+

Après fragmentation à travers un réseau MTU=500:

Fragment 1:
+--------+--------+
|| En-tête IP | 480 octets | MF=1, Offset=0
+--------+--------+

Fragment 2:
+--------+--------+
|| En-tête IP | 480 octets | MF=1, Offset=60
+--------+--------+

Fragment 3:
+--------+--------+
|| En-tête IP | 520 octets | MF=0, Offset=120
+--------+--------+

Champs de fragmentation :

  • Identification : Identifie le datagramme original
  • Drapeaux (Flags) :
    • DF (Don't Fragment) : Ne pas fragmenter
    • MF (More Fragments) : D'autres fragments suivent
  • Décalage de fragment (Fragment Offset) : Position du fragment dans le datagramme original (unités de 8 octets)

Modèle de fonctionnement​

Le modèle de fonctionnement est qu'un module internet réside dans chaque hôte engagé dans la communication internet et dans chaque passerelle qui interconnecte les réseaux. Ces modules partagent des règles communes pour interpréter les champs d'adresse et pour fragmenter et assembler les datagrammes internet. De plus, ces modules (en particulier dans les passerelles) ont des procédures pour prendre des décisions de routage et d'autres fonctions.

Le protocole internet traite chaque datagramme internet comme une entité indépendante non liée à tout autre datagramme internet. Il n'y a pas de connexions ou de circuits logiques (virtuels ou autres).

Expéditeur:
1. Recevoir les données de la couche supérieure
2. Ajouter l'en-tête IP
3. Consulter la table de routage
4. Fragmenter si nécessaire
5. Passer au réseau local

Passerelle intermédiaire:
1. Recevoir le datagramme IP
2. Vérifier l'adresse de destination
3. Consulter la table de routage
4. Décrémenter le TTL
5. Fragmenter si nécessaire
6. Transmettre au prochain saut

Destinataire:
1. Recevoir le datagramme IP
2. Vérifier l'adresse de destination (est-ce pour moi?)
3. Réassembler si fragmenté
4. Passer au protocole de couche supérieure

Mécanismes clés​

Le protocole internet utilise quatre mécanismes clés pour fournir son service : Type de service, Durée de vie, Options et Somme de contrôle d'en-tête.

Type de service (Type of Service)

  • Utilisé pour indiquer la qualité de service souhaitée
  • Ensemble abstrait ou généralisé de paramètres
  • Utilisé par les passerelles pour sélectionner les paramètres de transmission
  • Guide les décisions de routage et de sélection de réseau

Durée de vie (Time to Live)

  • Limite supérieure sur la durée de vie du datagramme
  • Définie par l'expéditeur, décrémentée à chaque saut
  • Datagramme détruit quand le TTL atteint zéro
  • Peut être considérée comme une limite de temps d'autodestruction

Options

  • Fonctions de contrôle nécessaires dans certaines situations
  • Inutiles pour la plupart des communications courantes
  • Incluent des dispositions pour les horodatages, la sécurité et le routage spécial

Somme de contrôle d'en-tête (Header Checksum)

  • Vérification que l'en-tête a été transmis correctement
  • Les données peuvent contenir des erreurs (non vérifiées par IP)
  • Si la somme de contrôle échoue, le datagramme est immédiatement rejeté

Modèle de fiabilité​

Le protocole internet ne fournit pas de mécanisme de communication fiable. Il n'y a pas d'accusés de réception ni de bout en bout ni de saut en saut. Il n'y a pas de contrôle d'erreur pour les données, seulement une somme de contrôle d'en-tête. Il n'y a pas de retransmissions. Il n'y a pas de contrôle de flux.

Les erreurs détectées peuvent (may) être signalées via le Protocole de messages de contrôle Internet (Internet Control Message Protocol, ICMP) [3] qui est implémenté dans le module de protocole internet.

Résumé des concepts clés​

Datagramme​

  • Paquet indépendant
  • Contient des informations d'adressage complètes
  • Peut être routé indépendamment

Sans connexion​

  • Aucun établissement de connexion nécessaire
  • Chaque datagramme traité indépendamment
  • Simple et efficace

Meilleur effort​

  • Aucune garantie de livraison
  • Aucune garantie d'ordre
  • Aucune garantie contre la duplication
  • Fiabilité gérée par les protocoles de couche supérieure

Philosophie de conception : Le protocole IP suit la philosophie de conception « réseau simple, points terminaux intelligents », poussant la complexité vers les bords du réseau et maintenant le cœur du réseau simple et scalable. Cette conception permet à l'internet de supporter une grande variété d'applications et de services.

Dernière mise à jour le