Scheda di revisione: Communication réseau : sockets TCP/UDP

📋 Plan du Cours

1. Introduction générale
2. Accès réseau TCP/UDP
3. Adressage et sockets
4. Sockets UDP en C
5. Sockets UDP en Java
6. Sockets TCP en C
7. Sockets TCP en Java
8. Gestion multi-clients TCP
9. Multicast UDP/IP
10. Configuration sockets
11. Diffusion broadcast
12. Middleware et RMI

📖 1. Introduction générale

🔑 Notions clés & Définitions

• Problématique : La communication dans un système distribué nécessite des techniques pour assurer l’échange d’informations entre machines distantes, en gérant notamment l’identification, la transmission et la réception de données. (source : Léa Brunschwig, 2023)

• Concepts généraux : La communication réseau repose sur des techniques permettant l’échange de flux de données à distance, en assurant la gestion de la concurrence et de l’accès aux ressources via des protocoles et des structures spécifiques. (source : Léa Brunschwig, 2023)

• Accès réseau : Techniques permettant la communication à distance entre applications, utilisant notamment TCP ou UDP pour l’émission et la réception de flux de données. (source : Léa Brunschwig, 2023)

• Flux et concurrence : La gestion simultanée de plusieurs flux de données et la coordination des accès pour éviter les conflits ou pertes d’informations. (source : Léa Brunschwig, 2023)

• Adressage : Identification unique des machines et processus sur un réseau, utilisant une combinaison d’adresse IP et de port, notée @IP:port ou nomMachine:port. (source : Léa Brunschwig, 2023)

• Adresse IP : Identifiant numérique d’une machine sur un réseau, permettant de la localiser de façon unique. (source : Léa Brunschwig, 2023)

• Port : Numéro local associé à une application ou processus sur une machine, servant à distinguer plusieurs processus sur une même machine. (source : Léa Brunschwig, 2023)

• Sockets : Prise associée à un port, point d’accès à la couche réseau transport, permettant l’émission et la réception de données. (source : Léa Brunschwig, 2023)

• Sockets UDP en C : Structures d’en-têtes système, conversion d’adresses IP, manipulation des adresses et noms d’hôte pour la communication sans connexion, non fiable, par datagrammes. (source : Léa Brunschwig, 2023)

• Sockets TCP en C : Gestion de la connexion, création, liaison, acceptation et fermeture de socket pour une communication fiable et orientée connexion. (source : Léa Brunschwig, 2023)

📝 Points essentiels

• La communication réseau repose sur l’utilisation de sockets, qui sont des points d’accès à la couche transport, permettant l’émission et la réception de flux de données via des protocoles comme TCP ou UDP.

• L’adressage est essentiel pour identifier de façon unique chaque machine et processus : l’adresse IP localise la machine, le port identifie le processus ou l’application.

• Les sockets UDP en C utilisent des structures d’en-têtes spécifiques, avec des fonctions pour convertir les adresses IP entre formats numériques et chaînes de caractères, facilitant la manipulation des adresses et noms d’hôte.

• La gestion des sockets TCP en C implique la création, la liaison à un port précis ou libre, l’acceptation de connexions, puis la fermeture, pour assurer une communication fiable.

• La communication par UDP est non connectée, sans garantie de livraison, mais permet une émission rapide de datagrammes, tandis que TCP garantit la fiabilité via une connexion établie.

💡 À retenir

La communication réseau dans un système distribué repose sur l’utilisation de sockets, qui identifient de façon unique chaque application via une adresse IP et un port, et qui permettent d’échanger des flux de données en utilisant TCP ou UDP selon les besoins de fiabilité et de rapidité.

📖 2. Accès réseau TCP/UDP

🔑 Notions clés & Définitions

• Adressage : identification unique des machines et processus sur un réseau, notée @IP:port ou nomMachine:port.
• Adresse IP : identifiant de la machine sur laquelle tourne l’application, par exemple 192.129.12.34.
• Numéro de port : identifiant local réseau de l’application ou processus, par exemple 80 pour HTTP, ports < 1024 réservés pour des processus ou protocoles systèmes.
• Sockets : prise associée à un port, point d’accès à la couche réseau transport (TCP/UDP), permettant l’émission et la réception de données.
• Mode de connexion : choix du port par la socket, port précis ou libre (déterminé par le système).
• Socket client/serveur : rôle du processus initiant la communication (client) ou écoutant sur un port connu (serveur).
• Sockets UDP : point de communication bidirectionnel dans le contexte UDP, permettant l’émission et réception de datagrammes, sans connexion fiable.
• En-têtes système (en C) : structures pour la manipulation des adresses IP, conversion d’adresses, gestion des noms d’hôte, et structures pour la gestion des sockets.
• Conversion d’adresses IP : fonctions pour transformer entre représentation en chaîne de caractères ("X.X.X.X") et format binaire (ex : inet_ntoa, inet_aton, inet_pton).
• Gestion des sockets en C : création (socket()), liaison à un port (bind()), envoi (sendto()), réception (recvfrom()), fermeture (close()).
• Représentation des adresses : struct sockaddr_in pour IPv4, avec sin_family, sin_port, sin_addr.
• Communication UDP : envoi avec sendto() et réception avec recvfrom(), sans connexion préalable, avec possibilité de perte de paquets.
• Taille des datagrammes UDP : généralement conseillé de ne pas dépasser 8 Ko, limite pratique d’environ 512 octets pour éviter la perte ou la troncature.

📝 Points essentiels

• L’adressage identifie de façon unique chaque machine et processus via @IP:port.
• La socket est une prise associée à un port, servant de point d’accès à la couche transport (TCP ou UDP).
• En UDP, la communication est sans connexion, basée sur l’envoi et réception de datagrammes, sans garantie de fiabilité.
• La création d’une socket en C se fait avec socket(), en précisant le domaine (AF_INET), le type (SOCK_DGRAM pour UDP), et le protocole (0 par défaut).
• La liaison d’une socket à un port spécifique est réalisée avec bind(), en utilisant une structure sockaddr_in.
• La conversion d’adresses IP entre chaîne ("X.X.X.X") et format binaire est assurée par inet_ntoa() et inet_aton() ou inet_pton().
• La communication UDP en C utilise sendto() pour l’émission et recvfrom() pour la réception, en précisant l’adresse du destinataire ou de l’émetteur.
• La taille maximale pratique d’un datagramme UDP est d’environ 8 Ko pour éviter la perte ou la troncature.
• La gestion des erreurs lors de la création, liaison, envoi ou réception se fait via errno ou perror().

💡 À retenir

L’accès réseau TCP/UDP repose sur l’utilisation de sockets, qui identifient de manière unique chaque processus via une combinaison d’adresse IP et de port, permettant une communication sans connexion (UDP) ou connectée (TCP), avec des mécanismes spécifiques pour la création, la liaison, l’envoi et la réception de données.

📖 3. Adressage et sockets

🔑 Notions clés & Définitions

• Adressage : identification unique des machines et processus sur un réseau, notée @IP:port ou nomMachine:port.
• Adresse IP : identifiant de la machine sur laquelle tourne l’application, par exemple 192.129.12.34.
• Numéro de port : identifiant local réseau de l’application ou processus, par exemple 80 pour HTTP, ports < 1024 réservés pour des processus système.
• Sockets : prise associée localement à un port, point d’accès à la couche réseau transport (TCP/UDP), permettant l’émission et la réception de données via ce port.
• Socket UDP en C : structures d’en-têtes système, conversion d’adresses IP, manipulation des adresses et noms d’hôte.
• Structures d’en-têtes système en C :
  • <netinet/in.h> : structures pour manipulation des adresses IP (ex : struct in_addr)
  • <arpa/inet.h> : fonctions de conversion entre adresses réseau et chaînes de caractères (inet_ntoa, inet_aton, inet_pton)
  • <netdb.h> : gestion des identifiants de machines (ex : gethostbyname, gethostbyaddr)
  • <unistd.h> : accès aux identifiants locaux d’une machine (gethostname, gethostid)
  • <sys/socket.h> : création, gestion, liaison, fermeture des sockets, structures (sockaddr_in)

📝 Points essentiels

• Adressage :
  • Identifie de manière unique une machine et un processus via @IP:port ou nomMachine:port.
  • Adresse IP : identifiant de la machine, par exemple 192.129.12.34.
  • Numéro de port : identifiant local, ports < 1024 réservés pour processus système, ex : 80, 21.
• Sockets :
  • Prise associée à un port, point d’accès à la couche réseau transport.
  • Permet la communication entre deux applications distantes, avec un socket à chaque extrémité.
  • Mode de connexion :
    • Port précis choisi par le programme.
    • Mode connecté (TCP) : socket liée à un port déterminé, gestion de connexion.
    • Mode non connecté (UDP) : envoi de datagrammes sans établissement de connexion.
• Sockets UDP en C :
  • Structures d’en-têtes système (<netinet/in.h>) : struct sockaddr_in avec sin_family, sin_port, sin_addr.
  • Conversion d’adresses IP :
    • inet_ntoa : adresse en chaîne "X.X.X.X".
    • inet_aton / inet_pton : chaîne en adresse réseau.
  • Manipulation des adresses et noms d’hôte :
    • gethostbyname : recherche d’une machine par nom.
    • gethostbyaddr : recherche d’une machine par adresse IP.
    • gethostname : nom de la machine locale.
    • gethostid : adresse IP locale sous forme d’entier.
• Création et gestion des sockets UDP en C :
  • socket() : création d’une socket (ex : AF_INET, SOCK_DGRAM).
  • bind() : liaison à un port spécifique.
  • sendto() / recvfrom() : émission et réception de datagrammes.
  • Conversion des nombres entre mode réseau et mode local : htons, htonl, ntohs, ntohl.
  • Fermeture : close().

💡 À retenir

L’adressage et les sockets permettent d’identifier de façon unique machines et processus sur un réseau, et d’établir une communication efficace via des structures et fonctions spécifiques, notamment en UDP avec manipulation précise des adresses IP, ports, et structures d’en-têtes système en C.

📖 4. Sockets UDP en C

🔑 Notions clés & Définitions

• Socket UDP : Point de communication bidirectionnel dans le contexte du protocole UDP, permettant l’émission et la réception de datagrammes sans connexion (Brunschwig, 2023). Il ne garantit pas la fiabilité ou l’ordre des paquets.

• En-têtes système : Structures de données utilisées pour manipuler les adresses IP, notamment <netinet/in.h>, <arpa/inet.h>, <netdb.h>, <unistd.h>, <sys/socket.h>. Ces structures facilitent la gestion des adresses IP, noms d’hôte, et la conversion entre formats.

• Conversion d’adresses IP : Processus de traduction entre une adresse IP sous forme binaire et une chaîne de caractères. Fonctions principales :

  • inet_ntoa(struct in_addr) : Adresse IP en chaîne "X.X.X.X" (Brunschwig, 2023).
  • inet_aton(const char *, struct in_addr *) : Chaîne "X.X.X.X" en adresse IP.
  • inet_pton() : Supporte IPv4 et IPv6, convertit en format binaire.

• Manipulation des adresses et noms d’hôte :

  • gethostbyname() : Recherche des informations d’une machine à partir de son nom, retourne un hostent *.
  • gethostbyaddr() : Recherche des informations d’une machine à partir de son adresse IP, retourne un hostent *.
  • gethostname() : Récupère le nom de la machine locale.
  • gethostid() : Retourne l’adresse IP de la machine locale sous forme d’un entier.

• Structures d’adresses :

  • struct sockaddr_in : Spécifique à IPv4, contient sin_family, sin_port, sin_addr.
  • struct sockaddr : Structure générique pour toutes les familles d’adresses.

• Création d’une socket UDP :

  • socket(AF_INET, SOCK_DGRAM, 0) : Retourne un descripteur de socket UDP.
  • En cas d’erreur, retourne -1.

• Liaison d’une socket :

  • bind() : Associe une socket à une adresse locale et un port spécifique.
  • Erreur EADDRINUSE si le port est déjà utilisé, EACCES si liaison non autorisée.

• Conversion des nombres :

  • htons(), htonl() : Convertissent respectivement les entiers courts et longs du format local au format réseau.
  • ntohs(), ntohl() : Convertissent du format réseau au format local.

• Envoi de données :

  • sendto() : Envoie un datagramme à une adresse spécifique, en précisant le contenu et la destination.

• Réception de données :

  • recvfrom() : Reçoit un datagramme, fournit le contenu, l’adresse de l’expéditeur, et la longueur.
  • Mode bloquant par défaut, peut être configuré avec setSoTimeout().

• Taille des datagrammes :

  • Limite pratique : 8 Ko, mais la taille maximale IP est 65 467 octets.
  • En pratique, il est conseillé de ne pas dépasser 512 octets pour éviter la perte de données.

• Fermeture d’une socket :

  • close() : Libère le port et ferme la socket.

📝 Points essentiels

• La communication UDP est sans connexion, non fiable, et ne garantit pas l’ordre ni la livraison des paquets.
• La création d’une socket UDP se fait via socket(AF_INET, SOCK_DGRAM, 0).
• La liaison d’une socket à un port spécifique utilise bind(), avec gestion des erreurs EADDRINUSE et EACCES.
• La conversion des adresses IP entre formats binaire et chaîne est essentielle pour l’interopérabilité, utilisant inet_ntoa(), inet_aton(), ou inet_pton().
• La gestion des adresses IP et noms d’hôte est facilitée par gethostbyname() et gethostbyaddr().
• La transmission de données s’effectue avec sendto(), et la réception avec recvfrom(), en mode bloquant ou avec timeout.
• La taille des datagrammes UDP doit être adaptée pour éviter la tronquation ou la perte de données.

💡 À retenir

Les sockets UDP en C permettent une communication simple et rapide, mais sans garantie de fiabilité, en utilisant des structures et fonctions spécifiques pour manipuler adresses, ports, et datagrammes, avec une gestion attentive de la taille des paquets.

📖 5. Sockets UDP en Java

🔑 Notions clés & Définitions

• Sockets UDP (DatagramSocket) : Classe permettant d’envoyer et de recevoir des paquets de données (datagrammes) sans connexion préalable, mode non connecté (Brunschwig, 2023).
• DatagramPacket : Structure de données utilisée pour représenter un paquet UDP, contenant les données, l’adresse IP de destination ou d’origine, et le port associé (Brunschwig, 2023).
• InetAddress : Classe pour le codage des adresses IP, permettant de créer des objets représentant une machine via son nom ou son adresse IP (Brunschwig, 2023).
• Méthodes de DatagramPacket :
  • Constructeurs :
    • DatagramPacket(byte[] buf, int length) : paquet pour réception, buf stocke les données reçues.
    • DatagramPacket(byte[] buf, int length, InetAddress address, int port) : paquet pour envoi, buf contient les données, address et port précisent la destination.
  • Getters :
    • getAddress() : adresse IP de l’expéditeur ou destinataire.
    • getPort() : port de l’expéditeur ou destinataire.
    • getData() : tableau d’octets contenant les données.
    • getLength() : longueur des données dans le paquet.
  • Setters :
    • setAddress(InetAddress adr) : définit l’adresse IP du destinataire.
    • setPort(int port) : définit le port du destinataire.
    • setData(byte[] data) : définit les données à envoyer.
    • setLength(int length) : définit la longueur des données à envoyer.
• Méthodes de DatagramSocket :
  • send(DatagramPacket p) : envoi d’un paquet vers la destination précisée dans p.
  • receive(DatagramPacket p) : réception bloquante d’un paquet, stocke dans p les données, l’adresse et le port de l’expéditeur.
  • close() : ferme la socket UDP.
  • setSoTimeout(int timeout) : limite le délai d’attente pour la réception, en millisecondes (Brunschwig, 2023).
  • getLocalPort() : retourne le port local sur lequel la socket est liée (Brunschwig, 2023).

📝 Points essentiels

• Communication non connectée : pas d’établissement préalable de connexion entre client et serveur, envoi et réception de datagrammes indépendants (Brunschwig, 2023).
• Création d’un socket UDP : DatagramSocket socket = new DatagramSocket() ou new DatagramSocket(port) pour lier la socket à un port spécifique (Brunschwig, 2023).
• Envoi de données :
  • Créer un DatagramPacket avec les données, l’adresse IP et le port du destinataire.
  • Utiliser send() pour transmettre le paquet.
• Réception de données :
  • Préparer un DatagramPacket avec un buffer de réception.
  • Appeler receive() qui bloque jusqu’à réception d’un paquet ou jusqu’à expiration du timeout (Brunschwig, 2023).
• Gestion des adresses IP : utilisation de InetAddress.getByName() pour obtenir l’objet IP à partir d’un nom ou d’une chaîne d’adresse.
• Taille des datagrammes : généralement conseillé de ne pas dépasser 8 Ko pour éviter la perte ou la tronquation des données, même si UDP supporte jusqu’à 65 467 octets (Brunschwig, 2023).
• Réception bloquante avec limite : setSoTimeout() permet de limiter le temps d’attente pour la réception d’un datagramme (Brunschwig, 2023).

💡 À retenir

Les sockets UDP en Java permettent d’envoyer et de recevoir des datagrammes sans connexion, en utilisant la classe DatagramSocket et la structure DatagramPacket, avec une gestion simple des adresses IP via InetAddress. La taille des datagrammes doit être adaptée pour éviter la perte de données.

📖 6. Sockets TCP en C

🔑 Notions clés & Définitions

Gestion de la connexion (voir <sys/socket.h>) : Processus d'établissement, de maintien et de terminaison d'une communication TCP entre deux applications via des sockets. Elle inclut la création, la liaison, l'acceptation et la fermeture de socket.

Création de socket (voir <sys/socket.h>) : Fonction socket() qui retourne un descripteur de socket, en spécifiant le domaine (AF_INET), le type (SOCK_STREAM) et le protocole (0 par défaut). Elle initialise le point d’accès à la couche transport.

Liaison (bind) (voir <sys/socket.h>) : Fonction bind() qui associe une socket à une adresse IP et un port précis. Elle peut échouer si le port est déjà utilisé ou si la liaison n’est pas autorisée (ex : ports < 1024).

Acceptation (accept) (voir <sys/socket.h>) : Fonction accept() qui, dans un serveur, attend une connexion entrante et crée une nouvelle socket dédiée à cette connexion. La socket d’origine reste à l’écoute pour d’autres connexions.

Fermeture de socket (close) (voir <sys/socket.h>) : Fonction close() qui termine la communication en fermant la socket et libère le descripteur.

Gestion multi-clients TCP (voir <sys/socket.h>) : Modèle de serveur capable de gérer plusieurs connexions simultanées. Cela peut se faire par multithreading, multiplexage avec select(), poll(), ou epoll().

Modèles de serveur (voir <sys/socket.h>) : Structures permettant de gérer plusieurs connexions TCP en parallèle, notamment le modèle itératif (un client à la fois) ou le modèle concurrent (plusieurs clients simultanément).

📝 Points essentiels

• La création d’une socket TCP se fait via socket(AF_INET, SOCK_STREAM, 0).
• La liaison (bind) doit être effectuée avant d’écouter ou d’accepter des connexions.
• Le mode serveur utilise listen() pour indiquer qu’il attend des connexions entrantes.
• La fonction accept() bloque jusqu’à ce qu’un client se connecte, créant une nouvelle socket pour cette connexion.
• La fermeture d’une socket se réalise avec close(), libérant le port et le descripteur.
• La gestion multi-clients peut se faire en utilisant des mécanismes de multiplexage ou en créant un thread par client.
• La communication se fait via read() et write() ou recv() et send() sur la socket dédiée.

💡 À retenir

La gestion des sockets TCP en C implique leur création, liaison, écoute, acceptation et fermeture, avec la possibilité de gérer plusieurs connexions simultanées grâce à des modèles de serveur adaptés.

📖 7. Sockets TCP en Java

🔑 Notions clés & Définitions

• Gestion multi-clients TCP : gestion de plusieurs connexions simultanées, permettant à un serveur de traiter plusieurs clients en même temps, souvent via des modèles de serveur (par exemple, modèle multithread). (source : Léa Brunschwig)

• Multicast UDP/IP : envoi de paquets à plusieurs destinataires en même temps, en utilisant des groupes multicast. La gestion des groupes multicast permet d’envoyer des données à un ensemble de machines membres d’un groupe spécifique. (source : Léa Brunschwig)

📝 Points essentiels

• Sockets TCP en Java : utilisent la classe Socket pour le client et ServerSocket pour le serveur, permettant une communication fiable et orientée connexion. La gestion de plusieurs clients nécessite souvent la création de threads pour chaque connexion, afin de gérer plusieurs sockets simultanément.

• Gestion multi-clients : implique la création de plusieurs sockets ou l’utilisation de threads pour traiter plusieurs connexions TCP en parallèle, assurant la disponibilité et la réactivité du serveur face à plusieurs demandes.

• Multicast UDP/IP : en Java, la classe MulticastSocket permet de rejoindre un groupe multicast (joinGroup) et d’envoyer ou recevoir des paquets à destination de plusieurs hôtes simultanément. La gestion des groupes multicast est essentielle pour la diffusion efficace de données à plusieurs destinataires.

💡 À retenir

La gestion multi-clients TCP en Java repose sur la création de plusieurs sockets ou threads pour traiter simultanément plusieurs connexions, tandis que le multicast UDP/IP permet d’envoyer des paquets à plusieurs destinataires en utilisant des groupes multicast, facilitant la diffusion de données à grande échelle.

📖 8. Gestion multi-clients TCP

🔑 Notions clés & Définitions

• Sockets : prises associées à un port, point d’accès à la couche réseau transport permettant l’émission et la réception de données (voir section 10).
• Mode de connexion (TCP) : mode connecté où chaque socket est liée à un port spécifique, permettant une communication fiable entre deux applications distantes (voir section 10).
• Serveur : entité qui possède une socket liée à un port d’écoute, prête à accepter des connexions entrantes (voir section 10).
• Client : entité qui initie une connexion ou communication en créant une socket et en se connectant à un serveur (voir section 10).
• Gestion multi-clients : capacité du serveur à gérer plusieurs connexions TCP simultanément, souvent via des modèles de gestion (voir source).

📝 Points essentiels

• La gestion multi-clients TCP repose sur la création d’une socket pour chaque connexion, ou sur des mécanismes permettant de gérer plusieurs connexions en parallèle.
• La création d’une socket TCP se fait avec la fonction socket() (voir section 10).
• La liaison à un port spécifique est réalisée avec bind() (voir section 10).
• La gestion de plusieurs connexions simultanées peut utiliser différents modèles de serveur, permettant d’accueillir et traiter plusieurs clients en même temps.
• La fermeture d’une socket est effectuée avec close() (voir section 10).
• La gestion efficace des connexions nécessite souvent des mécanismes de multiplexage ou de multithreading pour traiter plusieurs clients en parallèle.

💡 À retenir

La gestion multi-clients TCP consiste à permettre à un serveur de maintenir plusieurs connexions fiables simultanées, en utilisant des sockets dédiés ou des mécanismes de gestion avancés, pour assurer une communication efficace avec plusieurs clients.

📖 9. Multicast UDP/IP

🔑 Notions clés & Définitions

• Diffusion broadcast : envoi de paquets à tous les hôtes du réseau, permettant la communication simultanée avec tous les destinataires présents sur le réseau local ou étendu (voir section 11).
• Mécanismes de diffusion : techniques permettant la transmission de données à plusieurs hôtes via des protocoles comme UDP en mode broadcast ou multicast, sans établir de connexions préalables.
• Middleware et RMI : programmation à distance, invocation de méthodes distantes, abstraction de la communication (voir section 12).

📝 Points essentiels

• La communication multicast UDP/IP permet d’envoyer un seul paquet à un groupe spécifique d’hôtes via une adresse multicast.
• La taille maximale d’un datagramme UDP/IP recommandée est généralement inférieure à 8 Ko pour éviter la fragmentation ou la perte de données.
• La transmission multicast ne garantit pas la livraison, la perte de paquets est possible, contrairement à une communication fiable.
• La structure des données en mode datagramme UDP en Java utilise la classe DatagramPacket, qui peut contenir l’adresse IP et le port du destinataire ou de l’expéditeur.
• La classe DatagramSocket permet d’envoyer et de recevoir des paquets UDP, avec des méthodes comme send() et receive().
• La gestion des adresses IP en mode multicast utilise des adresses spécifiques (ex : 224.0.0.0 à 239.255.255.255).
• La conversion des adresses IP se fait via des fonctions comme inet_ntoa(), inet_aton(), ou inet_pton() (voir <arpa/inet.h>).
• La taille des données envoyées ou reçues doit être adaptée pour éviter la troncature ou la perte d’informations.
• La méthode setSoTimeout() permet de limiter le temps d’attente lors de la réception d’un paquet, évitant ainsi un blocage indéfini.

💡 À retenir

La communication multicast UDP/IP permet d’envoyer efficacement un même message à plusieurs hôtes, mais sans garantie de livraison, ce qui nécessite une gestion spécifique selon les besoins de fiabilité.

📖 10. Configuration sockets

🔑 Notions clés & Définitions

• Gestion de socket : Opération permettant de configurer, ouvrir, lier, et fermer une socket pour la communication réseau (voir <sys/socket.h>).
• bind() : Fonction qui associe une socket à une adresse locale spécifique (adresse IP et port). Retourne -1 en cas d’échec, notamment si le port est déjà utilisé ou si la liaison n’est pas autorisée (ex : ports < 1024).
• getsockname() : Fonction qui récupère l’adresse locale associée à une socket, en renseignant une structure sockaddr et sa taille.
• Création d’une socket : Utilisation de socket() avec paramètres domaine (AF_INET pour IP), type (SOCK_DGRAM pour UDP, SOCK_STREAM pour TCP), et protocole (souvent 0 pour protocole par défaut). Retourne un descripteur ou -1 en cas d’erreur.
• Fermeture d’une socket : Utilisation de close() pour libérer la socket et le port associé.
• Conversion d’adresses : Fonctions telles que htons(), htonl(), ntohs(), ntohl() pour convertir entre mode réseau et mode local, évitant ainsi les erreurs d’interprétation des nombres.
• Structure sockaddr_in : Structure spécifique pour IPv4, contenant sin_family (AF_INET), sin_port (port en mode réseau), et sin_addr (adresse IP en mode réseau).
• bind() : Fonction qui lie une socket à une adresse locale spécifique, en utilisant une structure sockaddr_in et sa taille. Retourne -1 si erreur, notamment si le port est déjà occupé ou si liaison non autorisée.
• setSoTimeout() : Fonction permettant de définir un délai d’attente pour la réception de données sur une socket, évitant une attente indéfinie.
• getLocalPort() : Fonction qui retourne le port local sur lequel la socket est liée.

📝 Points essentiels

• La configuration d’une socket inclut sa création via socket(), sa liaison à une adresse locale avec bind(), et éventuellement sa fermeture avec close().
• La fonction bind() doit être appelée pour associer explicitement une socket à un port précis, sauf si le système le fait automatiquement lors du premier envoi.
• Lors de la liaison, il est crucial de vérifier les erreurs, notamment EADDRINUSE (port occupé) ou EACCES (liaison non autorisée, ports < 1024).
• La structure sockaddr_in doit être initialisée avec sin_family = AF_INET, sin_port en mode réseau (htons()), et sin_addr (souvent INADDR_ANY pour lier toutes les interfaces).
• La conversion des nombres (ports, adresses) en mode réseau est essentielle pour assurer la compatibilité inter-plateformes.
• La méthode setSoTimeout() permet de limiter le temps d’attente lors de la réception de données, évitant ainsi un blocage infini.
• La récupération de l’adresse locale d’une socket liée est possible avec getsockname().

💡 À retenir

La configuration des sockets repose sur leur création, leur liaison à une adresse locale spécifique, et leur gestion via des fonctions standard pour assurer une communication fiable et contrôlée. La liaison explicite à un port est essentielle pour recevoir des données, et la gestion des erreurs doit être systématique pour garantir la stabilité des applications réseau.

📖 11. Diffusion broadcast

🔑 Notions clés & Définitions

Diffusion broadcast : Technique de communication permettant d’envoyer un message à tous les hôtes d’un réseau local ou étendu, sans distinction de destinataires spécifiques. Elle utilise un mode de transmission où un seul paquet est adressé à tous les récepteurs du groupe ou du réseau.

Mécanisme de diffusion : Processus consistant à transmettre un paquet de données à l’ensemble des hôtes d’un réseau, généralement en utilisant une adresse spéciale (ex : adresse de broadcast IP).

Broadcast IP : Adresse IP spécifique utilisée pour la diffusion, permettant d’envoyer un message à tous les hôtes d’un sous-réseau ou d’un réseau entier.

Multicast : Mode de communication où un message est envoyé à un groupe spécifique d’hôtes, différent de la diffusion générale (broadcast). (voir section 9)

Diffusion locale (broadcast local) : Diffusion limitée au réseau local, utilisant une adresse de broadcast spécifique à ce réseau.

Diffusion globale (broadcast étendu) : Diffusion à tous les hôtes d’un réseau étendu ou Internet, moins courante en pratique.

📝 Points essentiels

• La diffusion broadcast permet d’envoyer un même message à tous les hôtes d’un réseau sans établir de connexions individuelles.
• Elle est souvent utilisée pour la découverte de services, la configuration automatique ou la mise à jour de réseaux locaux.
• La taille maximale d’un datagramme UDP dans une diffusion est généralement limitée à 8 Ko pour éviter la perte de données, même si la limite théorique est de 65 467 octets.
• La taille des paquets UDP doit être adaptée pour éviter la fragmentation ou la perte de données, notamment en pratique, il est conseillé de ne pas dépasser 512 octets.
• La diffusion peut être locale ou étendue, selon l’adresse IP de broadcast utilisée.
• La réception de paquets broadcast est bloquante par défaut, mais peut être configurée avec un délai limite via la méthode setSoTimeout().

💡 À retenir

La diffusion broadcast permet d’envoyer efficacement un message à tous les hôtes d’un réseau, mais doit être utilisée avec précaution pour éviter la surcharge du réseau ou la perte de données, notamment en limitant la taille des paquets UDP.

📖 12. Middleware et RMI

🔑 Notions clés & Définitions

• Adressage : identification unique des machines et processus sur un réseau, permettant de localiser et d’adresser précisément chaque machine ou application.
• Adresse IP : identifiant de la machine sur le réseau, représenté par une valeur numérique (ex. 192.168.12.34).
• Port : numéro d’identification local d’un processus ou d’une application sur une machine, utilisé dans la couche transport (TCP/UDP).
• Sockets : prise associée à un port, point d’accès à la couche réseau transport, permettant l’émission et la réception de données.
• Sockets UDP en C : structures d’en-têtes système (ex. <netinet/in.h>, <arpa/inet.h>, <netdb.h>, <unistd.h>, <sys/socket.h>) permettant la manipulation des adresses IP, la conversion d’adresses et la gestion des noms d’hôte.
• Structures d’en-têtes système : structures telles que sockaddr_in, hostent, in_addr qui organisent les informations d’adressage pour la communication réseau.
• Conversion d’adresses IP : opérations permettant de passer d’une représentation numérique à une chaîne de caractères (ex. inet_ntoa) ou inversement (inet_aton, inet_pton) pour assurer la compatibilité entre formats local et réseau.
• Manipulation des adresses et noms d’hôte : fonctions permettant de résoudre un nom d’hôte en adresse IP (gethostbyname), ou une adresse IP en nom d’hôte (gethostbyaddr), facilitant l’identification des machines distantes.

📝 Points essentiels

• L’adressage identifie de manière unique chaque machine et processus sur un réseau via une combinaison d’adresse IP et de port.
• La structure sockaddr_in est utilisée pour représenter une adresse IP et un port dans le contexte IP.
• La conversion d’adresses IP entre formats numérique et chaîne est essentielle pour la manipulation et la résolution d’adresses dans les programmes réseau.
• La gestion des noms d’hôte et des adresses IP se fait à l’aide des fonctions gethostbyname, gethostbyaddr, et des structures hostent.
• En C, les en-têtes <netinet/in.h>, <arpa/inet.h>, <netdb.h>, <unistd.h>, <sys/socket.h> fournissent les structures et fonctions pour manipuler ces concepts.
• La liaison d’une socket à un port spécifique se fait via la fonction bind, et la conversion d’adresses est souvent nécessaire pour la communication.

💡 À retenir

L’adressage réseau repose sur l’association d’une adresse IP et d’un port pour identifier de façon unique chaque machine et processus, avec des outils en C permettant la manipulation précise de ces informations pour la communication.

📊 Tableaux de Synthèse

Critère	UDP	TCP	Auteur / Référence
Nature	Sans connexion, datagrammes	Connexion orientée, flux fiable	Léa Brunschwig, 2023
Fiabilité	Non fiable (perte possible)	Fiable (garantit livraison)	Léa Brunschwig, 2023
Mode de communication	Envoi de datagrammes (sendto/recvfrom)	Établissement de connexion (socket, accept)	Léa Brunschwig, 2023
Taille maximale des datagrammes	Environ 8 Ko, pratique 512 octets	N/A	Léa Brunschwig, 2023
Création de socket	socket(AF_INET, SOCK_DGRAM, 0)	socket(AF_INET, SOCK_STREAM, 0)	Léa Brunschwig, 2023
Liaison à un port	bind() (optionnel pour serveur)	bind() (pour serveur)	Léa Brunschwig, 2023
Envoi	sendto()	send() / write()	Léa Brunschwig, 2023
Réception	recvfrom()	recv() / read()	Léa Brunschwig, 2023

Critère	Socket UDP en C	Socket TCP en C	Auteur / Référence
Structures d’en-tête	struct sockaddr_in, inet_ntoa(), inet_aton()	struct sockaddr_in, accept(), listen()	Léa Brunschwig, 2023
Conversion d’adresses	inet_pton(), inet_ntoa()	Même que UDP, gestion via sockaddr_in	Léa Brunschwig, 2023
Fonctionnalités principales	Envoi/réception datagrammes, non connecté	Connexion, fiabilité, flux continu	Léa Brunschwig, 2023

⚠️ Pièges & Confusions Fréquentes

1. Confondre sockets UDP et TCP : UDP est sans connexion, TCP est orienté connexion.
2. Oublier la liaison (bind()) pour un socket UDP serveur, ce qui empêche la réception.
3. Utiliser send() et recv() pour UDP au lieu de sendto() et recvfrom() : erreur fréquente.
4. Dépasser la taille recommandée de 8 Ko pour un datagramme UDP, entraînant des pertes.
5. Ne pas gérer les erreurs lors de la création, liaison ou envoi de sockets, ce qui peut provoquer des crashs.
6. Confondre l’ordre des paramètres dans les fonctions d’envoi/réception (ex : sendto()).
7. Oublier de convertir l’adresse IP en format binaire avec inet_pton() ou inet_aton().

✅ Checklist Examen

1. Connaître la définition de Léa Brunschwig sur la communication dans un système distribué.
2. Expliquer la différence entre sockets TCP et UDP, en insistant sur la fiabilité et la connexion.
3. Savoir comment créer, lier, accepter et fermer une socket TCP en C et en Java.
4. Savoir comment créer, lier, envoyer et recevoir avec une socket UDP en C et en Java.
5. Maîtriser la structure sockaddr_in et la conversion d’adresses IP (inet_pton, inet_ntoa).
6. Connaître la gestion des ports, notamment ports réservés (<1024).
7. Comprendre le rôle de l’adressage IP et port dans l’identification des processus.
8. Savoir utiliser les fonctions sendto() et recvfrom() pour UDP.
9. Identifier les risques liés à la taille des datagrammes UDP.
10. Connaître la gestion des erreurs lors de la création ou l’utilisation des sockets.
11. Expliquer le fonctionnement de la gestion multi-clients TCP (acceptation, boucle).
12. Maîtriser la configuration des sockets pour la diffusion broadcast et multicast UDP/IP.
13. Connaître les principes du middleware RMI en lien avec la communication réseau.
14. Savoir comment configurer une socket pour la diffusion broadcast.
15. Identifier les principaux auteurs et références : Léa Brunschwig, 2023.