Transmisin UDP

El objetivo de esta prctica es implementar un Pinger utilizando el UDP (User Datagram Protocol) y as aprender a usar su API.

Un Pinger es una aplicacin de red que enva uno o varios paquetes de datos desde el host que ejecuta la parte cliente hasta el host que ejecuta la parte servidora. Esta los devuelve y permite al cliente calcular el RTT (Round-Trip Time) entre ambos hosts.

1 El comando ping

Un Pinger es una aplicacin bsica de chequeo del estado de la red. Por este motivo, en la mayora de los sistemas operativos encontramos una utilidad llamada ping. Vemos un ejemplo:

Como podemos ver, por defecto se envan paquetes cuyo payload contiene 56 bytes, que sumados a los 8 bytes de cabecera del IGMP dan 64 bytes, el tamao de los paquetes transmitidos (sin contar la cabecera del IP). Ntese que no se utiliza ningn protocolo de la capa de transporte.

El cliente calcula el tiempo que transcurre desde que cada paquete es enviado hasta que la correspondiente contestacin es recibida. Para finalizar, calcula el tiempo mnimo, medio y el mximo.

2 El ICMP (Internet Control Message Protocol)

La utilidad ping utiliza el protocolo de control de mensajes de Internet o ICMP. Dicho protocolo pertenece a la pila de protocolos TCP/IP y contempla un mensaje llamado Echo Request (Peticin de Eco). Cuando un host funciona adecuadamente, est conectado a Internet y no ha sido expresamente configurado para denegar las contestaciones Echo Response enva un mensaje ICMP del tipo Echo Response al host que le ha hecho la peticin.

Los mensajes de peticin y de respuesta son generalmente muy cortos. Esto significa que los tiempos de transmisin (no as los de propagacin) son prcticamente nulos y por tanto, ping se utiliza normalmente para medir el RTT entre nuestro host y el host remoto.

El Pinger presentado en esta prctica es una aplicacin que utiliza el UDP. El cliente enva paquetes UDP y el servidor los recibe y los retorna. Para describir ambas partes se ha utilizado el lenguaje de programacin Java.

3 El servidor

El servidor es bsicamente un bucle infinito que espera a recibir paquetes UDP. Para ello escucha en el puerto que se le indica por la lnea de comandos cuando es ejecutado.

Como la mayora de las ocasiones tendremos que ejecutar el cliente y el servidor en el mismo host, el servidor puede configurarse para:

1import java.io.*;
2import java.net.*;
3import java.util.*;
4
5/*
6 * Un servidor que procesa peticiones ping sobre UDP.
7 */
8public class PingServer {
9    private static final double LOSS_RATE = 0.3;
10    private static final int AVERAGE_DELAY = 100; // milisegundos
11
12    public static void main(String[] args) throws Exception {
13        /* Comprobamos que se han introducido los par’ametros de entrada
14           desde la l’inea de comandos. */
15        if (args.length < 1) {
16            System.out.println("You␣must␣specify␣a␣port");
17            return;
18        }
19
20        /* Puerto de escucha del servidor. */
21        int port = Integer.parseInt(args[0]);
22
23        /* Usaremos un generador de n’umeros aleatorios para simular la
24         * p’erdida de paquetes y el retraso de la red. */
25        Random random = new Random();
26
27        /* Creamos un socket de tipo DatragramSocket para recibir y
28         * enviar paquetes UDP. */
29        DatagramSocket socket = new DatagramSocket(port);
30
31        /* Processing loop. */
32        while (true) {
33
34            /* Creamos la estructura de datos que nos servir’a para
35               almacenar un paquete UDP. */
36            DatagramPacket request = new DatagramPacket(new byte[1024], 1024);
37
38            /* Nos bloqueamos hasta que se recibe el siguiente paquete
39               UDP. */
40            socket.receive(request);
41
42            /* Imprimimos el payload del paquete. */
43            printData(request);
44
45            /* Decidimos si responder o simular la p’erdida del paquete. */
46            if (random.nextDouble() < LOSS_RATE) {
47                System.out.println("␣␣␣Reply␣not␣sent.");
48                continue;
49            }
50
51            /* Simulamos el retraso de la red. */
52            Thread.sleep((int) (random.nextDouble() * 2 * AVERAGE_DELAY));
53
54            /* Enviamos la respuesta. */
55            InetAddress clientHost = request.getAddress();
56            int clientPort = request.getPort();
57            byte[] buf = request.getData();
58            DatagramPacket reply = new DatagramPacket(buf, buf.length,
59                                                      clientHost, clientPort);
60            socket.send(reply);
61            System.out.println("␣␣␣Reply␣sent.");
62        }
63    }
64
65    /*
66     * Imprime los datos del datagrama (payload) sobre la salida est’andar.
67     */
68    private static void printData(DatagramPacket request) throws Exception {
69        /* "buf" apunta al comienzo de los datos en el paquete. */
70        byte[] buf = request.getData();
71
72        /* Convertimos "buf" en un stream de entrada de bytes. */
73        ByteArrayInputStream bais = new ByteArrayInputStream(buf);
74
75        /* Convertimos "bais" en un stream de entrada de caracteres. */
76        InputStreamReader isr = new InputStreamReader(bais);
77
78        /* Convertimos "isr" en un stream de entrada de caracteres
79           buffereado. As’i podremos leer l’ineas completas. Una l’inea
80           es cualquier combinaci’on de caracteres que acaba en
81           cualquier combinaci’on de \r y \n. */
82        BufferedReader br = new BufferedReader(isr);
83
84        /* Los datos del mensaje est’an contenidos en una ’unica
85           l’inea. As’i la leemos. */
86        String line = br.readLine();
87
88        /* Imprimimos la direcci’on del host que env’ia el mensaje y los
89           datos del mismo. */
90        System.out.println("Received␣from␣" +
91                           request.getAddress().getHostAddress() +
92                           ":␣" +
93                           line);
94    }
95}

4 Compilacin del servidor

Evidntemente, deber tener instalado un compilador de Java para realizar la anterior accin. Existen versiones tanto para Linux como para Windows. Se recomienda el compilador y la mquina virtual de Sun para realizar esta parte de la prctica (http://java.sun.com) o el que se instala mediante el paquete openjdk-?-jdk.

5 Ejecucin del servidor

6 El cliente

El cliente enva 10 peticiones de ping al servidor especificado. Cada mensaje contiene un payload de datos donde figura la cadena PING, un nmero de secuencia y una estampa de tiempo.

Tras enviar un paquete, el cliente espera hasta un segundo para recibir una respuesta. Si transcurrido este tiempo sta no llega, el cliente supone que su paquete de peticin o el paquete de respuesta (o ambos) se ha(n) perdido.

1import java.io.*;
2import java.net.*;
3import java.util.*;
4
5/*
6 * Un cliente que genera peticiones ping sobre UDP.
7 */
8
9public class PingClient {
10    public static final String CRLF="\r\n";
11
12    public static void main(String[] args) throws Exception {
13
14        /* Comprobamos que se han introducido los par’ametros de entrada
15           desde la l’inea de comandos. */
16        if (args.length != 2) {
17            System.out.println("You␣must␣specify␣a␣server␣and␣a␣port");
18            return;
19        }
20
21        /* Obtenemos la dir IP del servidor a partir de su nombre. */
22        InetAddress serverAddress = InetAddress.getByName(args[0]);
23
24        /* Obtenemos el puerto en el que escucha el servidor. */
25        int serverPort = Integer.parseInt(args[1]);
26
27        /* Creamos un socket de tipo DatragramSocket para enviar y
28         * recibir paquetes UDP. */
29        DatagramSocket socket = new DatagramSocket();
30
31        /* Asignamos un tiempo m’aximo de espera de recepci’on a trav’es
32         * de este socket (time-out) de un segundo. */
33        socket.setSoTimeout(1000);
34
35        /* Creamos la estructura de datos que almacenar’a un paquete UDP. */
36        DatagramPacket reply = new DatagramPacket(new byte[1024], 1024);
37
38        /* Enviamos los 10 paquetes. */
39        for (int i=0; i<10; ++i) {
40
41            /* Generamos el payload del paquete con el instante en que
42               el paquete es generado. */
43            long sendingDate = (new Date()).getTime();
44            String payload = "Ping␣" + (i+1) + "␣" + sendingDate + CRLF;
45            DatagramPacket request =
46                new DatagramPacket(payload.getBytes(),
47                                   payload.getBytes().length,
48                                   serverAddress,
49                                   serverPort);
50
51            System.out.print("Packet␣sent␣with␣payload:␣" + payload);
52
53            /* Envi’amos el paquete. */
54            socket.send(request);
55
56            /* Esperamos la respuesta del servidor. */
57            try {
58                socket.receive(reply);
59            }
60            catch(SocketTimeoutException e) {
61                /* Se ha producido un time-out. */
62                System.out.println("Not␣response␣from␣server");
63                continue;
64            }
65
66            /* Calculamos el tiempo que el paquete ha tardado en regresar. */
67            long receivingDate = (new Date()).getTime();
68            System.out.println("Packet␣received␣after␣" +
69                               (receivingDate-sendingDate) + "␣miliseconds");
70        }
71    }
72}