Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/ Comunicazione Tra Processi (IPC)- - 1 Parte -

Transcript

1 Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/ Comunicazione Tra Processi (IPC)- - 1 Parte - 1

2 Sommario Comunicazione tra processi sulla stessa macchina: fifo (qualunque insieme di processi) Socket locali Comunicazione tra processi su macchine diverse in rete Socket TCP Esercizi: fifo Socket locali 2

3 - Comunicazione tra processi sulla stessa macchina: FIFO - 3

4 - Creazione di una fifo: mkfifo - Le fifo sono pipe con nome che si usano per realizzare una comunicazione tra processi qualunque, cioè non appartenenti alla stessa gerarchia. Per creare una fifo si usa: #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); Esempio d uso: mkfifo("nomefifo", S_IRUSR S_IWUSR S_IXUSR); Dove: pathname: è il nome della fifo mode: esprime i permessi sulla fifo (identico a open) Restituisce: 0 in caso di successo -1 altrimenti 4

5 - Apertura/chiusura/eliminazione: fifo - Una volta creata, una FIFO deve essere aperta prima di utilizzare. Per aprire una FIFO si utilizza la funzione: open Quindi la FIFO è un tipo di file che ha le caratteristiche di pipe: poterla #include <sys/types.h> #include <sys/stat.h> fd=open("nomefifo",o_rdonly); fd=open("nomefifo", O_WRONLY); una I dati scritti vengono letti in ordine first-in-first-out. Non è possibile rileggere i dati già letti né posizionarsi all interno con lseek. La costante PIPE_BUF stabilisce il massimo numero di byte che possono essere scritti in una FIFO in maniera atomica Per chiudere e per eliminare una FIFO si utilizzano le funzioni: close e unlink close(fd); unlink("nomefifo"); 5

6 - Utilizzo: fifo - Una volta aperta, si può accedere alla FIFO come ad un normale file mediante le funzioni read/write Leggere in una FIFO funzione: read int fd; char msg[10]; mkfifo( myfifo, S_IRUSR) fd=open( myfifo, O_RDONLY); read(fd,msg,10);//legge dalla fifo Scrivere in una FIFO funzione: write int fd; char msg[10]; mkfifo( myfifo, S_IWUSR) fd=open( myfifo, O_WRONLY); write(fd,msg,10);//scrive nella fifo 6

7 - pipe vs fifo - PIPE utilizzabile solo da processi gerarchici create con pipe() e aperte con open() chiuse con close() si elimina al termine del processo FIFO hanno un nome nel file system, possono essere usate da processi non gerarchici create con mkfifo() e aperte con open() chiuse da close() e distrutte da unlink() 7

8 - Comunicazione client/server half-duplex con FIFO - 8

9 Esercizio n 1 FIFO half-duplex Scrivere due programma C, server.c e client.c i quali comunicano attraverso una FIFO. Il programma server, crea la fifo serverfifo, la apre in sola lettura e si mette in attesa di ricevere una richiesta da parte del programma client.alla ricezione della richiesta, crea un processo figlio, il quale esegue il servizio di stampa a video del pid del processo client che ha inviato la richiesta e si rimette in attesa sulla serverfifo. Il programma client, riempie una struttura dati scrivendovi il proprio pid, dopodichè invia tale struttura al server tramite una scrittura nella serverfifo, quindi termina (lanciare i programmi in due shell separate sulla stessa macchina) Esecuzione in due shell diverse sulla stessa macchina shell1 $./server.out shell2 $./client.out 9

10 - Comunicazione client/server half-duplex con FIFO - server read pid FIFO half-duplex write pid client Stampa a video il pid del client Per interrompere l attività del server usare la funzione signal: signal(sigint, foo); \\CTRL-C imposta la funzione foo come handler del segnale SIGINT 10

11 Sol. Eser. n 1 FIFO server.c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <fcntl.h> #include <sys/types.h> #include <signal.h> typedef struct { pid_t clientpid; } richiesta; void disconnetti_fifo(); int main () { int fifo; pid_t figlio; richiesta buffer; signal(sigint, disconnetti_fifo);//ctrl-c if (mkfifo("serverfifo", S_IRUSR S_IWUSR ) < 0) if (errno!= EEXIST) { perror ("Impossibile creare la serverfifo.\n"); exit (-1); } 11

12 Sol. Eser. n 1 FIFO server.c if ((fifo = open ("serverfifo", O_RDONLY)) == -1) { perror ("Errore nella open.\n"); exit (-1); } while (1) {//loop infinito if( read (fifo, &buffer, sizeof (richiesta)) > 0 ) { if ((figlio = fork()) < 0) { perror ("Impossibile creare il figlio.\n"); exit (-1); } if (figlio == 0) { printf("richiesta di esecuzione di Stampa pid\n"); sleep(1); printf("pid del Client: %d\n", buffer.clientpid); } } }//end loop } //end server.c void disconnetti_fifo() {printf("server fermato. Rimozione FIFO dal sistema..."); unlink("serverfifo"); exit(0);} 12

13 Sol. Eser. n 1 FIFO client.c #include <stdio.h> #include <fcntl.h> #include <unistd.h> #include <stdlib.h> typedef struct { pid_t clientpid; Struttura contenente il pid } richiesta; int main () { int fifo; richiesta buffer; if ((fifo = open ("serverfifo", O_WRONLY)) == -1) { perror ("Errore nella open.\n"); exit (-1); } buffer.clientpid = getpid (); /*Pid del processo*/ write (fifo, &buffer, sizeof (buffer)); close (fifo); return 0; } 13

14 Esercizio n 2 FIFO - Scrivere due programmi C: server.c e client.c che implementano due processi server e client che comunicano tra loro mediante una FIFO. Il server riceve dal client una stringa contenente il comando ls UNIX e provvede ad eseguire tale comando al processo figlio creato con una fork. Il processo client una volta lanciato dall utente, chiede di scrivere il comando UNIX da far eseguire al server. Esecuzione: $ /.server.o da una shell $ /.client.o da un altra shell Inserire il comando da eseguire: Suggerimento: Usare execlp per eseguire il comando Sintassi: execlp( comando, comando, (char*)0); 14

15 #include <stdio.h> #include <fcntl.h> Soluzione Esercizio N 2 server.c 1/2 #include <signal.h> #include <stdlib.h> #include <errno.h> /* perror */ #include <unistd.h> /* write, lseek, close, exit */ #include <sys/types.h> /*open, lseek */ #include <sys/stat.h> /*open */ void disconnetti_fifo(); int main(int argc, char *argv[]){ int pid, fd, esito; char r[20]; signal(sigterm, disconnetti_fifo);//ctrl-\ signal(sigint, disconnetti_fifo);//ctrl-c esito = mkfifo("comandi", S_IRUSR S_IWUSR ); if ( esito == -1 ) { printf("errore nella creazione della FIFO lato server\n"); exit(1); } 15

16 Soluzione Esercizio N 2 2/2 server.c fd = open("comandi",o_rdonly); while(1) { if ((esito = read(fd, &r, sizeof(r)))!= 0) { pid = fork(); if (pid==0) { printf("richiesta di esecuzione di: %s\n", r); sleep(1); execlp(r, r, (char *)0); }}}} void disconnetti_fifo() { printf("server fermato. Rimozione FIFO dal sistema..."); unlink("comandi"); exit(0); } 15

17 #include <stdio.h> #include <fcntl.h> Soluzione Esercizio N 2 client.c #include <signal.h> #include <stdlib.h> void esci(); int main(int argc, char *argv[]) { int fd, esito; char r[20]; signal(sigpipe, esci);//viene generato se si esegue una write su di un file FIFO che nessun processo ha aperto in lettura printf("inserisci il comando da eseguire: "); scanf("%s", r); fd = open("comandi", O_WRONLY); if ( fd == -1 ) { printf("\n Servizio non disponibile \n"); exit(1);} if( esito = write(fd, &r, sizeof(r)) == -1 ); perror("write"); close(fd); exit(0); } void esci() { printf("il server non è in ascolto, uscita dal sistema..."); exit(0);} 15

18 - Comunicazione client/server full-duplex con FIFO - 18

19 Esercizio n 3 FIFO full-duplex Scrivere due programma C, fd_server.c e fd_client.c i quali comunicano attraverso FIFO. Il programma fd_server, crea due fifo: FIFO1 e FIFO2 ; fd_server aspetta di leggere un messaggio sulla FIFO1. Il programma fd_client, scrive sulla FIFO1 il messaggio passatogli da riga di comando che verrà letto dal fd_server il quale lo riscriverà in maiuscolo sulla FIFO2 poi letto dal fd_client read <messaggio> server write <MESSAGGIO> FIFO1 FIFO2 write <messaggio> client read <MESSAGGIO> Esecuzione in due shell diverse sulla stessa macchina shell1 $./fd_server.out & (lanciato in backgroud) shell2 $./fd_client.out 19

20 Sol. Eser. n 3 FIFO server.c #include <stdio.h> #include <errno.h> #include <fcntl.h> #include <stdlib.h> #define MAX_BUF_SIZE 255 int main(int argc, char *argv[]){ int rdfd, wrfd, ret_val, count, numread; char buf[max_buf_size]; /* Create the first named - pipe */ ret_val = mkfifo("fifo1", S_IRUSR S_IWUSR); if ((ret_val == -1) && (errno!= EEXIST)) { perror("error creating the named pipe"); exit (1);} ret_val = mkfifo("fifo2", S_IRUSR S_IWUSR); if ((ret_val == -1) && (errno!= EEXIST)) { perror("error creating the named pipe"); exit (1);} 20

21 Sol. Eser. n 3 FIFO server.c /* Open the first named pipe for reading */ rdfd = open("fifo1", O_RDONLY); /* Open the second named pipe for writing */ wrfd = open("fifo2", O_WRONLY); /* Read from the fifo1 */ numread = read(rdfd, buf, MAX_BUF_SIZE); buf[numread] = '\0'; printf("full Duplex Server: Read From the pipe: %s\n", buf); /*Convert to the string to upper case*/ count = 0; while (count < numread) { buf[count] = toupper(buf[count]); count++; } /*Write the converted string back to the second pipe */ write(wrfd, buf, sizeof(buf)); } 21

22 Sol. Eser. n 3 FIFO client.c #include <stdio.h> #include <errno.h> #include <fcntl.h> #include <stdlib.h> #define MAX_BUF_SIZE 255 int main(int argc, char *argv[]){ int wrfd, rdfd, numread; char rdbuf[max_buf_size]; /* Check if an argument was specified. */ if (argc!= 2) { printf("usage:%s <stringto be sent to the server>n", argv[0]); exit (1);} /* Open the first named pipe for writing */ wrfd = open("fifo1", O_WRONLY); /* Open the second named pipe for reading */ rdfd = open("fifo2", O_RDONLY); /* Write to the fifo1 */ write(wrfd, argv[1], sizeof(argv[1])); /* Read from the fifo2 */ numread = read(rdfd, rdbuf, MAX_BUF_SIZE); rdbuf[numread] = '\0'; printf("full Duplex Client: Read From the Pipe: %s\n", rdbuf);} 22

23 - I Socket - 23

24 - Socket: Generalità - I Socket sono Application Programming Interface (API) per interprocess Comunication (IPC) usate Il loro utilizzo è giustificato dall avere un interfaccia estremamente potente e flessibile: consentono la comunicazione tra processi eseguiti sulla stessa macchina o tra processi su macchine distribuite in rete possono essere utilizzate insieme a molte famiglie di protocolli tra le quali ricordiamo quella dei protocolli di Internet (TCP/IP). Sono referenziabili tramite descrittori cosi come avviene per i file ottenibili dopo la chiamata alla funzione socket() 24

25 - Socket: Generalità - Forniscono un canale di comunicazione bidirezionale. Utilizzate per la comunicazione client/server Caratterizzate da descrittori che consentono di utilizzare: read write close ecc. Due tipi di socket: Socket locali (per processi che risiedono sullo stesso host) Socket TCP (per processi che risiedono su host diversi in rete) server read/write socket write/read client 25

26 - Socket: Domini e stili - La logica su cui si basa la programmazione dei socket è semplice, infatti il tipo di comunicazione adottato passa attraverso la definizione di due parametri: dominio e stile Il dominio di un una socket equivale alla scelta di una famiglia di protocolli, ed indica lo spazio in cui risiedono client e server. Ad ogni dominio sono associate una o più costanti simboliche tipo PF_nomefamiglia, definite nell header <sys/socket.h> del Tra i domini più importanti ricordiamo: PF_LOCAL o PF_UNIX per le comunicazioni in locale tramite file system (socket locali) PF_INET, la famiglia TCP/IP con Ipv4 (socket TCP) PF_INET6, la famiglia TCP/IP con Ipv6 (socket TCP) 26

27 - Socket: Domini - A ciascun dominio, possono corrispondere: uno o più tipi di indirizzi; quindi per i socket è prevista la nozione di famiglia di indirizzi ciascuna identificata con una costante simbolica del tipo AF_nomefamiglia definita sempre nell header <sys/socket.h> ; I domini finora introdotti dispongono di un unico schema di indirizzi, per cui le attuali implementazioni prevedono l equivalenza tra nomi di dominio e nomi di indirizzi. 27

28 - Socket: stili - Lo stile di comunicazione definisce: le caratteristiche della trasmissione tra client e server Ad esempio, le trasmissioni possono avvenire a flusso o a pacchetti, essere affidabili o no, richiedere o meno una connessione. Lo stile di comunicazione è individuato da costanti simboliche del tipo SOCK_nomestile definite sempre nell header <sys/socket.h> Gli stili principali sono: SOCK_STREAM, corrispondente ad un canale di trasmissione bidirezionale a flusso, con connessione sequenziale ed affidabile (paradigma connection oriented). SOCK_DGRAM, che consiste in una trasmissione a pacchetti (datagram) di lunghezza max. prefissata, senza connessione e non affidabile (connectionless). Fissato un dominio, la scelta dello stile di comunicazione corrisponde in pratica ad individuare uno specifico protocollo tra quelli consentiti dal dominio stesso. 28

29 - Socket: Indirizzamento - Indirizzamento: Un altra caratteristica che è necessario definire prima di incominciare una trasmissione è l indirizzamento che consente di individuare le parti coinvolte nella trasmissione stessa. (client e server) Gli indirizzi vengono forniti alle socket mediante puntatori ad opportune strutture dati i cui nomi incominciano con sockaddr_ Il suffisso specifica il nome del relativo dominio. La struttura degli indirizzi è definita nell header <sys/socket.h> come segue: } struct sockaddr { sa_family sa_family, /* Tipo di dominio. AF_xxx */ char sa_data[14]; /*tipo di indirizzo nel dominio*/ 29

30 - Indirizzamento - Dominio I TER ET Domino Locale 30

31 - Indirizzi - 31

32 - Comunicazione client/server con Socket - 32

33 - client/server con socket - Lato server: crea un socket tramite la funzione socket il cui nome è noto anche ai processi client Gli assegna un indirizzo con la funzione bind affinchè sia condivisibili da altri processi client Tramite la funzione listen, attende la connessione al socket da parte dei vari client. La funzione listen crea una coda di lunghezza opportuna per consentire la gestione di connessioni simultanee da parte dei client. Accetta le connessioni da parte dei client tramite la funzione accept, il cui ruolo è quello di creare un socket per ogni nuova connessione con un client. Tale socket rappresenta il vero canale di comunicazione tra il client ed il server. 33

34 - client/server con socket - Lato server interattivo (un processo client per volta): Un client è posto in attesa di essere servito sulla coda generata dalla funzione listen aspettando che il server abbia terminato di servire il client precedente. Lato server concorrente (più processi client): Per ogni client viene generato un processo ad hoc per offrire il servizio richiesto, in modo che più client possano essere serviti in modalità concorrente. In tal caso l attesa sulla coda è limitata al tempo necessario alla gestione della richiesta del client da parte del server. Una volta creata la connessione con il client, di solito il server, crea un processo figlio che si occupa della gestione della connessione, mentre il processo originario continua ad accettare altre connessione da altri client 34

35 - client/server con socket - Lato client: crea un socket anonimo mediate la funzione socket e quindi chiede di essere connesso al socket del server non è presente la funzione bind in quanto il socket creato non deve essere indirizzabile. richiama la funzione connect per stabilire una connessione con il server, utilizzando il nome del socket predisposto dal server come indirizzo. Una connessione che ha successo restituisce un descrittore di file al client ed uno al server, che consentono di leggere e scrivere sul socket (funzioni read e write) 35

36 - socket lato server - Crea il socket Gli assegna un indirizzo Si mette in ascolto Accetta nuove connessioni Chiude il socket Cancella il file se socket locale Fuzione socket Funzione bind Funzione listen Funzione accept Funzione close Funzione unlink - socket lato client - Crea il socket Stabilire una connessione Chiude il socket Fuzione socket Funzione connect Funzione close 36

37 - Funzioni Socket lato server - 37

38 - Socket: include - Un programma che usa socket deve includere: <sys/types.h> <sys/socket.h> Inoltre deve anche includere: <sys/un.h> se usa socket del dominio: AF_LOCAL o AF_UNIX, socket locali <netinet/in.h> <arpa/inet.h> e <arpa/netdb.h> se usa socket del dominio: AF_INET 38

39 Funzione socket: creazione 39

40 - Esempio: creare un socket locale- Funzione socket: #include <sys/socket.h> int socket(int famiglia, int tipo, int protocollo); socket locale: famiglia = PF_LOCAL oppure PF_UNIX tipo = SOCK_STREAM (paradigma connection oriented) protocollo = 0 (protocollo di default) int socket( AF_LOCAL, SOCK_STREAM, 0 ); famiglia: specifica il dominio in cui utilizzare il socket Useremo: AF_UNIX oppure AF_LOCAL per socket locali AF_INET per socket distribuite tipo specifica il tipo di comunicazione (SOCK_STREAM) protocol specifica il protocollo da utilizzare per la trasmissione dei dati. Se vale 0, indica il protocollo di default per la copia dominio/tipo utlizzato 40

41 - Valori per creazione socket - 41

42 Funzione bind: Assegnare un indirizzo 42

43 - Assegnare un indirizzo ad una socket - Funzione bind: #include <sys/socket.h> int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); Assegna l indirizzo al socket sockfd, il tipo di indirizzo può essere locale (AF_UNIX) o di rete (AF_INET) a seconda del dominio del socket ed è memorizzato nella struttura puntata da myaddr Ad esempio, per socket locali (AF_LOCAL), l indirizzo è il path+il nome del file e la funzione bind fallisce se il file esiste già (quindi conviene fare prima unlink) Mentre per AF_INET l indirizzo è rappresentato dal numero di porta e dall indirizzo IP. Il terzo argomento addrlen rappresenta la dimensione dell indirizzo (sizeof) Restituisce 0 se ok -1 altrimenti 43

44 - Assegnare un indirizzo ad una socket locale - Funzione bind: Consideriamo la struttura sockaddr_ definita in <sys/un.h> che contiene l indirizzo #include <sys/un.h> #define UNIX_PATH_MAX 108 struct sockaddr_un { sa_family_t sun_family; //AF_LOCAL char sun_path[unix_path_max]; //pathname del socket }; Costruzione dell indirizzo per socket locale: struct sockaddr_un mio_indirizzo; mio_indirizzo.sun_family = AF_LOCAL; strcpy(mio_indirizzo.sun_path, /tmp/mio_socket ); bind(fd,(struct sockaddr *)&mio_indirizzo, sizeof(mio_indirizzo)); 44

45 Funzione listen: mettersi in ascolto 45

46 Funzione accept: accettare nuove connessioni 46

47 - Accettare una nuova connessione - Funzione accept: #include <sys/socket.h> int accept(int sockfd, struct sockaddr *indirizzo_client, socklen_t *dimensione_indirizzo); Crea un nuovo socket con gli stessi attributi di quello originario, dedicato a questa nuova connessione Lo connette al socket del client e restituisce un descrittore di file corrispondente che permette di comunicare con il client il vecchio socket resta in ascolto per accettare altre connessioni il secondo e terzo argomento servono ad identificare il client. Possono anche essere poste a NULL Restituisce Un nuovo descrittore se ok -1 altrimenti 47

48 - Struttura di un server con socket locale - int fd1, fd2; struct sockaddr_un mio_indirizzo; mio_indirizzo.sun_family = AF_LOCAL; strcpy(mio_indirizzo.sun_path, /tmp/mio_socket ); fd1 = socket(pf_local, SOCK_STREAM, 0);//crea socket locale bind(fd1,(struct sockaddr*)&mio_indirizzo, sizeof(mio_indirizzo)); listen(fd1, 5);//5 è la dim della coda di attesa fd2 = accept(fd1, NULL, NULL);... close(fd2); close(fd1); unlink( /tmp/mio_socket ); 48

49 - Funzioni socket lato server - Crea il socket Gli assegna un indirizzo Si mette in ascolto Accetta nuove connessioni Chiude il socket Cancella il file se socket locale fd socket(famiglia, tipo, protocollo) bind(fd, indirizzo, dimensione_indirizzo) listen(fd, lunghezza_coda) fd accept(fd, indirizzo_client, dimensione_ind) close(fd) unlink( nomefilesocket ) 49

50 - Funzioni Socket lato client - 50

51 - Funzioni socket lato client - Crea il socket Si connette ad un server Chiude il socket Funzione socket (uguale a quella server) Funzione connect Funzione close 51

52 Funzione connect: connettersi ad un server 52

53 Funzione connect: connettersi ad un server Funzione connect: #include <sys/socket.h> int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen); Connette il socket sockfd creato da un client ad un socket il cui indirizzo è presente nella struttura puntata da serv_addr il client deve conoscere l indirizzo del server il terzo argomento è la dimensione della struttura dati contenente l indirizzo Restituisce 0 ok -1 altrimenti 53

54 Funzione close: chiudere il socket 54

55 - Struttura di un client con socket locale - int fd; struct sockaddr_un indirizzo; indirizzo.sun_family = AF_LOCAL; strcpy(indirizzo.sun_path, /tmp/mio_socket ); fd = socket(pf_local, SOCK_STREAM, 0);//crea socket locale connect(fd,(struct sockaddr*)&indirizzo, sizeof(indirizzo));... close(fd); 55

56 Leggere da un socket 56

57 Scrivere in un socket 57

58 client/server con socket 58

59 - Esercizi: client/server con Socket locale - 59

60 Esercizio n 4 Socket locali Scrivere due programmi C, server.c e client.c. che comunicano tramite socket. Il server.c crea una socket locale, ed ogni volta che instaura una connessione con un client, mediate fork crea un nuovo processo. Tale processo, dovrà leggere sul socket il messaggio scritto dal client e scrivere il messaggio che il server manda al client. Il client.c dovrà connettersi al socket locale su cui scriverà il messaggio da mandare al server. (lanciare l esecuzione dei due programmi su due shell distinti della stessa macchina) Esecuzione $./server (shell1) MESSAGGIO DA CLIENT: Saluti da client $./client (shell2) MESSAGGIO DA SERVER: Saluti dal server 60

61 server socket - Comunicazione client/server con socket localeclient fork scrive il messaggio del server sulla socket legge il messaggio del client dalla socket processo figlio connection_handler 61

62 Sol. Eser. n 4 server.c #include <stdio.h> #include <sys/socket.h> Funzione chiamata dal processo #include <sys/un.h> figlio per comunicare con il client #include <sys/types.h> tramite socket #include <unistd.h> int connection_handler(int connection_fd) { int nbytes; char buffer[256]; sockfd //legge da socket il mess. del client nbytes = read(connection_fd, buffer, 256); buffer[nbytes] = 0; printf("messaggio DA CLIENT: %s\n", buffer); nbytes = sprintf(buffer, "Saluti dal server"); //Scrive su socket il mess. del server write(connection_fd, buffer, nbytes); close(connection_fd); return 0; } 62

63 Sol. Eser. n 4 server.c int main(void) //server { struct sockaddr_un address;//struttura degli indirizzi int socket_fd, conn_fd; size_t address_length; //dichiarazione delle variabili pid_t child; socket_fd = socket(pf_local, SOCK_STREAM, 0);//crea socket if(socket_fd < 0) { printf("socket() failed\n"); return 1; } unlink("./demo_socket"); /*Rimuove la socket se già esiste */ //valorizzo i campi della struttura sockaddr_un address.sun_family = AF_LOCAL; //setta il tipo di dominio address_length = sizeof(address.sun_family) + sprintf(address.sun_path, "./demo_socket"); 63

64 Sol. Eser. n 4 server.c if(bind(socket_fd, (struct sockaddr *) &address, address_length)!= 0) {printf("bind() failed\n"); return 1;} if(listen(socket_fd, 5)!= 0)//si mette in ascolto {printf("listen() failed\n"); return 1;} //crea la connessione con i client while((conn_fd = accept(socket_fd,(struct sockaddr *) &address, &address_length)) > -1) { child = fork();//crea il figlio if(child == 0){ return connection_handler(conn_fd);//comunica con client } close(conn_fd); }//end while close(socket_fd); unlink("./demo_socket"); /*Rimuove la socket*/ return 0; }//end server 64

65 Sol. Eser. n 4 client.c #include <stdio.h> #include <sys/socket.h> #include <sys/un.h> #include <unistd.h> int main(void) //client { struct sockaddr_un address; int socket_fd, nbytes; //dichiarazione delle variabili size_t address_length; char buffer[256]; socket_fd = socket(pf_local, SOCK_STREAM, 0);//crea socket if(socket_fd < 0) {printf("socket() failed\n"); return 1;} //valorizza i campi della struttura indirizzi address.sun_family = AF_LOCAL; address_length = sizeof(address.sun_family) + sprintf(address.sun_path, "./demo_socket"); 65

66 Sol. Eser. n 4 client.c //si propne di connettersi al socket del server prima accept if(connect(socket_fd, (struct sockaddr *) &address, address_length)!= 0) { printf("connect() failed\n"); return 1; } nbytes = sprintf(buffer, "Saluti da client"); //scrive su socket il mess. da madare al server write(socket_fd, buffer, nbytes); //legge da socket il mess. del server nbytes = read(socket_fd, buffer, 256); buffer[nbytes] = 0; printf("messaggio DA SERVER: %s\n", buffer); close(socket_fd); return 0; }//end client 66

67 Esercizio n 5 Socket locali Scrivere due programmi C, socket-server.c e socket-client.c. Il programma socket-server.c, crea una socket locale e rimane in attesa di ricevere una connessione. Quando riceve una connessione, legge il messaggio proveniente da essa, lo stampa e chiude la connessione. Se il messaggio ricevuto è quit, il programma server, rimuove la socket e termina l esecuzione. Il server prende il path della socket da linea di comando. Il programma client, si connette alla socket locale ed invia il messaggio. Il nome del path della socket e del messaggio da inviare sono specificati a linea di comando. (Lanciare i due programmi in due shell distinte) Esecuzione server: $./socket-server./demo_socket Esecuzione client: $./socket-client./demo_socket Messaggio $./socket-client./demo_socket quit 67

68 Sol. Eser. n 5 socket-server.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/un.h> #include <unistd.h> int server (int client_socket) { while (1) { int length; char* text; } } chiamata dal server per leggere il mess. del client nel socket Legge la lunghezza del messaggio dalla socket e la mette in length if (read (client_socket, &length, sizeof (length)) == 0) return 0; text = (char*) malloc (length); /*Alloca memoria per il buffer*/ read (client_socket, text, length);/*legge il messaggio e lo mette in text*/ printf ("%s\n", text); free (text); /*Pulisce il buffer */ if (!strcmp (text, "quit")) /*Se text è quit termina*/ return 1; 68

69 Sol. Eser. n 5 socket-server.c int main (int argc, char* const argv[]) { const char* const socket_name = argv[1]; //nome socket int socket_fd, serverlen, clientlen; int client_sent_quit_message; struct sockaddr_un serverunixaddress; /* Server address */ struct sockaddr_un clientunixaddress; /* Client address */ struct sockaddr* serversockaddrptr; /* Ptr to server address */ struct sockaddr* clientsockaddrptr; /* Ptr to client address */ //Parametri da passare all funzione bind serversockaddrptr = (struct sockaddr*) &serverunixaddress; serverlen = sizeof (serverunixaddress); //Parametri da passare all funzione accept clientsockaddrptr = (struct sockaddr*) &clientunixaddress; clientlen = sizeof (clientunixaddress); /*Continua nella slide successica*/ 69

70 Sol. Eser. n 5 socket-server.c socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0); serverunixaddress.sun_family = AF_LOCAL; strcpy (serverunixaddress.sun_path, socket_name); bind (socket_fd, serversockaddrptr, serverlen); listen (socket_fd, 5); /* Maximum pending connection length */ do { int client_socket_fd; client_socket_fd = accept (socket_fd, clientsockaddrptr, &clientlen); client_sent_quit_message = server (client_socket_fd); close (client_socket_fd); } while (!client_sent_quit_message); //cicla se non quit close (socket_fd); unlink (socket_name); /*Rimuove la socket*/ return 0; } //END SERVER 70

71 Sol. Eser. n 5 socket-client.c #include <stdio.h> #include <string.h> #include <sys/socket.h> #include <sys/un.h> #include <unistd.h> chiamata dal client per scrivere il mess. nel socket void write_text (int socket_fd, const char* text) { int length = strlen (text) + 1; /*Write the number of bytes in the string, including NUL-termination.*/ write (socket_fd, &length, sizeof (length)); write (socket_fd, text, length); } 71

72 Sol. Eser. n 5 socket-client.c int main (int argc, char* const argv[]) { const char* const socket_name = argv[1];//nome socket const char* const message = argv[2]; //messaggio int serverlen, socket_fd; struct sockaddr_un serverunixaddress; struct sockaddr* serversockaddrptr; serversockaddrptr = (struct sockaddr*) &serverunixaddress; serverlen = sizeof (serverunixaddress); socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0); //crea socket serverunixaddress.sun_family = AF_LOCAL; strcpy (serverunixaddress.sun_path, socket_name); connect (socket_fd, serversockaddrptr, serverlen); write_text (socket_fd, message);//scrittura mess. su socket close (socket_fd); return 0; } //end client 72

73 Esercizio n 6 Socket locali Scrivere due programmi C, chef.c (server) e cook.c (client). Il server crea un socket chiamato ricetta e tramite essa fornisce una ricetta a tutti i client che la richiedono. La ricetta è formata da una sequenza di stringhe terminate dal carattere \0. Il client si connette al socket chiamato ricetta e legge la ricetta fornita dal server. Man mano che il client legge la ricetta la mostra sullo standard output e quindi termina. Il server, crea un processo figlio che evade la richiesta del client. (lanciare i due programmi, su due shell distinte della stessa macchina) Esecuzione: $./chef.out (server) (shell1) $./cook.out (client) (shell2) Output: lato server: La ricetta è stata scritta nel socket lato client: prova, prova, prova, prova, prova, & prova. 73

74 Sol. Eser. n 6 chef.c (server) #include <stdio.h> #include <signal.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> /* For AF_UNIX sockets */ int writericette (int fd) { chiamata dal server per scrivere la ricetta nel socket static char* line1 = "prova, prova, prova, prova,"; static char* line2 = "prova, & prova."; write (fd, line1, strlen (line1) + 1); /* Write first line */ write (fd, line2, strlen (line2) + 1); /* Write second line */ } /*Continua nella slide successiva*/ 74

75 int main (void) { Sol. Eser. n 6 chef.c (server) int serverfd, clientfd, serverlen, clientlen; struct sockaddr_un serverunixaddress;/* Server address */ struct sockaddr_un clientunixaddress; /* Client address */ struct sockaddr* serversockaddrptr; /* Ptr to server address */ struct sockaddr* clientsockaddrptr; /* Ptr to client address */ //Parametri da passare alla bind serversockaddrptr = (struct sockaddr*) &serverunixaddress; serverlen = sizeof (serverunixaddress); //Parametri da passare alla accept clientsockaddrptr = (struct sockaddr*) &clientunixaddress; clientlen = sizeof (clientunixaddress); /*Continua nella slide successiva*/ 75

76 Sol. Eser. n 6 chef.c (server) serverfd = socket (PF_LOCAL, SOCK_STREAM, 0); serverunixaddress.sun_family = AF_LOCAL; /* Set domain type */ strcpy (serverunixaddress.sun_path, "ricetta"); /* Set name */ unlink ("ricetta"); /* Remove file if it already exists */ bind (serverfd, serversockaddrptr, serverlen); /* Create file */ listen (serverfd, 5); /* Maximum pending connection length */ while (1) { clientfd = accept (serverfd, clientsockaddrptr, &clientlen); if (fork () == 0) { /* Create child to send receipe */ writericette (clientfd); /* Send the recipe */ printf("la ricetta è stata scritta nel socket\n"); close (clientfd); /* Close the socket */ exit (0); /* Terminate */ } else close (clientfd); /* Close the client descriptor */ } }//END Chef-server 76

77 Sol. Eser. n 6 cook.c (client) #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> /* For AF_UNIX sockets */ chiamata dal client per leggere la ricetta nel socket int readricetta (int fd) { char str[200]; while (readline (fd, str)) /* Read lines until end-of-input */ printf ("%s\n", str); /* Echo line from socket */ } int readline (int fd, char *str) { int n; do { /* Read characters until \0 or end-of-input */ n = read (fd, str, 1); /* Read one character */ } while (n > 0 && *str++!= \0 ); return (n > 0); /* Return false if end-of-input */ } 77

78 int main (void) { Sol. Eser. n 6 cook.c (client) int clientfd, serverlen, result; struct sockaddr_un serverunixaddress; struct sockaddr* serversockaddrptr; serversockaddrptr = (struct sockaddr*) &serverunixaddress; serverlen = sizeof (serverunixaddress); clientfd = socket (PF_LOCAL, SOCK_STREAM, 0); serverunixaddress.sun_family = AF_LOCAL; strcpy (serverunixaddress.sun_path, "ricetta"); /*In attesa di connettersi alla socket*/ do { result = connect (clientfd, serversockaddrptr, serverlen); if (result == -1) sleep (1); /* Wait and then try again */ } while (result == -1); readricetta (clientfd); /* Read the recipe */ close (clientfd); /* Close the socket */ exit (0); /* Done */ }//end cook-client 78

79 - Fine Esercitazione - 79