Richiami di TCP Networking
in Java
Elementi di base
Prerequisiti
•Conoscere i fondamenti di TCP-IP
•Aver visto come si scrivono clients e servers di rete
in un qualche linguaggio
•Avere i fondamenti di Java I/O
•Utile (ma non indispensabile) avere i fondamenti di
multithreading in Java
Sockets
Java supporta un accesso semplificato e
object-oriented alle sockets.
Questo rende la network comunicazione di rete
sensibilmente più semplice.
Molto più semplice che in C++!!
Parlare ad un altra applicazione (locale o remota) può essere
semplice come leggere un file o ottenere un input da un
utente.
Clients and Servers
Quando si scrivono network applications, è comune
parlare di clients e servers. La distinzione è piuttosto
vaga, ma sostanzialmente possiamo pensare che :
•chi inizia la conversazione è il client.
•chi accetta la richiesta di parlare e’ il server.
Per I nostri scopi, la più importante differenza tra client e
server è che il client può in qualunque istante creare una socket
per iniziare una conversazione con una server application,
mentre un server si deve preparare ad ascoltare in anticipo per
possibili conversazioni in arrivo.
Sockets
La java.net.Socket class rappresenta un singolo lato di
una connessione socket indifferentemente su un client
o su un server.
Inoltre, il server usa la java.net.ServerSocket class per
attendere connessioni da clients. Un applicazione
agente come server crea un ServerSocket object e
attende, bloccato in una chiamata al suo metodo
accept(), finché non giunge una connessione. A quel
punto, il metodo accept() create un Socket object che il
server usa per comunicare con il client.
Sockets
Un server mantiene molte conversazioni
simultaneamente.
C’e’ una sola ServerSocket, ma una oggetto Socket
attivo per ogni cliente.
Server port
Un client ha bisogno di due informazioni per connettersi a un
server su Internet: un nome di host (per recuperare l’indirizzo
del server) e un numero di porta (per individuare il processo
sulla macchina server).
Una applicazione server ascolta su una porta predefinita
mentre attende una connessione. I clients selezionano il
numero di porta corrispondente al servizio desiderato.
I numeri di porta sono codificati nelle RFC (Es. Telnet 23, FTP
21, ecc.), ma possono anche essere scelti (quasi)
arbitrariamente per applicazioni custom.
Client port
Il numero di porta del client è tipicamente assegnato
dal sistema operativo: la scelta di tale numero non è
di solito rilevante.
Quando una client socket manda un pacchetto a una
server socket, il pacchetto include la specifica della
porta e dell’indirizzo del cliente: così il server è in
grado di rispondere.
Sockets
Usando le sockets, si deve decidere che tipo di
protocollo si desidera per il trasporto di pacchetti
sulla rete:
Un protocollo connection-oriented (TCP) o
Un protocollo connectionless (UDP).
Connection-oriented protocols
Richiami
Un protocollo connection-oriented offre l’equivalente
di una conversazione telefonica.
•Dopo aver stabilito la connessione, due
applicazioni possono scambiarsi dati.
•La connessione rimane in essere anche se nessuno
parla.
Il protocollo garantisce che non vengano persi dati e
che questi arrivino sempre nell’ordine corretto.
La classe Java Socket usa un protocollo connectionoriented, e “parla” TCP
Connectionless Protocols
Richiami
Un protocollo connectionless somiglia al servizio
postale.
Le applicazioni possono inviarsi brevi messaggi, ma
non viene tenuta aperta una connessione tra un
messaggio e l’altro.
Il protocollo NON garantisce che non vadano persi
dati e che ne’ che questi arrivino nell’ordine corretto.
La classe DatagramSocket usa un protocollo
connectionless, e “parla” UDP
Connection oriented Protocols
Richiami
Con un connection-oriented protocol, una client socket
stabilisce, alla sua creazione, una connessione con una
server socket. Stabilita la connessione, un protocollo
connection-oriented assicura la consegna affidabile dei dati,
ovvero:
1. Ogni pacchetto spedito, il pacchetto viene consegnato. Ad
ogni spedizione, la socket si aspetta di ricevere un
acknowledgement cheil pacchetto è stato ricevuto con
sucesso.
Se la socket non riceve l’acknowledgement entro un tempo
prestabilito, la socket ri-invia il pacchetto. La socket
continua a provare finché la trasmissione ha successo, o
finché decide che la consegna è impossibile.
Connection oriented Protocols
Richiami
2. I pacchetti sono letti dalla socket ricevente nello stesso
ordine in cui sono stati spediti. Per il modo in cui la rete
funziona, i pacchetti possono arrivare alla socket
destinataria in un ordine diverso da quello in cui sono stati
spediti.
Un protocollo affidabile, connection-oriented permette alla
socket ricevente di riordinare i pacchetti ricevuti, così che
possano essere letti dal programma ricevente nell’orine in
cui erano stati spediti.
java.net.Socket
Questa classe implementa una socket per interprocess
communication over the network.
I constructor methods creano la socket e la connettono allo
host e porta specificati.
java.net.Socket - metodi principali
Una volta creata la socket, getInputStream() e
getOutputStream() ritornano oggetti InputStream e
OutputStream che possono essere usati come se fossero canali
di I/O su file.
getInetAddress() e getPort() restituiscono indirizzo e porta a
cui la socket e’ connessa.
getLocalPort() ritorna la porta locale usata dalla socket .
close() chiude la socket.
java.net.ServerSocket
Questa classe e’ usata dai servers per ascoltare le
richieste di connessione.
Quando si crea una ServerSocket, si specifica su
quale porta si ascolta.
Il metodo accept() iniza ad ascoltare su quella porta,
e si blocca finché un client non richiede una
connessione su quella porta.
A quel punto, accept() accetta la connessione,
creando e ritornando una Socket che il server può
usare per comunicare col client.
java.net.ServerSocket - metodi principali
getInetAddress() restituisce indirizzo locale
getLocalPort() ritorna la porta locale usata dalla socket .
close() chiude la socket.
Sockets
Clients
Un applicazione client apre una connessione con un
server costruendo una Socket che specifica hostname e
port number del server desiderato:
try {
Socket sock = new Socket(“www.pippo.it", 80);
//Socket sock = new Socket("128.252.120.1", 80);
} catch ( UnknownHostException e ) {
System.out.println("Can't find host.");
} catch ( IOException e ) {
System.out.println("Error connecting to host.");
}
Connection-oriented protocol
Il lato server di un protocollo connection-oriented tipicamente
esegue questa sequenza:
•Crea un ServerSocket object per accettare connessioni.
•Quando il ServerSocket accetta la connection, crea un
oggetto Socket che incapsula la connessione.
•Alla Socket viene chiesto di creare oggetti InputStream e
OutputStream che leggono e scrivono bytes da e verso la
connessione.
•La ServerSocket può opzionalmente creare una nuova thread
per ogni connessione, così che il server possa ascoltare per
nuove connessioni mentre serve i clienti già acquisiti.
Reading & Writing raw bytes – Client side
Una volta stabilita la connessione, input e output
streams possono essere ottenuti con i metodi
getInputStream() e getOutputStream() di Socket .
try {
Socket server = new Socket("foo.bar.com", 1234);
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
// Write a byte
out.write(42);
// Read a byte
Byte back = in.read();
server.close();
} catch (IOException e ) { }
Reading & Writing newline delimited strings – Client
Incapsulando InputStream e OutputStream è possibile
accedere agli streams in modo più semplice.
try {
Socket server = new Socket("foo.bar.com", 1234);
InputStream in = server.getInputStream();
DataInputStream din = new DataInputStream( in );
OutputStream out = server.getOutputStream();
PrintStream pout = new PrintStream( out );
// Say "Hello" (send newline delimited string)
pout.println("Hello!");
// Read a newline delimited string
String response = din.readLine();
server.close();
} catch (IOException e ) { }
Reading & Writing raw bytes – Server side
try {
ServerSocket listener = new ServerSocket( 1234 );
while ( !finished ) {
Socket aClient = listener.accept();
// wait for connection
InputStream in = aClient.getInputStream();
OutputStream out = aClient.getOutputStream();
// Read a byte
Byte importantByte = in.read();
// Write a byte
out.write(43);
aClient.close();
}
listener.close();
} catch (IOException e ) { }
Reading & Writing newline delimited strings – Server
try {
ServerSocket listener = new ServerSocket( 1234 );
while ( !finished ) {
Socket aClient = listener.accept();
// wait for connection
InputStream in = aClient.getInputStream();
DataInputStream din = new DataInputStream( in );
OutputStream out = aClient.getOutputStream();
PrintStream pout = new PrintStream( out );
// Read a string
String request = din.readLine();
// Say "Goodbye"
pout.println("Goodbye!");
aClient.close();
}
listener.close();
} catch (IOException e ) { }
This server is single-threaded
Questo server e’ single-threaded
Tratta una sola connessione alla volta; non chiama
accept() per ascoltare nuove connessioni fin quando
non ha finito con quella corrente.
Un server più realistico avrebbe un ciclo che accetta
connessioni e le passa ad altre thread per servirle
concorrentemente.
Limitations
Applets e altre applicazioni che girano sotto il
controllo del SecurityManager possono avere
restrizioni arbitrarie su quali hosts possono
raggiungere, e sul fatto di poter accettare
connessioni.
La security policy standard imposta dai browsers
premette alle applets di aprire socket solo con lo host
da cui provengono.
Le applets hanno il permesso di aprire server sockets.
Limitations
Ora, questo non significa che una applet non possa
cooperare con il suo server per comunicare con
chiunque e ovunque. Il server può girare un proxy
che permette alla applet di comunicare
indirettamente con chiunque.
Questo pone l’onere del controllo della sicurezza sul
server originante, e non sulla macchina client.
Richiami di TCP Networking
in Java
Esempio 1:
Un server HTTP concorrente
Un mini-server concorrente HTTP – Introduz.
TinyHttpd ascolta su una port specificata and serve semplici
richieste HTTP "get file“:
GET /path/filename [optional stuff]
Il Web browser manda una o più di queste linee per ogni
documento da ottenere. Letta la richiesta, il server prova ad
aprire il file specificato e ne spedisce il contenuto. Se il
documento contiene referenze ad immagini o altro da mostrare
on-line, il browser continua con richieste GET addizionali. Per
ragioni di performance, TinyHttpd serve ogni richiesta in una
sua thread. Perciò TinyHttpd può servire molte richieste
concorrentemente.
Un mini-server concorrente HTTP
import java.net.*;
import java.io.*;
import java.util.*;
public class TinyHttpd {
public static void main( String argv[] ) throws IOException {
ServerSocket ss =
new ServerSocket(Integer.parseInt(argv[0]));
while ( true )
new TinyHttpdConnection( ss.accept() );
}
}
Un mini-server concorrente HTTP
class TinyHttpdConnection extends Thread {
Socket sock;
TinyHttpdConnection ( Socket s ) {
sock = s;
setPriority( NORM_PRIORITY - 1 );
start();
}
public void run() {
try {
OutputStream out = sock.getOutputStream();
DataInputStream d=new DataInputStream(sock.getInputStream());
String req = d.readLine();
System.out.println( "Request: "+req );
StringTokenizer st = new StringTokenizer( req );
Un mini-server concorrente HTTP
if ( (st.countTokens() >= 2) &&
st.nextToken().equals("GET") ) {
if ( (req = st.nextToken()).startsWith("/") )
req = req.substring( 1 );
if ( req.endsWith("/") || req.equals("") )
req = req + "index.html";
try {
FileInputStream fis = new FileInputStream ( req );
byte [] data = new byte [ fis.available() ];
fis.read( data );
out.write( data );
} catch ( FileNotFoundException e )
new PrintStream( out ).println("404 Not Found"); }
else new PrintStream( out ).println( "400 Bad Request" );
sock.close();
} catch ( IOException e )
System.out.println( "I/O error " + e );

}
}
Un mini-server concorrente HTTP - uso
Compila TinyHttpd e mettilo nel tuo class path. Vai in una
directory con qualche documento interessante e avvia il
daemon, specificando un numero di porta non usato come
argomento. Per esempio:
% java TinyHttpd 1234
Ora dovrebbe essere possibile usare un Web browser standard
per ottenere i files dal tuo host. Nella URL dovra’ essere
specificato il numero di porta scelto. Per esempio, se il tuo
hostname e’ xx.science.unitn.it, ed hai avviato il server come
sopra, sara’ possibile ottenere il file welcome.html con:
http://xx.science.unitn.it:1234/welcome.html
Un mini-server concorrente HTTP - Note
Abbassando la sua priorità a NORM_PRIORITY-1,
assicuriamo che la threads che serve le connessioni
già stabilite non blocchi la main thread di TinyHttpd
impedendole di accettare nuove richieste.
Un mini-server concorrente HTTP - Problemi
TinyHttpd ha nolte di possibilità di miglioramento!
Primo: consuma un sacco di memoria allocando un
array enorme per leggere un intero the file tutto d’un
colpo. Un’implementazione più realistica userebbe un
buffer ed invierebbe i dati in più passi.
TinyHttpd inoltre non riconosce semplici directories.
Non sarebbe difficile aggiungere alcune linee per
leggere directories e generare liste di link HTML
come fanno molti web server.
Un mini-server concorrente HTTP - Problemi
TinyHttpd soffre di limitazioni imposte dalla
debolezza di accesso al filesystem.
E’ importante ricordare che le pathnames sono
architecture dependent—così come il concetto stesso
di filesystem. TinyHttpd funziona, così com’è, su
systemi UNIX e DOS-like, ma richiede alcune
variazioni su altre piattaforme. E’ possibile scrivere
del codice più elaborato code che usa environmental
information offerte da Java per adattarsi al sistema
locale.
Un mini-server concorrente HTTP - Problemi
Il problema principale con TinyHttpd è che non ci
sono restrizioni sui files a cui può accedere. Con
qualche trucco, il daemon spedirebbe un qualunque
file del suo filesystem al client.
Sarebbe utile limitare TinyHttpd ai files che sono
nella directory corrente, or una sua subdirectory.
Richiami di TCP Networking
in Java
Esempio 2:
Un client SMTP
A simple e-mail client
import java.net.*;
import java.io.*;
import java.util.*;
class EMailClient{
public static void main(String[] args){
new EmailClient()
} // end main
EMailClient() {
String server = "put your email server name here";
int port = 25; //mail port
try{
//Get a socket, connected to the specified server
// on the specified port.
Socket socket = new Socket(server,port);
A simple e-mail client

//Get an input stream from the socket
BufferedReader inputStream =
new BufferedReader(new InputStreamReader(
socket.getInputStream()));
//Get an output stream to the socket. Note
// that this stream will autoflush.
PrintWriter outputStream =
new PrintWriter(new OutputStreamWriter(
socket.getOutputStream()),true);
//Begin the conversation with the email server.
outputStream.println(
"mail from: put your email name here");
System.out.println(inputStream.readLine());
outputStream.println(
"rcpt to: " + "put your email name here");
System.out.println(inputStream.readLine());
outputStream.println("data");
System.out.println(inputStream.readLine());
A simple e-mail client
String timeStamp = (new Date()).toString();
outputStream.println("Test message " + timeStamp);
outputStream.println(".");
System.out.println(inputStream.readLine());
//Close the socket
socket.close();
}//end try
catch(UnknownHostException e){
System.out.println(e);
System.out.println(
"Must be online to run properly.");
}//end catch UnknownHostException
catch(IOException e){System.out.println(e);}
}//end constructor
}//end class