Posibles implementaciones

Rafa Páez Jaime Ampliación de redes Universidad de Valencia 20 de Noviembre de 2010

Este trabajo consiste en una experiencia personal, concretamente en una práctica que tuve que realizar en la asignatura Transmisión de Datos de la Universidad Autónoma de Barcelona, en la carrera de Ingeniería Informática. Esta asignatura es considerada como una continuación de las dos asignaturas de redes que se realizan durante la carrera, así que está relacionada con Ampliación de Redes, que es la que se cursa en la Universidad de Valencia. Esta práctica consiste en la realización de una aplicación la cual permita intercambiar mensajes entre diferentes usuarios y que éstos tengan la opción de poder diferenciar entre mensajes públicos (para todos los usuarios que estén en la aplicación) y mensajes privados (únicamente para un usuario en concreto). Por lo tanto, con esta descripción que se nos ha dado, podemos ver claramente que estamos hablando de la creación de un chat, más concretamente de un chat que disponga con la opción de mensajes privados con los usuarios. Posibles implementaciones Para poder realizar dicha aplicación tenemos tres posibles implementaciones diferentes: La primera opción que tenemos es unicast. A primera vista podemos pensar que esta es la opción más fácil, ya que es con la que estamos acostumbrados a trabajar. El inconveniente de este sistema es que las comunicaciones se tendrán que hacer de host a host, es decir, entre cada uno de los diferentes usuarios. El problema que produce esto, es que tenemos que conocer previamente las direcciones IPs de cada uno de los usuarios del chat, teniéndo que tener una lista actualizada constantemente para saber quienes son los que están es el chat en ese momento y quienes no. Otro inconveniente es que para enviar un único mensaje público (para que todos puedan verlo) hay que realizar tantos envíos como usuarios haya, ya que para cada usuario hay que enviar el mismo mensaje, ya que son IPs diferentes, y esto hace que haya un envío de datos excesivo en la red, por lo que está se saturaría. Otra opción sería utilizar broadcast, pero el problema de este sistema es que únicamente serviría dentro de redes locales, ya que el router se encarga de capar los mensajes de tipo broadcast para que no salgan al exterior. De todas formas, si esto fuese suficiente para el uso de nuestra aplicación seguiríamos teniendo un inconveniente, y es que utilizando esto, todos los usuarios que estuviesen dentro de la red local recibirían los mensajes, estén interesados o no en recibirlos, ya que aunque un host no tenga la aplicación en ejecución, dichos mensajes le llegarían igualmente aunque su tarjeta los descartase en el momento de su recepción. De esta forma se conseguiría sobrecargar la red, ya que habría partes de esta en que no se necesitaría enviar los datos y aun y así estos irían navegando por esa parte de la red. Por último, la otra opción que nos queda es utilizar multicast. Multicast nos permite enviar un mismo mensaje a un grupo definido de tal forma que este mensaje solo se envía una vez, y lo reciben todas las personas que están a la escucha en el puerto X de dicho grupo. De esta forma, lo que podemos hacer es crear un grupo multicast con un puerto definido, que será donde se unirán todos aquellos usuarios que quieran enviar y

recibir estos mensajes. Así, un mensaje se enviará una única vez a esa dirección multicast y llegará únicamente a aquellas personas que estén interesadas en recibirlos. De esta manera haremos que se genere solo el tráfico necesario en la red evitando su saturación. Por lo tanto, vemos como claramente la mejor opción es utilizar multicast para el envío de dichos mensajes, y utilizar unicast para la realización de los mensajes privados, ya que estos únicamente van destinados a un solo usuario. Protocolo utilizado Una vez sabemos el tipo de implementación que utilizaremos, tenemos que definir un protocolo que nos permita diferenciar entre cada una de las funcionalidades de este chat, para tratar unos paquetes de una forma u otra. Para esto, hemos creado unas cabeceras que serán las que se enviarán y de esta forma podremos diferenciarlos gracias a estas cabeceras. Los diferentes mensajes que utilizaremos para el funcionamiento de la aplicación serán: Mensajes de registro: Estos mensajes serán enviados al grupo siempre que una persona se una al chat. De esta forma todos los presentes podrán ver que el usuario X se ha unido al chat y que desde ese mismo momento verá todos los mensajes generales y podrán enviarles mensajes a él. Su forma será: Donde Usuari del Xat será nuestro nick en el chat. Mensajes de participación en el chat: Este tipo de mensajes será el que cualquier usuario envía para que todos los demás puedan verlo. Por lo tanto será un mensaje general que irá enviado al grupo multicast. Su forma será: Donde Usuari del Xat será nuestro nick en el chat y Text el texto a enviar.

Mensajes de salida: Este tipo de mensajes será el que envíe un usuario cuando decida abandonar la aplicación, para que los demás miembros del grupo sepan que ese usuario ya no estará disponible. Su estructura será: Donde Usuari del Xat será nuestro nick en el chat. Mensajes de petición de IP: Estos mensajes serán los utilizados para el envío de mensajes privados y para averiguar la dirección IP de un usuario concreto del chat. Su estructura será: Donde Usuari del Xat será aquel usuario del que queremos saber su IP. Mensajes de respuesta IP y privado: Este mensaje será creado cuando queramos enviar un mensaje privado a un usuario en concreto. Tendrá la forma: Donde Usuari del Xat será aquel usuario que queremos enviar el privado. Como hemos visto, solamente con cinco tipos de mensajes diferentes ya podemos tener las diferentes características que proporcionará nuestro chat, pero si cada usuario tiene que crear la cabecera del mensaje cada vez, puede ser muy lioso y difícil de recordar, así que lo que haremos será crear unos comandos que creen las cabeceras automáticamente para que sea más fácil su ejecución. Mensaje de salida: Siempre que queramos salir de la aplicación escribiremos: Obtener IP de un usuario: Cuando queramos obtener la IP de algún usuario escribiremos: Donde <UsuariXat> será aquel usuario del que queremos obtener la IP.

Enviar privado a un usuario: Para enviar un mensaje privado escribiremos: Donde <UsuariXat> será aquel usuario que queremos enviar el privado y <Missatge> el mensaje que queremos enviar. En el caso de ser un mensaje normal, simplemente escribiendo el mensaje, el mismo programa ya se encargará de encapsularlo de la forma pertinente. Conexiones necesarias Una vez tenemos pensada la forma en que crearemos los mensajes, nos hace falta saber como estableceremos las comunicaciones, ya que los mensajes privados serán enviados a un socket unicast (a una única persona) y los mensajes generales se enviarán ar un socket multicast. De esta forma, para cada tipo de comunicación necesitaremos un puerto asociado a la correspondiente dirección IP en la que cada usuario estará a la escucha según el tipo de mensajes que vaya a recibir, de tal manera que quedaría un esquema como el siguiente: Como vemos, cada usuario necesita tener dos puertos en escucha, uno para los mensajes generales (puerto 5555 en el ejemplo) y otro para los mensajes privados. En ambos casos vemos como el emisor utiliza un socket unicast y el receptor (en el caso de los mensajes generales) uno multicast. Esto es así porque para enviar mensajes, siempre lo haremos desde un socket unicast, enviándolos a una dirección multicast. Únicamente utilizaremos el multicast para la recepción de estos mensajes. El funcionamiento es muy simple: el emisor utilizará el socket unicast con un puerto cualquiera asignado por el sistema operativo (de ahí que se utilice el puerto 0) para enviar los mensajes normales, los de obtener IP, y los de inicio del privado. El receptor, cuando reciba el mensaje por el puerto en el que está a la escucha (5555 en este caso) hará el correspondiente tratamiento para ver de que mensaje se trata, y en el caso que

sea un mensaje de obtener IP o de privado, lo que hará es lanza un thread en el que se creará un socket unicast para intercambiar los mensajes privados con el emisor. En este caso, el receptor enviará un mensaje privado a la dirección y puerto privado del emisor (que habrá obtenido mediante el paquete que éste le ha enviado anteriormente). El emisor recibirá la dirección IP y puerto privado del receptor y desde ese mismo instante ya podrán intercambiar mensajes privados y generales paralelamente, ya que ambos usuarios envían y reciben los privados por los threads que han lanzado. Implementación Para la implementación de este programa utilizaremos el lenguaje de programación Java, el cual nos proporciona un listado de funciones que nos facilitan mucho la tarea de la implementación de las diferentes comunicaciones utilizando sockets y el tratamiento de los strings. La explicación de todo el código considero que sería excesiva para este informe, ya que es un código que está muy comentado y es fácil de seguir (si se entiende un poco de programación), así que es solo haré una breve introducción del mismo. Como podemos ver, el código [Anexo] se divide en cuatro clases, dos para la parte del receptor (ReceptorPrivat.java y Receptorxat.java) y otras dos para la del emisor (RespostaIP.java y EmissorXat.java). Dentro de esta clasificación, tenemos dos para la parte de los mensajes generales (Receptorxat.java y EmissorXat.java) y dos para los mensajes privados (ReceptorPrivat.java y RespostaIP.java). De todas maneras, únicamente hay que ejecutar las relacionadas con los mensajes generales, ya que las otras podríamos decir que son clases internas que utiliza el mismo programa. Para lanzar la aplicación haremos dos llamadas diferentes, una para la parte emisora y otra para la parte receptora (donde se mostrarán todos los mensajes). Los argumentos que deberemos pasar son los siguientes: La parte del receptor la lanzaremos así: Donde <UsuariXat> será el nombre que queramos utilizar, <GrupIP> el grupo al que nos queremos unir, <port> el puerto multicast y <portprivat> será el puerto para los mensajes privados.

El emisor lo ejecutaremos como: Donde <UsuariXat> será el nombre que queramos utilizar, <GrupIP> el grupo al que nos queremos unir y <port> el puerto. En este caso vemos que el emisor no necesita puerto privado, esto es así porque los mensajes privados se enviarán por el puerto que el sistema operativo le asigne en ese momento.

Anexo Código de ReceptorXat.java: // ReceptorXat.java import java.io.*; import java.util.*; import java.net.*; public class ReceptorXat{ public static void main(string[] args){ String usuari=args[0]; String grupid= "230.0.0.1"; int port=5555; int portprivat=0; try{ //agafem els arguments int i=0; while(i<args.length){ if (args[i].equals("-p")) { port=integer.parseint(args[i+1]); if (args[i].equals("-g")) { grupid = args[i+1]; if (args[i].equals("-ppr")) { portprivat=integer.parseint(args[i+1]); i++; //Creem socket multicast per al receptor InetAddress group = InetAddress.getByName(grupID); MulticastSocket ms = new MulticastSocket(port); ms.joingroup(group); //Declarem el socket per escoltar els privats DatagramSocket socketprivat=null; if(portprivat!=0) { //Inicialitzem el socket amb el port privat socketprivat = new DatagramSocket(portPrivat); //Construim el threat amb el socket i l'enjeguem ReceptorPrivat privat = new ReceptorPrivat(socketPrivat); privat.start(); String tipusmissatge=""; String bufferstring=""; String nickusuari="";

int index1=0; String sensetipus=""; //Mostrem per pantalla que s'ha iniciat el xat System.out.println("\n Xat iniciat correctament.\n"); while(true){ //Rebem el datagrama byte[] buf = new byte[1000]; DatagramPacket recv = new DatagramPacket(buf, buf.length); ms.receive(recv); //Separem les dades del missatge //tipus del missatge (primera lletra) tipusmissatge=new String(buf,0,1); //resta del missatge sensetipus=new String(buf,2,buf.length-2); //Classifiquem segons el tipus de missatge //missatge normal if (tipusmissatge.equals("m")){ index1=sensetipus.indexof("#"); nickusuari=new String(buf,2,index1); bufferstring=new String(buf,3+index1,buf.length-3- index1); System.out.println(nickUsuari + "> " + bufferstring); //missatge d'entrada else if (tipusmissatge.equals("r")){ System.out.println(" [[ El usuari " + sensetipus + " ha entrat en el xat ]]"); //missatge de sortida else if (tipusmissatge.equals("s")){ System.out.println(" [[ El usuari " + sensetipus + " ha abandonat el xat ]]"); //peticio de IP else if (tipusmissatge.equals("i")){ nickusuari=new String(buf,2,usuari.length()); //si som el receptor que busquen, contestem if (nickusuari.equals(usuari)){ //comprovem que tinguem un port privat assignat if(portprivat!=0){ System.out.println(" [[ Han demanat la teva IP ]]"); //consturim el missatge de resposta String msgip= "P#" + usuari; //enviem el datagrama DatagramPacket datagramaaenviar = new DatagramPacket(msgIP.getBytes(), msgip.length(),recv.getaddress(),recv.getport()); socketprivat.send(datagramaaenviar); else System.out.println(" [[ Error, has

d'indicar un port privat ]] "); catch (UnknownHostException e){system.out.println(" UnknownHostException"); catch (IOException e){ System.out.println(" ioexception"); catch (ArrayIndexOutOfBoundsException e){ System.out.println(" ArrayIndexOutOfBoundsException"); catch (StringIndexOutOfBoundsException e){ System.out.println(" StringIndexOutOfBoundsException"); // Código de EmissorXat.java: // EmissorXat.java import java.io.*; import java.util.*; import java.net.*; public class EmissorXat{ public static void main(string[] args){ //Dades per defecte String usuari = args[0]; String grupid= "230.0.0.1"; int port=5555; String usuari2=""; //Agafem els arguments int i=0; while(i<args.length){ if (args[i].equals("-p")) { port=integer.parseint(args[i+1]); if (args[i].equals("-g")) { grupid = args[i+1]; i++; try{ String msg=""; String msg2 ="S#"+ args[0]; String rl=""; //variable per contar els missatges enviats int contadormissatges=0;

//creem datagrama unicast InetAddress addr = InetAddress.getByName(grupID); DatagramSocket ds = new DatagramSocket(0); DatagramPacket datagramaaenviar; //Variables per a llegir el contingut que entrem per l'entrada estandard InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); //Enviem missatge d'entrada al xat msg="r#" + usuari; datagramaaenviar = new DatagramPacket(msg.getBytes(), msg.length(),addr,port); ds.send(datagramaaenviar); //Mostrem que hem entrat al xat System.out.println(" [[ Hola " + usuari + "! Has entrat al xat " + grupid + ":" + port + " ]]"); do{ //Llegim el missatge entrat per teclat System.out.println("Missatge a enviar: "); rl=br.readline(); //Mirem que ha escrit l'usuari //sortir -> construim missatge de sortida if (rl.equals("#sortir")){ msg="s#" + usuari; //obtenir IP else if (rl.startswith("#obteip ")){ StringTokenizer st = new StringTokenizer(rl); st.nexttoken(); //agafem el nom d'usuari i construim el missatge if(st.hasmoretokens()) { usuari2= st.nexttoken(); msg="i#" + usuari2; //construim el datagrama que enviarem amb la peticio datagramaaenviar = new DatagramPacket(msg.getBytes(), msg.length(),addr,port); else { //Creem el thread per a obtenir la IP i l'enjeguem RespostaIP peticioe = new RespostaIP(usuari,datagramaAEnviar,"",0); peticioe.start(); System.out.println(" [[ Comanda incorrecte. Has d'indicar el nick del usuari.]]"); //enviar privat else if (rl.startswith("#privat ")){ StringTokenizer st = new StringTokenizer(rl); st.nexttoken(); //agafem l'usuari

if(st.hasmoretokens()) { usuari2= st.nexttoken(); msg="i#" + usuari2; //construim el datagrama datagramaaenviar = new DatagramPacket(msg.getBytes(), msg.length(),addr,port); //guardem el missatge privat que volem enviar msg = ""; while(st.hasmoretokens()) { msg += st.nexttoken()+" "; //construim el thread amb les dades i l'enjeguem RespostaIP peticioe = new RespostaIP(usuari,datagramaAEnviar,msg,1); else{ else { peticioe.start(); System.out.println(" [[ Comanda incorrecte. Has d'indicar el nick del usuari.]]"); msg ="M#"+ usuari + "#" + rl; //si volem obtenir l'ip o fer un privat la variable usuari2 estarà plena //i el thread s'encarregarà d'enviar les dades if (usuari2.equals("")) { int length = msg.length(); else if (length > 1000) { length=1000; //enviem els missatges que no siguin d'obtenir IP o privats datagramaaenviar = new DatagramPacket(msg.getBytes(), length,addr,port); ds.send(datagramaaenviar); usuari2=""; //borrem l'usuari que hem passat al thread //augmentem el nombre de missatges enviats contadormissatges++; //Mentre el missatge enviat no sigui S#usuari while(!msg.equalsignorecase(msg2)); //Informem de la sortida i de la quantitat de missatges enviats System.out.println(" [[ Has sortit del xat i has enviat un total de: " + (contadormissatges-1) + " missatge(s) ]]"); catch (SocketException e) {System.out.println(" SocketException"); catch (IOException e){ System.out.println(" ioexception");

catch (NullPointerException e){ System.out.println(" NullPointerException"); catch (NoSuchElementException e){ System.out.println(" NoSuchElementException"); // Código de RespostaIP.java: // RespostaIP.java import java.net.*; import java.io.*; public class RespostaIP extends Thread { private String usuarie; private DatagramPacket packete; private int opcioe=0; private String msge=""; //Constructor RespostaIP(String usuari, DatagramPacket packet, String missatge, int opcio){ //el nostre nick per enviar el missatge privat this.usuarie = usuari; //paquet a enviar this.packete = packet; //variable per saber si obtenim ip o fem privat this.opcioe = opcio; //missatge privat this.msge = missatge; public void run() { try{ //Socket per enviar peticio DatagramSocket dse = new DatagramSocket(0); dse.send(this.packete); byte[] buf = new byte[1000]; //Rebem resposta del Receptor DatagramPacket recv = new DatagramPacket(buf, buf.length); dse.receive(recv); //Agafem l'adreça IP i el PORT del datagrama que rebem InetAddress addr = recv.getaddress(); int port = recv.getport(); //Si estem fent privat enviem el missatge if (this.opcioe == 1) {

//construim el missatge privat this.msge = "M#"+this.usuariE+"#"+this.msgE; int length = this.msge.length(); if(length > 1000) length=1000; //Enviem missatge privat DatagramPacket datagramaaenviar = new DatagramPacket(this.msgE.getBytes(), length, addr,port); else dse.send(datagramaaenviar); //si nomes voliem obtenir la IP, mostrem les dades per pantalla System.out.println("[[ Adreça: "+addr.gethostaddress()+ " Port: "+recv.getport()+" ]]"); //Tanquem el socket dse.close(); catch (UnknownHostException e){system.out.println(" UnknownHostException"); catch (IOException e){ System.out.println(" ioexception"); catch (ArrayIndexOutOfBoundsException e){ System.out.println(" ArrayIndexOutOfBoundsException"); catch (StringIndexOutOfBoundsException e){ System.out.println(" StringIndexOutOfBoundsException"); //catch (SocketTimeoutException e){ System.out.println(" SocketTimeoutException"); // Código de ReceptorPrivat.java: // ReceptorPrivat.java import java.net.*; import java.io.*; public class ReceptorPrivat extends Thread { private DatagramSocket sprivat; //Constructor ReceptorPrivat(DatagramSocket socketprivat){ //guardem el socket per on escoltarem els privats this.sprivat = socketprivat; public void run()

{ try{ while(true) { byte[] buf = new byte[1000]; //Rebem missatge privats DatagramPacket recv = new DatagramPacket(buf, buf.length); this.sprivat.receive(recv); //Separem la informacio del missatge String tipusmissatge=new String(buf,0,1); String sensetipus=new String(buf,2,buf.length-2); //Comprovem que el missatge sigui correcte //ha de començar per M if (tipusmissatge.equals("m")) { int index1=sensetipus.indexof("#"); //agafem el nick String nickusuari=new String(buf,2,index1); //agafem el missatge String bufferstring=new String(buf,3+index1,buf.length-3-index1); //Mostrem el missatge al Receptor indicant que es un missatge privat System.out.println(nickUsuari + " (Privat) > " + bufferstring); catch (UnknownHostException e){system.out.println(" UnknownHostException"); catch (IOException e){ System.out.println(" ioexception"); catch (ArrayIndexOutOfBoundsException e){ System.out.println(" ArrayIndexOutOfBoundsException"); catch (StringIndexOutOfBoundsException e){ System.out.println(" StringIndexOutOfBoundsException"); //