Protocolo de datagramas de usuario confiable (RUDP)

RUDP significa protocolo de datagrama de usuario confiable, mientras que UDP es uno de los miembros principales de IP, es decir, el conjunto de protocolos de Internet. UDP se utiliza como un protocolo comunicativo altamente sensible al tiempo. R en RUDP significa Confiable, es una transferencia de datos basada en UDP pero con mayor confiabilidad. Proporciona confiabilidad mediante el uso del protocolo de ventana deslizante. RUDP es básicamente la solución para UDP donde se necesita confiabilidad de datos junto con confirmación.

Como UDP proporciona un protocolo de transferencia de datos poco confiable, que es un servicio poco confiable de las cosas y, lo peor, a veces desaparece sin previo aviso. UDP confiable utiliza retroalimentación tanto positiva como negativa para proporcionar confiabilidad de datos que proporciona una transferencia de datos confiable.

En UDP, el remitente simplemente envía un mensaje sin información previa sobre la disponibilidad del receptor, lo que da como resultado una velocidad más rápida, pero puede provocar la pérdida de algunos paquetes, también el receptor puede recibir paquetes duplicados y UDP tampoco proporciona información que el el paquete ha sido recibido o no. RUDP usó un protocolo de ventana deslizante que entrega o transfiere el datagrama con confiabilidad.

Arquitectura RUDP 

El proceso de envío y el proceso de recepción de la arquitectura se encuentran en la capa de aplicación. El servidor emisor envía los paquetes de datos al canal receptor utilizando el protocolo RUDP; Tanto el remitente como el receptor mantienen un tamaño de ventana, la ventana consiste en un valor predefinido que tiende al máximo evitando los errores de comunicación tomando todos los casos extremos donde los paquetes pueden descartarse. 

Implementación del protocolo RUDP:

Use búferes compartidos sincronizados usando semáforos de conteo para que solo un subproceso acceda al búfer a la vez para evitar que ocurra una situación de interbloqueo. 

Mantengamos dos variables llamadas base y next para mantener el seguimiento del funcionamiento de la ventana. Si el remitente envió el paquete, la siguiente variable se incrementa a 1, esta es la forma de calcular la cantidad de paquetes en el búfer.

Los tiempos de espera se manejan utilizando los temporizadores que se programan inmediatamente después de enviar el paquete por el canal, simulan la tasa de pérdida de paquetes y el retraso aleatorio de la red en el protocolo.

los paquetes se mantienen en una cola y se les asigna un valor que valora la hora actual del sistema más el retraso de la red. Cuando la hora actual del sistema se asocia con el valor asignado, el paquete se libera de la cola y se envía a través de la red. Mientras el paquete se envía a través de la red, da un reconocimiento (ACK). Cuando el acuse de recibo coincide con el número de secuencia, los remitentes envían otro paquete asignándole el número consecutivo.

Clases en Protocolo RUDP:

Las siguientes son las clases que se utilizan para implementar el protocolo RUDP:

• RUDP: contiene las funciones de envío() y recepción() llamadas por el cliente y el servidor.
• Buffer_RUDP: contiene el búfer compartido de implementación utilizando semáforos de conteo.
• Receiver_Thread : implementa una arquitectura de subprocesos que espera simultáneamente los paquetes en los sockets mientras envía y recibe los datos y espera para procesar los datos entrantes.
• Segment_RUDP: define la estructura de los paquetes RUDP.
• Timeout_Handler: para manejar los tiempos de espera
• Support_RUDP: proporciona funciones como send_UDP();
• Cliente: Envía los datos.
• Servidor: Recibe los datos.

Protocolo de ventana deslizante:

El protocolo de ventana deslizante, también conocido como SWP de RUDP en el que se basa RUDP, se utiliza cuando entra en juego la confiabilidad y es muy esencial o por razones de seguridad donde se requiere el conocimiento de los datos transferidos junto con la confirmación. Funciona en segmentos, lo que significa que divide los datos proporcionados en segmentos, luego los paquetes o paquetes de datos se preparan y envían a través de la red, lo que resulta en que cuando el receptor recibe el paquete, verifica el orden de los paquetes y descarta los duplicados y luego se envía. envía el acuse de recibo al remitente de los paquetes recibidos correctamente.

Hay 3 protocolos de ventana deslizante:

• Protocolo de ventana deslizante de un bit
• Volver al protocolo N
• Protocolo de repetición selectiva

Técnica de caballito:

El protocolo de ventana deslizante utiliza la técnica piggy-backing , la técnica se basa en el acuse de recibo que se recibe pero, ¿cómo se recibe? Entonces, la respuesta es que proporciona el protocolo de ventana deslizante para adjuntar el acuse de recibo en el siguiente cuadro, de modo que cuando un receptor recibe los datos, mantiene un conjunto de números de secuencia que corresponde a los cuadros que también pueden llamarse cuadros de reconocimiento dentro de un parte de la ventana del mismo o diferente tamaño.

Las matemáticas del cálculo de marcos:

Cuando el remitente envía un nuevo paquete al receptor, se le asigna la marca de secuencia de paquete más alta y el borde superior de la ventana se incrementa en uno para las tramas reconocidas y viceversa para las tramas no reconocidas. Eso calcula la marca de los marcos no reconocidos, así como los marcos reconocidos y cuando este número llega a cero, significa que todos los paquetes se han entregado con éxito y proporciona retroalimentación al remitente. Se utiliza en aplicaciones de uso intensivo de datos que requieren mucho trabajo en muy poco tiempo en redes de alta velocidad, donde la confiabilidad juega un papel muy importante.

Arquitectura de código del lado del servidor:

• Client Class establece la tasa de pérdida y envía los datos a la clase RUDP, donde los tamaños de ventana tanto del remitente como del receptor se establecen en la clase.
• La clase RUDP según el trabajo divide los datos en segmentos de igual tamaño y, por lo tanto, asigna los marcos, es decir, el número de secuencia y la suma de verificación a cada segmento por separado y luego lo coloca en la ventana del remitente si tiene algún espacio disponible.
• Support_RUDP entra en juego ahora, cuando el remitente envía los paquetes de datos en segmentos, esta clase recopila y prepara los paquetes de los segmentos y los envía a través del canal no confiable. Una vez que se envía, el temporizador se enciende inmediatamente.
• La clase Thread_receiver es la clase importante para la estructura RUDP. Proporciona un hilo junto con el hilo de los datos. En paralelo, envía un hilo con los datos y espera en el socket los datos entrantes. Cuando recibe el paquete del socket, hace un segmento y verifica la suma de verificación, si la suma de verificación aclara que son los datos enviados, luego verifica el reconocimiento si el reconocimiento recibió, luego elimina el paquete de la ventana del remitente y lo envía a través del socket; si ocurre un tiempo de espera y se pierde un paquete, reenvía el paquete y reinicia el temporizador inmediatamente. Si la clase RUDP recibe el paquete antes del tiempo de espera, cancela el temporizador.

Arquitectura del código del lado del receptor:

• Thread_receiver Clase que implementó un hilo paralelo se ejecuta con el hilo de los datos enviados y una de las instancias espera en el socket para continuar procesando los datos que van llegando. Una vez que la clase recibe el paquete, se verifica con el segmento y se crea un segmento a partir de él que coincide con la suma de comprobación. Si el segmento contiene los datos requeridos, envía un reconocimiento y lo coloca en la clase Buffer_receiver y, si el paquete no está allí, almacena todo lo que sigue a la pérdida en Buffer_receiver.
• Una vez que se recibe el paquete perdido, procesa todo y luego la clase RUDP entrega todos los paquetes reordenándolos correctamente una vez que se almacenaron en el servidor.
• Una vez que se proporciona la confirmación de que se han recibido todos los datos, la conexión se cierra.

Pseudocódigo para la clase RUDP:

Class RUDP{
//setting up the window sizes
set Receiver Window size
set Sender Window size
start receiver thread that receives the aka(Acknowledgment) and data for both the receiver and the sender
//sender calls
sent_data(byte[] data_gram, int size)
{
     //process flow => data -> segments -> store into sender buffer -> send -> start timer
     //breaking into segments and sending along with frames
     Divide into the segments.
     put every segment into the sender's buffer
     segment sending using sent_udp() of support_RUDP class
     timeout scheduling for the data that is divided into segments using frames
}
//receiver calls
receive_data(byte[] buffer, int size)
{
     //receiving of the segments of the data packets
     segment receiving once at a time including the frames
}
//call by both the sender and receiver
close()
{
     //creation of flag for the indication
     creation of a flag segment to indicate the data transfer status
     //verification of the data
     //if data receiving completed -> close
     once the complete data is received close the segment
}
}
//RUDP class ends here

Pseudo Código de la clase Thread_receiver:

Class Thread_receiver
{
while(true)
    {
         //waiting for the packet -> received
         Receive the packet from socket
         //numberize or make checksum of the data
        individualize a segment from the packet that is received
         //verification of the data
         checksum verification that is sent along the frames
         if segment contains acknowledgment
          process -> remove segments fromt he sender's buffer
         if segment contains data
          put data->receiver's buffer
          send acknowledgment
    }
}
//end of Thread_receiver Class  

Pseudocódigo para la clase Support_RUDP:

Class Support_RUDP
{
    //simulate over the conditions that can cause the segments not received completely
    random network delay
    network loss
    any other potential that can effect the packet
    //process
    packets from the segments received processing
    //sent
    sent the data packet over the socket
}
//end of Support_RUDP class

Pseudo Code for Client-Server Class
//Sender
Class Client{
    RUDP rudp = new RUDP(Host_name, Port, Local);
    //send the data
    rudp.send();
    //close
    rudp.close();
}
//client class end
//Receiver Class start
Class Server{
    RUDP rudp = new RUDP(Host_name, Port, Local);
    //receive the data
    rudp.receive();
    //close
    rudp.close();
}