🚀 go-pugleaf

El d�a Tue, 26 Jan 1999 23:30:34 +0100, "Ary" <ary@jet.es> escribi�:

>Entonces, (perdona si te doy un poco mas la plasta)

No te preocupes, que para eso estamos.

>DatagramSocket lleva sus
>cabeceras UDP, y le a�ado las cabecera TCP segun el paqute que envio.

M�s o menos. Tus clases b�sica deber�a ser una cosa aproximadamente
as�:

// Esta clase representa un segmento o paquete TCP, con su
// cabecera, que es lo que vas a enviar por la red.
//
class MiSegmentoTCP
{
	[campos de la cabecera del segmento TCP]
	[datos]

	[m�todos para serializar y des-serializar]
}


// Esta clase implementa la conexi�n en s�.
//
class MiSocket
{
	private DatagramSocket dgsocket;
	private InetAddress orgIP;
	private InetAddress destIP;
	private int orgPort;
	private int destPort;
	[otros atributos]	
	...
	
	MiSocket (InetAddress destIP, int destPort)
	{
		dgsocket = new DatagramSocket();
		this.destIP = destIP;
		this.destPort = destPort;
		...
	}

	[otros metodos]
}


En primer lugar deber�as definir una clase MiSegmentoTCP que es lo que
vas a enviar utilizando tu clase MiSocket. Ser�a buena idea que
incluyeras m�todos para que la clase fuese serializable, es decir,
para que por ejemplo puedas convertirla o recuperarla de un array de
bytes. Los atributos que debe tener la clase MiSegmentoTCP son tanto
los campos de que consta un segmento TCP (que no los tengo a mano),
como los propios datos a enviar. Busca informaci�n sobre los segmentos
TCP en casi cualquier libro que trate sobre redes de ordenadores, o
bien buscando los RFC que lo definen por Internet.

En cuanto a la clase MiSocket:, �sta debe incluir la informaci�n de
control necesaria para mantener la conexi�n funcionando. Ejemplo:
direcciones IP de origen y destino, puertos de origen y destino,
tama�o de la ventana de control de flujo, bits o flags de control,
datos confirmados hasta el momento, par�metros varios como timeouts y
dem�s, etc. Lo siguiente que tienes que hacer es coger las clases
Socket y ServerSocket del jdk, o cualquier otra librer�a de sockets de
cualquier otro lenguaje, y para cada funci�n o m�todo que te
encuentres (listen, accept, connect, send, receive, close, etc...), te
escribes t� un m�todo equivalente en MiClase.

B�sicamente, lo que tendr�s que hacer es:

1. Tener todos los atributos de tu clase correctamente actualizados
para contener la informaci�n de control que necesita el protocolo TCP.

2. Establecer las conexiones. Como UDP no es orientado a conexi�n,
establecer las conexiones en realidad es solo establecer las variables
de estado en el extremo local y en el extremo remoto; usa los
DatagramPackets para enviar al extremo remoto la informaci�n que
necesite (como por ejemplo qui�n eres, cual es tu direcci�n IP, cu�l
es tu puerto en el host local, etc.)

3. Para enviar informaci�n:

a) Crea un objeto de tipo MiSegmentoTCP y completa todos los atributos
(cabecera + informaci�n). Esto es lo que quieres enviar.
b) Serializa este objeto (convi�rtelo en un array de bytes) y lo
troceas si es necesario para mapearlo en uno o varios DatagramPackets
que enviar�s al extremo remoto mediante UDP.
c) En el extremo remoto, una vez recibidos los datagramas, reord�nalos
para obtener un array y des-serializa este array para recuperar el
paquete TCP original, del cual puedes extraer la informaci�n.
d) Actualiza todos los campos del socket de destino (atributos de
MiClase relativos al control de flujo y dem�s)

4. Lo mismo para recibir: recibir�s del otro extremo una serie de
datagramas UDP que deber�s reordenar para formar el paquete TCP
original, quitar los datos de la cabecera y recuperar la informaci�n.

Eso es lo general, luego hay otros detalles, como los timeouts, el
tema de las confirmaciones, la gesti�n de excepciones que puedes
lanzar si algo va mal, la clase MiServerSocket equivalente para
aplicaciones cliente/servidor, etc...

>Ya implementada la clase, en una nuva clase que me definiera, (pregunta)
>seria bueno implementarla como si fuera un automata (logico) que fuera
>pasando de estados (esperando, enviando, reciviendo...)

Es posible, pero en TCP la comunicaci�n es full-duplex, puedes enviar
y recibir de forma simult�nea, as� que yo veo dos opciones:

1.- Lo implementas como un aut�mata y, una vez establecida la
conexi�n, vas pasando por esos estados. Pero en ese caso aseg�rate de
fijar timeouts mediante  DatagramSocket.setSoTimeout(), pues si no lo
haces podr�as por ejemplo quedar atrapado intentando recibir (las
llamadas a receive son siempre bloqueantes) cuando en realidad nadie
te va a enviar nada.

2.- Lanzas dos threads separados por cada conexi�n, uno que env�e y
uno que reciba.

>Podrias ampliar un poco mas tu respuesta??? Muchisimas gracias por todo.

Espero que te sirva todo esto...

Salu2: GUILLE
----
Guillermo Rodriguez Garcia
<XXguille@XXiies.XXes>  (ya sabes :-)