Tutorial de cliente/servidor en Visual Basic 6.0

2. ¿Qué es
   cliente/servidor?
3. Preparando el Visual
   Basic
4. Descripción del componente
   Winsock
5. Mi primera aplicación
   cliente
6. Mi primera
   aplicación servidor
7. Aplicación servidor
   multi-conexión
8. Conclusión

INTRODUCCION

Este tutorial pretende explicar en forma práctica
la implementación y desarrollo de
aplicaciones cliente y servidor, ya sea mono-conexión o
multi-conexiones, usando el componente Winsock Control 6.0 sobre
el entorno de desarrollo de VisualBasic v6.0. Cualquier otra
versión de este control debería funcionar
también.

Para el seguimiento de este texto, se
recomienda ir practicando las cosas mencionadas a la vez que las
vallas leyendo, así podrás familiarizarte de mejor
manera con el entorno y no te perderás por el
camino.

Se da por entendido que el lector conoce el lenguaje
Visual Basic y
este familiarizado con su sintaxis y metodología de programación.

¿QUE ES
CLIENTE/SERVIDOR?

Imagino que esta es la primera pregunta que se
harán todos, ¿que es eso de cliente servidor?,
cliente/servidor no es más que la forma de llamar a las
aplicaciones que trabajan en conjunto como "nodos" de información (por así decirlo). Esto
es que existe una aplicación totalmente independiente de
la parte cliente la cual esta dispuesta a servir
información cuando el cliente se la
solicita.

Ejemplos de estos pueden ser los servidores de
Paginas Webs (HTTP), servidores
de Transferencia de Archivos
(FTP),
etc.

No podemos continuar sin antes dar una breve
definición de los términos Cliente y
Servidor.

Cliente: Es toda aplicación que
se conecta a un Servidor para solicitarle alguna
información.

Servidor: Es toda aplicación que se
mantiene a la espera de un cliente que solicite
información, la cual se la entregara si fuese posible. Se
dice que este ofrece o sirve un servicio.

Para que quede mas claro, voy a dar un ejemplo sobre el
funcionamiento del servidor de Paginas Webs (HTTP). Para ello
realizaremos una visita a un sitio Web en particular
y analizaremos después lo sucedido:

1. Ejecutamos nuestro navegador (Internet
   Explorer, Netscape, Firefox, etc.)
2. Ingresamos la dirección del sitio Web que deseamos ver,
   por ej. www.google.com
3. Le damos al botón "Ir", "Ver", etc. Para que
   nuestro navegador se conecte a la dirección.
4. Nuestro navegador inmediatamente comienza a recibir
   poco a poco la página
   Web solicitada.
5. Una vez concluida la descarga nuestro navegador se
   desconecta del sitio de forma oculta al usuario.

Ahora si analizamos los pasos que fueron necesarios para
visitar un sitio Web, veremos que lo primero que tenemos que
hacer es ejecutar un programa específico el cual
tiene la habilidad de conectarse a una dirección Web. Este
programa que
se conecta a X dirección, lo llamaremos Cliente,
porque es el que solicita la información, en este caso
solicita una pagina Web. Y quien le entrega dicha
información al cliente se llamara Servidor, que en
este caso es una aplicación que corre bajo la
dirección del sitio en un computador
remoto conectado a Internet (www.google.com).

Como conclusión, si analizamos la petición
de la página Web podemos obtener que los elementos
básicos que necesitamos para una conexión
cliente/servidor son:

• Un programa Cliente (el que solicita la
  información)
• Un programa Servidor (el que sirve la
  información que necesitamos)
• Una dirección hacia el servidor (para poder saber
  a donde conectar)

Con estos tres elementos podemos realizar una
conexión cliente/servidor sin problemas y es
la base de las aplicaciones.

También es muy importante mencionar, que en lo
que a "dirección" se refiere, esta formada por un
número IP (o DNS) y un
número de PUERTO. Este último es así porque
un computador puede tener muchos puertos destinados para ofrecer
distintos servicios, ya
sean Paginas Webs (Puerto 80), Mails (Puerto 25 y 110), FTP
(puerto 21), Telnet (23),
etc.

Estos puertos que he mencionado son los acostumbrados
para estos servicios, eso no quiere decir que tenga que ser
siempre así, por ej. Podemos usar el puerto 80
(Comúnmente para HTTP) para ofrecer un servicio FTP, o
bien implementar un Chat o
cualquier cosa que se nos ocurra. Los puertos solo están
disponibles para cualquier uso que le queramos dar.

Como referencia es bueno saber cuantos puertos puede
usar una computadora.
Los puertos están direccionados por 16 Bits, esto es que
existe un total de 2^16 puertos, lo que equivale a 65.536 puertos
disponibles, aunque como el puerto 0 no se puede usar solo
tenemos utilizables desde el puerto 1 al puerto
65.535.

PREPARANDO EL
VISUAL BASIC

El Visual Basic v6.0 por defecto no esta preparado para
trabajar con aplicaciones cliente/servidor, y hace falta acomodar
algunas cosas antes de comenzar a trabajar.

1. Lo primero será crear un nuevo proyecto. Elige
   Aplicación Estándar (prácticamente puede
   ser cualquier otra, pero en este caso se trabajara
   así)

2. 

   1. Ve al menú "Proyecto" y selecciona
      "Componentes".
   2. En la lista de componentes busca "Microsoft Winsock Control 6.0", puede ser
      otra versión o bien terminar con
      "(SP6)".
   3. Marca este control y dale al botón
      "Aceptar".
3. Ahora necesitaremos cargar el Control Winsock, para
   ello realiza lo sig.:

Con esto veremos que se nos agrega un nuevo control
llamado Winsock, con el icono .

Ahora ya nos encontramos listos para realizar una
aplicación Cliente/Servidor.

DESCRIPCION DEL
COMPONENTE WINSOCK

El componente Winsock del Visual Basic es el que permite
realizar conexiones Cliente/Servidor a través de protocolos TCP y
UDP. Este único componente puede trabajar de dos formas,
como Cliente (Conecta a un servidor) y como Servidor (Recibe
conexiones), además de poder realizar vectores de
Winsock lo que permite administrar varias conexiones con un mismo
código
en común.

Este componente depende directamente del control ActiveX
MSWINSCK.OCX.

A continuación paso a describir las principales
propiedades, métodos y
eventos del
componente.

Propiedades

Property BytesReceived As Long
(Solo lectura)

Retorna el número de Bytes
recibidos en la conexión.

Property Index As Integer (Solo
lectura)

Retorna/Asigna el numero que identifica
al control en un arreglo de controles.

Property LocalHostName As String
(Solo lectura)

Retorna el nombre de la maquina
local.

Property LocalIP As String (Solo
lectura)

Retorna la dirección IP de la
maquina local.

Property LocalPort As Long (Solo
lectura)

Retorna el puerto usado en la maquina
local.

Property Protocol As
ProtocolConstants

Retorna/Asigna el tipo de protocolo que
usara el Socket

Estos valores pueden
ser dos: sckTCPProtocol y sckUDPProtocol.

Property RemoteHost As
String

Retorna/Asigna el nombre
(dirección) usado para identificar a la maquina
remota.

Property RemoteHostIP As String
(Solo lectura)

Retorna la dirección IP del Host
Remoto.

Property RemotePort As
Long

Retorna/Asigna el puerto al cual se
conectara en el computador remoto.

Property SocketHandle As Long
(Solo lectura)

Retorna el manejador (Handle) del
Socket. (Solo para usuarios avanzados)

Property State As Integer (Solo
lectura)

Retorna el estado de
la conexion del Socket.

Metodos

Sub Accept(requestID As
Long)

Acepta un petición de
conexión entrante.

Sub Bind([LocalPort],
[LocalIP])

Amarra un socket a un específico
puerto y adaptador.

Sub Close()

Cierra la conexión
actual.

Sub Connect([RemoteHost],
[RemotePort])

Conecta a un computador
remoto.

Sub GetData(data, [type],
[maxLen])

Recibe datos enviados
por el computador remoto.

Sub Listen()

Se pone a la escucha de peticiones de
conexión entrantes.

Sub PeekData(data, [type],
[maxLen])

Mira los datos entrantes sin removerlos
desde el buffer.

Sub SendData(data)

Envía datos al computador
remoto.

Eventos

Event Close()

Ocurre cuando la conexión a sido cerrada
remotamente.

Event Connect()

Ocurre cuando la operación de conexión se
ha completo.

Event ConnectionRequest(requestID
As Long)

Ocurre cuando un cliente remoto se intenta
conectar.

Event DataArrival(bytesTotal As
Long)

Ocurre cuando se reciben datos desde un computador
remoto.

Event Error(Number As Integer,
Description As String, Scode As Long, Source As String, HelpFile
As String, HelpContext As Long, CancelDisplay As
Boolean)

Se dispara cuando ocurre algún error.

Event SendComplete()

Ocurre después que una operación de envio
se haya completado.

Event SendProgress(bytesSent As
Long, bytesRemaining As Long)

Ocurre mientras se esta enviando un dato.

Constantes

Enum StateConstants

Estas son las constantes devueltas por la propiedad
State.

Enum ProtocolConstants

Estos son los valores
permitidos por la propiedad Protocol.

Enum ErrorConstants

Constantes de errores, devueltas por el evento
Error.

MI PRIMERA
APLICACIÓN CLIENTE

Esta aplicación trabajara como un cliente simple
que conecte a cualquier servidor, permita enviar texto plano y a
la vez mostrar la información devuelta por este. Parecido
a como trabajan los clientes de
Telnet.

1. Creando la interfaz del usuario

Realiza un formulario como el mostrado abajo, con los
nombres por defecto de cada control y guarda el proyecto con el
nombre "Cliente.vbp".

2. Implementando la conexión

La primera acción
a realizar y fundamental para toda aplicación de este
tipo, es crear la conexión al servidor, ya que solo se
puede transmitir información si la conexión
cliente/servidor se encuentra activa.

Propiedades necesarias

– RemoteHost: Asignamos la dirección a la que
deseamos conectar.

– RemotePort: Asignamos el puerto al que deseamos
conectar en RemoteHost.

Métodos necesarios

– Connect(): Conecta al servidor.

– Close(): Cierra la conexión al
servidor.

Eventos involucrados

– Connect(): Ocurre cuando hemos establecido con
éxito
la conexión al servidor

– Close(): Ocurre cuando el servidor nos cierra la
conexión.

– Error(): Ocurre en caso de errores.

Para realizar la conexión utilizamos el siguiente
código:

Aquí se pueden ver claramente dos partes
principales:

En las primeras dos líneas asignamos los datos de
conexión al host remoto, como son la IP/DNS (RemoteHost) y
Puerto (RemotePort).

En la última línea llamamos al método
"Connect" para realizar la conexión, siempre
asegurándonos que el Socket no este utilizándose.
Para ello llamamos al método "Close" que se encarga de
cerrar toda conexión pendiente en el Socket.

Nota: También se puede especificar los datos
de conexión (IP y Puerto) directamente en el comando
"Connect" como parámetros, de la sig. Forma:
Winsock1.Connect(Host, Puerto).

Si la conexión se realiza con éxito se
dispara un evento para tal fin, en donde podemos realizar
acciones
inmediatas en el momento preciso en que se logra establecer la
conexión con el servidor. El evento es el
siguiente:

En este caso solo nos limitamos a mostrar un mensaje en
pantalla especificando que la conexión se ha realizado con
éxito.

En este momento ya tenemos creado los lazos
básicos para realizar cualquier intercambio de datos con
el servidor, ya sea texto ASCII o datos
binarios.

También hay que tener presente que en cualquier
momento el servidor nos puede cerrar la conexión, o bien
cerrarse por algún error, para ello es que contamos con el
evento "Close", que se dispara al perder la conexión con
el servidor:

Aquí solo desplegamos un mensaje en la pantalla
informando del evento ocurrido, y cerrando previamente el Socket
para asegurarnos de que este actualice sus valores según
el estado actual.

En cambio si
queremos cerrar nosotros mismos la conexión con el
servidor basta con llamar al método "Close"
directamente:

3. Enviando/recibiendo datos

Una vez realizada con éxito nuestra
conexión, solo resta comenzar a transferir datos, cabe
mencionar que estos datos se envían siempre en forma
binaria aunque sea solo texto, ya que el texto en si es una
representación grafica de un numero binario, con esto
quiero expresar que a través de un socket puedes enviar
texto normal o datos binario, todos como variables de
tipo String (cadenas).

Métodos necesarios

– SendData: Envía datos al otro extremo de la
conexión (socket remoto).

– GetData: Recibe datos enviados por el extremo remoto
(socket remoto).

Eventos involucrados

– DataArrival(): Ocurre cuando el socket remoto nos esta
enviando datos.

– Error(): Ocurre en caso de errores.

Para enviar datos utilizamos el método "SendData"
de la sig. forma:

Al método SendData solo se le pasa como
parámetro el dato a enviar (en este caso el contenido de
un TextBox + los caracteres de nueva línea y retorno de
carro) y este lo envía inmediatamente al socket
remoto.

Cuando el socket remoto nos envía un dato (de la
misma forma que realizamos anteriormente) se nos genera el evento
"DataArrival()" indicando que tenemos nueva información
disponible, y esta información la cogemos con el
método "GetData":

En este ejemplo solo obtenemos los datos y lo mostramos
inmediatamente en la ventana del cliente, no hacemos
ningún tratamiento previo de los datos, como sería
lo habitual.

4. Manejo de errores

Es muy importante tomar alguna acción cuando se
produzca algún error, aunque esta acción tan solo
sea cerrar la conexión e informar al usuario de lo
ocurrido.

Para el manejo de errores producidos durante la
conexión contamos con un evento dedicado, llamado
"Error()" el cual retorna varios valores para darnos
información al respecto, entre ellos los mas comunes
son:

En caso de producirse algún error la
acción más simple de realizar es simplemente cerrar
la conexión con el método "Close":

5. Prueba de la aplicación

En este punto ya estamos listo para comenzar a usar
nuestro programa cliente, solo le damos a ejecutar desde el
entorno del Visual Basic o bien compilamos y ejecutamos el
archivo.

Para asegurarnos que todo ha salido bien, vamos a
realizar una pequeña prueba, conectaremos a www.google.com
y solicitaremos la página de inicio:

En el campo "Servidor" de nuestro programa escribimos
"www.google.com", y en el campo "Puerto" colocamos el "80". Le
damos al botón "Conectar".

Si todo va bien, deberíamos obtener el mensaje
"Conexión establecida", si es así entonces en el
campo de enviar texto, escribimos "GET / HTTP/1.1":

Y para enviar presionamos dos veces el botón
"Enviar". La razón de esto es para que envié la
cadena que escribimos mas dos caracteres de retorno de carro o
nueva línea (vbCrLf), esto por especificaciones del
protocolo HTTP (que es lo que estamos utilizando
aquí).

Deberíamos ver algo como esto:

Si recibimos texto desde el servidor (Las cadenas que
inician con "Servidor >") es que nuestro cliente funciona
perfectamente y hemos realizado la conexión, enviado y
recibido datos con éxito. Ya podemos descasar un rato y
celebrar :).

MI
PRIMERA APLICACIÓN SERVIDOR

Vamos a realizar una aplicación que se mantenga a
la escucha de una conexión entrante y la acepte,
podrá enviar y recibir datos desde el cliente.

Al principio será mono-conexión, es decir,
solo permitirá una conexión a la vez al servidor,
pero luego la implementaremos para múltiples
conexiones.

Algunas partes del código para el servidor son
idénticas al del cliente (realizado anteriormente)
así que solo me limitare a mostrar como queda el
código y la explicación de la misma se
entenderá que es la correspondiente a la del
cliente.

1. Creando la interfaz del usuario

Realiza un formulario como el mostrado abajo, con los
nombres por defecto de cada control y guarda el proyecto con el
nombre "Servidor.vbp".

2. Implementando la conexión

Al igual que en el cliente, lo primero es habilitar el
socket para que pueda quedar esperando una conexión, se
dice que queda "a la escucha de". Para esto solo necesitamos un
botón "Escuchar" y como datos un puerto local (a
elección) en el cual deseamos recibir conexiones
entrantes.

Propiedades necesarias

– LocalPort: Asignamos el puerto local en el cual
deseamos recibir conexiones.

Métodos necesarios

– Listen(): Escucha peticiones entrantes.

– Close(): Cierra la conexión al
servidor.

Eventos involucrados

– ConnectionRequest(): Ocurre cuando un cliente nos
solicita una conexión al servidor.

– Close(): Ocurre cuando el servidor nos cierra la
conexión.

– Error(): Ocurre en caso de errores.

El código utilizado para el botón
"Escuchar" es el siguiente:

La primera línea de código cierra la
conexión actual, para luego poder modificar los datos y
crear una nueva conexión sin que nos de
errores.

La siguiente línea le dice en que puerto deseamos
recibir conexiones, y luego llama al socket para que quede a la
escucha de conexiones en ese puerto.

Hasta aquí el socket solo esta "escuchando"
conexiones, es decir aun nadie se puede conectar al servidor
completamente porque no se ha implementado esa parte por el
momento.

Esto solo nos permite avisarnos cada vez que un cliente
se quiera conectar o bien cada vez que un cliente "Solicita una
conexión entrante". Cuando este sucede se genera el evento
"ConnectionRequest()":

Con estas líneas ya estamos conectado
completamente, pero de seguro que quedan
muchas dudas, y precisamente este punto es uno de los mas
importantes, así que pasare a detallar cada
cosa.

Lo primero que habíamos realizado es dejar el
socket a la escucha de conexiones (para esto utilizamos el
método "Listen"). Con esto ya tenemos un puerto abierto y
atento a toda actividad.

Cuando un "Cliente" se intenta conectar a ese puerto, el
socket lo detectara y para ello generara el evento
"ConnectionRequest()" que significa "Petición de
conexión" y además le asigna una identidad a
esa "Petición" que identifica al "Cliente" remoto. Esta
identidad es pasada como parámetro en el evento
"ConnectionRequest()" con el nombre de "requestID" y es de tipo
"Long".

Cuando se genera el evento lo que tenemos que hacer es
"Aceptar" la conexión entrante "requestID" mediante el
metodo "Accept", si no lo hacemos al llegar al "End Sub" del
evento, la conexión del "Cliente" será cerrada
automáticamente.

Algo interesante es ver que antes de aceptar la
conexión con "Accept" primero cerramos la conexión
con "Close", esto que puede parecer ilógico no lo es,
porque el socket lo teníamos ocupado y activo "escuchando
conexiones", y ahora necesitamos que establezca una
conexión par a par con el cliente, por ello es que
cerramos la función de "Escuchar conexiones del socket" y
le decimos que acepte la conexión entrante y así
automáticamente se conecta en forma directa con el cliente
y ya no entenderá nuevas conexiones entrantes. (No puede
realizar dos funciones a la
vez)

Para cerrar la conexión basta con usar el
método "Close" en cualquier momento:

3. Enviando/recibiendo datos

Esto es idéntico al explicado en la parte del
cliente:

4. Manejo de errores

Esto es idéntico al explicado en la parte del
cliente:

5. Prueba de la aplicación

Después de mucho "copiar/pegar" :), ya estamos
listos con nuestra aplicación servidor y listos para
realizar las primeras pruebas y ver
si todo trabaja correctamente.

Lo primero, ejecuta la aplicación servidor y
donde dice "Puerto" coloca cualquier número de los 65.535
disponibles, por ej. el "23". Luego dale al botón
"Escuchar":

Ahora ejecuta la aplicación Cliente y en
"Servidor" coloca "localhost" o "127.0.0.1" y en "Puerto" coloca
el "23". Dale al botón "Conectar".

En el servidor obtienes:

Ya estamos listos y trabajando con nuestra
aplicación Cliente/Servidor!!, ¿No lo crees?,
prueba a enviar texto entre cliente->servidor y
servidor->cliente y compruébalo tu mismo:

Ahora que sabemos que todo trabaja correctamente te
invito a hacer una prueba más. Con la conexión
establecida y funcionando de par a par ente cliente/servidor,
ejecuta una nueva aplicación "Cliente" e intenta conectar
al servidor en el mismo puerto (en este caso servidor "localhost"
y puerto "23"), y espera los resultados:

Nos dice que no logra establecer la conexión,
este es el mismo mensaje que entrega si el servidor al que
intenta conectar No tiene ningún puerto abierto!!,
lo que sucede es que el servidor ya no se encuentra "a la escucha
de conexiones" y por lo tanto no atenderá nuevas
peticiones de conexión.

APLICACIÓN SERVIDOR
MULTI-CONEXIÓN

Ahora nos encontramos con los conocimientos suficientes
para implementar un servidor que pueda aceptar un número
indefinido de conexiones entrantes.

En este proyecto usaremos el mismo código fuente
del servidor mono-conexión utilizado anteriormente, ya que
los cambios son muy pocos en realidad.

Bien, entonces abrimos el proyecto del servidor
mono-conexión y lo guardamos como "Servidor Multi.vbp"
para comenzar a trabajar.

La interfaz la dejaremos tal cual, todo el cambio
será en relación al código mismo y a la
modificación de algunos controles. También
trabajaremos con arreglo de controles, si nunca lo has hecho
podrías buscar un poco de información al respecto o
bien intentar seguir adelante, que lo explicare de forma
breve.

1. Vista general del funcionamiento

Como vimos anteriormente en el Servidor
mono-conexión, dejábamos un socket a la escucha de
conexiones entrantes, y al recibir una petición de
conexión (evento "ConnectionRequest") le decíamos
al Winsock que aceptara esa identidad y este a su vez
establecía una conexión con el cliente.

Los principios para
crear un servidor multi-conexión son los mismos, salvo que
necesitamos dejar un socket escuchando permanentemente conexiones
entrantes, este nunca se debe cerrar (al contrario de lo que
pasaba en el caso del servidor mono-conexión), entonces
¿como podemos aceptar una conexión si no podemos
cerrar el socket que tenemos a la escucha?, ¿acaso podemos
dejar un mismo socket escuchando conexiones y atendiendo otra a
la vez?, la respuesta es No podemos, pero nada nos impide
hacer que otro socket que se encuentra inactivo acepte y atienda
una petición de conexión. De esta forma el trabajo
total se reparte entre varios sockets: un socket permanentemente
escuchando peticiones de conexión (recepcionista) y otros
tantos socket que se encargan de atender a cada uno de los
clientes (ejecutivos).

2. Creando el arreglo de WinSocks

Para poder trabajar con varias conexiones a la vez
necesitamos varios sockets disponibles, ya que cada uno solo
puede trabajar con una sola conexión, y como en
principio no conocemos la cantidad de Winsocks que necesitaremos
debemos inclinarnos por crear Arreglos de controles Winsock e
irlos cargando dinámicamente.

Si lo deseas también puedes crear una N cantidad
de Winsocks y solo trabajar con ellos, pero tu número
máximo de conexiones posibles será el máximo
de Winsocks que tengas.

Entonces, para crear el arreglo debemos seguir los sig.
pasos:

1. Agregar un nuevo Winsock al formulario
   (Winsock2)
2. Copiar el control (Clic derecho sobre este y
   seleccionar "Copiar")
3. Pegar el control en el formulario, y cuando pregunte
   por si deseas crear el arreglo dile que "Si". (Clic derecho
   sobre el formulario y seleccionar "Pegar")
4. Borramos el nuevo Winsock que se ha creado
   (Winsock2(1)).

La razón de borrar este último Winsock es
porque no nos hace falta, como mencionamos en un principio,
nosotros crearemos los Winsocks necesarios de forma dinámica, solo necesitamos tener existente
el Winsock2 de índice cero.

3. Limpiando código innecesario

En realidad no hay código innecesario pero si
código que debe cambiar de lugar, como veremos en su
momento, por ahora solo nos limitaremos a borrar todo el
código del evento "Winsock1_DataArrival" ya que nunca lo
usaremos en este Winsock porque solo trabajara como repartidor de
trabajo y
"Winsock1_ConnectionRequest" que será implementada mas
adelante, lo mismo para la acción del botón
"Enviar" (Command1_Click).

4. Enviando/recibiendo datos

Vamos a ver como se realizan las acciones de recibir y
enviar datos cuando tenemos arreglos de sockets (Winsock2()), nos
guardaremos la
administración de las peticiones de conexiones para
más adelante.

Para enviar datos (mediante el botón "enviar")
podemos hacerlo directamente con algún socket
específico, definiendo su identidad, o bien con todos los
sockets recorriendo el arreglo. Esto último es lo que
haremos a modo de ejemplo:

Y cuando recibamos datos desde el cliente se nos
generara el evento "Winsock2_DataArrival" que ahora incluye un
nuevo parámetro "Index" de tipo "Integer" y contiene el
número o índice del socket que genera el evento
(todo en relación al arreglo de sockets).

Para recibir datos solo tenemos que tomar en cuenta ese
"Index" y el resto es igual a lo visto en el servidor de
conexión mono-usuario:

5. Evento Error y Close

El código para los eventos "Error" y "Close" del
arreglo de sockets es muy simple:

5. Escuchando y atendiendo a las
conexiones

El siguiente paso será recibir las peticiones de
conexión y asignárselas a cada socket para que las
atienda. Para ello necesitaremos crear un nuevo socket cada vez
que recibamos una petición de conexión y decirle
que acepte la identidad de la conexión.

Para facilitar las cosas nosotros haremos una
función que se encargue de crear los sockets y que
además devuelva el número del nuevo socket
creado:

Esta función no solo crea un nuevo socket, sino
que además si encuentra alguno que se había creado
antes y este se encuentra inactivo (desconectado) lo selecciona
para volverlo a utilizar y así aprovechar mas los recursos del
sistema.

Nota: Esta no es la forma más óptima de
manejar arreglos de objetos, ya que no nos permite ir liberando
de la memoria
(borrando) los sockets que ya no son utilizados y solo se limita
a crear nuevos.

Ahora nos situamos en el evento "ConnectionRequest()"
del "Winsock1" (el que hará de recepción) y
escribimos el siguiente código:

Aquí lo primero es crear un nuevo socket (o
reutilizar alguno disponible) y decirle a ese socket que acepte
aquella conexión. Una vez realizado esto ya estamos libres
nuevamente para recibir otra conexión.

También es posible denegar conexiones realizadas
desde alguna IP especifica, para ello solo hay que revisar la
propiedad "Winsock1.RemoteHostIP" y ver si aceptamos su
conexión o bien se la rechazamos con "Close".

6. Prueba de la aplicación

Ahora que todo parece estar completo, realizaremos la
prueba del servidor.

Ejecuta la aplicación, como "Puerto" coloca el
"23" y dale al botón "Escuchar".

Ahora ejecuta dos aplicaciones "Cliente" y
conéctalos al puerto "23" de "Localhost". Notaras que ya
no da el error que vimos con el servidor mono-conexión y
que ambos se encuentran conectados:

Prueba a enviar mensajes entre ellos y veras que todo
trabaja perfectamente!!, puedes identificar cada conexión
porque en el mensaje aparece "SockN" donde "N" es el
índice del socket, así sabrás en cada
momento que socket es el que esta enviando el mensaje:

y ya funciona todo ok!.

CONCLUSIÓN

Hemos llegado al final de este tutorial, y hemos
aprendido a realizar conexión Cliente/Servidor mono y
multi-conexiones de forma básica, digo básica
porque hay mejores maneras de implementarlas y mas minuciosas,
pero esta es la base de todas ellas, y el resto lo
obtendrás por la practica.

Espero que este texto les halla sido de utilidad y
cualquier duda o errores encontrados no dudes en
comunicármelo, que lo corregiré tan pronto como
pueda.

Por ultimo los códigos fuente de los proyectos
aquí realizados los puedes bajar desde la pagina
Web http://www.gemu.da.ru.

Gemu –

www.gemu.da.ru

Todos los derechos reservados –
Septiembre de 2005