Programación de Sockets en JavaJava

¿Qué es un Socket?

• Socket– Combinación de dir. IP y nro. de puerto (RFC 793-TCP)– Dos tipos

• Stream socket (comunicación confiable de streams y de dos vías)

• Datagram socket (de dos vías)

• Par de Sockets– Especifica los 2 puntos finales que identifican univocamente

cada conexión TCP en internet.– 4-tupla: (dir. IP cliente, nro. port cliente, dir. IP server,

nro. port server)

Aplicaciones Client-Server

• Implementación de un protocolo estandar definido en un RFC (FTP, HTTP, SMTP…)

– Respeta las reglas dictadas por el RFC– Usará el número de puerto asociado con el protocolo

• Aplicaciones propietarias client-server.

– Un desarrollador o un equipo crea tanto el programa cliente como el servidor

– Deben tener cuidado en no usar los números de puerto bien conocidos* definidos en los RFCs.

* número de puerto bien conocido : administrados por la IANA (Internet Assigned Numbers Authority)

Programación de Socket con TCP

proceso proceso

Proceso de comunicación con sockets TCP

El desarrollador de la aplicación es capaz de setear algunos parametros TCP, como el buffer máximo y los tamaños de segmento máximo.

controlado por el

desarrollador

controlado por el

desarrollador

controlado por el S.O.

controlado por el S.O.

Sockets TCP para el Server y el Client

• Server– Socket en espera

• Espera algún contacto inicial desde el cliente.

– Socket con conexión establecida• Es creado con el contacto inicial del cliente.• El nuevo socket es dedicado a un cliente en particular.• El nuevo socket es dedicado a un cliente en particular.

• Client– Socket

• Inicia una conexión TCP al servidor. (Three-way handshake)

• Especifica la dirección del proceso servidor: la dir. IP del server y el nro. de puerto del proceso.

Sockets con TCP

Socket Client, Socket Server y el establecimiento de la conexión

Llamadas funcionales a Socket

• socket (): crea un socket

• bind(): enlaza un socket a una dir. IP y un nro. de port

• listen(): esperando pasivamente por conexiones

• connect(): iniciando conexión a otro socket• connect(): iniciando conexión a otro socket

• accept(): acepta la nueva conexión

• write(): escribe datos en el socket

• read(): lee datos del socket

• sendto(): envia un datagrama a otro socket UDP

• recvfrom(): lee un datagrama desde otro socket UDP

• close(): cierra el socket (se termina la conexión)

Programación de Socket usando TCPServicio TCP:Servicio TCP:Servicio TCP:Servicio TCP: transferencia de streams confiableconfiableconfiableconfiable

client server

socket( )bind( )connect( )

socket( )bind( )listen( )

accept( )send( )

recv( )

TCP conn. request

TCP ACK

proceso

TCP (buffers)

socket

Controlado porel desarrolladorde la aplicación

Controlado porel sistema

operativo

proceso

TCP (buffers)

socket

internet

recv( )

close( ) close( )

recv( )send( )

Programación de Socket usando TCP

1. El cliente lee una linea del standard input (inFromUserstream)

2. El cliente lo envía al server vía socket (outToServerstream)

3. El server lee la línea desde el

Input stream:

Secuencia de bytes hacia adentro

Output stream:

Proceso

Cliente

1

3. El server lee la línea desde el socket

4. El server procesa la línea y responde al cliente

5. El cliente lee la respuestadesde el socket (inFromServer stream)

Output stream:

Secuencia de bytes hacia afuera

client TCP socket

2

3 4

5

Interacción client/server: TCP

wait for incoming

create socket,port=x, forincoming request:

welcomeSocket = ServerSocket()

create socket,connect to hostid, port=x

Server (hostid) Client

TCP connection setup

wait for incomingconnection request

connectionSocket =welcomeSocket.accept()

connect to hostid, port=xclientSocket =

Socket()

closeconnectionSocket

read reply fromclientSocket

closeclientSocket

send request usingclientSocketread request from

connectionSocket

write reply toconnectionSocket

connection setup

JAVA TCP Sockets• Package java.net

– java.net.ServerSocket• Implementa un socket servidor.• Espera pedidos de conexión a través de la red.• Realiza operatoria basada en el requerimiento• Constructor y Metodos

– ServerSocket(int port)– Socket accept(): Escucha pedidos de conexión y los acepta. Este – Socket accept(): Escucha pedidos de conexión y los acepta. Este

método “bloquea” al socket hasta que ocurre la conexión

– java.net.Socket• Implementa un socket cliente• Es un extremo en la comunicación entre 2 hosts• Constructor y Métodos

– Socket(String host, int port): Crea un socket y lo conecta al número de port del host especificado

– InputStream getInputStream()– OutputStream getOutputStream()– close()

TCPServer.javaimport java.io.*; import java.net.*; /** TCPServer convierte a mayúscula el msg. que recibe desde el cliente*/

class TCPServer {

public static void main(String argv[]) throws Exception {

String sentenciaCliente; String sentenciaCliente; String sentenciaMayuscula;

ServerSocket socketBienvenida = new ServerSocket(6789);

while(true) {

Socket socketConectado = socketBienvenida.accept();

BufferedReader inFromClient = new BufferedReader(newInputStreamReader(socketConectado.getInputStream()));

TCPServer.java

sentenciaCliente = inFromClient.readLine();

sentenciaMayuscula = sentenciaCliente.toUpperCase() + '\n';

DataOutputStream outToClient = DataOutputStream outToClient = new DataOutputStream(socketConectado.getOutputStream());

outToClient.writeBytes(sentenciaMayuscula);

socketConectado.close();}

} }

TCPClient.javaimport java.io.*; import java.net.*;

class TCPClient { public static void main(String argv[]) throws Exception {

String sentencia; String sentenciaModificada; String sentenciaModificada;

BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));

sentencia = inFromUser.readLine();

Socket socketCliente = new Socket(“10.1.1.5", 6789);

DataOutputStream outToServer = new DataOutputStream(socketCliente.getOutputStream());

TCPClient.java

outToServer.writeBytes(sentencia + '\n');

BufferedReader inFromServer = new BufferedReader(new

InputStreamReader(socketCliente.getInputStream()));

sentenciaModificada = inFromServer.readLine();sentenciaModificada = inFromServer.readLine();

System.out.println(“DESDE EL SERVIDOR: " + sentenciaModificada);

socketCliente.close();

} }

Socket sobre UDP

• UDP– Servicio sin conexión y no confiable – No hay fase inicial de handshaking– Los datos transmitidos pueden recibirse desordenados y

pueden perderse

• Programación de Socket con UDP– No se necesita un socket creado en espera.– No hay “streams” (flujos) adjuntos a los sockets– El host que envía, crea “paquetes” adjuntando la dir. IP

destino y nro. de port a cada conjunto de bytes– El proceso receptor debe “desempaquetar” el paquete

recibido para obtener los bytes de información del paquete

Interacción client/server: UDPServer (hostid)

create socket,

clientSocket = DatagramSocket()

Client

Create, address (hostid, port=x,

create socket,port=x, forincoming request:

serverSocket = DatagramSocket()

closeclientSocket

read reply fromclientSocket

Create, address (hostid, port=x,send datagram request using clientSocket

read request fromserverSocket

write reply toserverSocketspecifying clienthost address,port number

Ejemplo cliente Java (UDP)

Input: recibe paquetes (TCP recibe “byte

Proceso

Cliente

Output: envía paquetes (TCP envía “byte stream”)

(TCP recibe “byte stream”)

client UDP socket

JAVA UDP Sockets

• Package java.net– java.net.DatagramSocket

• Socket para envío y recepción de “datagramas”

• Constructor y Métodos– DatagramSocket(int port): Construye un socket – DatagramSocket(int port): Construye un socket

UDP y lo enlaza al port especificado en el host local

– void receive(DatagramPacket p)

– void send(DatagramPacket p)

– void close()

UDPClient.javaimport java.io.*; import java.net.*;

class UDPClient { public static void main(String args[]) throws Exception {

BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));

byte[] datosAEnviar = new byte[1024]; byte[] datosARecibir = new byte[1024];

String sentencia = inFromUser.readLine();

datosAEnviar = sentencia.getBytes();

DatagramSocket socketCliente = new DatagramSocket();

InetAddress IPAddress = InetAddress.getByName(“server.com");

UDPClient.java

DatagramPacket paqueteAEnviar = new DatagramPacket(datosAEnviar, datosAEnviar.length,

IPAddress, 9876);

socketCliente.send(paqueteAEnviar);

DatagramPacket paqueteARecibir = new DatagramPacket(datosARecibir, datosARecibir.length);

socketCliente.receive(paqueteARecibir);

String sentenciaModificada = new String(paqueteARecibir.getData());

System.out.println(“DESDE EL SEVIDOR:" + sentenciaModificada);

socketCliente.close();

} }

UDPServer.javaimport java.io.*; import java.net.*;

class UDPServer { public static void main(String args[]) throws Exception {

DatagramSocket socketServidor = new DatagramSocket(9876);

byte[] datosARecibir = new byte[1024]; byte[] datosARecibir = new byte[1024]; byte[] datosAEnviar = new byte[1024];

while(true) {

DatagramPacket paqueteARecibir = new DatagramPacket(datosARecibir, datosARecibir.length);

serverSocket.receive(paqueteARecibir);

String sentencia = new String(paqueteARecibir.getData());

UDPServer.java

InetAddress IPAddress = paqueteARecibir.getAddress();

int port = paqueteARecibir.getPort();

String sentenciaMayuscula = sentencia.toUpperCase();

datosAEnviar = sentenciaMayuscula.getBytes(); datosAEnviar = sentenciaMayuscula.getBytes();

DatagramPacket paqueteAEnviar = new DatagramPacket(datosAEnviar, datosAEnviar.length,

IPAddress, port);

serverSocket.send(paqueteAEnviar);

} }

}

Construyendo un simple Web Server

• Atiende un requerimiento HTTP a la vez

• Acepta y parsea el requerimiento HTTP

• Obtiene el archivo requerido desde el • Obtiene el archivo requerido desde el sistema de archivos del servidor

• Crea un mensaje de respuesta HTTP con el archivo requerido precedido por información en el header

• Envía la respuesta directamente al cliente

WebServer.javaimport java.io.*; import java.net.*;import java.util.*; class WebServer {

public static void main(String argv[]) throws Exception { String requestMessageLine; String fileName;

ServerSocket listenSocket = new ServerSocket(80);Socket connectionSocket = listenSocket.accept();

BufferedReader inFromClient = new BufferedReader(new

InputStreamReader(connectionSocket.getInputStream()));

DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());

WebServer.java

requestMessageLine = inFromClient.readLine();

StringTokenizer tokenizedLine = new StringTokenizer(requestMessageLine);

if (tokenizedLine.nextToken().equals("GET")){ fileName = tokenizedLine.nextToken(); fileName = tokenizedLine.nextToken(); if (fileName.startsWith("/") == true )

fileName = fileName.substring(1);

File file = new File(fileName); int numOfBytes = (int) file.length(); FileInputStream inFile = new FileInputStream (fileName); byte[] fileInBytes = new byte[numOfBytes];

inFile.read(fileInBytes);

WebServer.javaoutToClient.writeBytes("HTTP/1.0 200 Document Follows\r\n");

if (fileName.endsWith(".jpg")) outToClient.writeBytes("Content-Type: image/jpeg\r\n");

if (fileName.endsWith(".gif")) outToClient.writeBytes("Content-Type: image/gif\r\n");

outToClient.writeBytes("Content-Length: " + numOfBytes + "\r\n");

outToClient.writeBytes("\r\n"); outToClient.write(fileInBytes, 0, numOfBytes); connectionSocket.close();

} else System.out.println("Bad Request Message");

} }

Server con atención concurrente

• El server debe atender nuevos requerimientos de conexión mientras se procesa el previo requerimiento. Así trabajan en general los server TCP.

• Cuando llega un nuevo requerimiento de conexión al server, éste acepta e invoca un nuevo proceso para interactuar con el nuevo cliente (crea un thread por cada conexión).

Método de la clase Serverpublic void listenSocket(){

try{ server = new ServerSocket(4321); } catch (IOException e) {

System.out.println("Could not listen on port 4321"); System.exit(-1);

} while(true){

Server con atención concurrente

ClientWorker w; try{

connection w = new ClientWorker(server.accept(), textArea);

Thread t = new Thread(w); t.start();

} catch (IOException e) { System.out.println("Accept failed: 4321"); System.exit(-1);

} }

}

class ClientWorker implements Runnable {ClientWorker(Socket client, JTextArea textArea) { this.client = client; this.textArea = textArea; }

public void run() {//Enviar o recibir a través de “client”

} }

Cliente

Programación de Socket: referencias

C-language tutorial (audio/slides):

• “Unix Network Programming” (J. Kurose),http://manic.cs.umass.edu/~amldemo/courseware/intro.html

Java-tutorials:Java-tutorials:

• “All About Sockets” (Sun tutorial), http://docs.oracle.com/javase/tutorial/networking/sockets/index.html

• “Socket Programming in Java: a tutorial,” http://www.javaworld.com/javaworld/jw-12-1996/jw-12-sockets.html