viernes, 3 de julio de 2015

Código de ejemplo (Java)

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:
public static void main(String[] args) {

  try {
   System.out.println("server creado........");
   // 1. crear el servidor..
   DatagramSocket socket = new DatagramSocket(45000);

   // 2. recibir mensaje desde el cliente...

   // 2.1 crear el paquete donde se recibe el mensaje.
   byte[] buffer = new byte[1024];
   DatagramPacket paqueteCliente = new DatagramPacket(buffer, 1024);
   // 2.2 recibir el paquete. operacion bloqueante.
   System.out.println("socket esperando....");
   socket.receive(paqueteCliente);

   // 2.3 leer el paquete como string...
   String msj = new String(paqueteCliente.getData());

   System.out.println("desde "
     + paqueteCliente.getAddress().getHostAddress()
     + " desde el puerto " + paqueteCliente.getPort()
     + " se recibio:" + msj);

   // 3. enviar respuesta..
   String resp = new Date().toString();// la hora como respuesta.
   // 3.1 crear datagrama de envio.
   // direccion destino..
   InetAddress addr = paqueteCliente.getAddress();// la misma del
            // cliente.
   int port = paqueteCliente.getPort();
   // el datagrama contiene la información del destino.
   DatagramPacket paqueteEnvio = new DatagramPacket(resp.getBytes(),
     resp.length(), addr, port);
   System.out.println("enviando:"+new String(paqueteEnvio.getData()));
   // 3.2 enviar paquete...
   socket.send(paqueteEnvio);
   
   //4. cerrar el socket...
   socket.close();

  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

 }
Cliente:
public static void main(String[] args) {
  try {

   // 1. crear el socket por donde se enviara la peticion y se recibira
   // la respuesta..
   DatagramSocket socket = new DatagramSocket(32000);

   // 2. crear datagrama para enviar la info. el datagrama contiene
   // toda la info necesaria para que llegue el msj
   String msj = "Hola Server....."; // msj a enviar.
   String ip = "127.0.0.1";
   int port = 45000;
   // 2.1 crear datagrama
   DatagramPacket paqueteEnvio = new DatagramPacket(msj.getBytes(),
     msj.length(), InetAddress.getByName(ip), port);
   // 2.2 enviar paquete.
   socket.send(paqueteEnvio);

   // 3. recibir respuesta...

   // 3.1 crear datagrama de recepcion.
   byte[] resp = new byte[1024];
   DatagramPacket paqueteRecibido = new DatagramPacket(resp,
     resp.length);

   // 3.2 recibir paquete.
   socket.receive(paqueteRecibido);

   // 4. mostrar info...
   System.out.println("Server respondio desde "
     + paqueteRecibido.getAddress().getHostAddress()
     + " por el puerto " + paqueteRecibido.getPort()
     + " se recibio:" + new String(paqueteRecibido.getData()));

   // 5. cerrar
   socket.close();

  } catch (IOException e) {
   e.printStackTrace();
  }

 }

Código de ejemplo (Python 3.x)

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:
import socketserver
print("Servidor iniciado...")
class MyUDPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print("{0} Ha escrito:".format(self.client_address[0]))
        print(data)
        socket.sendto(data.upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = socketserver.UDPServer((HOST, PORT), MyUDPHandler)
    server.serve_forever()
Cliente (Cambia "localhost" por la dirección IP del servidor.):
import socket
import sys
print("Cliente iniciado...")
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

sock.sendto(bytes(data + "\n","utf8"), (HOST, PORT))
received = sock.recv(1024)

print("Enviado: {0}".format(data))
print("Recibido: {0}".format(received))

Código de ejemplo (C)

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:
#include <winsock.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")

const int BufLen = 1024;

int main()
{
   WSADATA wsaData;
   SOCKET RecvSocket;
   sockaddr_in RecvAddr;
   int Puerto = 2345;
   char RecvBuf[BufLen];
   sockaddr_in SenderAddr;
   int SenderAddrSize = sizeof(SenderAddr);
   WSAStartup(MAKEWORD(2,2), &wsaData);
   RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   RecvAddr.sin_family = AF_INET;
   RecvAddr.sin_port = htons(Puerto);
   RecvAddr.sin_addr.s_addr = INADDR_ANY;
   bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));
   recvfrom(RecvSocket,RecvBuf, BufLen,0,(SOCKADDR *)&SenderAddr,&SenderAddrSize);
 printf("%s\n",RecvBuf);
   closesocket(RecvSocket);
   WSACleanup();
}
Cliente (Cambia "127.0.0.1" por la dirección IP del servidor):
#include <winsock.h>
#pragma comment(lib,"ws2_32.lib")

int main()
{
 WSADATA wsaData;
   SOCKET SendSocket;
   sockaddr_in RecvAddr;
 int Puerto = 2345;
   char ip[] = "127.0.0.1";
   char SendBuf[] = "Hola!!!!";
   WSAStartup(MAKEWORD(2,2), &wsaData);
   SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   RecvAddr.sin_family = AF_INET;
   RecvAddr.sin_port = htons(Puerto);
   RecvAddr.sin_addr.s_addr = inet_addr(ip);
   sendto(SendSocket,SendBuf,strlen(SendBuf)+1,0,(SOCKADDR *) &RecvAddr,sizeof(RecvAddr));
   WSACleanup();
}

Comparativa entre UDP y TCP (Transmission Control Protocol)

  • UDP: proporciona un nivel de transporte no fiable de datagramas, ya que apenas añade la información necesaria para la comunicación extremo a extremo al paquete que envía al nivel inferior. Lo utilizan aplicaciones como NFS (Network File System) y RCP (comando para copiar ficheros entre ordenadores remotos), pero sobre todo se emplea en tareas de control y en la transmisión de audio y vídeo a través de una red. No introduce retardos para establecer una conexión, no mantiene estado de conexión alguno y no realiza seguimiento de estos parámetros. Así, un servidor dedicado a una aplicación particular puede soportar más clientes activos cuando la aplicación corre sobre UDP en lugar de sobre TCP.
  • TCP: es el protocolo que proporciona un transporte fiable de flujo de bits entre aplicaciones. Está pensado para poder enviar grandes cantidades de información de forma fiable, liberando al programador de la dificultad de gestionar la fiabilidad de la conexión (retransmisiones, pérdida de paquetes, orden en el que llegan los paquetes, duplicados de paquetes...) que gestiona el propio protocolo. Pero la complejidad de la gestión de la fiabilidad tiene un coste en eficiencia, ya que para llevar a cabo las gestiones anteriores se tiene que añadir bastante información a los paquetes que enviar. Debido a que los paquetes para enviar tienen un tamaño máximo, cuanta más información añada el protocolo para su gestión, menos información que proviene de la aplicación podrá contener ese paquete (el segmento TCP tiene una sobrecarga de 20 bytes en cada segmento, mientras que UDP solo añade 8 bytes). Por eso, cuando es más importante la velocidad que la fiabilidad, se utiliza UDP. En cambio, TCP asegura la recepción en destino de la información para transmitir.

Transmisión de vídeo y voz

UDP es generalmente el protocolo usado en la transmisión de vídeo y voz a través de una red. Esto es porque no hay tiempo para enviar de nuevo paquetes perdidos cuando se está escuchando a alguien o viendo un vídeo en tiempo real.
Ya que tanto TCP como UDP circulan por la misma red, en muchos casos ocurre que el aumento del tráfico UDP daña el correcto funcionamiento de las aplicaciones TCP. Por defecto, TCP pasa a un segundo lugar para dejar a los datos en tiempo real usar la mayor parte del ancho de banda. El problema es que ambos son importantes para la mayor parte de las aplicaciones, por lo que encontrar el equilibrio entre ambos es crucial.
Todo este tipo de protocolos son usados en telemática.


Publicadas por a la/s

No hay comentarios.:

Publicar un comentario

Suscribirse a: Comentarios de la entrada (Atom)