|
|
Entête UDP
par _SebF
1 -
Définition du
protocole
2 -
Structure de l'entête
3 -
Définition des différents
champs
3.1 -
Port source
3.2 - Port destination
3.3 -
Longueur
3.4 -
Checksum
4 - Discussion autour de la
documentation
5 -
Suivi du document
Le protocole UDP est basé
en couche 4. Il
n'ouvre pas de session et n'effectue pas de control d'erreur. Il est alors
appelé "mode non connecté". Il est donc peut fiable, cependant, il permet
aux applications d'accéder directement à un service de transmission de Datagrammes
rapide.
UDP est utilisé pour transmettre de faibles quantités de données où le coût de
la création de connexions et du maintient de transmissions fiables s'avèrent
supérieur aux données à émettre. UDP peut également être utilisé pour les
applications satisfaisant à un modèle de type "interrogation réponse". La
réponse étant utilisée comme un accusé de réception à l'interrogation. On y
trouve classiquement Snmp et Dns. UDP est aussi utilisé dans un second cas, tel
que la voix sur IP. L'envoi en temps réel est primordiale, donc si une
trame n'arrivait pas, la retransmission serait inutile
Vous trouverez tous les détails du protocole UDP dans la
Rfc 768.
Voici la structure de l'entête UDP basé sur 8 octets.
Le champ Port source est codé sur 16 bits et correspond au port relatif à l'application en
cours sur la machine source.
Le champ
Port destination est codé sur 16 bits et il correspond au port relatif à l'application en
cours sur la machine de destination.
Vous trouverez
la liste des ports TCP
officialisées par l'IANA,
organisation gérant mondialement les adressage IP.
Le champ
Longueur est codé sur 16 bits et il représente la taille de l'entête et des données. Sont unité est l'octet
et sa valeur maximale est 64 Koctets (216).
Le champ Checksum est codé sur 16 bits et représente la validité du paquet
de la couche 4 UDP.
Le Checksum est constitué en calculant le complément à 1 sur 16 bits de la somme
des compléments à 1 des octets de l'en-tête et des données pris deux par deux
(mots de 16 bits). Si le message entier contient un nombre impair d'octets, un 0
est ajouté à la fin du message pour terminer le calcul du Checksum. Cet octet
supplémentaire n'est pas transmis. Lors du calcul du Checksum, les positions des
bits attribués à celui-ci sont marquées à 0.
Le Checksum couvre de plus, une pseudo en-tête de 96 bits préfixée à l'en-tête
UDP. Cette pseudo en-tête comporte les adresses Internet source et
destinataires, le
type de protocole et la longueur du message UDP. Ceci protège
UDP contre les erreurs de routage.
La longueur UDP compte le nombre d'octets de l'en-tête UDP et des données du
message, en excluant les 12 octets de la pseudo en-tête.
Voici un exemple de fonction permettant le calcul du checksum UDP. Elle est
identique à celle de
TCP.
|
struct pseudo_entete
{
unsigned long ip_source;
// Adresse ip source
unsigned long ip_destination;
// Adresse ip destination
char mbz;
// Champs à 0
char type;
// Type de protocole (6->TCP et 17->UDP)
unsigned short length;
// htons( Taille de l'entete Pseudo + Entete TCP
ou UDP + Data )
};
unsigned short calcul_du_checksum(bool
liberation, unsigned short *data,
int taille)
{
unsigned long checksum=0;
//
********************************************************
// Complément à 1 de la somme des complément à 1 sur 16 bits
// ********************************************************
while(taille>1)
{
if (liberation==TRUE)
liberation_du_jeton(); // Rend la main à la fenêtre
principale
checksum=checksum+*data++;
taille=taille-sizeof(unsigned
short);
}
if(taille)
checksum=checksum+*(unsigned
char*)data;
checksum=(checksum>>16)+(checksum&0xffff);
checksum=checksum+(checksum>>16);
return (unsigned
short)(~checksum);
}
unsigned short calcul_du_checksum_udp(bool
liberation, unsigned long ip_source_tampon,
unsigned long ip_destination_tampon,
struct udp udp_tampon, char
data_tampon[65535])
{
struct pseudo_entete pseudo_udp;
char tampon[65535];
unsigned short checksum;
//
********************************************************
// Initialisation du checksum
// ********************************************************
udp_tampon.checksum=0; // Doit être à 0 pour le calcul
//
********************************************************
// Le calcul du Checksum UDP (Idem à TCP)
// ********************************************************
// Le calcul passe par une pseudo entete UDP + l'entete UDP +
les Data
pseudo_udp.ip_source=ip_source_tampon;
pseudo_udp.ip_destination=ip_destination_tampon;
pseudo_udp.mbz=0;
pseudo_udp.type=IPPROTO_UDP;
pseudo_udp.length=htons((unsigned short)(sizeof(struct
udp)+(unsigned short)strlen(data_tampon)));
memcpy(tampon,&pseudo_udp,sizeof(pseudo_udp));
memcpy(tampon+sizeof(pseudo_udp),&udp_tampon,sizeof(struct
udp));
memcpy(tampon+sizeof(pseudo_udp)+sizeof(struct
udp),data_tampon,strlen(data_tampon));
checksum=calcul_du_checksum(liberation,(unsigned
short*)tampon,sizeof(pseudo_udp)+sizeof(struct
udp)+strlen(data_tampon));
return(checksum);
} |
Vous pouvez poser toutes vos questions,
vos remarques et vos expériences à propos de l'entête UDP. Pour cela,
rendez-vous sur le
Forum
"TCP-IP".
Le 16 novembre 2003, par _SebF, ajout du schéma de la pseudo entête.
Le 15 septembre 2003, par _SebF, création du document.
|
|