Il sistema operativo LINUX Inter Process Communication. Sommario. popen ( ) PIPE. pipe ( ) popen ( ) Sistemi operativi Modulo II

Transcript

1 Il sistema operativo LINUX Inter Process Communication Sommario Giorgio Di Natale Stefano Di Carlo Politecnico di Torino Dip. Automatica e Informatica dup FIFO SOCKET PIPE popen ( ) Una PIPE è un flusso dati tra due processi Ciascun processo, attraverso un file descriptor, accede ad uno degli estremi della FILE *popen ( const char *cmd, const char *open_mode); P1 P2 int close (FILE *f); Invoca cmd redirigendone o popen ( ) read_fp = popen ( uname -a, r ); if (read_fp!= NULL) { nchar = fread (buffer, sizeof(char), BUFSIZ, read_fp); pclose(read_fp); int (int fd[2]); ( ) L array fd contiene due nuovi file descriptor fd[1] scrittura sulla fd[0] lettura dalla Valore di ritorno: fd 0 OK -1 Error 1

2 & fork I processi figli ereditano i descrittori di file Una (aperta) consente al processo padre di comunicare con il figlio fd fd #include <stdlib.h> #include <string.h> int main() { int data_processed; int file_s[2]; const char some_data[] = "123"; char buffer[bufsiz + 1]; pid_t fork_result; Esempio if ((file_s) == 0) { fork_result = fork(); if (fork_result == -1) { fprintf(, "Fork failure"); exit(exit_failure); if (fork_result == 0) { // child close(file_s[1]); // child reads data_processed = read( file_s[0], buffer, BUFSIZ); printf("read %d bytes: %s\n", data_processed, buffer); exit(exit_success); dup ( ) else { // parent close(file_s[0]); // parent writes data_processed = write( file_s[1], some_data, strlen(some_data)); printf("wrote %d bytes\n", data_processed); exit(exit_success); int dup (int fd); Duplica fd sul primo file descriptor libero int dup2 (int oldfd, int newfd); Duplica il vecchio (oldfd) file descriptor usando newfd 2

3 dup ( ) / redirection file descriptor dup(2) file descriptor ls -la more Si crea una si chiude lettura della (che ora redirige lo del processo) lettura della exec more si chiude scrittura della (che ora redirige lo del processo) scrittura della exec ls -la / redirection / redirection Si crea una si chiude () Si crea una si chiude () / redirection / redirection Si crea una si chiude () Si crea una si chiude () 3

4 / redirection / redirection Si crea una si chiude () Si crea una si chiude () Esempio Esempio main() { int fda[2]; if ((fda)==-1) exit (1); switch (fork()) { case -1: exit(1); case 0: close (1); // Chiude dup (fda[1]); // Duplica la (w) close (fda[1]); // Chiude la close (fda[0]); execlp ( ls, ls, -la, 0); printf ( Errore ); break; Esempio FIFO default: close (0); // Chiude dup (fda[0]); // Duplica la (r) close (fda[1]); // Chiude la close (fda[0]); execlp ( more, more, 0); printf ( Errore ); break; Le consentono la comunicazione solo tra processi che hanno un antenato comune Una FIFO è una che può essere utilizzata da diversi processi e referenziata con il suo nome (named ) il comando mkfifo fifoname consente di creare una FIFO (nelle versioni più vecchie di UNIX si utilizza mknod) 4

5 FIFO open ( ) Su una FIFO possono agire le chiamate open() read() write() close() Una FIFO può essere aperta: O_RDONLY O_WRONLY O_NONBLOCK Una open in lettura è bloccante fino a che LA FIFO non viene aperta anche in scrittura Una open in scrittura è bloccante fino a che la FIFO non viene aperta anche in lettura Una open in scrittura non bloccante genera errore se la FIFO non è già aperta in lettura Socket Socket Estendeono il concetto di per la comunicazione client/server tra processi (distribuiti) Sono uno standard per le comunicazioni TCP/IP Una coppia di connessi fornisce una interfaccia tipo I possono essere visti come dei le speciali che devono essere aperti dai due processi comunicanti e usati con le normali read e write. Attributi dei Principali domain I sono caratterizzati da: domain: individua una famiglia di omogenei (AF_INET, AF_UNIX, AF_ISO, ) type: individua il meccanismo di comunicazione utilizzato (stream o datagram nella famiglia AF_INET) protocollo: individua il protocollo di trasporto utilizzato (laddove siano possibili alternative) AF_UNIX: file system per la comunicazione tra processi locali AF_INET: unix network per reti TCP/IP AF_ISO: protocolli standard ISO AF_NS: protocolli di rete Xerox AF_IPX: protocollo IPX Novell 5

6 Creare un Bind #include <sys/types.h> int (int domain, int type, int protocol); Caratteristiche: restituisce un descriptor read() e write() consentono di leggere e scrivere sul Per utilizzare un occorre associarlo ad un indirizzo tramite la chiamata bind( ) int bind( int, const struct sockaddr *address, size_t address_len); Indirizzamento Indirizzamento AF_UNIX: struct sockaddr_un { sa_family_t sun_family; /* AF_UNIX */ char sun_path[]; /* pathname */ ; AF_INET struct sockaddr_in { short int sin_family; /* AF_INET */ unsigned short int sin_port; /* Port Number */ struct in_addr sin_addr; /* Internet addr.*/ struct in_addr { unsigned long int s_addr; ; listen ( ) accept ( ) Per ricevere connessioni su un server occorre creare una coda int listen (int, int backlog); Dopo aver creato una coda il server deve mettersi in ascolto per ricevere eventuali connessioni int accept ( int, struct socaddr *address, size_t *address_len); 6

7 accept ( ) connect ( ) La accept è bloccante, a meno di non settare il flag O_NONBLOCK int flags = fcntl(, F_GETFL, 0); fcntl(, F_SETFL, O_NONBLOCK flag); Stabilisce una connessione verso il server int connect(int, const struct socaddr *address, size_t address_len); Tipi di AF_INET Porte TCP e UDP Un è il punto di terminazione (endpoint) di una comunicazione TCP/IP, identificato da un nome, un indirizzo IP ed una porta Esistono tre tipi di AF_INET: i datagram forniscono un interfaccia ai servizi a datagramma UDP (User Datagram Protocol) gli stream forniscono un interfaccia ai servizi connection-oriented TCP i raw forniscono un interfaccia ai livelli di rete (IP e ICMP) Sono il mezzo con cui un programma client indirizza un programma server un www client si connette ad un www server indicando: l indirizzo IP dell elaboratore remoto il numero della porta associata al server web Caratteristiche indentificate da un numero naturale su 16 bit = porte predefinite = porte utente Socket port Well know ports L indirizzamento di porta consente di selezionare diverse applicazioni su un host di rete Servizio Porta TCP UDP daytime 13 X X ftp 21 X telnet 23 X smtp 25 X finger 79 X http 80 X pop2 109 X pop3 110 X nntp 119 X 7

8 Socket: pre-connessione Socket: richiesta di connessione IP A coda IP B IP A richiesta di collegamento coda IP B Il client: 1. crea un Il server: 1. crea un 2. associa una porta al 3. si mette in ascolto sulla coda Il client: 1. richiede collegamento alla porta del server Il server: 1. riceve una richiesta di collegamento IP A Socket: connessione stabilita 1052 canale virtuale coda 80 IP B Stream CLIENT ( ) ( ) bind ( ) listen ( ) SERVER attende una connessione 80 Il server: 1. accetta la richiesta 2. completa il canale con un nuovo 3. si rimette in attesa sulla coda del originale connect ( ) write ( ) read ( ) accept ( ) richiesta read ( ) elabora la risposta risposta write ( ) attende una richiesta invia la risposta /* AF_INET client */ #include <sys/types.h> #include <netinet/in.h> #include <arpa/inet.h> int main() { int sockfd; int len; struct sockaddr_in address; int result; char ch = 'A'; /* Create a for the client. */ sockfd = (AF_INET, SOCK_STREAM, 0); /* Name the, as agreed with the server. */ address.sin_family = AF_INET; address.sin_addr.s_addr = inet_addr(" "); address.sin_port = 9734; len = sizeof(address); /* Now connect our to the server's. */ result = connect(sockfd, (struct sockaddr *)&address, len); if(result == -1) { perror("oops: client2"); exit(1); /* We can now read/write via sockfd. */ write(sockfd, &ch, 1); read(sockfd, &ch, 1); printf("char from server = %c\n", ch); close(sockfd); exit(0); 8

9 /* AF_INET server */ #include <sys/types.h> #include <netinet/in.h> #include <arpa/inet.h> int main() { int server_sockfd, client_sockfd; int server_len, client_len; struct sockaddr_in server_address; struct sockaddr_in client_address; /* Create an unnamed for the server. */ server_sockfd = (AF_INET, SOCK_STREAM, 0); /* Name the. */ server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = inet_addr(" "); server_address.sin_port = 9734; server_len = sizeof(server_address); bind(server_sockfd, (struct sockaddr *)&server_address, server_len); /* Create a connection queue and wait for clients. */ listen(server_sockfd, 5); while(1) { char ch; printf("server waiting\n"); /* Accept a connection. */ client_len = sizeof(client_address); client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len); /* We can now read/write to client on client_sockfd. */ read(client_sockfd, &ch, 1); ch++; write(client_sockfd, &ch, 1); close(client_sockfd); Datagram CLIENT ( ) SERVER ( ) bind ( ) sendto ( ) bind ( ) recvfrom ( ) elabora richiesta attende un messaggio recvfrom ( ) sendto ( ) invia la risposta 9