El documento describe una práctica introductoria sobre el uso del paquete de comunicaciones lower layer UDP, que permite la comunicación entre procesos a través de end points formados por direcciones IP y puertos. Se detalla cómo construir, atarse y desatarse de end points, así como la composición, envío y recepción de mensajes utilizando buffers. Además, se proponen actividades prácticas para estudiar y modificar los programas cliente y servidor relacionados con el paquete.

1. Pr´ ctica de Redes I: Pr´ ctica introductoria
a a
El paquete de comunicaciones Lower Layer
Grupo de Sistemas y Comunicaciones
Octubre de 2006
Resumen
En las pr´ cticas de Redes I se utilizar´ el paquete de comunicaciones Lower Layer, que ofrece un
a a
servicio extremo a extremo de env´o de mensajes no orientado a conexi´ n y no fiable. El objetivo de
ı o
esta pr´ ctica es familiarizarse con este paquete de comunicaciones y realizar un cliente y un servidor
a
sencillos que lo utilicen.
1. Introducci´ n
o
El paquete Lower Layer UDP 1 es el que ofrece las primitivas de comunicaciones que utilizar´ n los
a
programas a realizar en las pr´ cticas. Cons´ ltese su especificaci´ n2 adjunta.
a u o
2. Direcciones y puertos: los End Point
Un End Point es el destino que tienen los datos que un proceso de una m´ quina le env´a a otro proceso
a ı
en otra m´ quina. Un End Point se construye a partir de la direcci´ n IP y de un puerto de la m´ quina del
a o a
proceso al que van dirigidos los datos. Los End Point son puntos de destino y origen de los mensajes que
transportan los datos.
2.1. Construir un End Point
Para construir un End Point se usa el procedimiento Build:
Server_EP := Lower_Layer_UDP.Build("212.128.4.155", 6001);
Un proceso puede construir tantos End Point como desee, sean de la m´ quina que sean (en la que
a
reside u otra cualquiera).
2.2. Atarse a un End Point
Para que un proceso pueda recibir datos de otros, es necesario que anteriormente se ate a un End Point.
De esta forma indica su intenci´ n de escuchar mensajes dirigidos a ese End Point. Esto se puede hacer
o
de dos formas:
At´ ndose a un puerto concreto: Se hace llamando primero a Build para construir un End Point,
a
y luego a Bind para atarse a el. N´ tese que la direcci´ n IP que se usa en el Build ha de ser
´ o o
necesariamente de la m´ quina en la que se ejecuta el c´ digo:
a o
Server_EP := Lower_Layer_UDP.Build ("212.128.4.155", 6001);
Lower_Layer_UDP.Bind (Server_EP);
1 Lower Layer UDP es un sencillo recubrimiento de la biblioteca Lower Layer para utilizar solamente la parte de UDP. No es
necesario entender toda la complejidad de Lower Layer para realizar las pr´ cticas, sino solamente el subconjunto que aparece en
a
Lower Layer UDP
2 ./lower_layer_udp.ads
1

2. At´ ndose a un puerto libre cualquiera: Se hace llamando a Bind_Any, que autom´ ticamente
a a
construye un End Point con la direcci´ n IP de la m´ quina y un puerto libre cualquiera asignado por
o a
´
el sistema operativo, y luego se ata a el. Este End Point es devuelto como par´ metro en modo out
a
por Bind_Any3 :
LLU.Bind_Any(Client_EP);
2.3. Desatarse de un End Point
´
Cuando un proceso ya no quiere recibir m´ s datos en un End Point, puede desatarse de el. De esta
a
forma indica que ya no va a escuchar´ en mensajes dirigidos a ese End Point. Esto se hace utilizando el
a
procedimiento Unbind:
Lower_Layer_UDP.Unbind (Client_EP);
Hay que tener en cuenta que antes de llamar a Unbind es necesario estar seguro de que no hay
mensajes pendientes de recibir en ese End Point.
Por otro lado, antes de terminar un programa que utilice Lower Layer UDP, despu´ s de desatarse de
e
todos los End Point que se han utilizado, es necesario llamar al procedimiento Finalize:
Lower_Layer_UDP.Finalize;
3. Composici´ n de mensajes: Buffers
o
Cuando un proceso va a enviar un mensaje a otro es necesario que lo almacene previamente en un
Buffer.
3.1. Declaraci´ n de un Buffer
o
Para utilizar un Buffer es necesario declarar una variable del tipo Buffer_Type4 . En dicha decla-
raci´ n es necesario proporcionar el tama˜ o en bytes que se reserva para almacenar datos en ella. Como
o n
ser´ necesario utilizar el atributo ’Access de estas variables, es necesario declarar la variable como
a
aliased:
Buffer: aliased LLU.Buffer_Type(1024);
3.2. Inicializaci´ n de un Buffer
o
El procedimiento Reset permite vaciar el contenido de un Buffer. Es necesario vaciar siempre un
Buffer antes de utilizarlo para componer un nuevo mensaje a enviar, y antes de recibir un nuevo mensaje
´ ´
en el. De esta forma se garantiza que dicho Buffer no tiene datos previos en el:
Lower_Layer_UDP.Reset(Buffer);
3.3. Inserci´ n de datos en un Buffer
o
La forma de introducir un dato en un Buffer es invocando el atributo ’Write del tipo del dato en
cuesti´ n, de la siguiente forma:
o
Buffer: aliased Buffer_Type (1024);
I: Integer;
...
I := 5;
Integer’Write (Buffer’Access, I);
Tras introducir un dato en un Buffer, el siguiente dato que se introduzca en el mismo Buffer se colo-
car´ a continuaci´ n de aqu´ l.
a o e
3 Para comprender mejor c´ mo se comporta “Bind
o Any”, puede pensarse que se deber´a llamar m´ s bien “Build Any And Bind”
ı a
4 Nota: Este tipo deriva del tipo Stream de la biblioteca est´ ndar de Ada.
a
2

3. 3.4. Extracci´ n de datos en un Buffer
o
Para extraer un dato de un Buffer se invoca el atributo ’Read del tipo del dato en cuesti´ n, de la
o
siguiente forma:
Buffer: aliased Buffer_Type(1024);
I: Integer;
...
Integer’Read (Buffer’Access, I);
Una vez extra´do un dato de un Buffer, la siguiente invocaci´ n de Read que se realice sobre el mismo
ı o
Buffer extraer´ el dato que se encuentre a continuaci´ n de aqu´ l.
a o e
4. Env´o y recepci´ n de mensajes
ı o
4.1. Env´o
ı
Cuando un proceso quiere enviar datos a otro proceso, ha de conocer el End Point en el que escucha
el proceso receptor.
Una vez que sabe el End Point de destino de su mensaje, un proceso lo env´a utilizando el procedi-
ı
miento Send_From cuya cabecera es:
procedure Send_From (From: in End_Point_Type;
To : in End_Point_Type;
Data: access Buffer_Type);
Los par´ metros son:
a
From: El End Point desde el que se envia el mensaje, y en el que posiblemente se esperan mensajes
de respuesta.
To: End Point destino del proceso al que se env´a el mensaje.
ı
Data: acceso a un Buffer vac´o en el que se hayan los datos que se quieren enviar.
ı
As´, el c´ digo que llama a Send_From tendr´ el aspecto:
ı o a
Lower_Layer_UDP.Send_From (From_EP, To_EP, Buffer’Access);
4.2. Recepci´ n
o
Un proceso que quiere recibir mensajes previamente debe construir un End Point con la direcci´ n IP
o
´
de su m´ quina y un puerto libre, y atarse en el. Una vez hecho esto, usa el procedimiento Receive_From,
a
cuya cabecera es:
procedure Receive_From (From : out End_Point_Type;
To : in End_Point_Type;
Data : access Buffer_Type;
Timeout: in Duration;
Expired: out Boolean);
Los par´ metros son:
a
From: El End Point desde el que se envi´ el mensaje y en el que posiblemente el emisor espera
o
respuesta.
To: End Point en el que escucha el proceso y al que se envi´ el mensaje.
o
Data: acceso a un Buffer vac´o en el que se quedar´ almacenado el mensaje que llegue. Es muy
ı a
importante haber reinicializado dicho Buffer, llamando a Reset, antes de llamar a Receive.
3

4. Timeout: plazo (en segundos) durante el cual se esperar´ la llegada del mensaje de un mensaje.
a
Si no llegara en este plazo, el procedimiento retorna igualmente, quedando el Buffer vac´o. El tipo
ı
Duration es compatible con Float.
Expired: par´ metro de vuelta. Toma el valor True cuando expira el plazo Timeout sin que
a
llegue ning´ n mensaje (con lo que el Buffer queda vac´o). Toma el valor False cuando llega
u ı
alg´ n mensaje antes de que venza el plazo, mensaje que queda almacenado en el Buffer.
u
As´, el c´ digo que llama a Receive_From tendr´ el aspecto:
ı o a
Receive_From (From_EP, To_EP, Buffer’Access, 2.0, Expired);
if Expired then
Put_Line ("Expir´ el plazo");
o
else
Integer’Read (Buffer’Access, I);
end if;
5. Pr´ ctica a realizar
a
1. Estudiar la especificaci´ n del paquete de comunicaciones Lower Layer UDP (lower layer udp.ads5 ).
o
2. Estudiar el c´ digo del programa cliente (client.adb6 ) y del programa servidor (server.adb7 ).
o
3. Compilar el cliente y el servidor y probarlos. Es necesario que el comando gnatmake encuentre
la biblioteca de comunicaciones Lower_Layer. Esto puede hacerse de dos formas:
Teniendo previamente definida la variable de entorno ADA_INCLUDE_PATH en la forma:
export ADA_INCLUDE_PATH=/opt/ll/lib
Utilizando el flag -I al llamar a gnatmake, en la forma:
gnatmake -I/opt/ll/lib client.adb
4. Modifica el cliente y el servidor de forma que:
el servidor reciba como argumento en la l´nea de comandos el puerto en en el que se debe
ı
atar.
el cliente reciba como argumentos en la l´nea de comandos el nombre de la m´ quina y el
ı a
puerto en el que est´ atado el servidor.
a
Utiliza las funciones Get_Host_Name y To_IP que aparecen en la especificaci´ n de Lower_Layer_UDP
o
y consulta la especificaci´ n del paquete Ada.Command_Line en el manual de referencia del len-
o
guaje.
5. Realiza modificaciones sencillas al cliente y al servidor para cerciorarte de que comprendes su
funcionamiento.
5 ./lower_layer_udp.ads
6 ./client.adb
7 ./server.adb
4