|
|
|
|
6) Le protocole UDP
6-1) Définition
Bien que TCP/IP soit une association ancrée dans les esprits, elle n’est
pas la seule possible. Aussi existe-t-il des
protocoles comme UDP qui peuvent se révéler parfois bien plus
efficaces que TCP.
UDP est un protocole sans connexion permettant l'échange de paquets avec
vérification de l'intégrité des
données. UDP est utilisé lorsque les protocoles de niveaux supérieurs
ne nécessitent pas l'établissement de circuit
qui ralentit et charge le réseau.
Le protocole UDP travaille sur un réseau sans effectuer de connexion
en vue d'établir un circuit virtuel. Son rôle,
en tant que niveau transport, se limite à multiplexer les données
provenant des différentes applications. En plus
UDP effectue un contrôle d'erreurs sur les données transposées.
Chaque application possède un numéro de port et chaque datagramme
émis possède en en-tête le numéro du port
destinataire.
Les principes de base du protocole UDP sont :
_Transport en mode non connecté
_Mécanisme simple d'échange de données entre applications
_Pas de remise en ordre garantie
_Pas de remise garantie
_S'il y a remise, alors elle est correcte
_Orienté vers un échange transactionnel
_Récupération des erreurs reportées aux niveaux supérieurs
_Un seul type de message
Ses caractéristique font de UDP un protocole peu sûr, mais convient
pour des applications dont l’ordre d’arrivée
des paquets n’est pas important.
6-2) Les datagrammes UDP
Pour utiliser le protocole de transport UDP, il est nécessaire en Java
de manipuler deux classes
DatagramPacket et DatagramSocket.
6-2-1) La classe DatagramPacket
Cette classe permet de créer des objets qui contiendront les données
envoyées ou reçues ainsi que l'adresse de
destination ou de provenance du datagramme. Deux constructeurs sont disponibles,
un pour les paquets à
recevoir l'autre pour les paquets à envoyer.
public DatagramPacket(byte buffer[], int taille)
Construit un objet pour recevoir un datagramme. Le paramètre buffer correspond
à la zone où doit être stocké le
datagramme reçu et le paramètre taille correspond à la
taille maximale des datagrammes à recevoir.
public DatagramPacket(byte buffer[], int taille, InetAddress
adresse, int
port)
Construit un objet pour envoyer un datagramme. Le paramètre buffer correspond
à la zone où est stocké le
datagramme à envoyer, le paramètre taille correspond à
la taille du datagramme à envoyer, adresse correspond à
l'adresse de la machine à qui envoyer le datagramme et port sur quel
port UDP.
Des méthodes sont disponibles pour manipuler de tels objets :
_public synchronized InetAddress getAddress () :
retourne l'adresse stockée dans le paquet.
_public synchronized int getPort () :
retourne le port stocké dans le paquet.
_public synchronized byte[] getData () :
retourne les données stockées dans le paquet.
_public synchronized int getLength () :
retourne la taille des données stockées dans le paquet.
_public synchronized void setAddress(InetAddress iaddr) :
modifie ou affecte l'adresse de destination.
_public synchronized void setPort(int iport) :
modifie ou affecte le port de destination.
_public synchronized void setData(byte ibuf[]) :
modifie ou affecte la référence de la zone contenant les données.
_public synchronized void setLength(int ilength) :
modifie ou affecte la taille de la zone contenant les données.
6-2-2) La classe DatagramSocket
Cette classe permet de créer des sockets UDP qui permettent d'envoyer
et de recevoir des datagrammes UDP.
Avant toute communication en mode UDP il est nécessaire de créer
une socket aussi bien du coté client que du
coté serveur. Pour cela Java propose trois constructeurs :
public DatagramSocket () throws SocketException
Crée un objet de type socket et l'attache à un port disponible
de la machine locale. Ce constructeur doit être
utilisé dans les clients pour lesquels le port d'attachement n'a pas
besoin d'être connu.
public DatagramSocket (int port) throws SocketException
Crée un objet de type socket et l'attache au port UDP local passé
en paramètre. En particulier, ce constructeur
doit être utilisé dans les serveurs pour lesquels le port d'attachement
a besoin d'être fixé préalablement afin qu'il
soit connu des clients.
public DatagramSocket(int port, InetAddress laddr) throws SocketException
Crée un objet de type socket, l'attache au port UDP local passé
en paramètre et à une adresse spécifique de la
machine locale. Ce constructeur n'est utile que si la machine locale dispose
de plusieurs adresses Internet.
Une fois la socket (objet de type DatagramSocket) créée et attachée
à un port particulier de la machine
locale il est possible d'envoyer et de recevoir des datagrammes, via cette socket,
au moyen des méthodes
suivantes :
public void send(DatagramPacket data) throws IOException
Permet d'envoyer les données contenues dans la variable data vers la
machine et le port dont les valeurs ont été
préalablement spécifiées dans la variable data.
public synchronized void receive(DatagramPacket data) throws IOException
Permet de recevoir un datagramme qui sera stocké dans data. Après
appel, data contient les données reçues, leur
taille, l'adresse de l'envoyeur ainsi que son port d'attachement. Cette méthode
est bloquante tant qu'il n'y a rien à
recevoir. Si le message est trop long pour être stocké, celui-ci
est tronqué, et le reste est perdu. Il n'est donc pas
possible de recevoir des messages dont on ne connaît pas préalablement
la taille.
Il est possible de spécifier un délai d'attente maximal en réception.
Pour cela, il faut positionner une variable de
timeout sur la socket au moyen de la méthode :
public synchronized void setSoTimeout(int timeout) throws SocketException
Une valeur de 0 (zéro) correspond à ne pas avoir de timeout. D'autres
méthodes sont disponibles pour manipuler
ces sockets.
Ferme la socket et libère les ressources qui lui sont associées.
La socket ne pourra plus être utilisée ni pour
envoyer, ni pour recevoir des datagrammes.
public void close ()
Retourne le port d'attachement de la socket.
public int getLocalPort ()
Retourne la valeur courante du timeout associé à la socket.
public synchronized int getSoTimeout() throws SocketException
Exemple :
Dans cet exemple nous créons deux classes :
une classe ServeurEcho qui attend une chaîne de caractères et la
retourne et une classe ClientEcho qui
envoie une chaîne de caractères, attend que le serveur la lui retourne
et l'affiche.
import java.io.*;
import java.net.*;
class ServeurEcho
{
final static int port = 8532;
final static int taille = 1024;
final static byte buffer[] = new byte[taille];
public static void main(String argv[]) throws Exception
{
DatagramSocket socket = new DatagramSocket(port);
while(true)
{
DatagramPacket data = new DatagramPacket(buffer,buffer.length);
socket.receive(data);
System.out.println(data.getAddress());
socket.send(data);
}
}
}
class ClientEcho
{
final static int taille = 1024;
final static byte buffer[] = new byte[taille];
public static void main(String argv[]) throws Exception
{
InetAddress serveur = InetAddress.getByName(argv[1]);
int length = argv[2].length();
byte buffer[] = new byte[length];
argv[2].getBytes(0,length,buffer,0);
DatagramPacket data = new
DatagramPacket(buffer,length,serveur,ServeurEcho.port);
DatagramSocket socket = new DatagramSocket();
socket.send(data);
socket.receive(data);
System.out.write(buffer);
}
}
 |
|
|
|
© 2001 IsepFAQtory Tous droits réservés
|