Networking. Apertura di uno stream sulla rete: URL

Transcript

1 Networking Il networking in java è supportato nel package java.net, che permette, mediante classi e metodi opportuni, di trasferire informazioni attraverso la rete utilizzando: protocolli derivati dal mondo WWW (classe URL) tecniche associate alla programmazione socket (classi Socket e ServerSocket) Le applet sono soggette alla restrizione di poter comunicare solamente con il server da cui provengono. La comunicazione non è possibile se si utilizza un alias (nome logico differente associato allo stesso host) da quello iniziale. Per trasferire un file da un host della rete Internet utilizzando protocolli Web, ovvero per aprire uno stream sulla rete utilizzando la classe URL,sideve: creare un istanza della classe URL, che contiene l indirizzo WWW del file da trasferire creare un istanza della classe URLConnection che permetta di caricare la URL precedentemente istanziata utilizzare i metodi connect() e getinputstream() della classe URLConnection per collegarsi alla URL desiderata creare un oggetto InputStreamReader che permette di leggere uno stream di dati dalla URL creare un oggetto BufferedReader per leggere in modo efficiente i caratteri dallo stream. : NETWORKING 1 Apertura di uno stream sulla rete: URL import java.awt.*;import java.awt.event.*;import java.net.*;import java.io.*; public class GetFile extends Frame implements Runnable { Thread runner; URL page; TextArea box = new TextArea("Sto cercando di scaricare il file..."); public GetFile() { super("get File"); add(box); try { page = new URL(" catch (MalformedURLException e) { System.out.println("URL errata: " + page); public static void main(string[] arguments) { GetFile frame = new GetFile(); WindowListener l = new WindowAdapter() { public void windowclosing(windowevent e) {System.exit(0); ; frame.addwindowlistener(l); frame.pack(); frame.setvisible(true); if (frame.runner == null) { frame.runner = new Thread(frame); frame.runner.start(); : NETWORKING 2

2 Apertura di uno stream sulla rete: URL public void run() { URLConnection conn = null; InputStreamReader in; BufferedReader data; String line; StringBuffer buf = new StringBuffer(); try { conn = this.page.openconnection(); conn.connect(); box.settext("connessione aperta..."); in = new InputStreamReader(conn.getInputStream()); data = new BufferedReader(in); box.settext("sto leggendo i dati..."); while ((line = data.readline())!= null) {buf.append(line + "\n"); box.settext(buf.tostring()); catch (IOException e) { System.out.println("IO Error:" + e.getmessage()); : NETWORKING 3 Programmazione socket: cenni La programmazione socket si basa sul classico modello client-server della rete Internet. Il programma server è sempre in esecuzione può fornire più servizi si rende visibile in rete attraverso uno o più punti di accesso (detti porte) ognuno dei quali corrisponde ad un ben preciso servizio. Le porte sono sempre disponibili. Il programma client presenta richieste ad uno specifico server utilizza una porta temporanea tratta ogni singola richiesta come operazione isolata. I server possono essere di tipo iterativo: se il servizio è di breve durata si serve la richiesta del client, rendendosi indisponibili a servire altri client contemporaneamente concorrente: se il servizio è di lunga durata si attiva un sottoprocesso che gestisce l interazione con lo specifico client e ci si pone in attesa di una nuova richiesta. In questo modo si è disponibili a servire più client contemporaneamente PROGRAMMAZIONE SOCKET 1

3 UNIX: input/output Le applicazioni in Unix interagiscono con il sistema operativo mediante le system calls, chiamate di sistema. Le system calls sono del tutto analoghe a chiamate a procedura. L input/output (I/O) in Unix segue un processo che prevede l uso in sequenza delle funzioni open(): l esecuzione della open() su un file (oppure in generale su un device, un dispositivo generico) permette di ottenere un descrittore del file. read() - write(): è possibile eseguire operazioni di lettura e scrittura utilizzando il descrittore del file. close(): al termine delle operazioni si rilascia il descrittore con una chiamata a close(). PROGRAMMAZIONE SOCKET 2 UNIX: input/output in rete Molto simile all I/O su file, ma si basa sul concetto di socket. Un (o una) socket permette di interagire in rete in modo analogo a come si agisce su un file, mediante un descrittore di socket. Esistono tre tipi di socket: STREAM: utilizzati per comunicazioni orientate alla connessione. Sono bidirezionali, affidabili e prevedono flusso sequenziale dei dati, senza limiti di dimensione di messaggio. DATAGRAM: utilizzati per comunicazioni non orientate alla connessione. Sono bidirezionali, non affidabili e prevedono flusso non sequenziale dei dati, con limiti di dimensione di messaggio a 8KB. RAW: accesso diretto al protocollo sottostante. Non usato da applicativi utente. Esistono due tipi di famiglie di indirizzi di socket: AF UNIX: per comunicazione tra processi UNIX AF INET: per comunicazione tra processi in rete PROGRAMMAZIONE SOCKET 3

4 Famiglia AF INET La struttura dati dei socket appartenenti alla famiglia AF INET è: struct sockaddr_in { short sin_family; /* TAG (AF_INET) */ u_short sin_port; /* Numero della porta */ struct in_addr sin_addr; /* Indirizzo IP */ char sin_zero[0]: /* Padding */ ; typedef in_addr { unsigned long s_addr; PROGRAMMAZIONE SOCKET 4 Client e server Si esaminano le seguenti operazioni: creazione di un socket da parte di un server che fornisce un servizio orientato alla connessione trasferimento dati parte di un server iterativo concorrente creazione di un socket da parte di un client che richiede un servizio orientato alla connessione connessione al server da parte del client trasferimento dati da parte del client PROGRAMMAZIONE SOCKET 5

5 Server: creazione di un socket 1. Si crea un descrittore di socket sock di tipo intero mediante la chiamata sock = socket(af INET, SOCK STREAM, 0);, specificando famiglia del socket tipo del socket protocollo di basso livello che si intende utilizzare (TCP, UDP) 2. Si esegue il binding, ovvero si crea un legame tra un nome ed il socket, associando al descrittore di socket una struttura dati opportuna. #define SERVER_PORT 2438 /* Porta maggiore di 1024 struct sockaddr_in server; server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; /* Wildcard per accettare connessioni /* da qualunque indirizzo server.sin_port = htons(server_port); /* Conversione a big endian bind(sock, server, sizeof (server)); /* Se binding fallisce, torna -1 PROGRAMMAZIONE SOCKET 6 Server: creazione di un socket 3. Il server dichiara al sistema operativo la disponibilità ad accettare connessioni sul socket sock con la chiamata: listen(sock,n), limitando il numero di connessioni accodate con il parametro n. 4. Il server si pone in attesa di richieste di connessioni, con una chiamata bloccante alla procedura accept(): struct sockaddr_in int fd, client_len; client; client_len = sizeof client; fd = accept(sock, &client, &client_len); 5. All arrivo della richiesta di connessione, la procedura accept() ritorna un descrittore di connessione, sbloccando il server. Il descrittore di connessione permette di identificare in modo univoco la connessione con il client. PROGRAMMAZIONE SOCKET 7

6 Server: creazione di un socket Le connessioni sono univocamente identificate dall insieme di: un protocollo indirizzo IP del server indirizzo IP del client numero di porta del server numero di porta del client Esistono importanti differenze tra i descrittori: Il descrittore di socket non è utilizzanto per trasferire dati tra client e server, ma solo per accettare connessioni. È associato al socket e rimane valido fino a quando il socket non è chiuso. Il descrittore di connessione è utilizzanto per trasferire dati tra client e server. Il descrittore di connessione è associato alla singola connessione e scompare quando la connessione è chiusa. PROGRAMMAZIONE SOCKET 8 Trasferimento dati: server iterativo Per trasferire dati tra client e server, si utilizza il descrittore di connessione, in modo del tutto analogo a quanto avviene per un descrittore di file. Si utilizzano le chiamate alle procedure write(), read(), close(). char inbuf[1000], outbuf[1000]; while (TRUE) { fd = accept (sock, &client, &client_len); while ( read(fd, inbuf, 1000) > 0) {... /* elabora dati prelevati da inbuf */... write(fd, outbuf, 1000); close(fd); PROGRAMMAZIONE SOCKET 9

7 Trasferimento dati: server concorrente 1. Il server concorrente crea, con una chiamata fork(), un processo figlio nel momento in cui il client apre una connessione. 2. Il processo figlio serve il client ed eredita il descrittore di connessione dal padre. 3. Il processo padre resta in attesa di ulteriori connessioni. char inbuf[1000], outbuf[1000]; while (TRUE) { fd = accept (sock, &client, &client_len); if (fork() == 0) {... /* elabora richiesta client nel processo figlio */ /* il processo figlio eredita il descrittore */... exit(0); close(fd); /* rilascio descrittore di connessione nel processo padre */ PROGRAMMAZIONE SOCKET 10 Client: creazione di un socket 1. Il client crea un socket sock = socket(af INET, SOCK STREAM, 0); Il processo di binding non è necessario, ed il numero di porta è fornito dal sistema operativo (a meno che il client non richieda una porta riservata, con numero ½¼¾ ). 2. Per aprire la connessione si devono determinare l indirizzo IP del server, supponendo noto il nome logico dell host il numero di porta a cui risponde il server (se ignoto) µ Si utilizzano le funzioni gethostbyname() e getservbyname(). 3. La chiamata a procedura connect() permette al client di tentare di aprire una connessione utilizzando il descrittore di socket. Il client non genera un descrittore di connessione, ma esegue l I/O utilizzando direttamente il descrittore di socket. La procedura connect() torna -1 in caso di connessione non riuscita. PROGRAMMAZIONE SOCKET 11

8 Trasferimento dati: client La procedura gethostbyname(), torna un puntatore alla struttura dati hostent. struct hostent { char *h_name; /* nome dell host */ char **h_aliases; /* lista degli alias */ int h_addrtype /* tipo di indirizzo */ int h_length; /* lunghezza indirizzo */ char **h_addr_list; /* indirizzi */ ; La procedura getservbyname("servizio", proto) torna il numero di porta a cui è offerto il servizio specificato con il protocollo specificato in una struttura servent, mediante ricerca nel file /etc/services. struct servent { char *s_name; /* official service name */ char **s_aliases; /* alias list */ int s_port; /* port number */ char *s_proto; /* protocol to use */ PROGRAMMAZIONE SOCKET 12 Esempio di file /etc/services # services This file describes various services # available from the TCP/IP subsystem. # It should be consulted instead of using # the numbers in the ARPA include files. # # /30/93 # Author: Fred N. van Kempen, # <waltje@uwalt.nl.mugnet.org> # echo 7/tcp echo 7/udp discard 9/tcp sink null discard 9/udp sink null systat 11/tcp users daytime 13/tcp daytime 13/udp netstat 15/tcp qotd 17/tcp quote chargen 19/tcp ttytst source chargen 19/udp ttytst source ftp-data 20/tcp ftp 21/tcp telnet 23/tcp smtp 25/tcp mail time 37/tcp timserver time 37/udp timserver name 42/udp nameserver whois 43/tcp nicname domain 53/tcp domain 53/udp tftp 69/udp gopher 70/tcp # gopher server finger 79/tcp http 80/tcp # www www 80/tcp # http is more correct pop-3 110/tcp # PostOffice V.3 auth 113/tcp ident # User Verification nntp 119/tcp usenet # Network News Transfer ntp 123/tcp # Network Time Protocol ntp 123/udp # Network Time Protocol imap 143/tcp # imap mail protocol snmp 161/udp # End of services. PROGRAMMAZIONE SOCKET 13

9 Trasferimento dati: client struct hostent struct sock_addr_in *host_info; server; /* leggo nome host da linea di comando */ host_info = gethostbyname(argv[1]); server.sin_addr = *(long*)host_info->h_addr; /* porta supposta nota */ server.sin_port = htons(1997); connect (sock, &server, sizeof server); /* leggo dati */ read(sock, buffer, LINESIZE); PROGRAMMAZIONE SOCKET 14 Codice completo di un client /***********************************************************************/ /* Programma: simple_client.c */ /* Autore: Claudio Casetti */ /* Descrizione: il seguente programma interroga un server */ /* connection-oriented, in ascolto su una porta nota */ /* e stampa il messaggio ricevuto dal client. */ /* Il server puo essere specificato sia attraverso il */ /* suo indirizzo IP sia attraverso l hostname */ /* Sintassi: */ /* simple_client <indirizzoserver> */ /***********************************************************************/ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #define SERVER_PORT 1997 #define LINESIZE 50 PROGRAMMAZIONE SOCKET 15

10 main (argc, argv) int argc; char *argv[]; { struct sockaddr_in server; struct hostent *host_info; int sock, count; char *server_name, inbuf[linesize]; Codice completo di un client /* Ottengo il nome del server dalla linea di comando: se non c e, uso */ /* localhost, cioe l indirizzo dell interfaccia di rete locale */ server_name = (argc>1)? argv[1] : "localhost"; /* creo la socket in modalita connection-oriented */ sock = socket(af_inet, SOCK_STREAM, 0); if (sock < 0) { perror("creating stream socket"); exit(1); PROGRAMMAZIONE SOCKET 16 Codice completo di un client /* cerco di risolvere l hostname del server */ host_info = gethostbyname(server_name); if (host_info == NULL) { fprintf(stderr, "%s: unknown host: %s\n", argv[0], server_name); exit(2); /* Costruisco la struttura di indirizzo del server */ server.sin_family = host_info->h_addrtype; /* uso memcpy per evitare un errore se l indirizzo IP non ha */ /* una lunghezza compatibile a quella di un long */ memcpy(&server.sin_addr, host_info->h_addr, host_info->h_length); server.sin_port = htons(server_port); /* apro la connessione verso il server */ if (connect(sock, (struct sockaddr *)&server, sizeof server) <0) { perror("impossibile collegarsi al server"); exit(3); printf("connessione Effettuata!\n"); /* prelevo il messaggio del server */ read(sock, inbuf, LINESIZE); printf("il server dice: %s\n", inbuf); PROGRAMMAZIONE SOCKET 17

11 Codice completo di un server /***********************************************************************/ /* Programma: simple_server.c */ /* Autore: Claudio Casetti */ /* Descrizione: il seguente programma attiva un server iterativo */ /* connection-oriented, che resta in ascolto su una porta */ /* e invia un messaggio alla richiesta del client. */ /* Il server puo essere interrogato con un opportuno */ /* client o, in remoto, con il comando: */ /* telnet <indirizzoserver> <##porta> */ /***********************************************************************/ #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <stdio.h> #include <syslog.h> #include <signal.h> #include <errno.h> #define SERVER_PORT 1997 #define MAXLEN 50 PROGRAMMAZIONE SOCKET 18 main() { int sock, fd, client_len; struct sockaddr_in server, client; char outbuf[maxlen]; Codice completo di un server /* definisco il socket descriptor */ sock = socket(af_inet, SOCK_STREAM, 0); if (sock < 0) { perror("creating stream socket"); exit(1); /* definisco i campi di indirizzo del server ed effettuo il bind */ server.sin_family = AF_INET; server.sin_addr.s_addr = htonl(inaddr_any); server.sin_port = htons(server_port); if (bind(sock, (struct sockaddr *) &server, sizeof server) < 0) { perror("binding socket"); exit(2); PROGRAMMAZIONE SOCKET 19

12 Codice completo di un server listen(sock, 5); /* accetto fino a 5 connessioni su sock */ /* entro in loop: attendo di ricevere connessioni e scrivo sul connection */ /* descriptor fd il messaggio del Server */ while (TRUE) { client_len = sizeof(client); if ((fd = accept(sock, (struct sockaddr *) &client, &client_len)) < 0) { perror("accepting connection"); exit(3); /* segnalo l arrivo di una connessione, indicando l indirizzo del client: */ /* ATTENZIONE: il comando ritorna il valore decimale dell indirizzo IP, */ /* non l indirzzo IP in notazione decimale puntata (dotted decimal) */ printf("connessione ricevuta da %lu\n", client.sin_addr.s_addr); /* invio al client il messaggio */ sprintf(outbuf, "Sono il Server!\n"); write (fd, outbuf, strlen(outbuf)); close(fd); /* chiudo la comunicazione con il client */ PROGRAMMAZIONE SOCKET 20 Socket in Java È fornito supporto alla programmazione socket mediante le classi Socket e ServerSocket. La classe Socket fornisce le funzionalità necessarie alla programmazione di un client. La classe ServerSocket fornisce le funzionalità necessarie alla programmazione di un server. PROGRAMMAZIONE SOCKET IN 1

13 Socket in Java: il client 1. Per aprire una connessione si istanzia un oggetto Socket: Socket cconnection = new Socket(hostname, portnumber); // portnumber di tipo int hostname può essere un oggetto di tipo String che rappresenta il nome logico dell host InetAddress che rappresenta un indirizzo IP, ottenuto invocando i metodi getbyname(hostname) o getallbyname(hostname), che torna un array di InetAddress 2. Per trasferire dati si utilizzano stream di input (output) per leggere (scrivere) sul Socket. BufferedInputStream bis = new BufferedInputStream(cConnection.getInputStream()); DataInputStream in = new DataInputStream(bis); BufferedOutputStream bos = new BufferedOutputStream(cConnection.getOutputStream()); DataOutputStream out = new DataOutputStream(bos); 3. Al termine delle operazioni si chiude il Socket ed automaticamente sono chiusi gli stream ad esso associati: cconnection.close(); PROGRAMMAZIONE SOCKET IN 2 Socket in Java: il server 1. Per rendersi disponibile ad accettare connessioni, è necessario istanziare un oggetto ServerSocket: ServerSocket sconnection = new ServerSocket(portnumber); portnumber è il numero di porta a cui il server risponde. 2. Il server si pone poi in ascolto: sconnection.accept(): 3. Per trasferire dati si utilizzano stream di input (output) per leggere (scrivere). 4. Il ServerSocket non è mai chiuso, se non quando termina il programma server. PROGRAMMAZIONE SOCKET IN 3

14 Socket in Java: un esempio Il server (iterativo), a fronte di una richiesta di connessione: invia una domanda casuale al client attende una risposta dal client controlla la correttezza della risposta ed invia notifica al client domanda al client se intende rispondere ad un altra domanda attende una risposta e, se positiva, ripete il processo dall inizio Il client è un applicazione che accetta comandi dalla linea di comando. apre una connessione con il server e si pone in attesa di ricevere la domanda quando riceve la domanda la presenta all utente e legge la risposta dell utente invia la risposta al server e si pone in attesa quando riceve la risposta la presenta all utente e gli domanda se intende proseguire invia la risposta dell utente al server e, se necessario, si pone in attesa di una domanda successiva PROGRAMMAZIONE SOCKET IN 4 Il client Trivia import java.io.*; import java.net.*; public class Trivia { private static final int PORTNUM = 1234; public static void main(string[] arguments) { Socket socket = null; InputStreamReader isr = null; BufferedReader in = null; PrintWriter out = null; String address; // Check the command-line args for the host address if (arguments.length!= 1) { System.out.println("Usage: java Trivia <address>"); return; else address = arguments[0]; PROGRAMMAZIONE SOCKET IN 5

15 Il client Trivia // Initialize the socket and streams try { socket = new Socket(address, PORTNUM); isr = new InputStreamReader(socket.getInputStream()); in = new BufferedReader(isr); out = new PrintWriter(socket.getOutputStream(),true); catch (IOException e) { System.err.println("Exception: couldn t create stream socket " + e.getmessage()); System.exit(1); // Process user input and server responses try { StringBuffer str = new StringBuffer(128); String instr; int c; PROGRAMMAZIONE SOCKET IN 6 Il client Trivia while ((instr = in.readline())!= null) { System.out.println("Server: " + instr); if (instr.equals("bye.")) break; while ((c = System.in.read())!= \n ) str.append((char)c); System.out.println("Client: " + str); out.println(str.tostring()); out.flush(); str.setlength(0); // Close while loop out.close(); in.close(); socket.close(); catch (IOException e) { System.err.println("I/O error: "+ e.tostring()); PROGRAMMAZIONE SOCKET IN 7

16 Il server TriviaServer import java.io.*; import java.net.*; import java.util.random; public class TriviaServer extends Thread { private static final int PORTNUM = 1234; private static final int WAITFORCLIENT = 0; private static final int WAITFORANSWER = 1; private static final int WAITFORCONFIRM = 2; private String[] questions; private String[] answers; private ServerSocket serversocket; private int numquestions; private int num = 0; private int state = WAITFORCLIENT; private Random rand = new Random(); PROGRAMMAZIONE SOCKET IN 8 Il server TriviaServer public TriviaServer() { super("triviaserver"); try { serversocket = new ServerSocket(PORTNUM); System.out.println("TriviaServer up and running..."); catch (IOException e) { System.err.println("Exception: couldn t create socket"); System.exit(1); public static void main(string[] arguments) { TriviaServer server = new TriviaServer(); server.start(); PROGRAMMAZIONE SOCKET IN 9

17 Il server TriviaServer: run() public void run() { // Initialize the arrays of questions and answers Socket clientsocket = null; if (!initqna()) { System.err.println("Error: couldn t initialize questions and answers"); return; // Look for clients and ask trivia questions while (true) { if (serversocket == null) // Wait for a client return; try { clientsocket = serversocket.accept(); catch (IOException e) { System.err.println("Exception: couldn t connect to client socket"); System.exit(1); PROGRAMMAZIONE SOCKET IN 10 Il server TriviaServer: run() try { // Perform the question/answer processing InputStreamReader isr = new InputStreamReader(clientSocket.getInputStream()) BufferedReader is = new BufferedReader(isr); PrintWriter os = new PrintWriter(new BufferedOutputStream(clientSocket.getOutputStream()), false); String outline; // Output server request outline = processinput(null); os.println(outline); os.flush(); while (true) { // Process and output user input String inline = is.readline(); if (inline.length() > 0) { outline = processinput(inline); os.println(outline); os.flush(); if (outline.equals("bye.")) break; PROGRAMMAZIONE SOCKET IN 11

18 Il server TriviaServer os.close(); // Close is.close(); clientsocket.close(); catch (Exception e) { System.err.println("Exception: " + e); e.printstacktrace(); PROGRAMMAZIONE SOCKET IN 12 Il server TriviaServer: initqna() private boolean initqna() { try { File infile = new File("QnA.txt"); FileInputStream instream = new FileInputStream(inFile); byte[] data = new byte[(int)infile.length()]; // Read the questions and answers into a byte array if (instream.read(data) <= 0) { System.err.println("Error: couldn t read questions and answers"); return false; // See how many question/answer pairs there are for (int i = 0; i < data.length; i++) if (data[i] == (byte) \n ) numquestions++; numquestions /= 2; questions = new String[numQuestions]; answers = new String[numQuestions]; PROGRAMMAZIONE SOCKET IN 13

19 Il server TriviaServer: initqna() // Parse the questions and answers into arrays of strings int start = 0, index = 0; boolean isq = true; for (int i = 0; i < data.length; i++) if (data[i] == (byte) \n ) { if (isq) { questions[index] = new String(data, start, i - start - 1); isq = false; else { answers[index] = new String(data, start, i - start - 1); isq = true; index++; start = i + 1; catch (FileNotFoundException e) { System.err.println("Exception: couldn t find the question file"); return false; catch (IOException e) { System.err.println("Exception: I/O error trying to read questions"); return false; return true; PROGRAMMAZIONE SOCKET IN 14 Il server TriviaServer: processinput() String processinput(string instr) { String outstr = null; switch (state) { case WAITFORCLIENT: // Ask a question outstr = questions[num]; state = WAITFORANSWER; break; case WAITFORANSWER: // Check the answer if (instr.equalsignorecase(answers[num])) outstr = "That s correct! Want another? (y/n)"; else outstr = "Wrong, the correct answer is " + answers[num] + ". Want another? (y/n)"; state = WAITFORCONFIRM; break; PROGRAMMAZIONE SOCKET IN 15

20 Il server TriviaServer: processinput() case WAITFORCONFIRM: // See if they want another question if (instr.equalsignorecase("y")) { num = Math.abs(rand.nextInt()) % questions.length; outstr = questions[num]; state = WAITFORANSWER; else { outstr = "Bye."; state = WAITFORCLIENT; break; return outstr; PROGRAMMAZIONE SOCKET IN 16