TCP/IP : qu'est-ce que c'est, pile de protocoles et transmission de données

Qu'est-ce que TCP/IP ?

TCP/IP (Transmission Control Protocol / Internet Protocol) est une pile de protocoles développée dans les années 1970 pour ARPANET et devenue le standard de facto pour l'Internet mondial. Elle définit comment les données sont divisées en paquets, adressées, transmises et reassemblées côté destinataire.

L'architecture TCP/IP est construite sur un principe multicouche, où chaque couche abstrait des fonctions spécifiques. La couche application traite les données de l'application, la couche transport assure la fiabilité, la couche réseau gère le routage et la couche liaison gère la transmission physique. La modularité permet de remplacer les protocoles au sein d'une couche sans affecter les couches voisines.

Dans le développement mobile, TCP/IP est utilisé par chaque application qui effectue des requêtes réseau. Les bibliothèques URLSession, OkHttp, AFNetworking et Alamofire fonctionnent au-dessus de cette pile, cachant au développeur les détails de l'empaquetage et du routage des paquets. Cependant, comprendre TCP/IP est nécessaire pour l'optimisation des performances : configurer les paramètres TCP via URLSessionConfiguration permet de gérer les délais d'attente, de maintenir des connexions HTTP persistantes et de configurer des proxys pour les environnements d'entreprise.

Comprendre TCP/IP est essentiel pour diagnostiquer les problèmes réseau : si une application ne peut pas se connecter à un serveur, le problème peut se situer à n'importe quelle couche de la pile — du canal physique au protocole d'application. Des outils comme tcpdump, Wireshark et Charles Proxy permettent d'analyser le trafic à chaque couche et de trouver les goulots d'étranglement. Pour les développeurs mobiles, Xcode fournit un Network Debug Dashboard et Android Studio offre un Network Inspector pour analyser les connexions TCP en temps réel.

Couches du modèle TCP/IP

Le modèle TCP/IP comprend quatre couches, chacune exécutant des fonctions strictement définies lors de la transmission des données. Comprendre cette hiérarchie est nécessaire pour diagnostiquer les problèmes réseau et optimiser les applications.

Couche application

Au niveau de la couche application opèrent les protocoles avec lesquels les applications interagissent directement : HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Cette couche formate les données d'une manière compréhensible par l'application et les transmet à la couche transport. Les développeurs d'applications mobiles travaillent à cette couche via des bibliothèques réseau.

Couche transport

La couche transport assure la transmission des données entre les applications sur différents appareils. Les principaux protocoles sont TCP (transmission fiable avec accusé de réception) et UDP (transmission rapide sans garanties). TCP ajoute les ports de l'expéditeur et du destinataire aux données, gère l'ordre des paquets et contrôle la congestion du réseau.

Couches réseau et liaison

La couche réseau est implémentée par le protocole IP, qui définit l'adressage (IPv4, IPv6) et le routage des paquets. Chaque paquet contient les adresses IP de l'expéditeur et du destinataire, et les routeurs le long du chemin prennent des décisions sur le nœud suivant en fonction des tables de routage. IPv4 utilise des adresses 32 bits (environ 4,3 milliards), tandis qu'IPv6 utilise des adresses 128 bits, résolvant le problème d'épuisement des adresses.

La couche liaison travaille avec le support de transmission physique : Ethernet, Wi-Fi, Bluetooth. Cette couche convertit les paquets en signaux et vice versa, gère l'accès au support de transmission via les adresses MAC et détecte les erreurs de la couche physique à l'aide de séquences de contrôle de trame (FCS).

Au niveau de la couche liaison opèrent des protocoles comme ARP (Address Resolution Protocol), qui convertit les adresses IP en adresses MAC des appareils sur le réseau local, et PPP (Point-to-Point Protocol), utilisé dans les connexions VPN et les réseaux de données mobiles.

Comment fonctionne le protocole TCP

TCP (Transmission Control Protocol) est l'un des principaux protocoles de la couche transport. Il assure une livraison fiable, ordonnée et vérifiée des erreurs d'un flux d'octets entre les applications. Avant de transmettre des données, TCP établit une connexion via une poignée de main en trois étapes.

La poignée de main en trois étapes (three-way handshake) commence par l'envoi d'un paquet SYN par le client. Le serveur répond avec un paquet SYN-ACK, confirmant la réception. Le client termine la poignée de main avec un paquet ACK, après quoi la transmission des données commence. Ce processus garantit que les deux parties sont prêtes pour l'échange et synchronisées sur les numéros de séquence.

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
response = sock.recv(4096)
print(response.decode())
sock.close()

Dans l'exemple, un socket TCP est créé avec le type SOCK_STREAM, qui effectue automatiquement la poignée de main en trois étapes lors de l'appel de connect. La méthode send transmet une requête HTTP et recv reçoit la réponse. Après la fin, close envoie un paquet FIN pour fermer correctement la connexion.

Serveur TCP avec gestion des clients

Examinons un exemple de serveur TCP en Python qui accepte plusieurs clients via des threads. Chaque connexion est traitée dans un thread séparé, permettant de servir plusieurs clients simultanément sans bloquer la boucle principale.

import socket
import threading

def handle_client(conn, addr):
    print(f'Client connecté : {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Client {addr} déconnecté')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('Serveur TCP démarré sur le port 9090')

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

Le serveur TCP traite chaque connexion dans un thread séparé, en appelant accept dans une boucle infinie. La fonction handle_client reçoit les données, les convertit en majuscules et les renvoie via sendall. Lorsque la boucle recv se termine (lorsque le client ferme la connexion), le thread se termine et le socket se ferme automatiquement. Dans les applications mobiles, ce travail de bas niveau avec les sockets n'est pas utilisé directement — les bibliothèques HTTP mobiles gèrent les connexions via des pools de threads et réutilisent automatiquement les connexions TCP.

Différences entre TCP et UDP

Le choix entre TCP et UDP est l'une des décisions clés lors de la conception de la communication réseau. TCP garantit la livraison, l'ordre et l'intégrité des données au prix d'une latence supplémentaire. UDP sacrifie la fiabilité pour une latence minimale et une charge de canal réduite.

Pour les applications mobiles, le choix du protocole dépend du scénario : les API REST et le chargement de données nécessitent TCP, tandis que les appels vidéo et les jeux en ligne bénéficient de la vitesse d'UDP. Certaines applications combinent les deux protocoles — TCP pour le contrôle et UDP pour le flux média. Le protocole moderne QUIC, qui fonctionne sur UDP et est utilisé dans HTTP/3, combine les avantages des deux approches et est déjà pris en charge sur iOS et Android via URLSession automatiquement.

Exemples de code TCP/IP

Examinons un exemple de client TCP en Python avec gestion des erreurs et délai d'attente. Cette approche est utilisée dans les applications mobiles pour une connexion fiable au serveur.

import socket
import sys

def tcp_client(host, port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(10)
        sock.connect((host, port))
        print(f'Connecté à {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Erreur de connexion : {err}')
        sys.exit(1)

sock = tcp_client('api.example.com', 443)
sock.close()

La fonction tcp_client prend un hôte et un port, crée un socket avec un délai d'attente de 10 secondes et tente de se connecter. En cas d'erreur de connexion — par exemple, serveur indisponible ou blocage par pare-feu — une exception est levée avec une description du problème. Dans les applications mobiles, le délai d'attente de connexion est critique : trop court provoque de fausses erreurs sur les réseaux lents, trop long provoque le gel de l'interface. La valeur recommandée pour les réseaux mobiles est de 10 à 15 secondes pour timeoutIntervalForRequest et de 30 à 60 secondes pour timeoutIntervalForResource dans la configuration URLSession.