2010 Programacion de socketsUDP

Facultad Regional Concepción del Uruguay
Ingeniería en sistemas de información

Redes de información 4to año
Servicio de Datagramas - Socket UDP

Contenidos
Introducción ..............................................................................................................................................................1
Crear un Paquete UDP - DatagramPacket...............................................................................................................2
Ejercicio A .............................................................................................................................................................2
Protocolos a transportar por UDP – Ej. MSSP .........................................................................................................4
Ejercicio B .............................................................................................................................................................4
Ejercicio C .............................................................................................................................................................4
Crear un Socket UDP - DatagramSocket .................................................................................................................6
Ejercicios D ...........................................................................................................................................................6
Enviar Datos con un Socket UDP.............................................................................................................................6
Recibir datos con un Socket UDP – DatagramSocket .............................................................................................8
Ejercicio E .............................................................................................................................................................9
Ejercicio F .............................................................................................................................................................9
Introducción
En los protocolos TCP/IP la capa de transporte proporciona dos servicios básicos, orientado a conexión (a
través del protocolo TCP) y no orientado a conexión a través del protocolo UDP (User Datagram Protocol). En
este práctico se realizarán programas utilizando el protocolo UDP.
El servicio prestado por UDP es de entrega de datagramas sin conexión, este servicio es “no confiable” ya que
los datagramas pueden perderse, duplicarse o corromperse en el viaje a su destino y UDP no hace nada para
solucionar o mejorar estas dificultades. Si se decide trabajar con el protocolo UDP los controles hay que
realizarlos en capas superiores.
El formato de un datagrama UDP es el mostrado en la figura:
El protocolo esta organizado en bloques de 32 bits, el primer bloque corresponde a los puertos origen y destino,
el segundo bloque comprende los campos de longitud y suma de comprobación.
Un Datagrama UDP se encapsula en un protocolo IP. La comunicación se realiza de la siguiente forma: una
aplicación genera un datagrama UDP con los datos del usuario y lo envía a otra aplicación en un host remoto.
Si por alguna razón el datagrama no llega, o llega con errores, el Software UDP no realiza ninguna corrección.
Ing. Ulises M. A. Rapallini - 1

El protocolo IP puede transportar datagramas UDP de distintas aplicaciones entre dos host (dos aplicaciones en
el host origen y dos en el host destino) por esto se requiere identificar la aplicación para conocer donde hay que
entregar los datos, UDP conoce a que aplicación debe entregar los datos identificándola con un número de
puerto.
UDP utiliza el puerto destino para realizar la demultiplexación. El proceso receptor del mensaje utiliza un
conector (un socket por ejemplo) enlazado a un puerto, este conector puede realizar operaciones de envío y
recepción de datagramas, la operación de recepción espera a recibir un datagrama a través del puerto donde
esta enlazado el conector. Si al llegar un datagrama UDP se detecta que el puerto de destino no esta enlazado
a un conector, el datagrama se descarta. El nivel UDP demultiplexa los datagramas según el puerto destino.
La siguiente figura describe el proceso en el host destino :
La figura muestra : el software IP pasa los datos (datagrama UDP) al software UDP, el software UDP válida el
datagrama y lo envía al puerto de destino, el puerto de destino esta enlazado con un conector, la aplicación
utiliza el conector para realizar la operación de ”recibir”.
Una aplicación puede acceder al servicio de UDP utilizando la Interfaz Socket. Las clases de Java que se
utilizan para realizar aplicaciones en red están agrupadas en un “Paquete” el pakage java.net. La interfaz
Socket se implementa con varias clases entre las que están : Socket, SocketServer, DatagramSocket
DatagramPacket, en este practico utilizaremos, entre otras, las correspondientes a UDP.
Crear un Paquete UDP - DatagramPacket
La clase DatagramPacket modela un Datagrama UDP, al crear un objeto DatagramPacket se crea un Paquete
UDP,
el siguiente ejemplo crea un Datagrama UDP :
//importar las clases requeridas

import java.net.InetAddress;
import java.net.DatagramPacket;

public class Pru_UDP {

public static void main(String arg[]) {
try {
DatagramPacket paqueteUDP; //declaracion del paquete UDP
String host = new String("127.0.0.1"); // Dir. Internet host remoto
InetAddress dir_remota = InetAddress.getByName( host );

int port = 1000; //puerto donde se envia el datagrama
//Datos a enviar en el datagrama

String datos = new String("Hola, estos son los datos !!");
Byte[] buffer = datos.getBytes(); // retorna los bytes del string
//crear el paquete UDP

paqueteUDP = new DatagramPacket(buffer, buffer.length, dir_remota, port);
//mostrar los datos del paquete

System.out.println("Paquete UDP :");
System.out.println("Direccion Internet:" + paqueteUDP.getAddress());
System.out.println("Datos :" + paqueteUDP.getData());
System.out.println("Longitud :" + paqueteUDP.getLength());
System.out.println("Offset :" + paqueteUDP.getOffset());
System.out.println("Puerto :" + paqueteUDP.getPort());
} //cierra el try
catch(Exception e) {
System.out.println(e);
}
} //cierra el main
}
Ejercicio A
Crear un programa en Java para armar un Datagrama UDP y luego mostrar los datos del datagrama, los datos
de:
HOST (donde se enviará el datagrama )
PUERTO (puerto donde lee la aplicación remota)
DATOS (datos en el datagrama)
se obtienen desde la línea de comandos.
Por ejemplo: el siguiente programa “ArmarUDP” construye y muestra los datos del datagrama :
C:\works\uader\lic_redes>java ArmarUDP 127.0.0.1 80 hola

Paquete UDP :
Direccion Internet:127.0.0.1/127.0.0.1
Datos como bytes[] :[B@68d258d9
Datos como String :hola
Longitud :4
Offset :0
Puerto :80

el constructor de la Clase DatagramPacket se describe a continuación :
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
Buf : es un array de bytes cuyo contenido son los datos del datagrama
Length : es la longitud de los datos
Address : es la direccon de destino del datagrama
Port : es el puerto de destino.
Existen otros constructores que usted deberá verificar en la documentación de Java accediendo a :
http://java.sun.com
Observe que los datos de un datagrama UDP son del tipo array de bytes, por esto, hay que transformar los
datos de usuario de cualquier formato a un array de bytes para poder crear el Datagrama, afortunadamente
Java proporciona métodos para realizar esta transformación como se verá el la siguiente sección.
Observe también que el constructor requiere una dirección Internet ( InetAddress ) para crear el datagrama. El
protocolo UDP no tiene entre sus campos la dirección de destino, pero la suma de comprobación se calcula en
función de una pseudo cabecera que involucra la dirección IP origen y IP destino.
Protocolos a transportar por UDP – Ej. MSSP

Supongamos un protocolo sencillo para enviar mensajes utilizando UDP, la longitud de los mensajes no mayor
a 256 bits (32 caracteres de 8 bits), para enviar mensajes largos se utiliza fragmentación, por esto el protocolo
tiene un identificador de mensaje, número de secuencia y un campo de datos de 32 caracteres fijos. Llamemos
a este protocolo MSSP, Message Short Simple Protocol, el formato del protocolo es:
- Identificador 1 byte
- Número de secuencia 1 byte
- Datos 50 bytes
El identificador se utiliza para identificar a los mensajes largos, y diferenciarlos de otros mensajes fragmentados
al mismo host. El número de secuencia identifica el fragmento del mensaje.
En Java este protocolo se puede modelar con una clase, la clase diseñada de ejemplo incorpora un constructor
para crear el mensaje, un método que retorna un array de bytes ( para encapsular en un paquete UDP) y un
segundo Método constructor para transformar un array de byte (proveniente de un paquete UDP) en un MSSP.
Ejercicio B
B.a) Programa la clase MSSP, agregar a la clase métodos para setear (set) y obtener el mensaje, también
métodos set y get para el ID y el número de secuencia.
B.b) Utilizando la clase anterior realizar un programa para crear protocolos MSSP‘s, correspondientes a un
mensaje dividido en tres partes, el mensaje se identifica con el número “8”, las tres partes tienen números de
secuencia consecutivos, 1, 2, 3. Utilizar el método programados en el ejercicio anterior para mostrar los campos
de los tres protocolos MSSP.
A continuación se muestra la clase ya programada:

/** Clase MSSP

* Protocolo Simple de mensajes Cortos

*/
public class MSSP {
// atributos de la clase
byte id_msn;
byte sec_msn;
String msn;
/** Constructor de la clase

* id_mensaje : identificador del mensaje
* secuencia : numero de secuencia del mensaje
* menasje : mensaje a enviar
*/
MSSP(byte id_mensaje, byte secuencia, String mensaje){
id_msn = id_mensaje;
sec_msn = secuencia;
msn = mensaje;
}
/** Constructor para armar un MSSP a partir de un array de bytes

*/
MSSP(byte[] datos_UDP){
Byte msg_aux[]; // variable auxiliar para armar el mensaje en un String
Id_msn = datos_UDP[0]; // copia el identificador
Sec_msn = datos_UDP[1]; // copia el numero de secuencia
//dimensiona el array de byte para el mensaje String

msg_aux = new byte[datos_UDP.length-2];
//copia los bytes del string
for(int i=2;i<datos_UDP.length;i++) msg_aux[i-2] = datos_UDP[i];
//transform el array de byte en un mansaje String
msn = new String(msg_aux);
}
/**retorna el MSSP como un array de bytes, listo para generar

* un paquete UDP*/
public byte[] getArrayBytes(){
byte proto[] = new byte[52]; //array de bytes para todo el protocolo
byte msn_by[] = msn.getBytes(); //transforma el msn String a byte[]
proto[0] = id_msn; //asigan el primer byte
proto[1] = sec_msn; //asigna el segundo byte
//asigna el mensaje al array, byte a byte

for(int i=0;i<msn_by.length;i++) {
proto[i+2] = msn_by[i];
}
return proto; //retorna el MSSP como byte[]
}
Ejercicio C
C.a) Agregar a la clase anterior métodos para setear (set) y obtener el mensaje (atributo “msn” de la clase),
también métodos set y get para el ID y el número de secuencia. (en total 6 métodos).
C.b) Utilizando la clase anterior realizar un programa para crear protocolos MSSP‘s, correspondientes a un
mensaje dividido en tres partes, el mensaje se identifica con el número “8”, las tres partes tienen números de
secuencia consecutivos, 1, 2, 3. Utilizar los método programados en el ejercicio anterior para mostrar los
campos de los tres protocolos MSSP.
Crear un Socket UDP - DatagramSocket

Una vez creado el paquete UDP se puede enviar con un Socket UDP a destino, Java proporciona la clase
DatagramSocket para realizar esta tarea. La clase DatagramSocket Incorpora dos métodos para enviar y recibir
paquetes UDP (clase DatagramPacket), receive() y send(). EL siguiente esquema muestra el host origen,
destino, la red y las entidades en cada parte en relación con un programa Java.
La clase DatagramSocket tiene varios Constructores que se utilizan con eventos diferentes, uno de ellos es:
DatagramSocket(int port)
Constructs a datagram socket and binds it to the specified port on the local host machine.
Esta clase proporciona métodos para “setear” y obtener : los datos del Socket, la dirección Internet y Puerto de
origen, la dirección Internet y puerto destino, el tamaño de los buffer de envío y recepción, el tiempo de
TimeOUT del datagrama. El Siguiente ejemplo muestra la utilización de estos métodos.
Aquí se realiza una conexión al host local para poder mostrar la dirección de destino y el puerto de destino, si
no se realiza esta conexión el socket queda inactivo hasta el envío de algún mensaje. En realidad el socket
UDP no establece conexiones, en este caso solo envía un mensaje para verificar que el puerto esta libre y todo
funciona correctamente.
//importar las clases requeridas

import java.net.InetAddress;
import java.net.DatagramSocket;

public class ArmarSocketUDP {
try {
int port_local = 80;
DatagramSocket ds = new DatagramSocket(port_local);
ds.setReceiveBufferSize(800);
ds.setSendBufferSize(800);
ds.setSoTimeout(100);
ds.connect( InetAddress.getByName("127.0.0.0"), 81);
//mostrar los datos del socket

System.out.println("Dir Local:"+ds.getLocalAddress());
System.out.println("Puerto Local:"+ds.getLocalPort());
System.out.println("Dir Remota:"+ds.getInetAddress());
System.out.println("Puerto Remoto:"+ds.getPort());
System.out.println("Buffer de recepción:"+ds.getReceiveBufferSize()+ "

bytes");
System.out.println("Buffer de envío:"+ds.getSendBufferSize()+ " bytes");
System.out.println("Tiempo de TimeOut:"+ds.getSoTimeout()+ " milisegundos");
}
catch(Exception e){
}
}
}
Ejercicios D
Crear un Socket UDP, “setear” el tamaño del buffer de envío y de recepción, también activar el TimeOUT del
socket a 1000 milisegundos. Imprimir el estado del socket,
Enviar Datos con un Socket UDP

Por ejemplo si tenemos que enviar un Datagrama UDP podemos utilizar el primer constructor del socket UDP y
enviar el datagrama con el método send, como se indica a continuación:
DatagramSocket ds = new DatagramSocket();
ds.send(paqueteUDP);
Por razones de claridad en el programa no se muestra la declaración ni la creación del objeto paqueteUDP, fue
creado como se indica más arriba. Este simple programa envía un datagrama UDP.
El siguiente segmento de programa muestra como se crea un datagrama, se crea un socket UDP y se envía al
host “www.google.com” al puerto 80.

try { // necesario para capturar los posibles errores
DatagramPacket paqueteUDP; //declaracion del paquete UDP

InetAddress dir_remota = InetAddress.getByName( "www.google.com" );
int port = 80;
String datos = "estos son los datos del datagrama";
byte[] buffer = datos.getBytes(); // retorna los bytes del string
paqueteUDP = new DatagramPacket(buffer, buffer.length, dir_remota, port);
//crea el socket y envía el paquete

DatagramSocket ds = new DatagramSocket();
ds.send(paqueteUDP);
}
catch(Exception e) {
}
}
Observe que no es necesario setear todos los parámetros.
Recibir datos con un Socket UDP – DatagramSocket

Recibir datos con un socket UDP es muy sencillo simplemente hay que llamar al método receive(...) de la clase
DatagramSocket, el siguiente ejemplo muestra como se leen los datos recibidos. Al realizar la operación de
recibir el socket queda bloqueado hasta que llegue algún paquete, luego los datos que llegan con el paquete
se obtienen con el método getData() que retorna un array de byte.
byte pkg_byte[] = null; //buffer para la asignacion de los datos

try {
byte buffer[] = new byte[this.MAX_LON]; //buffer solo para el DatagramPacket
data_reciv = new DatagramPacket( buffer, this.MAX_LON);
so_reciv.receive(data_reciv); //lee los datos
pkg_byte = new byte[data_reciv.getLength()]; //array de bytes para los datos
pkg_byte = data_reciv.getData(); // asigna los bytes de datos
}
catch(Exception e){
}
El programa muestra solo la parte de recepción del socket, tome en cuenta que no esta la creación del
socket, tampoco se muestran las variables de la clase donde esta la variable final LON_MAX.
El constructor que se utiliza para la clase DatagramPacket es diferente que el usado anteriormente para el
envío, este recibe un buffer array de bytes que se utiliza solo para crear un DatagramPaquet Vacio.
El método receive( pkg) requiere de un DatagramPacket “vacío” para cargar en él el paquete recibido. Observe
que el array de bytes que se crea para el paquete no se utiliza para otra cosa, los datos recibidos se deben
obtener con el método getData() y asignar en un array de bytes distinto al creado para el DatagramPacket.
En el programa no se indica en que puerto se leen los datos, esto se indica cuando se crea el socket con el
constructor:

so_reciv = new DatagramSocket(puerto);
Ejercicio E
Crear un programa que lee en el puerto 80 de su host paquetes UDP, transforme los datos de array de bytes a
String y muestre el String por consola.
Ejercicio F
Utilizando la clase MSSP realice dos aplicaciones una para enviar mensajes y otra para recibir mensajes.

2010 Programacion de socketsUDP

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

2010 Programacion de socketsUDP

Uploaded by

Copyright:

Available Formats

Facultad Regional Concepción del Uruguay

Ingeniería en sistemas de información

Servicio de Datagramas - Socket UDP

El formato de un datagrama UDP es el mostrado en la figura:

Ing. Ulises M. A. Rapallini - 1

La siguiente figura describe el proceso en el host destino :

Crear un Paquete UDP - DatagramPacket

el siguiente ejemplo crea un Datagrama UDP :

//importar las clases requeridas

Ing. Ulises M. A. Rapallini - 2

public class Pru_UDP {

InetAddress dir_remota = InetAddress.getByName( host );

//Datos a enviar en el datagrama

//crear el paquete UDP

//mostrar los datos del paquete

C:\works\uader\lic_redes>java ArmarUDP 127.0.0.1 80 hola

Ing. Ulises M. A. Rapallini - 3

el constructor de la Clase DatagramPacket se describe a continuación :

DatagramPacket(byte[] buf, int length, InetAddress address, int port)

Protocolos a transportar por UDP – Ej. MSSP

A continuación se muestra la clase ya programada:

Ing. Ulises M. A. Rapallini - 4

* Protocolo Simple de mensajes Cortos

/** Constructor de la clase

/** Constructor para armar un MSSP a partir de un array de bytes

//dimensiona el array de byte para el mensaje String

/**retorna el MSSP como un array de bytes, listo para generar

//asigna el mensaje al array, byte a byte

Crear un Socket UDP - DatagramSocket

//importar las clases requeridas

Ing. Ulises M. A. Rapallini - 6

public class ArmarSocketUDP {

public static void main(String arg[]) {

//mostrar los datos del socket

System.out.println("Buffer de recepción:"+ds.getReceiveBufferSize()+ "

Enviar Datos con un Socket UDP

public static void main(String arg[]) {

Ing. Ulises M. A. Rapallini - 7

try { // necesario para capturar los posibles errores

DatagramPacket paqueteUDP; //declaracion del paquete UDP

//crea el socket y envía el paquete

Observe que no es necesario setear todos los parámetros.

Recibir datos con un Socket UDP – DatagramSocket

byte pkg_byte[] = null; //buffer para la asignacion de los datos

Ing. Ulises M. A. Rapallini - 8

so_reciv = new DatagramSocket(puerto);

Ing. Ulises M. A. Rapallini - 9

You might also like