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

Dimensione: px
Iniziare la visualizzazioe della pagina:

Download "Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012. - 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

Socket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server.

Socket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale architettura consente ai sistemi di condividere risorse e cooperare per il raggiungimento

Dettagli

Program m azione di Sistem a 6

Program m azione di Sistem a 6 Program m azione di Sistem a 6 Lucidi per il corso di Laboratorio di Sistemi Operativi tenuto da Paolo Baldan presso l'università Ca' Foscari di Venezia, anno accademico 2004/ 2005. Parte di questo materiale

Dettagli

I Socket. Laboratorio Software 2008-2009 M. Grotto R. Farina

I Socket. Laboratorio Software 2008-2009 M. Grotto R. Farina M. Grotto R. Farina Sommario 1. Applicazioni Distribuite 2. I Socket Introduzione Interfacce e protocolli Descrizione Stile di comunicazione Namespace e protocollo Include e system call Creazione e chiusura

Dettagli

COMUNICAZIONE TRA PROCESSI REMOTI IN UNIX

COMUNICAZIONE TRA PROCESSI REMOTI IN UNIX A cura del prof. Gino Tombolini 1 COMUNICAZIONE TRA PROCESSI REMOTI IN UNIX Il sistema UNIX TCP/IP fornisce un meccanismo di comunicazione tra processi residenti su nodi distinti di una rete, compatibili

Dettagli

Socket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server.

Socket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale architettura consente ai sistemi di condividere risorse e cooperare per il raggiungimento

Dettagli

Lab. di Sistemi Operativi - Esercitazione n 9- -Thread-

Lab. di Sistemi Operativi - Esercitazione n 9- -Thread- Lab. di Sistemi Operativi - Esercitazione n 9- -Thread- 1 Sommario Esercizi su: Comunicazione tra processi: la funzione pipe() Condivisione dati e codice tra due o più processi: concetto di Thread 2 -

Dettagli

Esercitazione [6] Client/Server con Socket

Esercitazione [6] Client/Server con Socket Esercitazione [6] Client/Server con Socket Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di

Dettagli

Interazione (TCP) Client-Server con le socket

Interazione (TCP) Client-Server con le socket Interazione (TCP) Client-Server con le socket D. Gendarmi Interazione TCP Client/Server Server 2. Assegnare un local address alla socket 3. Settare la socket all ascolto 4. Iterativamente: a. Accettare

Dettagli

Lab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix-

Lab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix- Lab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix- 1 Sommario Esercizi sulla gestione dei processi Creazione di un nuovo processo: fork Sincronizzazione tra processi: wait 2 -

Dettagli

IPC Inter Process Communication

IPC Inter Process Communication Il protocollo TCP controlla che la trasmissione tra due end points avvenga correttamente. Non stabilisce alcun criterio su chi deve iniziare la comunicazione. Questo compito è svolto dalle applicazioni

Dettagli

Chiamate di sistema per la Inter Process Communication (IPC) in POSIX. E.Mumolo, DEEI mumolo@units.it

Chiamate di sistema per la Inter Process Communication (IPC) in POSIX. E.Mumolo, DEEI mumolo@units.it Chiamate di sistema per la Inter Process Communication (IPC) in POSIX E.Mumolo, DEEI mumolo@units.it Pipe Cos'è un pipe? E' un canale di comunicazione che unisce due processi Caratteristiche: La più vecchia

Dettagli

Cenni di programmazione distribuita in C++ Mauro Piccolo piccolo@di.unito.it

Cenni di programmazione distribuita in C++ Mauro Piccolo piccolo@di.unito.it Cenni di programmazione distribuita in C++ Mauro Piccolo piccolo@di.unito.it Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale

Dettagli

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2013-14. Pietro Frasca.

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2013-14. Pietro Frasca. Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2013-14 Pietro Frasca Lezione 22 Martedì 7-1-2014 1 System Call per l'uso dei segnali Un processo che

Dettagli

Una semplice applicazione client/server 1

Una semplice applicazione client/server 1 Una semplice applicazione client/server 1 Il nostro obiettivo In questa parte del corso implementeremo un applicazione client/server che usa i socket Internet disponibili nei sistemi Unix/Linux. Nello

Dettagli

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

Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012. - Comunicazione Tra Processi (IPC) - - 2 Parte - Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012 - Comunicazione Tra Processi (IPC) - - 2 Parte - 1 Sommario Comunicazione tra processi su macchine diverse in rete: Socket TCP o Socket Stream

Dettagli

I/O su Socket TCP: read()

I/O su Socket TCP: read() I/O su Socket TCP: read() I socket TCP, una volta che la connessione TCP sia stata instaurata, sono accedibili come se fossero dei file, mediante un descrittore di file (un intero) ottenuto tramite una

Dettagli

rsystem Maximiliano Marchesi maximiliano.marchesi@studenti.unipr.it

rsystem Maximiliano Marchesi maximiliano.marchesi@studenti.unipr.it Maximiliano Marchesi 28 Settembre 2005 Diario delle Revisioni Revisione 1.2 28 Settembre 2005 maximiliano.marchesi@studenti.unipr.it Sommario Introduzione..................................................................................

Dettagli

Esempio 1: stampa locale di file remoto

Esempio 1: stampa locale di file remoto Alcuni esempi di uso di Socket Esempio 1: stampa locale di file remoto Visualizzazione locale del contenuto di un file remoto. Il client deve richiedere la creazione della connessione e successivamente

Dettagli

Esercitazione [5] Input/Output su Socket

Esercitazione [5] Input/Output su Socket Esercitazione [5] Input/Output su Socket Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo

Dettagli

Laboratorio di Sistemi Operativi

Laboratorio di Sistemi Operativi Le FIFO pipe vs fifo la pipe può essere usata solo tra processi "imparentati" (che hanno un antenato comune che ha creato la pipe) la fifo consente di scambiare dati tra processi qualsiasi 2 1 FIFO (named

Dettagli

File I/O. M. R. Guarracino: File I/O 1

File I/O. M. R. Guarracino: File I/O 1 File I/O M. R. Guarracino: File I/O 1 File I/O Gran parte delle operazioni su file in ambiente UNIX possono essere eseguite utilizzando solo cinque funzioni: open read write lseek close M. R. Guarracino:

Dettagli

Laboratorio di Sistemi Operativi 29-01-2009. Cognome Nome Mat.

Laboratorio di Sistemi Operativi 29-01-2009. Cognome Nome Mat. Il compito è costituito da domande chiuse, domande aperte ed esercizi. Non è consentito l uso di libri, manuali, appunti., etc. Tempo massimo 2 ore. Domande chiuse: ogni domanda corrisponde ad un punteggio

Dettagli

La sincronizzazione è legata alla implementazione delle pipe: int pipe(int fd[2]);

La sincronizzazione è legata alla implementazione delle pipe: int pipe(int fd[2]); int pipe(int fd[2]); Le pipe sono canali di comunicazione unidirezionali che costituiscono un primo strumento di comunicazione (con diverse limitazioni), basato sullo scambio di messaggi, tra processi

Dettagli

(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ&

(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ& (VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ& 3ULPRHVHUFL]LR6RFNHWVWUHDPFRQULGLUH]LRQH Si progetti un applicazione distribuita Client/Server per una rete di workstation UNIX (BSD oppure System V). In particolare,

Dettagli

Inter Process Communication. Laboratorio Software 2008-2009 C. Brandolese

Inter Process Communication. Laboratorio Software 2008-2009 C. Brandolese Inter Process Communication Laboratorio Software 2008-2009 C. Brandolese Introduzione Più processi o thread Concorrono alla relaizzazione di una funzione applicativa Devono poter realizzare Sincronizzazione

Dettagli

Programmazione socket. Queste slide sono distribuite con licenza Creative Commons Attribuzione-Non commerciale-condividi allo stesso modo 2.

Programmazione socket. Queste slide sono distribuite con licenza Creative Commons Attribuzione-Non commerciale-condividi allo stesso modo 2. Programmazione socket Queste slide sono distribuite con licenza Creative Commons Attribuzione-Non commerciale-condividi allo stesso modo 2.5 Italia Applicazioni di rete Realizzare un'applicazione di rete

Dettagli

ESERCIZI DI PROGRAMMAZIONE C IN AMBIENTE UNIX

ESERCIZI DI PROGRAMMAZIONE C IN AMBIENTE UNIX ESERCIZI DI PROGRAMMAZIONE C IN AMBIENTE UNIX Introduzione In questa dispensa sono stati raccolti alcuni esercizi di programmazione C in ambiente Unix, tratti dagli esami di Sistemi Operativi svoltisi

Dettagli

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3. 1 strace : visualizzazione delle system call invocate da un processo

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3. 1 strace : visualizzazione delle system call invocate da un processo UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Informatica a.a. 2005-2006 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3 1 strace : visualizzazione delle system call

Dettagli

Esercitazione [8] Pipe e FIFO

Esercitazione [8] Pipe e FIFO Esercitazione [8] Pipe e FIFO Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo Multi-Nodo

Dettagli

Sviluppo di Applicazioni su Rete. Introduzione all API socket di Berkeley. Interazione tra Processi. Modello Client-Server

Sviluppo di Applicazioni su Rete. Introduzione all API socket di Berkeley. Interazione tra Processi. Modello Client-Server a.a. 2003/04 Introduzione all API socket di Berkeley Prof. Vincenzo Auletta auletta@dia.unisa.it http://www.dia.unisa.it/professori/auletta/ Università degli studi di Salerno Laurea e Diploma in Informatica

Dettagli

AXO. Operativo. Architetture dei Calcolatori e Sistema. programmazione di sistema

AXO. Operativo. Architetture dei Calcolatori e Sistema. programmazione di sistema AXO Architetture dei Calcolatori e Sistema Operativo programmazione di sistema Il sistema operativo Il Sistema Operativo è un insieme di programmi (moduli software) che svolgono funzioni di servizio nel

Dettagli

Creare una applicazione Winsock di base

Creare una applicazione Winsock di base Creare una applicazione Winsock di base Usiamo le API Winsock incluse in Creare un progetto per una Socket Windows (in Dev C++) Selezionare la file New Projects Selezionare Empty Project Salvare

Dettagli

SC per Inter Process Comminication. Comunicazione fra macchine diverse: socket

SC per Inter Process Comminication. Comunicazione fra macchine diverse: socket SC per Inter Process Comminication Comunicazione fra macchine diverse: socket 1 Sockets File speciali utilizzati per connettere due o più processi con un canale di comunicazione i processi possono risiedere

Dettagli

Socket per TCP: Fondamenti

Socket per TCP: Fondamenti Socket per TCP: Fondamenti Network Applications Molte applicazioni di rete sono formate da due programmi distinti (che lavorano su due diversi host) uno detto server ed uno detto client. Il server si mette

Dettagli

Laboratorio di Reti di Calcolatori

Laboratorio di Reti di Calcolatori Laboratorio di Reti di Calcolatori Funzioni utili, server ricorsivi, echo client ed echo server. Paolo D Arco Abstract Scopo della lezione è presentare alcune funzioni di utilità generale (e.g., funzioni

Dettagli

Paradigma client-server

Paradigma client-server Interazione Client Server (socket) Vittorio Maniezzo Università di Bologna Vittorio Maniezzo Università di Bologna 15 CliSer - 1/31 Paradigma client-server Le applicazioni utente devono interagire con

Dettagli

Esercitazione Laboratorio di Sistemi Operativi 20-01-2014. Cognome Nome Mat.

Esercitazione Laboratorio di Sistemi Operativi 20-01-2014. Cognome Nome Mat. Il compito è costituito da domande chiuse e domande aperte. Non è consentito l uso di libri, manuali, appunti., etc. Tempo massimo 2 ore. Domande chiuse: ogni domanda corrisponde ad un punteggio di 1 punto

Dettagli

Digressione: man 2...

Digressione: man 2... Syscall File I/O Digressione: man 2... Le funzioni della libreria standard UNIX associate alle system call di Linux sono documentate nella sezione 2 di man e.g.: man 2 open Ogni manpage di system call

Dettagli

Programmazione di applicazioni di rete

Programmazione di applicazioni di rete Programmazione di applicazioni di rete Valeria Cardellini Università di Roma Tor Vergata Applicazioni di rete Applicazioni di rete - forniscono i servizi di alto livello utilizzati dagli utenti - determinano

Dettagli

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3 UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Elettronica-Informatica-Telecomunicazioni a.a. 2001-2002 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3 1 Trasferimento

Dettagli

unsigned long inet_addr(cp) char *cp;

unsigned long inet_addr(cp) char *cp; /* bcopystru.c #include struct point int x; char *y; ; struct point a, b; struct pint *pta, *ptb; a.x = 5; a.y = pippo ; b = a; printf i valori del secondo point sono: %d %s\n,b.x,b.y); pta=

Dettagli

Laboratorio di Programmazione in Rete

Laboratorio di Programmazione in Rete Laboratorio di rogrammazione in Rete a.a. 2005/2006 http://www.di.uniba.it/~lisi/courses/prog-rete/prog-rete0506.htm dott.ssa Francesca A. Lisi lisi@di.uniba.it Orario di ricevimento: mercoledì ore 10-12

Dettagli

T.A.R.I. Socket (ICT, AL)

T.A.R.I. Socket (ICT, AL) Internet Applications (Client-Server Concept, Use of Protocol Ports, Socket API, DNS, E-mail, TELNET, FTP) Funzionalità Livello di trasporto e livelli sottostanti Comunicazione base Disponibilità Livello

Dettagli

Socket TCP. prima parte

Socket TCP. prima parte Socket TCP prima parte Cosa cambia: socket int fd = socket(pf_inet, SOCK_STREAM, 0); if (fd

Dettagli

Reti (già Reti di Calcolatori )

Reti (già Reti di Calcolatori ) Reti (già Reti di Calcolatori ) Cenni di Socket Programming Renato Lo Cigno http://disi.unitn.it/locigno/index.php/teaching-duties/computer-networks Socket API Programmazione dei socket Obiettivo:imparare

Dettagli

DATAGRAM SOCKET. Angelastro Sergio Diomede Antonio Viterbo Tommaso

DATAGRAM SOCKET. Angelastro Sergio Diomede Antonio Viterbo Tommaso DATAGRAM SOCKET Angelastro Sergio Diomede Antonio Viterbo Tommaso Definizione supporta i datagram privo di connessione messaggi inaffidabili di una lunghezza massima prefissata il protocollo UDP supporta

Dettagli

Sincronizzazione e comunicazione tra processi in Unix. usati per trasferire ad un processo l indicazione che un determinato evento si è verificato.

Sincronizzazione e comunicazione tra processi in Unix. usati per trasferire ad un processo l indicazione che un determinato evento si è verificato. Processi parte III Sincronizzazione e comunicazione tra processi in Unix Segnali: usati per trasferire ad un processo l indicazione che un determinato evento si è verificato. Pipe: struttura dinamica,

Dettagli

Socket TCP. seconda parte

Socket TCP. seconda parte Socket TCP seconda parte Schema della connessione Computer 1 127.43.18.1 indirizzo I1 indirizzo I2 Computer 2 143.225.5.3 porta 45000 socket porta 5200 socket processo client processo server socket(...)

Dettagli

CREAZIONE PROCESSI IN UNIX 20

CREAZIONE PROCESSI IN UNIX 20 CREAZIONE PROCESSI IN UNIX 20 STRUTTURE DATI PER PROCESSI Un processo puo' essere in escuzione in 2 modi: kernel e utente. Un processo ha almeno 3 regioni: codice, dati e stack Lo stack è allocato dinamicamente.

Dettagli

Inter-process communication: socket

Inter-process communication: socket Le Socket Inter-process communication: socket Abbiamo visti alcune tipologie di Inter-process communication: Anonymous pipes FIFOs o named pipes Le socket di comunicazione si pongono nell'ipc per realizzare:

Dettagli

Esercizio sulla gestione di file in Unix

Esercizio sulla gestione di file in Unix Esercizio sulla gestione di file in Unix 1 Esercizio Si vuole realizzare un programma C che, utilizzando le system call di Unix, realizzi uno schema di comunicazione tra due processi (padre e figlio) mediante

Dettagli

Laboratorio di Reti di Calcolatori

Laboratorio di Reti di Calcolatori Laboratorio di Reti di Calcolatori Socket UDP. Paolo D Arco Abstract Scopo della lezione è descrivere le funzioni che l interfaccia dei socket offre per far interagire client e server attraverso il protocollo

Dettagli

IPC System V. Code di messaggi

IPC System V. Code di messaggi IPC System V Code di messaggi Panoramica coda di messaggi una lista concatenata di messaggi, FIFO semaforo un contatore condiviso, atomicamente modificabile memoria condivisa uno spazio di memoria accessibile

Dettagli

Laboratorio di Programmazione in rete

Laboratorio di Programmazione in rete Laboratorio di rogrammazione in rete Introduzione alla programmazione C di socket A.A. 2005/06 Comunicazione tra computer Come far comunicare più computer su una rete? Una collezione di protocolli: TC/I

Dettagli

Corso di Laboratorio di Sistemi Operativi

Corso di Laboratorio di Sistemi Operativi Corso di Laboratorio di Sistemi Operativi Lezione 5 Alessandro Dal Palù email: alessandro.dalpalu@unipr.it web: www.unipr.it/~dalpalu Processi in Unix Approfondimenti: http://gapil.gnulinux.it/download/

Dettagli

Digressione: man (2)...

Digressione: man (2)... Syscall File I/O Digressione: man (2)... Le funzioni della libreria standard UNIX associate alle system call di Linux sono documentate nella sezione 2 di man e.g.: man 2 open Ogni manpage di system call

Dettagli

Processi UNIX. I Processi nel SO UNIX. Gerarchie di processi UNIX. Modello di processo in UNIX

Processi UNIX. I Processi nel SO UNIX. Gerarchie di processi UNIX. Modello di processo in UNIX Processi UNIX I Processi nel SO UNIX UNIX è un sistema operativo multiprogrammato a divisione di tempo: unità di computazione è il processo Caratteristiche del processo UNIX: processo pesante con codice

Dettagli

Una prima applicazione in C per l utilizzo delle socket

Una prima applicazione in C per l utilizzo delle socket Una prima applicazione in C per l utilizzo delle socket Richiamo sulle socket Socket in Windows (WinSock) Differenze tra sistemi operativi D. Gendarmi Socket API API: Application Programming Interface

Dettagli

Sistemi Operativi: Programmazione di Sistema

Sistemi Operativi: Programmazione di Sistema Corso di Sistemi Operativi: Programmazione di Sistema Corso di Laurea in Informatica, Università di Firenze Anno accademico 2011/2012 Prof. Luca Ferrari e-mail: ferrari@dsi.unifi.it telefono: 055 4237454

Dettagli

request reply richiesta client processo di servizio processo server principale From - Valeria Cardellini, Corso Sist. Distr. A.A.

request reply richiesta client processo di servizio processo server principale From - Valeria Cardellini, Corso Sist. Distr. A.A. Applicazioni di rete Forniscono i servizi di alto livello utilizzati dagli utenti Determinano la percezione di qualità del servizio (QoS) che gli utenti hanno della rete sottostante Programmazione di applicazioni

Dettagli

Sistemi Operativi (modulo di Informatica II)

Sistemi Operativi (modulo di Informatica II) Sistemi Operativi (modulo di Informatica II) La comunicazione tra processi Patrizia Scandurra Università degli Studi di Bergamo a.a. 2008-09 Sommario Processi cooperanti La comunicazione tra processi Necessità

Dettagli

*HVWLRQHDYDQ]DWDGHOOH6RFNHWLQ& ODSULPLWLYDVHOHFW

*HVWLRQHDYDQ]DWDGHOOH6RFNHWLQ& ODSULPLWLYDVHOHFW *HVWLRQHDYDQ]DWDGHOOH6RFNHWLQ& ODSULPLWLYDVHOHFW 7&3H8'3&OLHQW6HUYHUXVDQGRVHOHFW Si progetti un applicazione distribuita Client/Server per una rete di workstation UNIX (BSD oppure System V). In particolare,

Dettagli

Chiamate di sistema per la Gestione dei processi in POSIX. E.Mumolo, DEEI mumolo@units.it

Chiamate di sistema per la Gestione dei processi in POSIX. E.Mumolo, DEEI mumolo@units.it Chiamate di sistema per la Gestione dei processi in POSIX E.Mumolo, DEEI mumolo@units.it Process id ed altri identificatori pid_t getpid(); // Process id del processo chiamante pid_t getppid(); // Process

Dettagli

Introduzione ai Device Drivers in Linux. E.Mumolo, DEEI mumolo@units.it

Introduzione ai Device Drivers in Linux. E.Mumolo, DEEI mumolo@units.it Introduzione ai Device Drivers in Linux E.Mumolo, DEEI mumolo@units.it 1 Device Drivers Moduli software che gestiscono le periferiche attraverso il file system Tutte le periferiche sono viste come file

Dettagli

Applicazione Client-Server con Server Concorrente Specifiche

Applicazione Client-Server con Server Concorrente Specifiche Applicazione Client-Server con Server Concorrente Specifiche Il progetto consiste nello sviluppo di un'applicazione client/server. Client e server devono comunicare tramite socket TCP.. Il server deve

Dettagli

Gestione dei processi

Gestione dei processi Gestione dei processi Dormire unsigned int sleep(unsigned int); Attende un numero specificato di secondi a meno che non si verifichi un segnale Restituisce 0 se l'attesa è terminata senza interruzioni,

Dettagli

Laboratorio di Sistemi Operativi

Laboratorio di Sistemi Operativi II Semestre - Marzo/Giugno 2008 Matricole congr. 0 mod 3 File & Directory #include #include stat,fstat e lstat int stat (const char *pathname, struct stat *buf); int fstat (int

Dettagli

I Socket in PHP. Introduzione. Gestione degli errori nei socket. Funzioni socket di PHP. (manuale PHP)

I Socket in PHP. Introduzione. Gestione degli errori nei socket. Funzioni socket di PHP. (manuale PHP) I Socket in PHP (manuale PHP) Introduzione Questa estensione implementa una interfaccia a basso livello verso i socket, fornendo la possibilità di agire sia come server sia come client. Per l'utilizzo

Dettagli

programmazione distribuita Introduzione Introduzione alla programmazione distribuita

programmazione distribuita Introduzione Introduzione alla programmazione distribuita Reti Informatiche Introduzione alla programmazione distribuita Introduzione Richiami di Programmazione C Differenze principali C/C++ 2 1 Definizioni di variabili Le variabili possono essere definite solo

Dettagli

Interprocess Communications - II. Franco Maria Nardini

Interprocess Communications - II. Franco Maria Nardini Interprocess Communications - II Franco Maria Nardini XSI IPC Tre tipi di IPC introdotti da System V: semafori shared memory code di messaggi Comunicazioni tra processi su stesso host Tutte consentono

Dettagli

Appunti tratti dal videocorso on-line di Algoritmi e Programmazione Avanzata By ALeXio

Appunti tratti dal videocorso on-line di Algoritmi e Programmazione Avanzata By ALeXio Appunti tratti dal videocorso on-line di Algoritmi e Programmazione Avanzata By ALeXio 1-La memoria dinamica La scrittura di un programma (indipendentemente dal linguaggio adottato) deve sempre tener conto

Dettagli

CREAZIONE DI UN FILE

CREAZIONE DI UN FILE #include #include CREAZIONE DI UN FILE fd = creat(filename, mode); int fd, mode; char *filename; La primitiva creat crea un file, se non ne esiste uno col nome specificato, oppure

Dettagli

I SISTEMI OPERATIVI (1)

I SISTEMI OPERATIVI (1) I SISTEMI OPERATIVI (1) 1 un computer può essere pensato come una stratificazione di macchine virtuali, ciascuna delle quali mette a disposizione alcuni servizi, che sono utilizzabili mediante chiamate

Dettagli

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 6

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 6 UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Informatica, Elettronica e delle Telecomunicazioni a.a. 2005-2006 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 6 1 Socket

Dettagli

Sistemi Operativi (M. Cesati)

Sistemi Operativi (M. Cesati) Sistemi Operativi (M. Cesati) Compito scritto del 16 luglio 2015 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare

Dettagli

Laboratorio reti AA 2008/2009. Dott. Matteo Roffilli Ricevimento in ufficio dopo la lezione

Laboratorio reti AA 2008/2009. Dott. Matteo Roffilli Ricevimento in ufficio dopo la lezione Laboratorio reti AA 2008/2009 Dott. Matteo Roffilli roffilli@csr.unibo.it Ricevimento in ufficio dopo la lezione 1 Laboratorio reti AA 2008/2009 Per esercitarvi fate SSH su: alfa.csr.unibo.it si-tux00.csr.unibo.it.

Dettagli

Appunti del corso di Informatica 1 (IN110 Fondamenti) 6 Introduzione al linguaggio C

Appunti del corso di Informatica 1 (IN110 Fondamenti) 6 Introduzione al linguaggio C Università di Roma Tre Facoltà di Scienze M.F.N. Corso di Laurea in Matematica Appunti del corso di Informatica 1 (IN110 Fondamenti) 6 Introduzione al linguaggio C Marco Liverani (liverani@mat.uniroma3.it)

Dettagli

Gestione dei File. dischi nastri cd

Gestione dei File. dischi nastri cd Gestione dei File Per mantenere disponibili i dati tra le diverse esecuzioni di un programma, questi si devono archiviare in file su memoria di massa (dati persistenti): dischi nastri cd Un file è un astrazione

Dettagli

Comunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC)

Comunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC) Comunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC) Le pipe sono canali di comunicazione unidirezionali Limitazione pipe: permettono la comunicazione solo

Dettagli

Corso di Sistemi Operativi A.A. 2008-2009 - CHIAMATE DI SISTEMA PER IL CONTROLLO DEI PROCESSI. Fabio Buttussi

Corso di Sistemi Operativi A.A. 2008-2009 - CHIAMATE DI SISTEMA PER IL CONTROLLO DEI PROCESSI. Fabio Buttussi Corso di Sistemi Operativi A.A. 2008-2009 - CHIAMATE DI SISTEMA PER IL CONTROLLO DEI PROCESSI Fabio Buttussi La programmazione di sistema Il kernel è la parte di Unix che corrisponde al sistema operativo

Dettagli

System call fcntl e record locking

System call fcntl e record locking System call fcntl e record locking Esempio: prenotazione di voli aerei La compagnia ACME Airlines usa un sistema di prenotazione dei voli basato su unix. Possiede due uffici per la prenotazione, A e B,

Dettagli

Introduzione alle applicazioni di rete

Introduzione alle applicazioni di rete Introduzione alle applicazioni di rete Definizioni base Modelli client-server e peer-to-peer Socket API Scelta del tipo di servizio Indirizzamento dei processi Identificazione di un servizio Concorrenza

Dettagli

Strutture. Strutture e Unioni. Definizione di strutture (2) Definizione di strutture (1)

Strutture. Strutture e Unioni. Definizione di strutture (2) Definizione di strutture (1) Strutture Strutture e Unioni DD cap.10 pp.379-391, 405-406 KP cap. 9 pp.361-379 Strutture Collezioni di variabili correlate (aggregati) sotto un unico nome Possono contenere variabili con diversi nomi

Dettagli

Program m azione di Sistem a 5

Program m azione di Sistem a 5 Program m azione di Sistem a 5 Lucidi per il corso di Laboratorio di Sistemi Operativi tenuto da Paolo Baldan presso l'università Ca' Foscari di Venezia, anno accademico 2004/ 2005. Parte di questo materiale

Dettagli

Appunti del corso di Informatica 1. 6 Introduzione al linguaggio C

Appunti del corso di Informatica 1. 6 Introduzione al linguaggio C Università di Roma Tre Dipartimento di Matematica e Fisica Corso di Laurea in Matematica Appunti del corso di Informatica 1 (IN110 Fondamenti) 6 Introduzione al linguaggio C Marco Liverani (liverani@mat.uniroma3.it)

Dettagli

Transmission Control Protocol

Transmission Control Protocol Transmission Control Protocol Franco Callegati Franco Callegati IC3N 2000 N. 1 Transmission Control Protocol - RFC 793 Protocollo di tipo connection-oriented Ha lo scopo di realizzare una comunicazione

Dettagli

Struttura dati FILE. Concetto di FILE

Struttura dati FILE. Concetto di FILE Struttura dati FILE Concetto di FILE Per poter mantenere disponibili dei dati tra diverse esecuzioni di un programma (PERSISTENZA dei dati), è necessario poterli archiviare su memoria di massa. Un file

Dettagli

Scrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file:

Scrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file: Scrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file: usare lseek per spostarsi alla fine del file e poi scrivere: lseek(filedes, (off_t)0, SEEK_END); write(filedes, buf, BUFSIZE);

Dettagli

Processi in Linux. Stru/ura file eseguibili

Processi in Linux. Stru/ura file eseguibili SISTEMI OPERATIVI Processi in Linux Stru/ura file eseguibili» ELF - Executable and Linking Format formato di default degli eseguibili in Linux definizione nel file include » StruGura un header contenente

Dettagli

Creare un'elementare backdoor in C in ambiente UNIX

Creare un'elementare backdoor in C in ambiente UNIX Creare un'elementare backdoor in C in ambiente UNIX DISCLAIMER: Questo tutorial è a solo scopo didattico. L'autore NON si prende alcuna responsabilità circa usi errati o non legali delle informazioni qui

Dettagli

Controllo Winsock di Visual Basic

Controllo Winsock di Visual Basic Controllo Winsock di Visual Basic Il controllo Winsock, non visibile all'utente, consente di accedere ai servizi di rete TCP e UDP. Per creare applicazioni client o server non è necessario conoscere in

Dettagli

Reti di Calcolatori:

Reti di Calcolatori: Reti di Calcolatori: Internet, Intranet e Mobile Computing a.a. 2007/2008 http://www.di.uniba.it/~lisi/courses/reti/reti0708.htm dott.ssa Francesca A. Lisi lisi@di.uniba.it Orario di ricevimento: mercoledì

Dettagli

GESTIONE INFORMATICA DEI DATI AZIENDALI

GESTIONE INFORMATICA DEI DATI AZIENDALI GESTIONE INFORMATICA DEI DATI AZIENDALI Alberto ZANONI Centro Vito Volterra Università Tor Vergata Via Columbia 2, 00133 Roma, Italy zanoni@volterra.uniroma2.it Rudimenti di programmazione Programming

Dettagli

File e Directory. M. Guarracino - File e Directory 1

File e Directory. M. Guarracino - File e Directory 1 File e Directory M. Guarracino - File e Directory 1 Date dei file Ogni volta che accediamo ai dati contenuti in un file, il sistema memorizza la data di ultimo accesso La stessa cosa accade quando modifichiamo

Dettagli

Programmazione di Sistema 5. Pipe e Fifo. IPC: Inter Process Communication. Pipe anonimi e con nome (FIFO) Paolo Baldan

Programmazione di Sistema 5. Pipe e Fifo. IPC: Inter Process Communication. Pipe anonimi e con nome (FIFO) Paolo Baldan IPC: Inter Process Communication Programmazione di Sistema 5 Paolo Baldan Università Ca Foscari Venezia Corso di Laurea in Informatica Parte di questo materiale è rielaborato dalle slide del Corso di Laboratorio

Dettagli

Parte II: Reti di calcolatori Lezione 12

Parte II: Reti di calcolatori Lezione 12 Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2014-15 Parte II: Reti di calcolatori Lezione 12 Giovedì 16-04-2015 1 Confronto architetture C/S e

Dettagli

Corso di Sistemi Operativi

Corso di Sistemi Operativi Corso di Sistemi Operativi Comunicazione tra processi (IPC) a.a. 2012/2013 Francesco Fontanella Comunicazione tra processi I processi in esecuzione concorrente possono essere indipendenti o cooperanti.

Dettagli

Introduzione al Linguaggio C

Introduzione al Linguaggio C Introduzione al Linguaggio C File I/O Daniele Pighin April 2009 Daniele Pighin Introduzione al Linguaggio C 1/15 Outline File e dati Accesso ai file File I/O Daniele Pighin Introduzione al Linguaggio C

Dettagli

Luca Mari, Sistemi informativi applicati (reti di calcolatori) appunti delle lezioni. Architetture client/server: applicazioni client

Luca Mari, Sistemi informativi applicati (reti di calcolatori) appunti delle lezioni. Architetture client/server: applicazioni client Versione 25.4.05 Sistemi informativi applicati (reti di calcolatori): appunti delle lezioni Architetture client/server: applicazioni client 1 Architetture client/server: un esempio World wide web è un

Dettagli

Interazione, sincronizzazione e comunicazione tra processi

Interazione, sincronizzazione e comunicazione tra processi Interazione, sincronizzazione e comunicazione tra processi Classificazione Processi interagenti processi interagenti/indipendenti due processi sono indipendenti se l esecuzione di ognuno non è in alcun

Dettagli