Entête UDP
Sommaire
1 – Définition du protocole UDP
Le protocole UDP est basé en couche 4 du modèle OSI. Il n’ouvre pas de session et n’effectue pas de control d’erreur. Il est alors appelé « mode non connecté ». Il est donc peu 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 les protocoles 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.
2 – Structure de l’entête UDP
Voici la structure de l’entête UDP basé sur 8 octets.
3 – Définition des différents champs
3.1 – Port source UDP
Le champ Port source est codé sur 16 bits et correspond au port relatif à l’application en cours sur la machine source.
3.2 – Port destination UDP
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.
3.3 – Longueur
Le champ Longueur est codé sur 16 bits et il représente la taille de l’entête et des données. Son unité est l’octet et sa valeur maximale est 64 Koctets (216).
3.4 – Checksum
Le champ Checksum est codé sur 16 bits et représente la validité du paquet de la couche 4.
Le Checksum est constitué en calculant le complément à 1 sur 16 bits de la somme des compléments à 1 des octets de l’entê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 entête de 96 bits préfixée à l’entête UDP. Cette pseudo entê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 compte le nombre d’octets de l’entête UDP et des données du message, en excluant les 12 octets de la pseudo entê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->le mode non connecte) unsigned short length; // htons( Entete TCP ou non connecte + 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(bool liberation, unsigned long ip_source_tampon, unsigned long ip_destination_tampon, struct entete tampon, char data_tampon[65535]) { struct pseudo_entete pseudo; char tampon[65535]; unsigned short checksum; // ******************************************************** // Initialisation du checksum // ******************************************************** tampon.checksum=0; // Doit être à 0 pour le calcul // ******************************************************** // Le calcul du Checksum (Idem à TCP) // ******************************************************** // Le calcul passe par une pseudo entete + l'entete + les Data pseudo.ip_source=ip_source_tampon; pseudo.ip_destination=ip_destination_tampon; pseudo.mbz=0; pseudo.type=17; pseudo.length=htons((unsigned short)(sizeof(struct entete)+(unsigned short)strlen(data_tampon))); memcpy(tampon,&pseudo,sizeof(pseudo)); memcpy(tampon+sizeof(pseudo),&tampon,sizeof(struct entete)); memcpy(tampon+sizeof(pseudo)+sizeof(struct entete),data_tampon,strlen(data_tampon)); checksum=calcul_du_checksum(liberation,(unsigned short*)tampon,sizeof(pseudo)+sizeof(struct entete)+strlen(data_tampon)); return(checksum); }
4 – Les vidéos
5 – Suivi du document
Création et suivi de la documentation par _SebF
Modification de la documentation par _SebF
- Ajout du schéma de la pseudo entête.
6 – Discussion autour de l’entête UDP
Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’entête UDP. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :
Bonjour,
Il me semble qu’il y a une contradiction, pour le calcul du checksum, pour la valeur de la longueur :
– dans le texte, vous dites « La longueur compte le nombre d’octets de l’entête UDP et des données du message, en excluant les 12 octets de la pseudo entête » ;
– dans le code d’exemple de calcul, le commentaire pour le champ longueur indique que sa valeur tient compte aussi de la longueur du pseudo-entête : « unsigned short length; // htons( Taille de l’entete Pseudo + Entete TCP ou non connecte + Data ) », ce qui est d’ailleurs fait lors de l’appel à la fonction calcul-du_checksum().
—
Merci pour votre site qui me permet de réviser et approfondir des notions toutes fraiches pour moi…
Lu Hérvé,
Je viens de relire et je pense que l’erreur est présente dans le commentaire du code C. En claire, le calcul doit bien ne pas inclure les 12 octets de la pseudo entête.
On peut le voir un peut plus bas dans le code :
pseudo.length=htons((unsigned short)(sizeof(struct entete)+(unsigned short)strlen(data_tampon)));
@+
Sebastien FONTAINE
« Sont unité est l’octet et sa valeur maximale est 64 Koctets (216). »
C’est « Son » pas « Sont » le 1er mot
Lu Kcl,
Merci de ta remarque, c’est corrigée.
@+
Sebastien FONTAINE