1 \chapter{Socket TCP elementari}
2 \label{cha:elem_TCP_sock}
4 In questo capitolo iniziamo ad approfondire 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
7 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}), previa una
8 descrizione delle principali caratteristiche del funzionamento di una
12 \section{Il funzionamento di una connessione TCP}
13 \label{sec:TCPel_connession}
15 Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
16 utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
17 del TCP; la conoscenza del funzionamento del protocollo è infatti essenziale
18 per capire il modello di programmazione ed il funzionamento delle API.
20 In particolare ci concentreremo sulle modalità con le quali il protocollo dà
21 inizio e conclude una connessione; faremo inoltre anche un breve accenno al
22 significato di alcuni dei vari stati che il protocollo assume durante la vita
23 di una connessione, che possono essere osservati per ciascun socket attivo con
24 l'uso del programma \texttt{netstat}.
26 \subsection{La creazione della connessione: il \textit{three way handshake}}
27 \label{sec:TCPel_conn_cre}
29 Il processo che porta a creare una connessione TCP è chiamato \textit{three
30 way handshake}; la successione tipica degli eventi (la stessa che si
31 verifica utilizzando il codice dei due precedenti esempi elementari
32 \figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
33 creazione di una connessione è la seguente:
36 \item Il server deve essere preparato per accettare le connessioni in arrivo;
37 il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
38 \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
39 \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
40 passiva il server chiama la funzione \texttt{accept} e il processo si blocca
41 in attesa di connessioni.
43 \item Il client richiede l'inizio della connessione usando la funzione
44 \texttt{connect}, attraverso un procedimento che viene chiamato
45 \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
46 \texttt{connect} blocca il processo e causa l'invio da parte del client di
47 un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
48 elementare di dati trasmessa dal protocollo TCP al livello superiore;
49 tutti i segmenti hanno un header che contiene le informazioni che servono
50 allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
51 che implementa il protocollo) per realizzare la comunicazione, fra questi
52 dati ci sono una serie di flag usati per gestire la connessione, come
53 \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
54 come \texttt{SYN} (che sta per \textit{syncronize}) corrispondono a
55 funzioni particolari del protocollo e danno il nome al segmento, (per
56 maggiori dettagli vedere \capref{cha:tcp_protocol})}, in sostanza viene
57 inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
58 il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
60 \item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
61 del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
62 client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
63 ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
64 \texttt{ACK} e sono settati.
66 \item una volta che il client ha ricevuto l'acknowledge dal server la funzione
67 \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
68 \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
69 quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
73 Il procedimento viene chiamato \textit{three way handshake} dato che per
74 realizzarlo devono essere scambiati tre segmenti. In \nfig\ si è
75 rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce
78 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
79 % sistema del telefono. La funzione \texttt{socket} può essere considerata
80 % l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al
81 % dire alle altre persone qual'è il proprio numero di telefono perché possano
82 % chiamare. La funzione \texttt{listen} è accendere il campanello del telefono
83 % per sentire le chiamate in arrivo. La funzione \texttt{connect} richiede di
84 % conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è
85 % quando si risponde al telefono.
89 \includegraphics[width=10cm]{img/three_way_handshake.eps}
90 \caption{Il \textit{three way handshake} del TCP}
94 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
95 riportati in \curfig); per gestire una connessione affidabile infatti il
96 protocollo TCP prevede nell'header la presenza di un numero a 32 bit (chiamato
97 appunto \textit{sequence number}) che identifica a quale byte nella sequenza
98 del flusso corrisponde il primo byte della sezione dati contenuta nel
101 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
102 \textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
103 all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
104 ciascun segmento viene effettuato dall'altro capo della connessione settando
105 il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
106 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
107 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
108 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
109 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
110 varrà anche (vedi \nfig) per l'acknowledgement di un FIN.
112 \subsection{Le opzioni TCP.}
113 \label{sec:TCPel_TCP_opt}
115 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
116 (le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
117 dati) che servono a comunicare all'altro capo una serie di parametri utili a
118 regolare la connessione. Normalmente vengono usate le seguenti opzioni:
121 \item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
122 opzione ciascun capo della connessione annuncia all'altro il massimo
123 ammontare di dati che vorrebbe accettare per ciascun segmento nella
124 connessione corrente. È possibile leggere e scrivere questo valore attraverso
125 l'opzione del socket \texttt{TCP\_MAXSEG}.
127 \item \textit{window scale option} come spiegato in \capref{cha:tcp_protocol} il
128 protocollo TCP implementa il controllo di flusso attraverso una
129 \textsl{finestra annunciata} (\textit{advertized window}) con la quale
130 ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
131 memoria per i dati. Questo è un numero a 16 bit dell'header, che così può
132 indicare un massimo di 65535 bytes (anche se Linux usa come massimo 32767
133 per evitare problemi con alcuni stack bacati che usano l'aritmetica con
134 segno per implementare lo stack TCP); ma alcuni tipi di connessione come
135 quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
136 ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
137 più grande per poter ottenere il massimo dalla trasmissione, per questo
138 esiste questa opzione che indica un fattore di scala da applicare al valore
139 della finestra annunciata\footnote{essendo una nuova opzione per garantire
140 la compatibilità con delle vecchie implementazioni del protocollo la
141 procedura che la attiva prevede come negoziazione che l'altro capo della
142 connessione riconosca esplicitamente l'opzione inserendola anche lui nel
143 suo SYN di risposta dell'apertura della connessione} per la connessione
144 corrente (espresso come numero di bit cui shiftare a sinistra il valore
145 della finestra annunciata inserito nel pacchetto).
147 \item \textit{timestamp option} è anche questa una nuova opzione necessaria
148 per le connessioni ad alta velocità per evitare possibili corruzioni di dati
149 dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
154 La MSS è generalmente supportata da quasi tutte le implementazioni del
155 protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
156 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
157 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
158 elevati. In ogni caso Linux supporta pienamente entrambe le opzioni.
160 \subsection{La terminazione della connessione}
161 \label{sec:TCPel_conn_term}
163 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
164 procedura di chiusura ne richiede quattro; ancora una volta si può fare
165 riferimento al codice degli esempi \figref{fig:net_cli_code} e
166 \figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
170 \item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
171 l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da
172 \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
173 significa che si è finito con l'invio dei dati sulla connessione.
175 \item L'altro capo della connessione riceve il FIN ed esegue la
176 \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
177 tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
178 viene passato al processo che ha aperto il socket come un end-of-file sulla
179 lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
180 ricevuto), dato che il ricevimento di un FIN significa che non si
181 riceveranno altri dati sulla connessione.
183 \item Dopo un certo tempo anche il secondo processo chiamerà la funzione
184 \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
187 \item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
191 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
192 normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
193 situazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
194 detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
195 accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
196 sequenza di scambio dei segmenti che stabilisce la connessione.
200 \includegraphics[width=10cm]{img/tcp_close.eps}
201 \caption{La chiusura di una connessione TCP}
202 \label{fig:TCPel_close}
205 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
206 l'ACK riporterà un \textit{acknowledge number} incrementato di uno.
208 Si noti che nella sequenza di chiusura fra i passi 2 e 3 è in teoria possibile
209 che si mantenga un flusso di dati dal capo della connessione che sta eseguendo
210 la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella
211 sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma
212 esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato
213 \textit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
214 più avanti, quando parleremo della funzione \texttt{shutdown}.
216 La emissione del FIN avviene quando il socket viene chiuso, questo però non
217 avviene solo per la chiamata della funzione \texttt{close} (come in
218 \figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
219 in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
220 viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
222 Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
223 più avanti in \secref{sec:TCPsimp_echo}) sia il client ad eseguire la chiusura
224 attiva, nella realtà questa può essere eseguita da uno qualunque dei due capi
225 della comunicazione (come in fatto in precedenza da
226 \figref{fig:net_serv_code}), e benché quello del client sia il caso più comune
227 ci sono alcuni servizi, il principale dei quali è l'HTTP, per i quali è il
228 server ad effettuare la chiusura attiva.
230 \subsection{Un esempio di connessione}
231 \label{sec:TCPel_conn_dia}
233 Le operazioni del TCP nella creazione e conclusione di una connessione sono
234 specificate attraverso il diagramma di transizione degli stati riportato in
235 \nfig. TCP prevede l'esistenza di 11 diversi stati per un socket ed un insieme
236 di regole per le transizioni da uno stato all'altro basate sullo stato
237 corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
238 che vengono riportati del comando \texttt{netstat} nel campo \textit{State}.
240 Una descrizione completa del funzionamento del protocollo va al di là degli
241 obiettivi di questo libro; un approfondimento sugli aspetti principali si
242 trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il
243 miglior riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a
244 descrivere brevemente un semplice esempio di connessione e le transizioni che
245 avvengono nei due casi appena citati (creazione e terminazione della
248 In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
249 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
250 diventa \texttt{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
251 emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
252 finale in cui avviene la gran parte del trasferimento dei dati.
254 Dal lato server in genere invece il passaggio che si opera con l'apertura
255 passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
256 stato \texttt{LISTEN} in cui vengono accettate le connessioni.
258 Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
259 chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
260 attiva) la transizione è verso lo stato \texttt{FIN\_WAIT\_1}; se invece
261 l'applicazione riceve un FIN nello stato \texttt{ESTABLISHED} (chiusura
262 passiva) la transizione è verso lo stato \texttt{CLOSE\_WAIT}.
264 In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
265 una un esempio di connessione, insieme ai vari stati che il protocollo viene
266 ad assumere per i due lati, server e client.
270 \includegraphics[width=9cm]{img/tcp_connection.eps}
271 \caption{Schema dello scambio di pacchetti per un esempio di connessione}
272 \label{fig:TPCel_conn_example}
275 La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
276 valore tipico per IPv4 su ethernet) con Linux, il server risponde con lo
277 stesso valore (ma potrebbe essere anche un valore diverso).
279 Una volta che la connessione è stabilita il client scrive al server una
280 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
281 1460 bytes annunciati dal server), quest'ultimo riceve la richiesta e
282 restituisce una risposta (che di nuovo supponiamo stare in un singolo
283 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
284 risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
285 volte che che il server è sufficientemente veloce a costruire la risposta, in
286 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
289 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
290 secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo
291 della connessione che esegue la chiusura attiva entra nello stato
292 \texttt{TIME\_WAIT} su cui torneremo fra poco.
294 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
295 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
296 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
297 costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
298 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
299 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
300 trasporto all'interno dell'applicazione.
302 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
303 si hanno in una applicazione di rete, perché non è detto che TCP sia la
304 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
305 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
306 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
307 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
308 dati rispondono meglio alle esigenze che devono essere affrontate.
310 \subsection{Lo stato \texttt{TIME\_WAIT}}
311 \label{sec:TCPel_time_wait}
313 Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
314 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
315 comune trovare nei newsgroup domande su come sia possibile evitare che
316 un'applicazione resti in questo stato lasciando attiva una connessione ormai
317 conclusa; la risposta è che non deve essere fatto, ed il motivo cercheremo di
320 Come si è visto nell'esempio precedente (vedi \curfig) \texttt{TIME\_WAIT} è
321 lo stato finale in cui il capo di una connessione che esegue la chiusura
322 attiva resta prima di passare alla chiusura definitiva della connessione. Il
323 tempo in cui l'applicazione resta in questo stato deve essere due volte la MSL
324 (\textit{Maximum Segment Lifetime}).
326 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
327 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
328 ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
329 Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
330 IP (per maggiori dettagli vedi \secref{sec:IP_xxx}), e viene decrementato
331 ad ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
332 Siccome il numero è ad 8 bit il numero massimo di ``salti'' è di 255, pertanto
333 anche se il TTL (da \textit{time to live}) non è propriamente un limite sul
334 tempo di vita, si stima che un pacchetto IP non possa restare nella rete per
337 Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
338 raccomanda 2 minuti, Linux usa 30 secondi), questo comporta una durata dello
339 stato \texttt{TIME\_WAIT} che a seconda delle implementazioni può variare fra
342 Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
345 \item implementare in maniera affidabile la terminazione della connessione
346 in entrambe le direzioni.
347 \item consentire l'eliminazione dei segmenti duplicati dalla rete.
350 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
351 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
352 capisce il perché della scelta di un tempo pari al doppio della MSL come
353 durata di questo stato.
355 Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
356 che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
357 attiva) vanga perso, chi esegue la chiusura passiva non ricevendo risposta
358 rimanderà un ulteriore FIN, per questo motivo chi esegue la chiusura attiva
359 deve mantenere lo stato della connessione per essere in grado di reinviare
360 l'ACK e chiuderla correttamente. Se non fosse così la risposta sarebbe un RST
361 (un altro tipo si segmento) che verrebbe interpretato come un errore.
363 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
364 connessione allora deve essere in grado di affrontare la perdita di uno
365 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
366 motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
367 dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale
368 ritrasmissione in caso di perdita.
371 Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
372 gli scenari in cui accade che i pacchetti si possono perdere nella rete o
373 restare intrappolati, per poi riemergere.
375 Il caso più comune in cui questo avviene è quello di anomalie
376 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
377 una connessione fra due router si interrompa. In questo caso i protocolli di
378 instradamento dei pacchetti possono impiegare diverso tempo (anche dell'ordine
379 dei minuti) prima di trovare e stabilire un percorso alternativo per i
380 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
381 pacchetti verso un'altro e quest'ultimo li rispedisce indietro, o li manda ad
382 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
383 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
385 Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
386 non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
387 stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
388 destinazione. Ma se dopo un po' di tempo (che non supera il limite dell'MSL)
389 l'anomalia viene a cessare il circolo di instradamento viene spezzato i
390 pacchetti intrappolati potranno essere inviati alla destinazione finale, con
391 la conseguenza di avere dei pacchetti duplicati; questo è un caso che il TCP
392 deve essere in grado di gestire.
394 Allora per capire la seconda ragione per l'esistenza dello stato
395 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
396 connessione fra l'IP 195.110.112.236 porta 1550 e l'IP 192.84.145.100 porta
397 22, che questa venga chiusa e che poco dopo si ristabilisca la stessa
398 connessione fra gli stessi IP sulle stesse porte (quella che viene detta,
399 essendo gli stessi porte e numeri IP, una nuova \textsl{incarnazione} della
400 connessione precedente); in questo caso ci si potrebbe trovare con dei
401 pacchetti duplicati relativi alla precedente connessione che riappaiono nella
404 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
405 creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
406 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
407 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
408 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
409 sicuri che lo stesso avvenga le risposte nella direzione opposta.
411 In questo modo il TCP si assicura che quando una viene creata una nuova
412 connessione tutti gli eventuali segmenti residui di una precedente connessione
413 che possono causare disturbi sono stati eliminati dalla rete.
416 \subsection{I numeri di porta}
417 \label{sec:TCPel_port_num}
419 In un ambiente multitasking in un dato momento più processi possono dover
420 usare sia UDP che TCP, e ci devono poter essere più connessioni in
421 contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
422 protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
423 vedere in \secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle
424 strutture degli indirizzi del socket.
426 Quando un client contatta un server deve poter identificare con quale dei vari
427 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
428 di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
429 identificano una serie di servizi noti (ad esempio la porta 22 identifica il
430 servizio \texttt{ssh}) effettuati da appositi server che rispondono alle
431 connessioni verso tali porte.
433 D'altra parte un client non ha necessità di usare un numero di porta
434 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
435 effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
436 nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
437 creazione della connessione. Queste sono dette effimere in quanto vengono
438 usate solo per la durata della connessione, e l'unico requisito che deve
439 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
441 La lista delle porte conosciute è definita dall'RFC1700 che contiene l'elenco
442 delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
443 ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
444 \texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
445 file \texttt{/etc/services} contiene un analogo elenco, con la corrispondenza
446 fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
450 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
451 controllate e assegnate dalla IANA. Se è possibile la stessa porta è
452 assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
453 è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal
456 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
457 sono controllate dalla IANA, che però registra ed elenca chi usa queste
458 porte come servizio agli utenti. Come per le precedenti si assegna una porta
459 ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
460 solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
461 anche se il protocollo è implementato solo tramite TCP.
463 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
464 65535. La IANA non dice nulla riguardo a queste porte che pertanto
465 sono i candidati naturali ad essere usate come porte effimere.
468 In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
469 scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
470 quelle di BSD, Solaris e Linux. Nel caso di Linux poi la scelta fra i due
471 intervalli possibili viene fatta dinamicamente a seconda della memoria a
472 disposizione del kernel per gestire le relative tabelle.
476 \includegraphics[width=10cm]{img/tcpip_overview.eps}
477 \caption{Allocazione dei numeri di porta}
478 \label{fig:TCPel_port_alloc}
481 I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
482 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
483 porte conosciute). La loro caratteristica è che possono essere assegnate a un
484 socket solo da un processo con i privilegi di root, per far si che solo
485 l'amministratore possa allocare queste porte per far partire i relativi
488 Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
489 \texttt{rlogin}) che richiedono una connessione su una porta riservata anche
490 dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
491 funzione \texttt{rresvport} assegnando al socket una porta libera
492 nell'intervallo fra 512 e 1023.
494 Data una connessione TCP si suole chiamare \textit{socket pair} la
495 combinazione dei quattro numeri che definiscono i due capi della connessione e
496 cioè l'indirizzo IP locale e la porta TCP locale, e l'indirizzo IP remoto e la
497 porta TCP remota; questa combinazione, che scriveremo usando una notazione del
498 tipo $(195.110.112.152:22, 192.84.146.100:20100)$, identifica univocamente una
499 connessione su internet. Questo concetto viene di solito esteso anche a UDP,
500 benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
501 programma \texttt{netstat} permette di visualizzare queste informazioni nei
502 campi \textit{Local Address} e \textit{Foreing Address}.
505 \subsection{Le porte ed il modello client/server}
506 \label{sec:TCPel_port_cliserv}
508 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
509 che fare con un'applicazione client/server (come quella che scriveremo in
510 \secref{sec:TCPel_cunc_serv}) esamineremo cosa accade con le connessioni nel
511 caso di un server TCP che deve gestire connessioni multiple.
513 Se eseguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
514 indirizzo 195.110.112.152) potremo avere un risultato del tipo:
516 Active Internet connections (servers and established)
517 Proto Recv-Q Send-Q Local Address Foreign Address State
518 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
519 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
520 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
522 essendo presenti e attivi un server ssh, un server di posta e un DNS per il
525 Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
526 mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
527 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
528 associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
529 equivalente all'asterisco utilizzato per il numero di porta ed indica il
530 valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
531 \texttt{arpa/inet.h}.
533 Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
534 specificati; in questo caso la \textit{socket pair} associata al socket può
535 essere indicata come $(*:22, *:*)$, usando l'asterisco anche per gli indirizzi
536 come carattere di \textit{wildchard}.
538 In genere avendo le macchine associato un solo IP ci si può chiedere che senso
539 abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
540 anche macchine che hanno più di un indirizzo IP (il cosiddetto
541 \textit{multihoming}) in questo modo si possono accettare connessioni
542 indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
543 con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
544 solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
545 caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
548 Una volta che ci si vorrà collegare a questa macchina da un'altra posta
549 all'indirizzo 192.84.146.100 si potrà lanciare un client \texttt{ssh} per
550 creare una connessione verso la precedente, e il kernel assocerà al suddetto
551 una porta effimera che per esempio potrà essere la 21100, la connessione
552 allora sarà espressa dalla socket pair $(192.84.146.100:21100,
553 195.110.112.152.22)$.
555 Alla ricezione della richiesta dal client il server creerà un processo figlio
556 per gestire la connessione, se a questo punto eseguiamo nuovamente il
557 programma netstat otterremo come risultato:
559 Active Internet connections (servers and established)
560 Proto Recv-Q Send-Q Local Address Foreign Address State
561 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
562 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
563 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
564 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
567 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
568 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
569 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
570 il processo figlio gestisce la connessione mentre il padre resta in ascolto
571 sul socket originale.
573 Se a questo punto lanciamo un'altra volta il client ssh per una seconda
574 connessione quello che otterremo usando netstat sarà qualcosa del genere:
576 Active Internet connections (servers and established)
577 Proto Recv-Q Send-Q Local Address Foreign Address State
578 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
579 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
580 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
581 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
582 tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
584 cioè il client effettuerà la connessione usando un'altra porta effimera, con
585 questa sarà aperta la connessione, ed il server creerà un'altro processo
586 figlio sarà creato per gestirla.
588 Tutto ciò mostra come TCP, per poter gestire le connessioni con un server
589 concorrente, non può suddividere i pacchetti solo sulla base della porta di
590 destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
591 compresa la porta dell'indirizzo remoto. E se andassimo a vedere quali sono i
592 processi a cui fanno riferimento i vari socket vedremmo che i pacchetti che
593 arrivano dalla porta remota 21100 vanno al primo figlio e quelli che arrivano
594 alla porta 21101 al secondo.
597 \section{Le funzioni dei socket TCP}
598 \label{sec:TCPel_functions}
600 In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
601 l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
602 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}) con l'eccezione
603 della funzione \texttt{socket} che è già stata esaminata in dettaglio in
604 \secref{sec:sock_socket}.
606 In \nfig\ abbiamo un tipico schema di funzionamento di un'applicazione
607 client-server che usa i socket TCP: prima il server viene avviato ed in
608 seguito il client si connette, in questo caso, a differenza di quanto accadeva
609 con gli esempi elementari del Cap.~\capref{cha:network} si assume che sia il
610 client ad effettuare delle richieste a cui il server risponde, il client
611 notifica poi di avere concluso inviando un end-of-file a cui il server
612 risponderà anche lui chiudendo la connessione per aspettarne una nuova.
617 \caption{Struttura delle funzioni dei socket per una semplice applicazione
618 client/server su TCP.}
619 \label{fig:TCPel_cliserv_func}
622 Useremo questo schema anche per l'esempio di reimplementazione del servizio
623 \texttt{daytime} che illustreremo in \secref{sec:TCPel_cunc_serv}.
626 \subsection{La funzione \texttt{bind}}
627 \label{sec:TCPel_func_bind}
630 La funzione \texttt{bind} assegna un indirizzo locale ad un socket, è usata
631 cioè per specificare la prima parte dalla socket pair. Viene usata sul lato
632 server per specificare la porta (e gli eventuali indirizzi locali) su cui poi
633 ci si porrà in ascolto.
635 Il prototipo della funzione è il seguente:
637 \begin{prototype}{sys/socket.h}
638 {int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)}
640 Il primo argomento è un file descriptor ottenuto da una precedente chiamata
641 a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
642 l'indirizzo (locale) del socket e la dimensione della struttura che lo
643 contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
645 La funzione restituisce zero in caso di successo e -1 per un errore, in caso
646 di errore. La variabile \texttt{errno} viene settata secondo i seguenti
649 \item \texttt{EBADF} il file descriptor non è valido.
650 \item \texttt{EINVAL} il socket ha già un indirizzo assegnato.
651 \item \texttt{ENOTSOCK} il file descriptor non è associato ad un socket.
652 \item \texttt{EACCESS} si è cercato di usare un indirizzo riservato senza
657 Con il TCP la chiamata \texttt{bind} permette di specificare l'indirizzo, la
658 porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
659 nota che assegnano all'avvio, se questo non viene fatto è il kernel a
660 scegliere una porta effimera quando vengono eseguite la funzioni
661 \texttt{connect} o \texttt{listen}, ma se questo è normale per il client non
662 lo è per il server\footnote{un'eccezione a tutto ciò i server che usano RPC.
663 In questo caso viene fatta assegnare dal kernel una porta effimera che poi
664 viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
665 demone che deve essere contattato dai client per ottenere la porta effimera
666 su cui si trova il server} che in genere viene identificato dalla porta su
669 Con \texttt{bind} si può assegnare un IP specifico ad un socket, purché questo
670 appartenga ad una interfaccia della macchina. Per un client TCP questo
671 diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati sul
672 socket, mentre per un server TCP questo restringerà l'accesso al socket solo
673 alle connessioni che arrivano verso tale indirizzo.
675 Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
676 kernel sceglie l'indirizzo di origine quando viene effettuata la connessione
677 sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
678 dalle regole di instradamento usate per raggiungere il server).
679 Se un server non specifica il suo indirizzo locale il kernel userà come
680 indirizzo di origine l'indirizzo di destinazione specificato dal SYN del
683 Per specificare un indirizzo generico con IPv4 si usa il valore
684 \macro{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
685 è pari a zero, nell'esempio \figref{fig:net_serv_code} si è usata
686 un'assegnazione immediata del tipo:
689 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
690 serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
694 Si noti che si è usato \func{htonl} per assegnare il valore
695 \macro{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
696 inutile; ma dato che tutte le costanti \macro{INADDR\_} sono definite
697 secondo l'ordinamento della macchina è buona norma usare sempre la funzione
700 L'esempio precedete funziona con IPv4 dato che l'indirizzo è rappresentabile
701 anche con un intero a 32 bit; non si può usare lo stesso metodo con IPv6,
702 in cui l'indirizzo è specificato come struttura, perché il linguaggio C non
703 consente l'uso di una struttura costante come operando a destra in una
704 assegnazione. Per questo nell'header \texttt{netinet/in.h} è definita una
705 variabile \texttt{in6addr\_any} (dichiarata come \texttt{extern}, ed
706 inizializzata dal sistema al valore \texttt{IN6ADRR\_ANY\_INIT}) che permette
707 di effettuare una assegnazione del tipo:
709 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
710 serv_add.sin6_addr = in6addr_any; /* connect from anywhere */
715 \subsection{La funzione \func{connect}}
716 \label{sec:TCPel_func_connect}
718 La funzione \texttt{connect} è usata da un client TCP per stabilire la
719 connessione con un server TCP, il prototipo della funzione è il seguente:
721 \begin{prototype}{sys/socket.h}
722 {int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t addrlen)}
724 Il primo argomento è un file descriptor ottenuto da una precedente chiamata
725 a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
726 l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
727 socket, già descritta in \secref{sec:sock_sockaddr}.
729 La funzione restituisce zero in caso di successo e -1 per un errore, in caso
730 di errore. La variabile \texttt{errno} viene settata secondo i seguenti
733 \item \texttt{EBADF} il file descriptor non è valido.
734 \item \texttt{EFAULT} l'indirizzo della struttura di indirizzi è al di fuori
735 dello spazio di indirizzi dell'utente.
736 \item \texttt{ENOTSOCK} il file descriptor non è associato ad un socket.
737 \item \texttt{EISCONN} il socket è già connesso.
738 \item \texttt{ECONNREFUSED} non c'è nessuno in ascolto sull'indirizzo remoto.
739 \item \texttt{ETIMEDOUT} si è avuto timeout durante il tentativo di
741 \item \texttt{ENETUNREACH} la rete non è raggiungibile.
742 \item \texttt{EADDRINUSE} l'indirizzo locale è in uso.
743 \item \texttt{EINPROGRESS} il socket è non bloccante e la connessione non
744 può essere conclusa immediatamente.
745 \item \texttt{EALREADY} il socket è non bloccante e un tentativo precedente
746 di connessione non si è ancora concluso.
747 \item \texttt{EAGAIN} non ci sono più porte locali libere.
748 \item \texttt{EAFNOSUPPORT} l'indirizzo non ha una famiglia di indirizzi
749 corretta nel relativo campo.
750 \item \texttt{EACCESS, EPERM} si è tentato di eseguire una connessione ad un
751 indirizzo broadcast senza che il socket fosse stato abilitato per il
756 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
757 numero di porta del server a cui ci si vuole connettere, come mostrato
758 nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
759 \secref{sec:sock_addr_func}.
761 Nel caso di socket TCP la funzione \texttt{connect} avvia il three way
762 handshake, e ritorna solo quando la connessione è stabilita o si è verificato
763 un errore. Le possibili cause di errore sono molteplici (ed i relativi codici
764 riportati sopra), quelle che però dipendono dalla situazione della rete e non
765 da errori o problemi nella chiamata della funzione sono le seguenti:
768 \item Il client non riceve risposta al SYN: l'errore restituito è
769 \texttt{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
770 di \texttt{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
771 dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
772 invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
773 di volte che può essere stabilito dall'utente sia con una opportuna
774 \texttt{sysctl} che attraverso il filesystem \texttt{/proc} scrivendo il
775 valore voluto in \texttt{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore di
776 default per la ripetizione dell'invio è di 5 volte, che comporta un timeout
777 dopo circa 180 secondi.
779 % Le informazioni su tutte le opzioni settabili via /proc stanno in
780 % Linux/Documentation/networking/ip-sysctl.txt
782 \item Il client riceve come risposta al SYN un RST significa che non c'è
783 nessun programma in ascolto per la connessione sulla porta specificata (il
784 che vuol dire probabilmente che o si è sbagliato il numero della porta o che
785 non è stato avviato il server), questo è un errore fatale e la funzione
786 ritorna non appena il RST viene ricevuto riportando un errore
787 \texttt{ECONNREFUSED}.
789 Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
790 dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
791 quando arriva un SYN per una porta che non ha nessun server in ascolto,
792 quando il TCP abortisce una connessione in corso, quando TCP riceve un
793 segmento per una connessione che non esiste.
795 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
796 destinazione non raggiungibile. In questo caso dato che il messaggio può
797 essere dovuto ad una condizione transitoria si ripete l'emissione dei SYN
798 come nel caso precedente, fino al timeout, e solo allora si restituisce il
799 codice di errore dovuto al messaggio ICMP, che da luogo ad un
800 \texttt{ENETUNREACH}.
804 Se si fa riferimento al diagramma degli stati del TCP riportato in
805 \figref{fig:TCP_state_diag} la funzione \texttt{connect} porta un socket
806 dallo stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket
807 appena creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento del
808 ACK, nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il
809 socket non è più utilizzabile e deve essere chiuso.
811 Si noti infine che con la funzione \texttt{connect} si è specificato solo
812 indirizzo e porta del server, quindi solo una metà della socket pair; essendo
813 questa funzione usata nei client l'altra metà contenente indirizzo e porta
814 locale viene lasciata all'assegnazione automatica del kernel, e non è
815 necessario effettuare una \texttt{bind}.
818 \subsection{La funzione \texttt{listen}}
819 \label{sec:TCPel_func_listen}
821 La funzione \texttt{listen} è usata per usare un socket in modalità passiva,
822 cioè, come dice il nome, per metterlo in ascolto di eventuali connessioni; in
823 sostanza l'effetto della funzione è di portare il socket dallo stato
824 \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si chiama la funzione in
825 un server dopo le chiamate a \texttt{socket} e \texttt{bind} e prima della
826 chiamata ad \texttt{accept}. Il prototipo della funzione come definito dalla
829 \begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
830 La funzione pone il socket specificato da \texttt{sockfd} in modalità
831 passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
832 a \texttt{backlog}. La funzione si può applicare solo a socket di tipo
833 \texttt{SOCK\_STREAM} o \texttt{SOCK\_SEQPACKET}.
835 La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
836 codici di errore restituiti in \texttt{errno} sono i seguenti:
838 \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
840 \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
841 \item \texttt{EOPNOTSUPP} il socket è di un tipo che non supporta questa
847 Il parametro \texttt{backlog} indica il numero massimo di connessioni pendenti
848 accettate; se esso viene ecceduto il client riceverà una errore di tipo
849 \texttt{ECONNREFUSED}, o se il protocollo, come nel caso del TCP, supporta la
850 ritrasmissione, la richiesta sarà ignorata in modo che la connessione possa
853 Per capire meglio il significato di tutto ciò occorre approfondire la modalità
854 con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
855 infatti vengono mantenute due code:
857 \item Una coda delle connessioni incomplete (\textit{incomplete connection
858 queue} che contiene un ingresso per ciascun socket per il quale è arrivato
859 un SYN ma il three way handshake non si è ancora concluso. Questi socket
860 sono tutti nello stato \texttt{SYN\_RECV}.
861 \item Una coda delle connessioni complete (\textit{complete connection queue}
862 che contiene un ingresso per ciascun socket per il quale il three way
863 handshake è stato completato ma ancora \texttt{accept} non è ritornata.
864 Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
867 Lo schema di funzionamento è descritto in \nfig, quando arriva un SYN da un
868 client il server crea una nuova entrata nella coda delle connessioni
869 incomplete, e poi risponde con il SYN$+$ACK. La entrata resterà nella coda
870 delle connessioni incomplete fino al ricevimento dell'ACK dal client o fino ad
871 un timeout. Nel caso di completamento del three way handshake l'entrata viene
872 sostata nella coda delle connessioni complete. Quando il processo chiama la
873 funzione \texttt{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
874 entrata nella coda delle connessioni complete è passata al programma, o, se la
875 coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo della
876 prima connessione completa.
878 Storicamente il valore del parametro \texttt{backlog} era corrispondente al
879 massimo valore della somma del numero di entrate possibili per ciascuna di
880 dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
881 valore, e provvede una tabella con i risultati ottenuti con vari kernel,
882 compreso Linux 2.0, che mostrano le differenze fra diverse implementazioni.
884 In Linux il significato di questo valore è cambiato a partire dal kernel
885 2.2 per prevenire l'attacco chiamato \texttt{syn flood}. Questo si basa
886 sull'emissione da parte dell'attaccante di un grande numero di pacchetti SYN
887 indirizzati verso una porta forgiati con indirizzo IP fasullo\footnote{con la
888 tecnica che viene detta \textit{ip spoofing}} così che i SYN$+$ACK vanno
889 perduti e la coda delle connessioni incomplete viene saturata, impedendo di
890 fatto ulteriori connessioni.
892 Per ovviare a questo il significato del \texttt{backlog} è stato cambiato a
893 indicare la lunghezza della coda delle connessioni complete. La lunghezza
894 della coda delle connessioni incomplete può essere ancora controllata usando
895 la \texttt{sysctl} o scrivendola direttamente in
896 \texttt{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
897 protezione dei syncookies però (con l'opzione da compilare nel kernel e da
898 attivare usando \texttt{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
899 viene ignorato e non esiste più un valore massimo. In ogni caso in Linux il
900 valore di \texttt{backlog} viene troncato ad un massimo di \texttt{SOMAXCONN}
901 se è superiore a detta costante (che di default vale 128).
903 La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
904 kernel non supportavano neanche valori superiori, ma la situazione corrente è
905 molto cambiata per via della presenza di server web che devono gestire un gran
906 numero di connessioni per cui un tale valore non è più adeguato. Non esiste
907 comunque una risposta univoca per la scelta del valore, per questo non
908 conviene specificarlo con una costante (il cui cambiamento richiederebbe la
909 ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi
910 \secref{sec:proc_environ}).
912 Lo Stevens tratta accuratamente questo argomento, con esempi presi da casi
913 reali su web server, ed in particolare evidenzia come non sia più vero che il
914 compito principale della coda sia quello di gestire il caso in cui il server è
915 occupato fra chiamate successive alla \texttt{accept} (per cui la coda più
916 occupata sarebbe quella delle connessioni completate), ma piuttosto quello di
917 gestire la presenza di un gran numero di SYN in attesa di concludere il
920 Infine va messo in evidenza che nel caso di socket TCP quando un SYN arriva
921 con tutte le code piene, il pacchetto deve essere ignorato. Questo perché la
922 condizione in cui le code sono piene è ovviamente transitoria, per cui se il
923 client ritrasmette il SYN è probabile che passato un po' di tempo possa
924 trovare nella coda lo spazio per una nuova connessione. Se invece si
925 rispondesse con un RST per indicare l'impossibilità di effettuare la
926 connessione la chiamata a \texttt{connect} nel client ritornerebbe con una
927 condizione di errore, costringendo a inserire nell'applicazione la gestione
928 dei tentativi di riconnessione che invece può essere effettuata in maniera
929 trasparente dal protocollo TCP.
932 \subsection{La funzione \texttt{accept}}
933 \label{sec:TCPel_func_accept}
935 La funzione \texttt{accept} è chiamata da un server TCP per gestire la
936 connessione una volta che sia stato completato il three way handshake, la
937 funzione restituisce un nuovo socket descriptor su cui si potrà operare per
938 effettuare la comunicazione. Se non ci sono connessioni completate il processo
939 viene messo in attesa. Il prototipo della funzione è il seguente:
941 \begin{prototype}{sys/socket.h}
942 {int listen(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
943 La funzione estrae la prima connessione relativa al socket \texttt{sockfd}
944 in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
945 con le stesse caratteristiche di \texttt{sockfd} (restituito dalla funzione
946 stessa). Il socket originale non viene toccato. Nella struttura
947 \texttt{addr} e nella variabile \texttt{addrlen} vengono restituiti
948 indirizzo e relativa lunghezza del client che si è connesso.
950 La funzione restituisce un numero di socket descriptor positivo in caso di
951 successo e -1 in caso di errore, nel qual caso la variabile \texttt{errno}
952 viene settata ai seguenti valori:
955 \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
957 \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
958 \item \texttt{EOPNOTSUPP} il socket è di un tipo che non supporta questa
960 \item \texttt{EAGAIN} o \item \texttt{EWOULDBLOCK} il socket è stato
961 settato come non bloccante, e non ci sono connessioni in attesa di essere
963 \item \texttt{EFAULT} l'argomento \texttt{addr} .
964 \item \texttt{EPERM} Firewall rules forbid connection.
966 \item \texttt{ENOBUFS, ENOMEM} Not enough free memory. This often means
967 that the memory allocation is limited by the socket buffer limits, not by
970 Inoltre possono essere restituiti gli errori di rete relativi al nuovo
971 socket come: \texttt{EMFILE}, \texttt{EINVAL}, \texttt{ENOSR},
972 \texttt{ENOBUFS}, \texttt{EPERM}, \texttt{ECONNABORTED},
973 \texttt{ESOCKTNOSUPPORT}, \texttt{EPROTONOSUPPORT}, \texttt{ETIMEDOUT},
974 \texttt{ERESTARTSYS}.
979 La funzione può essere usata solo con socket che supportino la connessione
980 (cioè di tipo \texttt{SOCK\_STREAM}, \texttt{SOCK\_SEQPACKET} o
981 \texttt{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
982 esplicita della connessione, (attualmente in Linux solo DECnet ha questo
983 comportamento), la funzione opera solo l'estrazione dalla coda delle
984 connessioni, la conferma della connessione viene fatta implicitamente dalla
985 prima chiamata ad una \texttt{read} o una \texttt{write} mentre il rifiuto
986 della connessione viene fatto con la funzione \texttt{close}.
988 È da chiarire che Linux presenta un comportamento diverso nella gestione degli
989 errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
990 \texttt{accept} passa gli errori di rete pendenti sul nuovo socket come codici
991 di errore per \texttt{accept}. Inoltre la funzione non fa ereditare ai nuovi
992 socket flag come \texttt{O\_NONBLOCK}, che devono essere rispecificati volta
993 volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
994 deve essere tenuto in conto per scrivere programmi portabili.
996 I due argomenti \texttt{cliaddr} e \texttt{addrlen} (si noti che quest'ultimo
997 è passato per indirizzo per avere indietro il valore) sono usati per ottenere
998 l'indirizzo del client da cui proviene la connessione. Prima della chiamata
999 \texttt{addrlen} deve essere inizializzato alle dimensioni della struttura il
1000 cui indirizzo è passato come argomento in \texttt{cliaddr}, al ritorno della
1001 funzione \texttt{addrlen} conterrà il numero di bytes scritti dentro
1002 \texttt{cliaddr}. Se questa informazione non interessa basterà inizializzare a
1003 \texttt{NULL} detti puntatori.
1005 Se la funzione ha successo restituisce il descrittore di un nuovo socket
1006 creato dal kernel (detto \textit{connected socket}) a cui viene associata la
1007 prima connessione completa (estratta dalla relativa coda, vedi
1008 \secref{sec:TCPel_func_listen}) che il client TCP ha effettuato verso il
1009 socket \texttt{sockfd}. Quest'ultimo (detto \textit{listening socket}) è
1010 quello creato all'inizio e messo in ascolto con \texttt{listen}, e non viene
1011 toccato dalla funzione.
1012 Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
1013 il processo\footnote{a meno che non si sia settato il socket per essere
1014 non-bloccante, nel qual caso ritorna con l'errore \texttt{EAGAIN},
1015 torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
1016 fintanto che non ne arriva una.
1018 Il meccanismo di funzionamento di \texttt{accept} è essenziale per capire il
1019 funzionamento di un server: in generale infatti c'è sempre un solo socket in
1020 ascolto, che resta per tutto il tempo nello stato \texttt{LISTEN}, mentre le
1021 connessioni vengono gestite dai nuovi socket ritornati da \texttt{accept} che
1022 si trovano automaticamente nello stato \texttt{ESTABLISHED} e utilizzati fino
1023 alla chiusura della connessione che avviene su di essi. Si può riconoscere
1024 questo schema anche nell'esempio elementare in \figref{fig:net_serv_code} dove
1025 per ogni connessione il socket creato da \texttt{accept} viene chiuso dopo
1029 \subsection{La funzione \texttt{close}}
1030 \label{sec:TCPel_func_close}
1032 La funzione standard unix \texttt{close} (vedi \secref{sec:file_close}) che si
1033 usa sui file può essere usata con lo stesso effetto anche sui socket
1036 L'azione standard di questa funzione quando applicata a socket è di marcarlo
1037 come chiuso e ritornare immediatamente al processo. Una volta chiamata il
1038 socket descriptor non è più utilizzabile dal processo e non può essere usato
1039 come argomento per una \texttt{write} o una \texttt{read} (anche se l'altro
1040 capo della connessione non avesse chiuso la sua parte). Il kernel invierà
1041 comunque tutti i dati che ha in coda prima di iniziare la sequenza di chiusura.
1043 Vedremo più avanti in \secref{sec:TCPadv_so_linger} come è possibile cambiare
1044 questo comportamento, e cosa deve essere fatto perché il processo possa
1045 assicurarsi che l'altro capo abbia ricevuto tutti i dati.
1047 Come per i file anche per i socket descriptor viene mantenuto un numero di
1048 riferimenti, per cui se più di un processo ha lo stesso socket aperto
1049 l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
1050 fintanto che il numero di riferimenti non si annulla. Questo è il
1051 comportamento normale che ci si aspetta in un'applicazione client/server quale
1052 quella che illustreremo in \secref{sec:TCPel_cunc_serv}.
1054 Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura si
1055 può usare la funzione \texttt{shutdown} su cui torneremo in seguito.
1058 \section{I server concorrenti su TCP}
1059 \label{sec:TCPel_cunc_serv}
1061 Il server \texttt{daytime} dell'esempio in \secref{sec:net_cli_sample} è un
1062 tipico esempio di server iterativo, in cui viene servita una richiesta alla
1063 volta; in generale però, specie se il servizio è più complesso e comporta uno
1064 scambio di dati più sostanzioso di quello in questione, non è opportuno
1065 bloccare un server nel servizio di un client per volta; per questo si ricorre
1066 alle capacità di multitasking del sistema.
1068 Il modo più immediato per creare un server concorrente è allora quello di
1069 usare la funzione \texttt{fork} per far creare al server per ogni richiesta da
1070 parte di un client un processo figlio che si incarichi della gestione della
1074 \subsection{Un esempio di server \textit{daytime} concorrente}
1075 \label{sec:TCPel_cunc_daytime}
1077 Per illustrare il meccanismo usato in generale per creare un server
1078 concorrente abbiamo riscritto il server \texttt{daytime} dell'esempio
1079 precedente in forma concorrente, inserendo anche una opzione per la stampa
1080 degli indirizzi delle connessioni ricevute.
1082 In \nfig\ è mostrato un estratto del codice, in cui si sono tralasciati il
1083 trattamento delle opzioni e le parti rimaste invariate rispetto al precedente
1084 esempio. Al solito il sorgente completo del server
1085 \texttt{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti.
1087 \begin{figure}[!htb]
1089 \begin{lstlisting}{}
1090 #include <sys/types.h> /* predefined types */
1091 #include <unistd.h> /* include unix standard library */
1092 #include <arpa/inet.h> /* IP addresses conversion utiliites */
1093 #include <sys/socket.h> /* socket library */
1094 #include <stdio.h> /* include standard I/O library */
1097 int main(int argc, char *argv[])
1099 int list_fd, conn_fd;
1101 struct sockaddr_in serv_add, client;
1102 char buffer[MAXLINE];
1108 /* write daytime to client */
1110 if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len))
1112 perror("accept error");
1115 /* fork to handle connection */
1116 if ( (pid = fork()) < 0 ){
1117 perror("fork error");
1120 if (pid == 0) { /* child */
1122 timeval = time(NULL);
1123 snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
1124 if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
1125 perror("write error");
1129 inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
1130 printf("Request from host %s, port %d\n", buffer,
1131 ntohs(client.sin_port));
1135 } else { /* parent */
1139 /* normal exit, never reached */
1143 \caption{Esempio di codice di un server concorrente elementare per il
1145 \label{fig:TCPel_serv_code}
1148 Come si può vedere (alle linee \texttt{\small 21--25}) la funzione
1149 \texttt{accept} stavolta è chiamata fornendo una struttura di indirizzi in cui
1150 saranno ritornati numero IP e porta da cui il client effettua la connessione,
1151 che stamperemo, se avremo abilitato il logging, sullo standard output
1152 (\texttt{\small 39--43}).
1154 Quando \texttt{accept} ritorna il server chiama la funzione \texttt{fork}
1155 (\texttt{\small 26--30}) per creare il processo figlio che effettuerà tutte le
1156 operazioni relative a quella connessione (\texttt{\small 31--45}), mentre il
1157 padre resterà in attesa di ulteriori connessioni.
1159 Si noti come il figlio operi solo sul socket connesso, chiudendo
1160 immediatamente il socket \texttt{list\_fd}; mentre il padre continua ad
1161 operare solo sul socket in ascolto chiudendo \texttt{sock\_fd} dopo ciascuna
1162 \texttt{accept}. Per quanto abbiamo detto in \secref{sec:TCPel_func_close}
1163 queste due chiusure non causano l'innesco della sequenza di chiusura perché il
1164 numero di riferimenti non si è annullato.
1166 Infatti subito dopo la creazione del socket \texttt{list\_fd} ha una
1167 referenza, e lo stesso vale per \texttt{sock\_fd} dopo il ritorno di
1168 \texttt{accept}, ma dopo la fork i descrittori vengono duplicati nel padre e
1169 nel figlio per cui entrambi i socket si trovano con due referenze. Questo fa
1170 si che quando il padre chiude \texttt{sock\_fd} esso resta con una referenza
1171 da parte del figlio, e sarà definitivamente chiuso solo quando quest'ultimo,
1172 dopo aver completato le sue operazioni, chiamerà la funzione \texttt{close}.
1174 In realtà per il figlio non sarebbero necessarie nessuna delle due chiamate a
1175 \texttt{close} in quanto nella \texttt{exit} tutti i file ed i socket vengono
1176 chiusi, ma si è preferito effettuare la chiusura esplicitamente per avere una
1177 maggiore chiarezza del codice ed evitare possibili errori.
1179 Si noti come sia essenziale che il padre chiuda ogni volta il socket connesso
1180 dopo la \texttt{accept}; se così non fosse nessuno di questi socket sarebbe
1181 effettivamente chiuso dato che alla chiusura da parte del figlio resterebbe
1182 ancora un riferimento. Si avrebbero così due effetti, il padre potrebbe
1183 esaurire i descrittori disponibili (che sono un numero limitato per ogni
1184 processo) e soprattutto nessuna delle connessioni con i client verrebbe
1188 \subsection{Le funzioni \texttt{getsockname} e \texttt{getpeername}}
1189 \label{sec:TCPel_get_names}
1191 Queste due funzioni vengono usate per ottenere la socket pair associata ad un
1192 certo socket; la prima restituisce l'indirizzo locale, la seconda quello
1195 \begin{prototype}{sys/socket.h}
1196 {int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
1198 La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
1199 codici di errore restituiti in \texttt{errno} sono i seguenti:
1201 \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
1203 \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
1204 \item \texttt{ENOBUFS} non ci sono risorse sufficienti nel sistema per
1205 eseguire l'operazione.
1206 \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
1207 spazio di indirizzi del processo.
1211 La funzione \texttt{getsockname} si usa tutte le volte che si vuole avere
1212 l'indirizzo locale di un socket; ad esempio può essere usata da un client (che
1213 usualmente non chiama \texttt{bind}) per ottenere numero IP e porta locale
1214 associati al socket restituito da una \texttt{connect}, o da un server che ha
1215 chiamato \texttt{bind} su un socket usando 0 come porta locale per ottenere il
1216 numero di porta effimera assegnato dal kernel.
1218 Inoltre quando un server esegue una \texttt{bind} su un indirizzo generico, se
1219 chiamata dopo il completamento di una connessione sul socket restituito da
1220 \texttt{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
1224 \begin{prototype}{sys/socket.h}
1225 {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
1227 La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
1228 codici di errore restituiti in \texttt{errno} sono i seguenti:
1230 \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
1232 \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
1233 \item \texttt{ENOTCONN} il socket non è connesso.
1234 \item \texttt{ENOBUFS} non ci sono risorse sufficienti nel sistema per
1235 eseguire l'operazione.
1236 \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
1237 spazio di indirizzi del processo.
1242 La funzione \texttt{getpeername} si usa tutte le volte che si vuole avere
1243 l'indirizzo remoto di un socket.
1245 Ci si può chiedere a cosa serva questa funzione dato che dal lato client
1246 l'indirizzo remoto è sempre noto quando si esegue la \texttt{connect} mentre
1247 dal lato server si possono usare, come si è fatto nell'esempio precedente, i
1248 valori di ritorno di \texttt{accept}.
1250 In generale però questa ultima possibilità è sempre possibile. In particolare
1251 questo avviene quando il server invece di far gestire la connessione
1252 direttamente a un processo figlio, come nell'esempio precedente, lancia un
1253 opportuno programma per ciascuna connessione usando \texttt{exec} (questa ad
1254 esempio è la modailità con cui opera il \textsl{super-server} \texttt{inetd}
1255 che gestisce tutta una serie di servizi lanciando per ogni connessione
1256 l'opportuno server).
1258 In questo caso benché il processo figlio abbia una immagine della memoria che
1259 è copia di quella del processo padre (e contiene quindi anche la struttura
1260 ritornata da \texttt{accept}), all'esecuzione di \texttt{exec} viene caricata
1261 in memoria l'immagine del programma eseguito che a questo punto perde ogni
1262 riferimento. Il socket descriptor però resta aperto. Allora se una opportuna
1263 convenzione è seguita per rendere noto al programma eseguito qual'è il socket
1264 connesso (\texttt{inetd} ad esempio fa sempre in modo che i file descriptor 0,
1265 1 e 2 corrispondano al socket connesso) quest'ultimo potrà usare la funzione
1266 \texttt{getpeername} per determinare l'indirizzo remoto del client.
1268 Infine è da chiarire (si legga la man page) che come per \texttt{accept} il
1269 terzo parametro che è specificato dallo standard POSIX 1003.1g come di tipo
1270 \texttt{socklen\_t *} in realtà deve sempre corrispondere ad un \texttt{int *}
1271 come prima dello standard perché tutte le implementazioni dei socket BSD fanno