martes, 23 de junio de 2015

CODIGO DE EJEMPLO UDP

codigo de ejemplos (java) udp


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)[editar]

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)[editar]

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();
}

VENTAJAS Y DESVENTAJAS DE UDP

VENTAJAS Y DESVENTAJAS DE UDP


   VENTAJAS UDP
  - Este protocolo aporta un procedimiento para que los programas de
    aplicación puedan enviar mensajes a otros programas con un mínimo
de     mecanismo de protocolo.

  - proporciona una sencilla interfaz entre la capa de red y la capa
de aplicación.
 Resultado de imagen para imagenes de ventajas y desventajas de udp

   DESVENTAJAS UDP
 - no otorga garantías para la entrega de sus mensajes y el origen UDP
no retiene
   estados   de los mensajes UDP que han sido enviados a la red.
Resultado de imagen para imagenes de ventajas y desventajas de udp - UDP sólo añade multiplexado de aplicación y suma de verificación de
la cabecera y la carga   útil. Cualquier tipo de garantías para la
transmisión de la información deben ser implementadas en capas
superiores.






INTERFAZ DE PROGRAMACION DE APLICACION DE UDP

INTERFAZ DE PROGRAMACIÓN DE APLICACIONES UDP


La interfaz de aplicación que ofrece UDP se describe en el RFC 768. Dicha interfaz proporciona:
La creación de nuevos puertos de recepción.
La recepción de operaciones que devuelven los bytes de datos y un indicador de puerto fuente y una dirección fuente IP.
El envío de operaciones que tienen como parámetros los datos, los puertos fuente y destino y las direcciones.
La forma en la que está implementado depende de cada vendedor.
Hay que ser conscientes de que UDP e IP no proporcionan entrega garantizada, control de flujo o recuperación de errores, así que estos mecanismos tienen que ser soportados por las aplicaciones.
Las aplicaciones estándares que utilizan UDP son:
Protocolo de Transferencia de Ficheros Trivial (TFTP)
Sistema de Nombres de Dominio (DNS) servidor de nombres
Llamada a Procedimiento Remoto (RPC), usado por el Sistema de Ficheros en Red (NFS)
Sistema de Computación de Redes (NCS)
Protocolo de Gestión Simple de Redes (SNMP)










 

FORMATO DEL DATAGRAMA DE UDP

FORMATO DEL DATAGRAMA UDP

Cada datagrama UDP se envía con un único datagrama IP. Aunque el datagrama IP se puede fragmentar durante la transmisión, la implementación de recepción IP lo re-ensamblará antes de presentarlo a la capa UDP. Todas las  implementaciones IP están preparadas para aceptar datagramas de 576 bytes, permitiendo un tamaño máximo de cabacera IP de 60 bytes sabiendo que un datagrama UDP de 516 bytes lo aceptan todas las implementaciones. Muchas implementaciones aceptarán datagramas mayores, aunque no se puede asegurar. El datagrama UDP tiene una cabecera de 16 bytes que se describe en la figura siguiente:


Dónde:
Puerto de origen
Indica el puerto del proceso que envía. Este es el puerto que se direcciona en las respuestas.
Puerto destino
Especifica el puerto del proceso destino en el host de destino.
Longitud
Es el tamaño (en bytes) de este datagrama de usuario incluyendo la cabecera.
Suma de comprobación (checasen)
Es un campo opcional de 16 bits en complemento a uno de la suma en complemento a uno de una cabecera pseudo-IP, la cabecera UDP y los datos UDP. La cabecera pseudo-IP contiene la dirección IP fuente y destino, el protocolo y la longitud UDP: