CABECERA UDP

1 – Definición del protocolo UDP

El protocolo UDP se basa en la capa 4 del modelo OSI. No se conecta y no realiza una comprobación de errores. Se llama entonces «modo offline». Por lo tanto, no es fiable, sin embargo, permite a las aplicaciones acceder directamente a un servicio de transmisión rápida de datagramas.

El UDP se utiliza para transmitir pequeñas cantidades de datos cuando el costo de crear conexiones y mantener transmisiones fiables es mayor que los datos a transmitir. El UDP también puede ser usado para aplicaciones que cumplan con un modelo de respuesta a consultas. La respuesta se utiliza como acuse de recibo de la consulta. Los protocolos típicos incluyen SNMP y DNS. UDP también se utiliza en un segundo caso, como la voz sobre IP. La transmisión en tiempo real es esencial, así que si no llega un cuadro, la retransmisión es inútil.

Los detalles completos del protocolo UDP se encuentran en el RFC 768.

2 – Estructura de la cabecera del UDP

Aquí está la estructura de la cabecera del UDP basada en 8 bytes.

3 – Definición de los diferentes campos

3.1 – Puerto de origen UDP

El campo Puerto de origen está codificado en 16 bits y corresponde al puerto relativo a la aplicación actual en la máquina de origen.

3.2 – Puerto de destino UDP

El campo Puerto de destino está codificado en 16 bits y corresponde al puerto relativo a la aplicación actual en la máquina de destino.

Encontrará la lista de puertos TCP oficializada por la IANA, una organización que gestiona el direccionamiento IP en todo el mundo.

3.3 – Longitud

El campo Longitud está codificado en 16 bits y representa el tamaño del encabezado y los datos. Su unidad es el byte y su valor máximo es de 64 Kbytes (216).

3.4 – Suma de comprobación

El campo Checksum está codificado en 16 bits y representa la validez del paquete de la Capa 4.

La suma de comprobación se forma calculando el complemento de 1 de 16 bits de la suma de los complementos de 1 de los bytes del encabezamiento y los datos tomados de dos en dos (palabras de 16 bits). Si todo el mensaje contiene un número impar de bytes, se añade un 0 al final del mensaje para completar el cálculo de la suma de control. Este byte extra no se transmite. Al calcular la suma de control, las posiciones de los bits asignados a la suma de control se marcan con un 0.

La suma de verificación también cubre un pseudo-cabezal de 96 bits prefijado al encabezado UDP. Este seudocabezado contiene las direcciones de Internet de origen y destino, el tipo de protocolo y la longitud del mensaje UDP. Esto protege al UDP de los errores de enrutamiento.

La longitud cuenta el número de bytes del encabezado UDP y los datos del mensaje, excluyendo los 12 bytes del pseudoencabezado.

El siguiente es un ejemplo de una función para calcular la suma de comprobación del UDP. Es idéntico al 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);
     }

Deja un comentario

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Más info

aceptar