1 \chapter{Socket TCP elementari}
2 \label{cha:elem_TCP_sock}
4 In questo capitolo inizieremo ad approndire la conoscenza dei socket TCP,
5 tratteremo qui dunque il funzionamento delle varie funzioni che si sono usate
6 nei due esempi elementari forniti in precedenza (vedi \ref{sec:net_cli_sample}
7 e \ref{sec:net_serv_sample}), previa una descrizione delle principali
8 caratteristiche del funzionamento di una connessione TCP.
10 La seconda parte del capitolo sarà poi dedicata alla scrittura di una prima
11 semplice applicazione client/server completa, che implementi il servizio
12 standard \texttt{echo} su TCP.
14 \section{Il funzionamento di una connessione TCP}
15 \label{sec:TCPel_connession}
17 Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
18 utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
19 del TCP, la conoscenza del funzionamento del protocollo è infatti essenziale
20 per capire il modello di programmazione ed il funzionamento delle API.
22 In particolare ci concentreremo sulle modalità con le quali il protocollo da
23 inizio e conclude una connessione; faremo anche un breve accenno al
24 significato di alcuni dei vari stati che il protocollo assume durante la vita
25 di una connessione, che possono essere osservati per ciascun socket attivo con
26 l'uso del programma \texttt{netstat}.
28 \subsection{La creazione della connessione: il \textit{three way handushake}}
29 \label{sec:TCPel_conn_cre}
31 Il processo che porta a creare una connessione TCP è chiamato \textit{three
32 way handushake}; la successione tipica degli eventi (la stessa che si
33 verifica utilizzando il codice dei due precedenti esempi elementari
34 \ref{fig:net_cli_code} e \ref{fig:net_serv_code}) che porta alla creazione di
35 una connessione è la seguente:
38 \item Il server deve essere preparato per accettare le connessioni in arrivo;
39 il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
40 \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
41 \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
42 passiva il server chiama la funzione \texttt{accept} e il processo si blocca
43 in attesa di connessioni.
45 \item Il client richiede l'inizio della connessione usando la funzione
46 \texttt{connect}, attraverso un procedimento che viene chiamato
47 \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
48 \texttt{connect} blocca il processo e causa l'invio da parte del client di
49 un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
50 elementare di dati trasmessa dal protocollo TCP al livello superiore;
51 tutti i segmenti hanno un header che contiene le informazioni che servono
52 allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
53 che implementa il protocollo) per realizzare la comunicazione, fra questi
54 dati ci sono una serie di flag usati per gestire la connessione, come
55 \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
56 come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a
57 funzioni particolari del protocollo e danno il nome al segmento, (per
58 maggiori dettagli vedere \ref{cha:tcp_protocol})}, in sostanza viene
59 inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
60 il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
62 \item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
63 del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
64 client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
65 ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
66 \texttt{ACK} e sono settati.
68 \item una volta che il client ha ricevuto l'acknowledge dal server la funzione
69 \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
70 \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
71 quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
75 Il procedimento viene chiamato \textit{three way handshake} dato che per
76 realizzarlo devono essere scambiati tre segmenti. In \nfig\ si è
77 rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce
80 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
81 % sistema del telefono. La funzione \texttt{socket} può essere considerata
82 % l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al
83 % dire alle altre persone qual'è il proprio numero di telefono perché possano
84 % chiamare. La funzione \texttt{listen} è accendere il campanello del telefono
85 % per sentire le chiamate in arrivo. La funzione \texttt{connect} richiede di
86 % conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è
87 % quando si risponde al telefono.
92 \caption{Il \textit{three way handshake} del TCP}
96 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
97 riportati in \curfig); per gestire una connessione affidabile infatti il
98 protocollo TCP prevede nell'header la presenza di un numero a 32 bit (chiamato
99 appunto \textit{sequence number}) che identifica a quale byte nella sequenza
100 del flusso corrisponde il primo byte della sezione dati contenuta nel
103 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
104 \textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
105 all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
106 ciascun segmento viene effettuato dall'altro capo della connessione settando
107 il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
108 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
109 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
110 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
111 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
112 varrà anche (vedi \nfig) per l'acknowledgement di un FIN.
114 \subsection{Le opzioni TCP.}
115 \label{sec:TCPel_TCP_opt}
117 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
118 (le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
119 dati) che servono a comunicare all'altro capo una serie di parametri utili a
120 regolare la connessione. Normalmente vengono usate le seguenti opzioni:
123 \item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
124 opzione ciascun capo della connessione annuncia all'altro il massimo
125 ammontare di dati che vorrebbe accettare per ciascun segmento nella
126 connesione corrente. È possibile leggere e scrivere questo valore attraverso
127 l'opzione del socket \texttt{TCP\_MAXSEG}.
129 \item \textit{window scale option} come spiegato in \ref{cha:tcp_protocol} il
130 protocollo TCP implementa il controllo di flusso attraverso una
131 \textsl{finestra annunciata} (\textit{advertized window}) con la quale
132 ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
133 memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può
134 indicare un massimo di 65535 bytes (anche se linux usa come massimo 32767
135 per evitare problemi con alcuni stack bacati che usano l'aritmetica con
136 segno per implementare lo stack TCP); ma alcuni tipi di connessione come
137 quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
138 ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
139 più grande per poter ottenere il massimo dalla trasmissione, per questo
140 esiste questa opzione che indica un fattore di scala da applicare al valore
141 della finestra annunciata\footnote{essendo una nuova opzione per garantire
142 la compatibilità con delle vecchie implementazioni del protocollo la
143 procedura che la attiva prevede come negoziazione che l'altro capo della
144 connessione riconosca esplicitamente l'opzione inserendola anche lui nel
145 suo SYN di risposta dell'apertura della connessione} per la connessione
146 corrente (espresso come numero di bit cui shiftare a sinistra il valore
147 della finestra annunciata inserito nel pacchetto).
149 \item \textit{timestamp option} è anche questa una nuova opzione necessaria
150 per le connessioni ad alta velocità per evitare possibili corruzioni di dati
151 dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
156 La MSS è generalmente supportata da quasi tutte le implementazioni del
157 protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
158 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
159 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
160 elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
162 \subsection{La terminazione della connessione}
163 \label{sec:TCPel_conn_term}
165 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
166 procedura di chiusura ne richede quattro; ancora una volta si può fare
167 riferimento al codice degli esempi \ref{fig:net_cli_code} e
168 \ref{fig:net_serv_code}, in questo caso la successione degli eventi è la
172 \item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
173 l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da
174 \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
175 significa che si è finito con l'invio dei dati sulla connessione.
177 \item L'altro capo della connessione riceve il FIN ed esegue la
178 \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
179 tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
180 viene passato al processo che ha aperto il socket come un end of file sulla
181 lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
182 ricevuto), dato che il ricevimento di un FIN significa che non si
183 riceveranno altri dati sulla connessione.
185 \item Dopo un certo tempo anche il secondo processo chiamerà la funzione
186 \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
189 \item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
194 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
195 normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
196 sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
197 detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
198 accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
199 sequenza di scambio dei segmenti che stabilisce la connessione.
204 \caption{Il \textit{three way handshake} del TCP}
205 \label{fig:TCPel_TWH}
208 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
209 l'ACK riporterà un \textit{acknowledge number} incrementato di uno.
211 Si noti che nella sequenza di chiusura fra i passi 2 e 3 è in teoria possibile
212 che si mantenga un flusso di dati dal capo della connessione che sta eseguendo
213 la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella
214 sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma
215 esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato
216 \textit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
217 più avanti, quando parleremo della funzione \texttt{shutdown}.
219 La emissione del FIN avviene quando il socket viene chiuso, questo però non
220 avviene solo per la chiamata della funzione \texttt{close} (come in
221 \ref{fig:net_serv_code}), ma anche alla terminazione di un processo (come in
222 \ref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo viene
223 terminato da un segnale tutte le connessioni aperte verranno chiuse.
225 Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
226 in \ref{sec:TCPel_echo_example}) sia il client ad eseguire la chiusura attiva,
227 nella realtà questa può essere eseguita da uno qualunque dei due capi della
228 comunicazione (come in fatto in precedenza da \ref{fig:net_serv_code}), e
229 benché quello del client sia il caso più comune ci sono alcuni servizi, il
230 principale dei quali è l'HTTP, per i quali è il server ad effettuare la
234 \subsection{Un esempio di connessione}
235 \label{sec:TCPel_conn_dia}
237 Le operazioni del TCP nella creazione e conclusione di una connessione sono
238 specificate attraverso il diagramma di transizione degli stati riportato in
239 \nfig. TCP prevede l'esistenza di 11 diversi stati per un socket ed un insieme
240 di regole per le transizioni da uno stato all'altro basate sullo stato
241 corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
242 che vengono riportati del comando \texttt{netstat} nel campo \textit{State}.
244 Una descrizione completa del funzionamento del protocollo va al di là degli
245 obiettivi di questo libro; un approfondimento sugli aspetti principali si
246 trova in \ref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
247 riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a descrivere
248 brevemente un semplice esempio di connessione e le transizioni che avvengono
249 nei due casi appena citati (creazione e terminazione della connessione).
251 In assenza di connessione lo stato del TCP è \textsl{CLOSED}; quando una
252 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
253 diventa \textsl{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
254 emette un ACK e passa allo stato \textsl{ESTABLISHED}; questo è lo stato
255 finale in cui avviene la gran parte del trasferimento dei dati.
257 Dal lato server in genere invece il passaggio che si opera con l'apertura
258 passiva è quello di portare il socket dallo stato \textsl{CLOSED} allo
259 stato \textsl{LISTEN} in cui vengono accettate le connessioni.
261 Dallo stato \textsl{ESTABLISHED} si può uscire in due modi; se un'applicazione
262 chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
263 attiva) la transizione è verso lo stato \textsl{FIN\_WAIT\_1}; se invece
264 l'applicazione riceve un FIN nello stato \textsl{ESTABLISHED} (chiusura
265 passiva) la transizione è verso lo stato \textsl{CLOSE\_WAIT}.
267 In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
268 una un esempio di connessione, insieme ai vari stati che il protocollo viene
269 ad assumere per i due lati, server e client.
274 \caption{Schema dello scambio di pacchetti per un esempio di connessione}
275 \label{fig:TPCel_conn_example}
278 La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
279 valore tipico per IPv4 su ethernet) con linux, il server risponde con lo
280 stesso valore (ma potrebbe essere anche un valore diverso).
282 Una volta che la connessione è stabilita il client scrive al server una
283 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
284 1460 bytes annunciati dal server), quest'ultimo riceve la richiesta e
285 restituisce una risposta (che di nuovo supponiamo stare in un singolo
286 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
287 risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
288 volte che che il server è sufficientemente veloce a costruire la risposta, in
289 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
292 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
293 secondo quanto visto in \ref{sec:TCPel_conn_term}; si noti che il capo della
294 connessione che esegue la chiusura attiva entra nello stato
295 \textsl{TIME\_WAIT} su cui torneremo fra poco.
297 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
298 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
299 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
300 costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
301 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
302 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
303 trasporto all'interno dell'applicazione.
305 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
306 si hanno in una applicazione di rete, perché non è detto che TCP sia la
307 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
308 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
309 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
310 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
311 dati rispondono meglio alle esigenze che devono essere affrontate.
313 \subsection{Lo stato \texttt{TIME\_WAIT}}
314 \label{sec:TCPel_time_wait}
316 Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
317 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
318 comune trovare nei newsgroup domande su come sia possibile evitare che
319 un'applicazione resti in questo stato lasciando attiva una connessione ormai
320 conclusa; la risposta è che non deve essere fatto, ed il motivo cercheremo di
323 Come si è visto nell'esempio precedente (vedi \curfig) \texttt{TIME\_WAIT} è
324 lo stato finale in cui il capo di una connessione che esegue la chiusura
325 attiva resta prima di passare alla chiusura definitiva della connessione. Il
326 tempo in cui l'applicazione resta in questo stato deve essere due volte la MSL
327 (\textit{Maximum Segment Lifetime}).
329 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
330 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
331 ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
332 Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
333 IP (per maggiori dettagli vedi \ref{sec:appA_xxx}), e viene decrementato ad
334 ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
335 Siccome il numero è ad 8 bit il numero massimo di ``salti'' è di 255, pertanto
336 anche se il TTL (da \textit{time to live}) non è propriamente un limite sul
337 tempo di vita, si stima che un pacchetto IP non possa restare nella rete per
340 Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
341 raccomanda 2 minuti, linux usa 30 secondi), questo comporta una durata dello
342 stato \textsl{TIME\_WAIT} che a seconda delle implementazioni può variare fra
345 Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
348 \item implementare in maniera affidabile la terminazione della connessione
349 in entrambe le direzioni.
350 \item consentire l'eliminazione dei segmenti duplicati dalla rete.
353 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
354 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
355 capisce il perché della scelta di un tempo pari al doppio della MSL come
356 durata di questo stato.
358 Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
359 che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
360 attiva) vanga perso, chi esegue la chiusura passiva non ricevndo risposta
361 rimanderà un ulteriore FIN, per questo motivo chi esegue la chiusura attiva
362 deve mantenere lo stato della connessione per essere in grado di reinviare
363 l'ACK e chiuderla correttamente. Se non fosse così la risposta sarebbe un RST
364 (un altro tipo si segmento) che verrebbe interpretato come un errore.
366 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
367 connessione allora deve essere in grado di affrontare la perdita di uno
368 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
369 motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
370 dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale
371 ritrasmissione in caso di perdita.
374 Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
375 gli scenari in cui accade che i pacchetti si possono perdere nella rete o
376 restare intrappolati, per poi riemergere.
378 Il caso più comune in cui questo avviene è quello di anomalie
379 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
380 una connessione fra due router si interrompa. In questo caso i protocolli di
381 instradamento dei pacchetti possono impiegare diverso temo (anche dell'ordine
382 dei minuti) prima di trovare e stabilire un percorso alternativo per i
383 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
384 pacchetti verso un'altro e quest'ultimo li rispedisce indietro, o li manda ad
385 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
386 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
388 Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
389 non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
390 stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
391 destinazione. Ma se dopo un po' di tempo (che non supera il limite dell'MSL)
392 l'anomalia viene a cessare il circolo di instadamento viene spezzato i
393 pacchetti intrappolati potranno essere inviati alla destinazione finale, con
394 la conseguenza di avere dei pacchetti duplicati; questo è un caso che il TCP
395 deve essere in grado di gestire.
397 Allora per capire la seconda ragione per l'esistenza dello stato
398 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
399 connessione fra l'IP 195.110.112.236 porta 1550 e l'IP 192.84.145.100 porta
400 22, che questa venga chiusa e che poco dopo si ristabilisca la stessa
401 connessione fra gli stessi IP sulle stesse porte (quella che viene detta,
402 essendo gli stessi porte e numeri IP, una nuova \textsl{incarnazione} della
403 connessione precedente); in questo caso ci si potrebbe trovare con dei
404 pacchetti duplicati relativi alla precedente connessione che riappaiono nella
407 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
408 creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
409 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
410 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
411 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
412 sicuri che lo stesso avvenga le risposte nella direzione opposta.
414 In questo modo il TCP si assicura che quando una viene creata una nuova
415 connessione tutti gli eventuali segmenti residui di una precedente connessione
416 che possono causare disturbi sono stati eliminati dalla rete.
419 \subsection{I numeri di porta}
420 \label{sec:TCPel_port_num}
422 In un ambiente multitasking in un dato momento più processi possono dover
423 usare sia UDP che TCP, e ci devono poter essere più connessioni in
424 contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
425 protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
426 vedere in \ref{sec:sock_sa_ipv4} e \ref{sec:sock_sa_ipv6} pure delle strutture
427 degli indirizzi del socket.
429 Quando un client contatta un server deve poter identificare con quale dei vari
430 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
431 di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
432 identificano una serie di servizi noti (ad esempio la porta 22 identifica il
433 servizio \texttt{ssh}) effettuati da appositi server che rispondono alle
434 connessioni verso tali porte.
436 D'altra parte un client non ha necessità di usare un numero di porta
437 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
438 effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
439 nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
440 creazione della connessione. Queste sono dette effimere in quanto vengono
441 usate solo per la durata della connessione, e l'unico requisito che deve
442 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
444 La lista delle porte conosciute è definita dall'RFC1700 che contiene l'elenco
445 delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
446 ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
447 \texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
448 file \texttt{/etc/services} contiene un analogo elenco, con la corrispondenza
449 fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
453 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
454 controllate e assegnate dalla IANA. Se è possibile la stessa porta è
455 assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
456 è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal
459 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
460 sono controllate dalla IANA, che però registra ed elenca chi usa queste
461 porte come servizio agli utenti. Come per le precedenti si assegna una porta
462 ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
463 solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
464 anche se il protocollo è implementato solo tramite TCP.
466 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
467 65535. La IANA non dice nulla riguardo a queste porte che pertanto
468 sono i candidati naturali ad essere usate come porte effimere.
471 In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
472 scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
473 quelle di BSD, Solaris e linux. Nel caso di linux poi la scelta fra i due
474 intervali possibili viene fatta dinamicamente a seconda della memoria a
475 disposizione del kernel per gestire le rative tabelle.
480 \caption{Allocazione dei numeri di porta}
481 \label{fig:TCPel_port_alloc}
484 I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
485 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
486 porte conosciute). La loro caratteristica è che possono essere assegnate a un
487 socket solo da un processo con i privilegi di root, per far si che solo
488 l'amministratore possa allocare queste porte per far partire relativi servizi.
490 Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
491 \texttt{rlogin}) che richiedono una connessione su una porta riservata anche
492 dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
493 funzione \texttt{rresvport} assegnando al socket una porta libera
494 nell'intervallo fra 512 e 1023.
496 Data una connessione TCP si suole chiamare \textit{socket pair} la
497 combinazione dei quattro numeri che definiscono i due capi della connessione e
498 cioè l'indirizzo IP locale e la porta TCP locale, e l'indirizzo IP remoto e la
499 porta TCP remota; questa combinazione, che scriveremo usando una notazione del
500 tipo $(195.110.112.152:22, 192.84.146.100:20100)$, identifica univocamente una
501 connessione su internet. Questo concetto viene di solito esteso anche a UDP,
502 benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
503 programma \texttt{netstat} permette di visualizzare queste informazioni nei
504 campi \textit{Local Address} e \textit{Foreing Address}.
507 \subsection{Le porte ed il modello client/server}
508 \label{sec:TCPel_port_cliserv}
510 Per capire meglio l'uso delle porte e come vengono utilizzate nella
511 programmazione di rete consideriamo cosa accade con una serie di esempi, se
512 esguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
513 indirizzo 195.110.112.152) potremo avere un risultato del tipo:
515 Active Internet connections (servers and established)
516 Proto Recv-Q Send-Q Local Address Foreign Address State
517 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
518 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
519 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
521 essendo presenti un server ssh, un server di posta e un DNS per il caching
524 Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
525 mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
526 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
527 associati alle interfaccie locali; la notazione 0.0.0.0 usata da netstat è
528 equivalente all'asterisco utilizzato per il numero di porta ed indica il
529 valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
530 \texttt{arpa/inet.h}.
532 Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
533 specificati; in questo caso la \textit{socket pair} associata al socket può
534 essere indicata come $(*:22, *.*)$, usando l'asterisco anche per gli indirizzi
535 come carattere di \textit{wildchard}.
537 In genere avendo le macchine associato un solo IP ci si può chiedere che senso
538 abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
539 anche macchine che hanno più di un indirizzo IP (il cosiddetto
540 \textit{miltihoming}) in questo modo si possono accettare connessioni
541 indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
542 con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
543 solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
544 caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
547 Una volta che ci si vorrà collegare a questa macchina da un'altra posta
548 all'indirizzo 192.84.146.100 si potrà lanciare un client \texttt{ssh} per
549 creare una connessione verso la precedente, e il kernel associerà al suddetto
550 una porta effimera che per esempio potrà essere la 21100, la connessione
551 allora sarà espressa dalla socket pair $(192.84.146.100:21100,
552 195.110.112.152.22)$.
554 Alla ricezione della richiesta dal client il server creerà un processo figlio
555 per gestire la connessione, se a questo punto eseguiamo nuovamente il
556 programma netstat otterremo come risultato:
558 Active Internet connections (servers and established)
559 Proto Recv-Q Send-Q Local Address Foreign Address State
560 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
561 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
562 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
563 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
566 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
567 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
568 la porta 22, ma ha specificato l'indirizzo locale, e che corrisponde al socket
569 con cui il processo figlio gestisce la connessione mentre il padre resta in
572 Se a questo lanciamo una seconda volta il client ssh per una seconda
573 conessione quello che otterremo sarà qualcosa del genere:
575 Active Internet connections (servers and established)
576 Proto Recv-Q Send-Q Local Address Foreign Address State
577 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
578 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
579 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
580 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
581 tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
583 cioè al client sarà stata assegnata un'altra porta effimera e con questa sarà
584 aperta la connessione, ed un nuovo processo figlio sarà creato per gestirla.
587 Tutto ciò mostra come TCP, per poter gestire le due connessioni, non può
588 suddividere i pacchetti solo sulla base della porta di destinazione, ma deve
589 usare tutta l'informazione contenuta nella socket pair, compresa la porta
590 dell'indirizzo remoto. E se andassimo a vedere quali sono i processi a cui
591 fanno riferimento i vari socket vedremmo che i pacchetti che arrivano dalla
592 porta remota 21100 vanno al primo figlio e quelli che arrivano alla porta
596 \section{Le funzioni dei socket TCP}
597 \label{sec:TCPel_functions}
599 In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
600 l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
601 \ref{sec:net_cli_sample} e \ref{sec:net_serv_sample}) con l'eccezione della
602 funzione \texttt{socket} che è già stata esaminata in dettaglio in
603 \ref{sec:sock_socket}.
605 In \nfig\ abbiamo un tipico schema di funzionamento di un'applicazione
606 client-server che usa i socket TCP: prima il server viene avviato ed in
607 seguito il client si connette, in questo caso, a differenza di quanto accadeva
608 con gli esempi elementari del Cap.~\ref{cha:network} si assume che sia il
609 client ad effettuare delle richieste a cui il server risponde, il client
610 notifica poi di avere concluso inviando un end-of-file a cui il server
611 risponderà anche lui chiudendo la connessione per aspettarne una nuova.
616 \caption{Struttura delle funzioni dei socket per una semplice applicazione
617 client/server su TCP.}
618 \label{fig:TCPel_cliserv_func}
621 Useremo questo schema per l'esempio di implementazione del servizio
622 \texttt{echo} che illustreremo in \ref{sec:TCPel_echo_example}.
624 \subsection{La funzione \texttt{connect}}
625 \label{sec:TCPel_func_connect}
627 La funzione \texttt{connect} è usata da un client TCP per stabilire la
628 connessione con un server TCP, il prototipo della funzione, definito in
629 \texttt{sys/socket.h}, è il seguente:
632 \item \texttt{int connect(int sockfd, const struct sockaddr *serv_addr,
635 Il primo argomento è un file descriptor ottenuto da una precedente chiamata
636 a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
637 l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
638 socket, già descritta in \ref{sec:sock_sockaddr}.
640 La funzione restituisce zero in caso di successo e -1 per un errore, in caso
641 di errore. La variabile \texttt{errno} viene settata secondo i seguenti
645 \item \texttt{EBADF} Il file descriptor non è valido.
646 \item \texttt{EFAULT} L'indirizzo della struttura di indirizzi è al di fuori
647 dello spazio di indirizzi dell'utente.
648 \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket
649 \item \texttt{EISCONN} Il socket è già connesso.
650 \item \texttt{ECONNREFUSED} Non c'è nessuno in ascolto sull'indirizzo remoto.
651 \item \texttt{ETIMEDOUT} Si è avuto timeout durante il tentativo di
653 \item \texttt{ENETUNREACH} La rete non è rggiungibile/
654 \item \texttt{EADDRINUSE} L'indirizzo locale è in uso.
655 \item \texttt{EINPROGRESS} Il socket è non bloccante e la connessione non
656 può essere conclusa immediatamente.
657 \item \texttt{EALREADY} Il socket è non bloccante e un tentativo precedente
658 di connessione non si è ancora concluso.
659 \item \texttt{EAGAIN} Non ci sono più porte locali libere.
660 \item \texttt{EAFNOSUPPORT} L'indirizzo non ha una famiglia di indirizzi
661 corretta nel relativo campo.
662 \item \texttt{EACCESS, EPERM}
666 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
667 numero di porta del server a cui ci si vuole connettere, come mostrato
668 nell'esempio \ref{sec:net_cli_sample} usando le funzioni illustrate in
669 \ref{sec:sock_addr_func}.
671 Nel caso di socket TCP la funzione \texttt{connect} avvia il three way
672 handshake, e ritorna solo quando la connessione è stabilita o si è verificato
673 un errore. Le possibili cause di errore sono molteplici (e brevemente
674 riassunte sopra), in particolare le principali sono:
677 \item Se il client non riceve risposta al SYN l'errore restituito è
678 \texttt{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
679 di \texttt{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
680 dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
681 invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
682 di volte che può essere stabilito dall'utente sia con una opportuna
683 \texttt{sysctl} che attraverso il filesystem \texttt{/proc} scrivendo il
684 valore voluto in \texttt{/proc/sys/net/ipv4/tcp_syn_retries}. Il valore di
685 default per la ripetizione dell'invio è di 5 volte, che comporta un timeout
686 dopo circa 180 secondi.
688 % Le informazioni su tutte le opzioni settabili via /proc stanno in
689 % linux/Documentation/networking/ip-sysctl.txt
691 \item Se il client riceve come risposta al SYN un RST significa che non c'è
692 nessun programma in ascolto per la connessione sulla porta specificata (il
693 che vuol dire probablmente che o si è sbagliato il numero della porta o che
694 non è stato avviato il server), questo è un errore fatale e la funzione
695 ritorna non appena il RST viene ricevuto riportando un errore
696 \texttt{ECONNREFUSED}.
698 Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
699 dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
700 quando arriva un SYN per una porta che non ha nessun server in ascolto,
701 quando il TCP abortisce una connessione in corso, quandi TCP riceve un
702 segmento per una connessione che non esiste.
704 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
705 destinazione non raggiungibile.
709 \subsection{La funzione \texttt{bind}}
710 \label{sec:TCPel_func_bind}
714 \subsection{La funzione \texttt{listen}}
715 \label{sec:TCPel_func_listen}
717 \subsection{La funzione \texttt{accept}}
718 \label{sec:TCPel_func_accept}
721 \section{Una semplice implementazione del servizio \textt{echo} su TCP}
722 \label{sec:TCPel_echo_example}