Protocolo TCP/IP

Introducción:

En esta sección vamos a explorar una de las características más interesantes de Java: su capacidad para integrarse en redes TCP/IP. Esto permite usar este lenguaje para construir aplicaciones distribuidas en muy poco tiempo.

A lo largo de esta sección asumiremos que el lector ya conoce suficientemente los aspectos de Java relacionados con Entrada/Salida, trabajo con flujos de datos, manejo de excepciones, etc.

Los pasos que seguiremos serán los siguientes: primero presentaremos los conceptos básicos de los protocolos de Internet, necesarios para la discusión posterior; a continuación veremos la forma que tiene Java de implementar dichos conceptos; finalmente analizaremos pequeños programas que nos muestren la mejor forma de utilizar las herramientas que Java pone a nuestra disposición.

Nota:Este capítulo no pretende ser una introducción genérica al funcionamiento de la pila de protocolos TCP/IP. Por ello recomendamos la lectura de obras de referencia que cumplen este objetivo. Para el lector interesado exclusivamente en el funcionamiento interno de TCP/IP, sugerimos "Internetworking with TCP/IP", de Douglas E. Comer. Para el que busque un texto más didáctico y que cubra el tema desde un punto de vista más generalista, es interesante "Computer Networks", de Andrew S. Tanenbaum. Ambos editados en inglés por Prentice Hall.

Toda la documentación original sobre los protocolos utilizados se encuentran disponibles como documentos RFC y STD en Internet. Uno de los "mirrors" españoles se encuentra en RedIris.

Conceptos básicos

Direcciones IP

Como el lector sabrá, todas las máquinas conectadas a una red IP (Internet Protocol), bien sea la red pública Internet o una red privada, se distinguen por su dirección IP. Esta dirección IP es un número de 32 bits, que por comodidad suele expresarse en forma de 4 números decimales separados por puntos. Cada uno de estos números se corresponde con 8 bits de la dirección IP. Por ejemplo: 209.41.57.70 es una dirección IP.

Esta dirección IP puede ser fija o puede ser distinta cada vez que la máquina se conecta a la red. Esto es lo que ocurre a casi todos los usuarios que se conectan a Internet a través de la línea telefónica.

Nombres de dominio

Para facilitar todavía más el trabajo con direcciones IP, existen los nombres de dominio. Estos nombres de dominio son cadenas alfanuméricas, más fáciles de recordar, y que suelen tener una única dirección IP asociada. Siguiendo con el ejemplo anterior, akal.com es el nombre de dominio asociado con la dirección IP 209.41.57.70.

Los encargados de traducir los nombres de dominios en dirección IP son los servidores DNS (Domain Name Server). Estos servidores DNS mantienen unas tablas de correspondencias entre direcciones y dominios. Estas tablas se actualizan periódicamente a medida que los distintos servidores DNS intercambian sus datos entre sí.

Puertos

La forma general de establecer una comunicación a través de Internet es: 1) Indicar la dirección IP de la máquina con la que queremos conectar y 2) especificar el número de puerto dentro de esa máquina a través del cual queremos establecer la comunicación.

Para que la comunicación se pueda establecer debe haber un proceso en esa máquina "escuchando" en el puerto especificado. Generalmente, cada máquina tiene una serie de servicios escuchando en ciertos puertos standard: el servidor HTTP (servidor Web) en el puerto 80, el servidor FTP en el puerto 21, el puerto 25 para SMTP (correo electrónico), etc. Estos puertos están asignados en el standard RFC 1700.

Circuitos y Paquetes

La forma más común de transmitir información a través de Internet es mediante los protocolos de transporte TCP (Transport Control Protocol) y UDP (User Datagram Protocol). Estos protocolos se diferencian principalmente en que TCP (definido en RFC 793) está orientado a la conexión (es decir, necesita el establecimiento de una conexión entre ambos extremos y realiza un complejo control de errores), mientras que UDP (definido en RFC 768) se basa en el envío de paquetes individuales, sin establecimiento previo de una conexión y sin control de errores.

Obviamente, cada tipo de comunicación tiene sus ventajas e inconvenientes, y será necesario decidirse por un protocolo u otro en función de las necesidades de cada aplicación.

****************************************************************************************

Mínimo Servidor TCP/IP

Veamos el código que presentamos en el siguiente ejemplo, donde desarrollamos un mínimo servidor TCP/IP, para el cual desarrollaremos después su contrapartida cliente TCP/IP. La aplicación servidor TCP/IP depende de una clase de comunicaciones proporcionada por Java: ServerSocket. Esta clase realiza la mayor parte del trabajo de crear un servidor.

import java.awt.*;
import java.net.*;
import java.io.*;

class minimoServidor {
   public static void main( String args[] ) {
       ServerSocket s = (ServerSocket)null;
       Socket s1;
       String cadena = "Tutorial de Java!";
       int longCad;
       OutputStream s1out;

       // Establece el servidor en el socket 4321 (espera 300 segundos)
       try {
           s = new ServerSocket( 4321,300 );
       } catch( IOException e ) {
           System.out.println( e );
           }

       // Ejecuta un bucle infinito de listen/accept
       while( true ) {
           try {
               // Espera para aceptar una conexión
               s1 = s.accept();
               // Obtiene un controlador de fichero de salida asociado
               // con el socket
               s1out = s1.getOutputStream();

               // Enviamos nuestro texto
               longCad = sendString.length();
               for( int i=0; i < longCad; i++ )
                   s1out.write( (int)sendString.charAt( i ) );

               // Cierra la conexión, pero no el socket del servidor
               s1.close();
           } catch( IOException e ) {
               System.out.println( e );
               }
           }
       }
   }

Mínimo Cliente TCP/IP

El lado cliente de una aplicación TCP/IP descansa en la clase Socket. De nuevo, mucho del trabajo necesario para establecer la conexión lo ha realizado la clase Socket. Vamos a presentar ahora el código de nuestro cliente más simple, que encaja con el servidor presentado antes. El trabajo que realiza este cliente es que todo lo que recibe del servidor lo imprime por la salida estándar del sistema.

import java.awt.*;
import java.net.*;
import java.io.*;

class minimoCliente {
   public static void main( String args[] ) throws IOException {
       int c;
       Socket s;
       InputStream sIn;

       // Abrimos una conexión con breogan en el puerto 4321
       try {
           s = new Socket( "breogan",4321 );
       } catch( IOException e ) {
           System.out.println( e );
           }

       // Obtenemos un controlador de fichero de entrada del socket y
       // leemos esa entrada
       sIn = s.getInputStream();
       while( ( c = sIn.read() ) != -1 )
           System.out.print( (char)c );
  
       // Cuando se alcance el fin de fichero, cerramos la conexión y
       // abandonamos
       s.close();
       }
   }