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. Ce 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 lindirizzo 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 dellindirizzo 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 Un protocollo connection-oriented offre lequivalente 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 nellordine corretto. La classe Java Socket usa un protocollo connection- oriented, e parla TCP Richiami

Connectionless Protocols Un protocollo connectionless somiglia al servizio postale. Le applicazioni possono inviarsi brevi messaggi, ma non viene tenuta aperta una connessione tra un messaggio e laltro. Il protocollo NON garantisce che non vadano persi dati e che ne che questi arrivino nellordine corretto. La classe DatagramSocket usa un protocollo connectionless, e parla UDP Richiami

Connection oriented Protocols 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 lacknowledgement 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. Richiami

Connection oriented Protocols 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 nellorine in cui erano stati spediti. Richiami

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( 80); //Socket sock = new Socket(" ", 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 lonere 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:

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 dun colpo. Unimplementazione 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 dependentcosì 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 client import java.net.*; import java.io.*; import java.util.*; class Client{ public static void main(String[] args){ new Client() } // end main Client() { String server = "put your 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 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 server. outputStream.println( "mail from: put your name here"); System.out.println(inputStream.readLine()); outputStream.println( "rcpt to: " + "put your name here"); System.out.println(inputStream.readLine()); outputStream.println("data"); System.out.println(inputStream.readLine());

A simple 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