Un server di posta (che usa il protocollo SMTP) è identificato dal numero di porta 25.

Transcript

1 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 che utilizzano TCP per la trasmissione dei dati usando un proprio protocollo, detto protocollo di applicazione. I protocolli di applicazione si basano sul modello client-server: quindi e precisato chi inizia la comunicazione (client) e a chi è diretta (server). Ai più diffusi protocolli dello strato applicazione sono stati assegnati numeri di porta specifici. Ad es., un processo server web (che usa il protocollo HTTP) è identificato dal numero di porta 80. Un server di posta (che usa il protocollo SMTP) è identificato dal numero di porta 25. Un elenco di ben conosciuti numeri di porta per tutti i protocolli standard di Internet è contenuto nella RFC Quando un programmatore crea una nuova applicazione, ad esso deve essere assegnato un nuovo numero di porta 1

2 Unix: strumenti di sincronizzazione, memorizzazione, comunicazione Uso di segnali (sincronizzazione ) Uso di file (memorizzazione) IPC Inter Process Communication caso processo invia limitata quantità info (solo un tipo di segnale) e manca il mittente del segnale solo tra processi che condividono un file system pipe (solo tra processi con un avo in comune) pipe con nome (per processi su una stessa macchina) shared memory (stessa macchina) remoto Socket (e RPC) 2

3 SOCKET Strumenti disponibili nei S.O. della famiglia Unix/Linux per la realizzazione dell interazione tra processi all interno di una rete. UNIX BSD 4.2. Interfaccia di programmazione (API) specifica per lo sviluppo di applicazioni di rete. Libreria di funzioni C basata sul concetto di socket. Una socket rappresenta il mezzo di comunicazione mediante il quale un processo può scambiare messaggi con altri processi. 3

4 Aspetti caratteristici della comunicazione dei processi attraverso socket: Eterogeneità: la comunicazione può avvenire tra oggetti che risiedono in architetture diverse; Trasparenza: la comunicazione tra processi avviene con le stesse modalità, indipendentemente dalla localizzazione fisica dei processi comunicanti; Indipendenza dalla rete :l interfaccia di comunicazione è indipendente dall architettura della rete; Compatibilità con i file: le socket sono rappresentate all interno dei programmi in modo omogeneo ai file 4

5 Proprietà delle socket Dominio di comunicazione. Ambiente nel quale avviene la comunicazione (rete internet: dominio PF-INET; Stesso S.O. Unix: PF_UNIX) Caratteristiche semantiche della comunicazione. Affidabilità, comunicazione uno a uno, uno a molti. Denotazione dei processi comunicanti Regole di formato da adottare per esprimere l indirizzo dei nodi 5

6 Tipo di socket Tipo: denota lo stile di comunicazione. connection-oriented (utilizzo di un canale virtuale) connection-less (senza canale) Socket stream - Connection oriented (affidabilità) - Comunicazione simmetrica uno-a- uno - Creazione del canale prima dell inizio della comunicazione (es., funzione connect); chiusura del canale al termine della comunicazione(es.: funzione shutdown). Socket datagram - Connectionless (non affidabile) - Possibilità di comunicazione con più di un processo (comunicazione asimmetrica) 6

7 Dominio di comunicazione Canale virtuale proc A Messaggio 1 Messaggio 2 proc B Socket stream 7

8 Dominio di comunicazione Proc B Proc A Proc C Socket datagram 8

9 Struttura dati associata alla socket Nel dominio Internet (PF-INET) ogni socket è individuata da: Indirizzo IP del nodo in cui risiede il processo proprietario della socket. Numero della porta cui è associata la socket Ogni processo che intende comunicare con altri processi deve: Creare una socket. Ogni socket viene rappresentata localmente mediante un file descriptor. Renderla individuabile univocamente dai processi del dominio attraverso la specifica del suo indirizzo 9

10 Nel caso del dominio PF-INET l indirizzo di una socket viene espresso attraverso questa struttura: struct sockaddr-in { sa-family-t sin-family; /*dominio*/ in-port-t sin-port; /*porta*/ struct-in-addr sin-addr; /*ind.nodo*/ char sin.zero [8] /*non usato*/ } dove il tipo del campo sin_addr, che rappresenta l indirizzo del nodo, e` dichiarato nel modo seguente: struct in_addr { uint32_t s_addr}; 10

11 I tipi di dato non primitivi utilizzati nelle precedenti definizioni sono descritti nella tabella A. 2, in cui vengono anche indicati i file header in cui sono contenute le rispettive dichiarazioni. Tipo Descrizione Header file sa_family_t Tipo associatoal dominio <sys/types.h> in_port_t Tipo associato alla porta <netinet/in.h> (di solito unsigned int a 16 bit) uint32_t unsigned int a 32 bit <sys/types.h> sockaddr Tipo generico associato all indirizzo <sys/socket.h> di una socket sockaddr_in Tipo specifico per l indirizzo di una socket nel dominio internet (IP v.4) <sys/socket.h> 11

12 Socket nodo: indirizzo IP Processo A nodo: indirizzo IP Processo B socket socket porta Internet (TCP/IP) porta Il canale di comunicazione tra il processo A e il processo B è definito da: <protocollo; indirizzo IP locale; porta locale; indirizzo IP remoto; porta remota> 12

13 Strutture dati Socket Una socket è creata all interno di un dominio di comunicazione Dominio di comunicazione: semantica di comunicazione + standard di denominazione Esempi di domini: UNIX, Internet, etc. struttura dati socket family: PF_INET service: SOCK_STREAM local IP: remote IP:... local port: remote port:... pgid:... DOMINIO - Protocol Family: Internet (oppure AF_INET, Address Family Internet) TIPO della socket: STREAM o DATAGRAM INDIRIZZO macchina locale (NB. il formato dell indirizzo dipende dal dominio di comunicazione della socket) gruppo di processi associati alla socket 13

14 FORMATO INDIRIZZI DOMINIO AF _ UNIX : L indirizzo ha lo stesso formato del nome di un file (pathname). DOMINIO AF_INET _ : indirizzo Internet composto da indirizzo IP dell host (32 bit) e da numero di porta (16 bit) 14

15 Creazione di una socket sd = socket (dominio, tipo, protocollo); int sd, dominio, tipo, protocollo; Crea una SOCKET e ne restituisce il descrittore sd (socket descriptor). dominio denota il particolare dominio di comunicazione (es. AF_INET) tipo indica il tipo di comunicazione (es. SOCK_STREAM o SOCK_DGRAM) protocollo specifica uno dei protocolli supportati dal dominio (se si indica zero viene scelto il protocollo di default) Definisce il protocollo usato dalla socket. In una connessione definisce: <protocollo;indirizzo IP locale;porta locale;indirizzo IP remoto;porta remota> 15

16 Associazione socket - indirizzo locale error = bind (sd, ind, lun); int error, sd; struct sockaddr * ind; int lun; Associa alla socket di descrittore sd l indirizzo codificato nella struttura puntata da ind e di lunghezza lun (la lunghezza è necessaria, poiché la funzione bind può essere impiegata con indirizzi di lunghezza diversa) Collega la socket a un indirizzo locale. In una connessione definisce : <protocollo;indirizzo IP locale;porta locale;indirizzo IP remoto;porta remota> 16

17 Comunicazione connection-oriented (socket STREAM o TCP) Collegamento (asimmetrico) tra processo Client e processo Server: 1) il server e il client devono creare ciascuno una propria socket e definirne l indirizzo (primitive socket e bind) 2) deve essere creata la connessione tra le due socket 3) fase di comunicazione 4) chiusura delle socket 17

18 Comunicazione connection oriented (lato Server) error = listen (sd, dim); int error, sd, dim; Trasforma la socket sd in passiva (listening), pronta per ricevere una richiesta di connessione. Crea una coda, associata alla socket sd in cui vengono inserite le richieste di connessione dei client. La coda può contenere al più dim elementi. Le richieste di connessione vengono estratte dalla coda quando il server esegue la accept(). 18

19 Comunicazione connection oriented (lato Client) error = connect (sd, ind, lun) ; int error, sd; struct sockaddr * ind; int lun; Richiede la connessione fra la socket locale il cui descrittore è sd e la socket remota il cui indirizzo è codificato nella struttura puntata da ind e la cui lunghezza è lun. La connect() può determinare la sospensione del processo?? Definisce l indirizzo remoto a cui si collega la socket: <protocollo;indirizzo IP locale;porta locale;indirizzo IP remoto;porta remota> 19

20 Comunicazione connection oriented (lato Server) nuovo_sd = accept (sd, ind, lun); int nuovo_sd, sd; struct sockaddr * ind; int * lun; Indirizzo è parametro in/out Estrae una richiesta di connessione dalla coda predisposta dalla listen(). Se non ci sono richieste di connessione in coda, sospende il server finché non arriva una richiesta alla socket sd. Quando la richiesta arriva, crea una nuova socket di lavoro nuovo_sd e restituisce l indirizzo della socket del client tramite ind e la sua lunghezza tramite lun. La comunicazione (read/write) si svolge sulla nuova socket nuovo_sd 20

21 Comunicazione connection oriented nodo: indirizzo IP nodo: indirizzo IP socket client porta client Processo Client socket server (sd) listen() + accept() rete (TCP/IP) Processo Server porta server socket server (nuovo_sd) read() e write() 21

22 Protocollo di creazione del canale virtuale processo client csd=socket ( ) connect(csd. <comunicazione attraverso il canale> crea csd richiesta di connessi one canale virtuale ssd asc crea crea asc=socket(..) bind(asc.) Listen(asc ssd=accept(asc. <comunicazione attraverso il canale> 22

23 Una volta creato il canale virtuale i due processi agli estremi di esso (client e server) possono scambiarsi messaggi in entrambe le direzioni (write, read) La spedizione di un messaggio viene richiesta tramite la system call write alla quale si fornisce il socket descriptor associato alla socket locale Il server può spedire un messaggio al client nel modo seguente: int asc,ssd; char msg[6] = 34Ciao!34; <creazione socket ed apertura del canale> write (ssd,msg,6) 23

24 Processo client int csd; char msg[6]; <creazione socket ed apertura del canale>; read (ssd,msg,6); Le socket sono bloccanti: se un destinatario esegue la read quando non vi è alcuna informazione all interno del canale, il processo viene sospeso. TCP non prevede separatori tra un messaggio e il successivo: il contenuto del canale è visto come una sequenza non strutturata di byte Accordo tra i due processi sulle caratteristiche dei messaggi (es. lunghezza costante prefissata) 24

25 Al termine di una sessione di comunicazione, la connessione può essere chiusa mediante la primitiva shutdown (int sd,int modo) dove sd rappresenta il socket descripror associato al terminale del canale modo esprime la modalità di chiusura. E possibile chiudere il canale soltanto in una direzione (valore 0 per la ricezione,valore 1 per la trasmissione) oppure in entrambe (valore di modo uguale a 2). Se la chiusura avviene in entrambe le direzioni la socket sd viene eliminata. 25

26 Processo client # include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> struct sockaddr_in *D, *server; char msg[2000]; int sd, l; int main() { sd=socket(af_inet,sock_stream,0); <inizializzazione indirizzo server> /* richiesta di connessione*/ connect(sd,&server,l); <preparazione messaggio msg>; } write(sd, msg,2000); /*invio messaggio*/ read(sd,ris, 2000); /*ricezione risposta */ shutdown (sd,2); /*chiusura connessione*/ 26

27 Processo server #include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> struct sockaddr_in *M, *mio; char msg[buffersize], ris[2000]; int asc, l,sd, addrlen ; int main() { asc=socket(af_inet,sock_stream,0); <inizializz. mio indirizzo> l=sizeof(struct sockaddr_in); bind (asc,&mio,l); /* pubblicazione indirizzo*/ listen(asc, 100); /*creazione della coda richieste*/ sd=accept(asc, M, &addrlen); /* apertura canale*/ read (sd, msg, 2000); /*ricezione messaggio*. <calcolo risposta ris> write (sd, ris, 2000); /*invio risposta*/ } 27

28 Socket datagram Poiché la comunicazione è senza connessione, in questo caso ogni processo, dopo aver creato la socket ed effettuato l operazione di binding, può già utilizzarla per la comunicazione con altri processi. system call specifiche di spedizione e ricezione dei messaggi sono sendto e recvfrom. int sendto(int s, char *msg, int lun, int flag, struct sockaddr *D, int lund); sd rappresenta il socket descriptor associato alla socket locale; msg è il puntatore al messaggio da inviare; lun è la lunghezza del messaggio; flag è un intero mediante il quale è possibile specificare opzioni particolari sul trasporto del messaggio; D è il puntatore alla struttura che contiene l indirizzo della socket; lund e` la lunghezza della struttura puntata da D; 28

29 La primitiva di ricezione prevede una sintassi analoga: int recvfrom(int sd, char *msg, int lun, int flag, struct sockaddr *M, int *lunm); sd rappresenta il socket descriptor associato alla socket locale; msg è il puntatore alla variabile a cui assegnare il messaggio ricevuto; lun è la lunghezza del messaggio; flag è un intero mediante il quale è possibile specificare opzioni particolari sul trasporto del messaggio; M e` il puntatore alla struttura nella quale viene memorizzato l indirizzo della socket del mittente; lun e` la lunghezza della struttura puntata da M; 29

30 La recvfrom può bloccare il processo destinatario, se il messaggio non è ancora disponibile; a differenza della comunicazione mediante stream, in questo caso i confini dei messaggi vengono mantenuti, e il processo quindi viene sospeso fino a che l intero messaggio non gli è stato recapitato. A differenza del caso di comunicazione con connessione, le primitive di comunicazione prevedono parametri specifici per gli indirizzi dei partner nella comunicazione: nell invio è necessario specificare l indirizzo del destinatario; nella ricezione è previsto che, assieme al messaggio la recvfrom fornisca anche l indirizzo del mittente. Per chiudere una socket datagram è possibile usare ancora la system call shutdown, oppure la system call close 30

31 Comunicazione senza connessione (socket DATAGRAM) Server Process Client Process socket() sendto() 1 socket() bind() recvfrom() <attesa richiesta> recvfrom() <attesa risp> close() 2 <elaborazione> sendto() close() 31

32 Process Client include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> struct sockaddr_in *D, *mio; char msg[2000], ris[buffersize]; int sd, l, addrlen; main() { sd=socket(af_inet,sock_dgram,0); <inizializz. mio indirizzo> l=sizeof(struct sockaddr_in); bind (sd,&mio,l); /* invio messaggio al server: */ sendto (sd, msg, 2000, 0, D,l); /* ricezione risposta: recvfrom (sd, ris, BUFFERSIZE,0, D, &addrlen);... close(sd); } 32

33 Processo server #include <sys/types.h> #include <netinet/in.h> #include <sys/socket.h> struct sockaddr_in *M, *mio; char msg[buffersize], ris[2000]; int sd, l, addrlen; main() { sd=socket(af_inet,sock_dgram,0); <inizializz. mio indirizzo> l=sizeof(struct sockaddr_in); bind (sd,&mio,l); addrlen =l; /* ricezione messaggio:*/ recvfrom (sd, msg, BUFFERSIZE,0, M, &addrlen); <calcolo risposta ris> /*invio risposta:/ sendto (sd, ris, 2000, 0, M, addrlen);... close(sd); } 33

34 Considerazioni conclusive sulle socket UDP : UDP non è reliable, in caso di perdita del messaggio del Client o della risposta del Server, il Client si blocca in attesa indefinita della risposta (utilizzo di timeout?) Blocco del Client anche nel caso di invio di una richiesta a un Server non attivo (errori nel collegamento al server notificati solo sulle socket connesse) UDP non ha flow control, se il Server riceve troppi datagrammi per le sue capacità di elaborazione, questi vengono scartati, senza nessuna notifica ai Client 34

35 Quale tipo di Socket utilizzare? Fare molta attenzione alle differenze semantiche tra le socket STREAM e quelle DATAGRAM, che in genere guidano nella scelta: servizi che richiedono una connessione connectionless servizi Problema dell affidabilità (STREAM si basano su TCP e sono quindi affidabili, DATAGRAM si basano su UDP e quindi non sono affidabili) Prestazioni: STREAM hanno costo più elevato delle DATAGRAM 35

36 Quale tipo di Socket? Quale livello di trasporto, UDP o TCP? Utilizzare TCP (con connessione) quando: affidabilità fondamentale l ordine dei messaggi è importante si vuole semantica at-most-once (servizio del server non idempotente, server con stato) Utilizzare UDP (senza connessione) quando: si vuole fare del broadcast/multicast troppe connessioni sarebbero richieste le prestazioni sono fondamentali (le socket DATAGRAM hanno un costo inferiore, non si deve stabilire una connessione, etc.) non ci sono problemi di ordinamento messaggi (es. ogni msg contenuto in un pacchetto UDP) va bene una semantica may-be 36

37 Un esempio: esecuzione remota di comandi Esecuzione remota di semplici comandi di un client su un server e visualizzazione locale dell output prodotto dai comandi eseguiti. Il client deve richiedere la creazione della connessione e successivamente inviare un messaggio contenente il nome di un comando. Il client si pone in attesa della risposta, rappresentata dall output del comando eseguito dal server; ogni byte ricevuto attraverso il canale viene copiato dal client sul dispositivo di standard output. 37

38 Processo client: #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> main(int argc, char **argv) { int sock, retval, i; char mess[10], ris[1000]; struct sockaddr_in rem_ind; /*indirizzo socket remota*/ /* Preparazione indirizzo del server */ rem_ind.sin_family = PF_INET; /*dominio*/ /* ad esempio: se l indirizzo internet del nodo server e` :*/ rem_ind.sin_addr.s_addr=inet_addr(" "); rem_ind.sin_port = 22375; /* numero di porta del server*/ 38

39 /* Preparazione del messaggio*/ strcpy(mess, argv[1]); /* Creazione della socket */ sock=socket(pf_inet, SOCK_STREAM, 0); connect(sock, &rem_ind, sizeof(struct sockaddr_in)); write(sock,mess, 10); /*invio messaggio*/ while (i=read(sock,ris, 1)>0) /*ric. risposta*/ write(1,ris,i); /* stampa su std. output */ shutdown(sock,2); /* chiusura collegamento*/ } 39

40 Processo server Ogni processo server ha tipicamente una struttura ciclica: ad ogni iterazione viene servita una particolare richiesta di connessione. Il processo server può, in generale, servire le richieste in modo sequenziale (viene servita una richiesta per volta) o concorrente (vengono servite più richieste in parallelo). Nell esempio il server è servito in modo sequenziale. Prima di entrare nel ciclo di servizio, il server crea la socket di ascolto, ne pubblica l indirizzo mediante l operazione di binding; successivamente, con la primitiva listen associa alla socket di ascolto una coda nella quale verranno inserite le eventuali richieste di connessione. Per ogni richiesta, dopo aver instaurato una nuova connessione dedicata ad essa (mediante accept), verrà creato un nuovo processo che: ricevera` dal canale il nome del comando da eseguire e, successivamente, dopo aver opportunamente ridirezionato la socket di comunicazione sullo standard output, passerà ad eseguire il comando mediante una system call della famiglia exec Al termine dell esecuzione del comando, il processo server chiudera` la socket e passera` al servizio di nuove richieste. 40

41 Processo server:*/ #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <stdio.h> main() { char comando[20]; int newsock, sock, figlio, status, i; struct sockaddr_in mio_ind; /* Creazione socket di ascolto */ sock=socket(pf_inet, SOCK_STREAM, 0); /* Preparazione indirizzo socket : */ mio_ind.sin_family=pf_inet; mio_ind.sin_addr.s_addr = INADDR_ANY; mio_ind.sin_port=22375; 41

42 /* Binding:*/ if(bind(sock, &mio_ind, sizeof(struct sockaddr_in))<0) { perror("bind"); exit(1); } /* sock ricevera` le richieste di connessione: */ listen(sock, 5); /*creaz. coda richieste connessione*/ for (;;)/* ciclo di servizio */ { /* estrazione nuova richiesta dalla coda: */ newsock=accept(sock,(struct sockaddr_in *) 0, 0); if ((figlio=fork())==0) { /* figlio */ close(sock); read(newsock, comando, 10); /* ricez. comando*/ /*ridirezione dell output sulla socket: */ close(1); dup(newsock); 42

43 /* esecuzione comando: */ if((i=execlp(comando, comando, (char )0))<0) { write(1,"errore", 7); exit(-1); } } /* figlio*/ else /*padre*/ { wait(&status); /* attesa figlio */ shutdown(newsock, 1); /* chiusura socket: */ close(newsock); } } close(sock); } 43

44 Controllato dal gestore dell applicazione Processo Socket Processo Socket Controllato dal gestore dell applicazione Controllato dal sistema operativo TCP con buffer, variabili Internet TCP con buffer, variabili Controllato dal sistema operativo Host o server Host o server 44

45 Processo client Processo server Stretta di mano a tre vie Socket di benvenuto Socket del client byte byte Socket di connessione tempo 45