• 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 1700. Quando un programmatore crea una nuova
applicazione, ad esso deve essere assegnato un nuovo numero di porta 1
 Unix: strumenti di sincronizzazione, memorizzazione,
comunicazione

Uso di segnali processo invia limitata quantità info

(sincronizzazione) (solo un tipo di segnale) e manca il
mittente del segnale
Uso di file solo tra processi che condividono un file
(memorizzazione) system
pipe (solo tra processi con un avo in comune)
IPC pipe con nome (per processi su una stessa
Inter macchina)
cas
Process o shared memory (stessa macchina)
Communication
rem
oto
Socket (e RPC)

2
 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
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
 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
 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
 Dominio di comunicazione
Canale
virtuale

Messaggio 1 proc
proc
A B
Messaggio 2

Socket
stream

7
 Dominio di comunicazione
Proc
B

Proc
A

Proc
C

Socket
datagram

8
 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
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; /*[Link]*/
char [Link] [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
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
 Socket
nodo: indirizzo IP nodo: indirizzo IP

Processo A 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
 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 DOMINIO - Protocol Family: Internet

family: PF_INET (oppure AF_INET, Address Family Internet)
service: SOCK_STREAM
local IP: [Link] TIPO della socket: STREAM o DATAGRAM
remote IP: ....
local port: 12345 INDIRIZZO macchina locale (NB. il formato dell’indirizzo
remote port: ..... dipende dal dominio di comunicazione della socket)
pgid:
.................... gruppo di processi associati alla socket

13
 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
 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
 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
 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
 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
 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
 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
 Comunicazione connection oriented

nodo: indirizzo IP nodo: indirizzo IP

Processo Processo
Client Server
socket
socket server
client (sd)
listen() +
accept()
socket
server
porta (nuovo_sd)
client read() e write()
rete (TCP/IP) porta
server

21
Protocollo di creazione del canale virtuale

processo client

asc
asc=socket(
crea
richiesta ..)
di
csd=socket csd connessi bind(asc.)
cre
a
(…) one
connect(csd. Listen(asc
ssd
canale crea ssd=accept(asc
virtuale .
<comunicazione
attraverso il <comunicazione
canale> attraverso il
canale>

22
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
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
• 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
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
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
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
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
• 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
 Comunicazione senza connessione
(socket DATAGRAM)

Server Process
socket()
Client Process
bind()
socket()
1 recvfrom()
sendto() <attesa
richiesta>
<elaborazione>
2
recvfrom() sendto()
<attesa risp>
close()
close()

31
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
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);
...
33
close(sd); }
 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
 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 servizi

connectionless

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
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
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
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`
[Link]:*/
rem_ind.sin_addr.s_addr=inet_addr("[Link]");
rem_ind.sin_port = 22375; /* numero di porta del server*/
38
/* 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
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
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
/* 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
/* 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
 Controllato dal Controllato dal
gestore Processo Processo gestore
dell’applicazione dell’applicazione
Socket Socket

Controllato TCP con TCP con Controllato

dal sistema buffer, Internet dal sistema
buffer, operativo
operativo variabili variabili

Host o server Host o server

44
 Processo client Processo server

Stretta di mano a tre vie

Socket di
benvenuto

Socket
del client

byte Socket di
byte connessione

tempo

45