1 \chapter{Socket TCP elementari}
2 \label{cha:elem_TCP_sock}
4 In questo capitolo iniziamo 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
7 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}), previa una
8 descrizione delle principali caratteristiche del funzionamento di una
11 Infine riscriveremo il precedente esempio elementare di server
12 \texttt{daytime} in una forma appena più evoluta (come server concorrente) e
13 con alcune caratteristiche aggiuntive che mettano in luce quanto andremo ad
16 \section{Il funzionamento di una connessione TCP}
17 \label{sec:TCPel_connession}
19 Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
20 utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
21 del TCP; la conoscenza del funzionamento del protocollo è infatti essenziale
22 per capire il modello di programmazione ed il funzionamento delle API.
24 In particolare ci concentreremo sulle modalità con le quali il protocollo dà
25 inizio e conclude una connessione; faremo inoltre anche un breve accenno al
26 significato di alcuni dei vari stati che il protocollo assume durante la vita
27 di una connessione, che possono essere osservati per ciascun socket attivo con
28 l'uso del programma \texttt{netstat}.
30 \subsection{La creazione della connessione: il \textit{three way handushake}}
31 \label{sec:TCPel_conn_cre}
33 Il processo che porta a creare una connessione TCP è chiamato \textit{three
34 way handushake}; la successione tipica degli eventi (la stessa che si
35 verifica utilizzando il codice dei due precedenti esempi elementari
36 \figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
37 creazione di una connessione è la seguente:
40 \item Il server deve essere preparato per accettare le connessioni in arrivo;
41 il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
42 \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
43 \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
44 passiva il server chiama la funzione \texttt{accept} e il processo si blocca
45 in attesa di connessioni.
47 \item Il client richiede l'inizio della connessione usando la funzione
48 \texttt{connect}, attraverso un procedimento che viene chiamato
49 \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
50 \texttt{connect} blocca il processo e causa l'invio da parte del client di
51 un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
52 elementare di dati trasmessa dal protocollo TCP al livello superiore;
53 tutti i segmenti hanno un header che contiene le informazioni che servono
54 allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
55 che implementa il protocollo) per realizzare la comunicazione, fra questi
56 dati ci sono una serie di flag usati per gestire la connessione, come
57 \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
58 come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a
59 funzioni particolari del protocollo e danno il nome al segmento, (per
60 maggiori dettagli vedere \capref{cha:tcp_protocol})}, in sostanza viene
61 inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
62 il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
64 \item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
65 del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
66 client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
67 ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
68 \texttt{ACK} e sono settati.
70 \item una volta che il client ha ricevuto l'acknowledge dal server la funzione
71 \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
72 \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
73 quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
77 Il procedimento viene chiamato \textit{three way handshake} dato che per
78 realizzarlo devono essere scambiati tre segmenti. In \nfig\ si è
79 rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce
82 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
83 % sistema del telefono. La funzione \texttt{socket} può essere considerata
84 % l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al
85 % dire alle altre persone qual'è il proprio numero di telefono perché possano
86 % chiamare. La funzione \texttt{listen} è accendere il campanello del telefono
87 % per sentire le chiamate in arrivo. La funzione \texttt{connect} richiede di
88 % conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è
89 % quando si risponde al telefono.
94 \caption{Il \textit{three way handshake} del TCP}
98 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
99 riportati in \curfig); per gestire una connessione affidabile infatti il
100 protocollo TCP prevede nell'header la presenza di un numero a 32 bit (chiamato
101 appunto \textit{sequence number}) che identifica a quale byte nella sequenza
102 del flusso corrisponde il primo byte della sezione dati contenuta nel
105 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
106 \textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
107 all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
108 ciascun segmento viene effettuato dall'altro capo della connessione settando
109 il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
110 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
111 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
112 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
113 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
114 varrà anche (vedi \nfig) per l'acknowledgement di un FIN.
116 \subsection{Le opzioni TCP.}
117 \label{sec:TCPel_TCP_opt}
119 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
120 (le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
121 dati) che servono a comunicare all'altro capo una serie di parametri utili a
122 regolare la connessione. Normalmente vengono usate le seguenti opzioni:
125 \item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
126 opzione ciascun capo della connessione annuncia all'altro il massimo
127 ammontare di dati che vorrebbe accettare per ciascun segmento nella
128 connesione corrente. È possibile leggere e scrivere questo valore attraverso
129 l'opzione del socket \texttt{TCP\_MAXSEG}.
131 \item \textit{window scale option} come spiegato in \capref{cha:tcp_protocol} il
132 protocollo TCP implementa il controllo di flusso attraverso una
133 \textsl{finestra annunciata} (\textit{advertized window}) con la quale
134 ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
135 memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può
136 indicare un massimo di 65535 bytes (anche se linux usa come massimo 32767
137 per evitare problemi con alcuni stack bacati che usano l'aritmetica con
138 segno per implementare lo stack TCP); ma alcuni tipi di connessione come
139 quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
140 ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
141 più grande per poter ottenere il massimo dalla trasmissione, per questo
142 esiste questa opzione che indica un fattore di scala da applicare al valore
143 della finestra annunciata\footnote{essendo una nuova opzione per garantire
144 la compatibilità con delle vecchie implementazioni del protocollo la
145 procedura che la attiva prevede come negoziazione che l'altro capo della
146 connessione riconosca esplicitamente l'opzione inserendola anche lui nel
147 suo SYN di risposta dell'apertura della connessione} per la connessione
148 corrente (espresso come numero di bit cui shiftare a sinistra il valore
149 della finestra annunciata inserito nel pacchetto).
151 \item \textit{timestamp option} è anche questa una nuova opzione necessaria
152 per le connessioni ad alta velocità per evitare possibili corruzioni di dati
153 dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
158 La MSS è generalmente supportata da quasi tutte le implementazioni del
159 protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
160 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
161 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
162 elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
164 \subsection{La terminazione della connessione}
165 \label{sec:TCPel_conn_term}
167 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
168 procedura di chiusura ne richede quattro; ancora una volta si può fare
169 riferimento al codice degli esempi \figref{fig:net_cli_code} e
170 \figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
174 \item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
175 l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da
176 \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
177 significa che si è finito con l'invio dei dati sulla connessione.
179 \item L'altro capo della connessione riceve il FIN ed esegue la
180 \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
181 tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
182 viene passato al processo che ha aperto il socket come un end of file sulla
183 lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
184 ricevuto), dato che il ricevimento di un FIN significa che non si
185 riceveranno altri dati sulla connessione.
187 \item Dopo un certo tempo anche il secondo processo chiamerà la funzione
188 \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
191 \item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
196 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
197 normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
198 sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
199 detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
200 accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
201 sequenza di scambio dei segmenti che stabilisce la connessione.
206 \caption{Il \textit{three way handshake} del TCP}
207 \label{fig:TCPel_TWH}
210 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
211 l'ACK riporterà un \textit{acknowledge number} incrementato di uno.
213 Si noti che nella sequenza di chiusura fra i passi 2 e 3 è in teoria possibile
214 che si mantenga un flusso di dati dal capo della connessione che sta eseguendo
215 la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella
216 sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma
217 esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato
218 \textit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
219 più avanti, quando parleremo della funzione \texttt{shutdown}.
221 La emissione del FIN avviene quando il socket viene chiuso, questo però non
222 avviene solo per la chiamata della funzione \texttt{close} (come in
223 \figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
224 in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
225 viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
227 Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
228 in \secref{sec:TCPel_echo_example}) sia il client ad eseguire la chiusura
229 attiva, nella realtà questa può essere eseguita da uno qualunque dei due capi
230 della comunicazione (come in fatto in precedenza da
231 \figref{fig:net_serv_code}), e benché quello del client sia il caso più comune
232 ci sono alcuni servizi, il principale dei quali è l'HTTP, per i quali è il
233 server ad effettuare la chiusura attiva.
235 \subsection{Un esempio di connessione}
236 \label{sec:TCPel_conn_dia}
238 Le operazioni del TCP nella creazione e conclusione di una connessione sono
239 specificate attraverso il diagramma di transizione degli stati riportato in
240 \nfig. TCP prevede l'esistenza di 11 diversi stati per un socket ed un insieme
241 di regole per le transizioni da uno stato all'altro basate sullo stato
242 corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
243 che vengono riportati del comando \texttt{netstat} nel campo \textit{State}.
245 Una descrizione completa del funzionamento del protocollo va al di là degli
246 obiettivi di questo libro; un approfondimento sugli aspetti principali si
247 trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
248 riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a descrivere
249 brevemente un semplice esempio di connessione e le transizioni che avvengono
250 nei due casi appena citati (creazione e terminazione della connessione).
252 In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
253 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
254 diventa \texttt{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
255 emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
256 finale in cui avviene la gran parte del trasferimento dei dati.
258 Dal lato server in genere invece il passaggio che si opera con l'apertura
259 passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
260 stato \texttt{LISTEN} in cui vengono accettate le connessioni.
262 Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
263 chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
264 attiva) la transizione è verso lo stato \texttt{FIN\_WAIT\_1}; se invece
265 l'applicazione riceve un FIN nello stato \texttt{ESTABLISHED} (chiusura
266 passiva) la transizione è verso lo stato \texttt{CLOSE\_WAIT}.
268 In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
269 una un esempio di connessione, insieme ai vari stati che il protocollo viene
270 ad assumere per i due lati, server e client.
275 \caption{Schema dello scambio di pacchetti per un esempio di connessione}
276 \label{fig:TPCel_conn_example}
279 La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
280 valore tipico per IPv4 su ethernet) con linux, il server risponde con lo
281 stesso valore (ma potrebbe essere anche un valore diverso).
283 Una volta che la connessione è stabilita il client scrive al server una
284 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
285 1460 bytes annunciati dal server), quest'ultimo riceve la richiesta e
286 restituisce una risposta (che di nuovo supponiamo stare in un singolo
287 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
288 risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
289 volte che che il server è sufficientemente veloce a costruire la risposta, in
290 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
293 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
294 secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo della
295 connessione che esegue la chiusura attiva entra nello stato
296 \texttt{TIME\_WAIT} su cui torneremo fra poco.
298 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
299 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
300 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
301 costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
302 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
303 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
304 trasporto all'interno dell'applicazione.
306 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
307 si hanno in una applicazione di rete, perché non è detto che TCP sia la
308 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
309 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
310 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
311 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
312 dati rispondono meglio alle esigenze che devono essere affrontate.
314 \subsection{Lo stato \texttt{TIME\_WAIT}}
315 \label{sec:TCPel_time_wait}
317 Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
318 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
319 comune trovare nei newsgroup domande su come sia possibile evitare che
320 un'applicazione resti in questo stato lasciando attiva una connessione ormai
321 conclusa; la risposta è che non deve essere fatto, ed il motivo cercheremo di
324 Come si è visto nell'esempio precedente (vedi \curfig) \texttt{TIME\_WAIT} è
325 lo stato finale in cui il capo di una connessione che esegue la chiusura
326 attiva resta prima di passare alla chiusura definitiva della connessione. Il
327 tempo in cui l'applicazione resta in questo stato deve essere due volte la MSL
328 (\textit{Maximum Segment Lifetime}).
330 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
331 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
332 ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
333 Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
334 IP (per maggiori dettagli vedi \secref{sec:appA_xxx}), e viene decrementato ad
335 ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
336 Siccome il numero è ad 8 bit il numero massimo di ``salti'' è di 255, pertanto
337 anche se il TTL (da \textit{time to live}) non è propriamente un limite sul
338 tempo di vita, si stima che un pacchetto IP non possa restare nella rete per
341 Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
342 raccomanda 2 minuti, linux usa 30 secondi), questo comporta una durata dello
343 stato \texttt{TIME\_WAIT} che a seconda delle implementazioni può variare fra
346 Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
349 \item implementare in maniera affidabile la terminazione della connessione
350 in entrambe le direzioni.
351 \item consentire l'eliminazione dei segmenti duplicati dalla rete.
354 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
355 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
356 capisce il perché della scelta di un tempo pari al doppio della MSL come
357 durata di questo stato.
359 Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
360 che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
361 attiva) vanga perso, chi esegue la chiusura passiva non ricevndo risposta
362 rimanderà un ulteriore FIN, per questo motivo chi esegue la chiusura attiva
363 deve mantenere lo stato della connessione per essere in grado di reinviare
364 l'ACK e chiuderla correttamente. Se non fosse così la risposta sarebbe un RST
365 (un altro tipo si segmento) che verrebbe interpretato come un errore.
367 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
368 connessione allora deve essere in grado di affrontare la perdita di uno
369 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
370 motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
371 dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale
372 ritrasmissione in caso di perdita.
375 Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
376 gli scenari in cui accade che i pacchetti si possono perdere nella rete o
377 restare intrappolati, per poi riemergere.
379 Il caso più comune in cui questo avviene è quello di anomalie
380 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
381 una connessione fra due router si interrompa. In questo caso i protocolli di
382 instradamento dei pacchetti possono impiegare diverso temo (anche dell'ordine
383 dei minuti) prima di trovare e stabilire un percorso alternativo per i
384 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
385 pacchetti verso un'altro e quest'ultimo li rispedisce indietro, o li manda ad
386 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
387 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
389 Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
390 non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
391 stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
392 destinazione. Ma se dopo un po' di tempo (che non supera il limite dell'MSL)
393 l'anomalia viene a cessare il circolo di instadamento viene spezzato i
394 pacchetti intrappolati potranno essere inviati alla destinazione finale, con
395 la conseguenza di avere dei pacchetti duplicati; questo è un caso che il TCP
396 deve essere in grado di gestire.
398 Allora per capire la seconda ragione per l'esistenza dello stato
399 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
400 connessione fra l'IP 195.110.112.236 porta 1550 e l'IP 192.84.145.100 porta
401 22, che questa venga chiusa e che poco dopo si ristabilisca la stessa
402 connessione fra gli stessi IP sulle stesse porte (quella che viene detta,
403 essendo gli stessi porte e numeri IP, una nuova \textsl{incarnazione} della
404 connessione precedente); in questo caso ci si potrebbe trovare con dei
405 pacchetti duplicati relativi alla precedente connessione che riappaiono nella
408 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
409 creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
410 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
411 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
412 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
413 sicuri che lo stesso avvenga le risposte nella direzione opposta.
415 In questo modo il TCP si assicura che quando una viene creata una nuova
416 connessione tutti gli eventuali segmenti residui di una precedente connessione
417 che possono causare disturbi sono stati eliminati dalla rete.
420 \subsection{I numeri di porta}
421 \label{sec:TCPel_port_num}
423 In un ambiente multitasking in un dato momento più processi possono dover
424 usare sia UDP che TCP, e ci devono poter essere più connessioni in
425 contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
426 protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
427 vedere in \secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle strutture
428 degli indirizzi del socket.
430 Quando un client contatta un server deve poter identificare con quale dei vari
431 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
432 di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
433 identificano una serie di servizi noti (ad esempio la porta 22 identifica il
434 servizio \texttt{ssh}) effettuati da appositi server che rispondono alle
435 connessioni verso tali porte.
437 D'altra parte un client non ha necessità di usare un numero di porta
438 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
439 effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
440 nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
441 creazione della connessione. Queste sono dette effimere in quanto vengono
442 usate solo per la durata della connessione, e l'unico requisito che deve
443 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
445 La lista delle porte conosciute è definita dall'RFC1700 che contiene l'elenco
446 delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
447 ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
448 \texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
449 file \texttt{/etc/services} contiene un analogo elenco, con la corrispondenza
450 fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
454 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
455 controllate e assegnate dalla IANA. Se è possibile la stessa porta è
456 assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
457 è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal
460 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
461 sono controllate dalla IANA, che però registra ed elenca chi usa queste
462 porte come servizio agli utenti. Come per le precedenti si assegna una porta
463 ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
464 solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
465 anche se il protocollo è implementato solo tramite TCP.
467 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
468 65535. La IANA non dice nulla riguardo a queste porte che pertanto
469 sono i candidati naturali ad essere usate come porte effimere.
472 In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
473 scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
474 quelle di BSD, Solaris e linux. Nel caso di linux poi la scelta fra i due
475 intervali possibili viene fatta dinamicamente a seconda della memoria a
476 disposizione del kernel per gestire le rative tabelle.
481 \caption{Allocazione dei numeri di porta}
482 \label{fig:TCPel_port_alloc}
485 I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
486 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
487 porte conosciute). La loro caratteristica è che possono essere assegnate a un
488 socket solo da un processo con i privilegi di root, per far si che solo
489 l'amministratore possa allocare queste porte per far partire relativi servizi.
491 Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
492 \texttt{rlogin}) che richiedono una connessione su una porta riservata anche
493 dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
494 funzione \texttt{rresvport} assegnando al socket una porta libera
495 nell'intervallo fra 512 e 1023.
497 Data una connessione TCP si suole chiamare \textit{socket pair} la
498 combinazione dei quattro numeri che definiscono i due capi della connessione e
499 cioè l'indirizzo IP locale e la porta TCP locale, e l'indirizzo IP remoto e la
500 porta TCP remota; questa combinazione, che scriveremo usando una notazione del
501 tipo $(195.110.112.152:22, 192.84.146.100:20100)$, identifica univocamente una
502 connessione su internet. Questo concetto viene di solito esteso anche a UDP,
503 benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
504 programma \texttt{netstat} permette di visualizzare queste informazioni nei
505 campi \textit{Local Address} e \textit{Foreing Address}.
508 \subsection{Le porte ed il modello client/server}
509 \label{sec:TCPel_port_cliserv}
511 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
512 che fare con un'applicazione client/server (come quella che scriveremo in
513 \secref{sec:TCPel_echo_example}) esaminaremo cosa accade con le connessioni nel
514 caso di un server TCP che deve gestire connessioni multiple.
516 Se esguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
517 indirizzo 195.110.112.152) potremo avere un risultato del tipo:
519 Active Internet connections (servers and established)
520 Proto Recv-Q Send-Q Local Address Foreign Address State
521 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
522 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
523 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
525 essendo presenti e attivi un server ssh, un server di posta e un DNS per il
528 Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
529 mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
530 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
531 associati alle interfaccie locali; la notazione 0.0.0.0 usata da netstat è
532 equivalente all'asterisco utilizzato per il numero di porta ed indica il
533 valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
534 \texttt{arpa/inet.h}.
536 Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
537 specificati; in questo caso la \textit{socket pair} associata al socket può
538 essere indicata come $(*:22, *.*)$, usando l'asterisco anche per gli indirizzi
539 come carattere di \textit{wildchard}.
541 In genere avendo le macchine associato un solo IP ci si può chiedere che senso
542 abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
543 anche macchine che hanno più di un indirizzo IP (il cosiddetto
544 \textit{miltihoming}) in questo modo si possono accettare connessioni
545 indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
546 con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
547 solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
548 caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
551 Una volta che ci si vorrà collegare a questa macchina da un'altra posta
552 all'indirizzo 192.84.146.100 si potrà lanciare un client \texttt{ssh} per
553 creare una connessione verso la precedente, e il kernel associerà al suddetto
554 una porta effimera che per esempio potrà essere la 21100, la connessione
555 allora sarà espressa dalla socket pair $(192.84.146.100:21100,
556 195.110.112.152.22)$.
558 Alla ricezione della richiesta dal client il server creerà un processo figlio
559 per gestire la connessione, se a questo punto eseguiamo nuovamente il
560 programma netstat otterremo come risultato:
562 Active Internet connections (servers and established)
563 Proto Recv-Q Send-Q Local Address Foreign Address State
564 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
565 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
566 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
567 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
570 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
571 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
572 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
573 il processo figlio gestisce la connessione mentre il padre resta in ascolto
574 sul socket originale.
576 Se a questo punto lanciamo un'altra volta il client ssh per una seconda
577 conessione quello che otterremo usando netstat sarà qualcosa del genere:
579 Active Internet connections (servers and established)
580 Proto Recv-Q Send-Q Local Address Foreign Address State
581 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
582 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
583 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
584 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
585 tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
587 cioè il client effettuerà la connessione usando un'altra porta effimera, con
588 questa sarà aperta la connessione, ed il server creerà un'altro processo
589 figlio sarà creato per gestirla.
591 Tutto ciò mostra come TCP, per poter gestire le connessioni con un server
592 concorrente, non può suddividere i pacchetti solo sulla base della porta di
593 destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
594 compresa la porta dell'indirizzo remoto. E se andassimo a vedere quali sono i
595 processi a cui fanno riferimento i vari socket vedremmo che i pacchetti che
596 arrivano dalla porta remota 21100 vanno al primo figlio e quelli che arrivano
597 alla porta 21101 al secondo.
600 \section{Le funzioni dei socket TCP}
601 \label{sec:TCPel_functions}
603 In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
604 l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
605 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}) con l'eccezione
606 della funzione \texttt{socket} che è già stata esaminata in dettaglio in
607 \secref{sec:sock_socket}.
609 In \nfig\ abbiamo un tipico schema di funzionamento di un'applicazione
610 client-server che usa i socket TCP: prima il server viene avviato ed in
611 seguito il client si connette, in questo caso, a differenza di quanto accadeva
612 con gli esempi elementari del Cap.~\capref{cha:network} si assume che sia il
613 client ad effettuare delle richieste a cui il server risponde, il client
614 notifica poi di avere concluso inviando un end-of-file a cui il server
615 risponderà anche lui chiudendo la connessione per aspettarne una nuova.
620 \caption{Struttura delle funzioni dei socket per una semplice applicazione
621 client/server su TCP.}
622 \label{fig:TCPel_cliserv_func}
625 Useremo questo schema per l'esempio di implementazione del servizio
626 \texttt{echo} che illustreremo in \secref{sec:TCPel_echo_example}.
629 \subsection{La funzione \texttt{bind}}
630 \label{sec:TCPel_func_bind}
633 La funzione \texttt{bind} assegna un indirizzo locale ad un socket, è usata
634 cioè per specificare la prima parte dalla socket pair. Viene usata sul lato
635 server per specificare la porta (e gli eventuali indirizzi locali) su cui poi
636 ci si porrà in ascolto.
638 Il prototipo della funzione è il seguente:
640 \begin{prototype}{sys/socket.h}
641 {int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)}
643 Il primo argomento è un file descriptor ottenuto da una precedente chiamata
644 a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
645 l'indirizzo (locale) del socket e la dimensione della struttura che lo
646 contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
648 La funzione restituisce zero in caso di successo e -1 per un errore, in caso
649 di errore. La variabile \texttt{errno} viene settata secondo i seguenti
652 \item \texttt{EBADF} Il file descriptor non è valido.
653 \item \texttt{EINVAL} Il socket ha già un indirizzo assegnato.
654 \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
655 \item \texttt{EACCESS} Si è cercato di usare un indirizzo riservato senza
660 Con il TCP la chiamata \texttt{bind} permette di specificare l'indirizzo, la
661 porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
662 nota che assegnano all'avvio, se questo non viene fatto è il kernel a
663 scegliere una porta effimera quando vengono eseguite la funzioni
664 \texttt{connect} o \texttt{listen}, ma se questo è normale per il client non
665 lo è per il server\footnote{un'eccezione a tutto ciò i server che usano RPC.
666 In questo caso viene fatta assegnare dal kernel una porta effimera che poi
667 viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
668 demone che deve essere contattato dai client per ottenere la porta effimera
669 su cui si trova il server} che in genere viene identificato dalla porta su
672 Con \texttt{bind} si può assegnare un IP specifico ad un socket, purché questo
673 appartenga ad una interfaccia della macchina. Per un client TCP questo
674 diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati sul
675 socket, mentre per un server TCP questo restringerà l'accesso al socket solo
676 alle connessioni che arrivano verso tale indirizzo.
678 Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
679 kernel sceglie l'indirizzo di orgine quando viene effettuata la connessione
680 sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
681 dalle regole di instradamento usate per raggiungere il server).
682 Se un server non specifica il suo indirizzo locale il kernel userà come
683 indirizzo di origine l'indirizzo di destinazione specificato dal SYN del
686 Per specificare un indirizzo generico con IPv4 si usa il valore
687 \texttt{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
688 è pari a zero, nell'esempio \figref{fig:net_serv_sample} si è usata
689 un'assegnazione immediata del tipo:
691 serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
694 Si noti che si è usato \texttt{htonl} per assegnare il valore
695 \texttt{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
696 inutile; ma dato che tutte le constanti \texttt{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 serv_add.sin6_addr = in6addr_any; /* connect from anywhere */
713 \subsection{La funzione \texttt{connect}}
714 \label{sec:TCPel_func_connect}
716 La funzione \texttt{connect} è usata da un client TCP per stabilire la
717 connessione con un server TCP, il prototipo della funzione è il seguente:
719 \begin{prototype}{sys/socket.h}
720 {int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t addrlen)}
722 Il primo argomento è un file descriptor ottenuto da una precedente chiamata
723 a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
724 l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
725 socket, già descritta in \secref{sec:sock_sockaddr}.
727 La funzione restituisce zero in caso di successo e -1 per un errore, in caso
728 di errore. La variabile \texttt{errno} viene settata secondo i seguenti
731 \item \texttt{EBADF} Il file descriptor non è valido.
732 \item \texttt{EFAULT} L'indirizzo della struttura di indirizzi è al di fuori
733 dello spazio di indirizzi dell'utente.
734 \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
735 \item \texttt{EISCONN} Il socket è già connesso.
736 \item \texttt{ECONNREFUSED} Non c'è nessuno in ascolto sull'indirizzo remoto.
737 \item \texttt{ETIMEDOUT} Si è avuto timeout durante il tentativo di
739 \item \texttt{ENETUNREACH} La rete non è raggiungibile.
740 \item \texttt{EADDRINUSE} L'indirizzo locale è in uso.
741 \item \texttt{EINPROGRESS} Il socket è non bloccante e la connessione non
742 può essere conclusa immediatamente.
743 \item \texttt{EALREADY} Il socket è non bloccante e un tentativo precedente
744 di connessione non si è ancora concluso.
745 \item \texttt{EAGAIN} Non ci sono più porte locali libere.
746 \item \texttt{EAFNOSUPPORT} L'indirizzo non ha una famiglia di indirizzi
747 corretta nel relativo campo.
748 \item \texttt{EACCESS, EPERM} Si è tentato di eseguire una connessione ad un
749 indirizzo broacast senza che il socket fosse stato abilitato per il
754 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
755 numero di porta del server a cui ci si vuole connettere, come mostrato
756 nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
757 \secref{sec:sock_addr_func}.
759 Nel caso di socket TCP la funzione \texttt{connect} avvia il three way
760 handshake, e ritorna solo quando la connessione è stabilita o si è verificato
761 un errore. Le possibili cause di errore sono molteplici (ed i relativi codici
762 riportati sopra), quelle che però dipendono dalla situazione della rete e non
763 da errori o problemi nella chiamata della funzione sono le seguenti:
766 \item Il client non riceve risposta al SYN: l'errore restituito è
767 \texttt{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
768 di \texttt{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
769 dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
770 invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
771 di volte che può essere stabilito dall'utente sia con una opportuna
772 \texttt{sysctl} che attraverso il filesystem \texttt{/proc} scrivendo il
773 valore voluto in \texttt{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore di
774 default per la ripetizione dell'invio è di 5 volte, che comporta un timeout
775 dopo circa 180 secondi.
777 % Le informazioni su tutte le opzioni settabili via /proc stanno in
778 % linux/Documentation/networking/ip-sysctl.txt
780 \item Il client riceve come risposta al SYN un RST significa che non c'è
781 nessun programma in ascolto per la connessione sulla porta specificata (il
782 che vuol dire probablmente che o si è sbagliato il numero della porta o che
783 non è stato avviato il server), questo è un errore fatale e la funzione
784 ritorna non appena il RST viene ricevuto riportando un errore
785 \texttt{ECONNREFUSED}.
787 Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
788 dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
789 quando arriva un SYN per una porta che non ha nessun server in ascolto,
790 quando il TCP abortisce una connessione in corso, quandi TCP riceve un
791 segmento per una connessione che non esiste.
793 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
794 destinazione non raggiungibile. In questo caso dato che il messaggio può
795 essere dovuto ad una condizione transitoria si ripete l'emmissione dei SYN
796 come nel caso precedente, fino al timeout, e solo allora si restituisce il
797 codice di errore dovuto al messaggio ICMP, che da luogo ad un
798 \texttt{ENETUNREACH}.
802 Se si fa riferimento al diagramma degli stati del TCP riportato in
803 \figref{fig:appB:tcp_state_diag} la funzione \texttt{connect} porta un socket
804 dallo stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket
805 appena creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento del
806 ACK, nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il
807 socket non è più utilizzabile e deve essere chiuso.
809 Si noti infine che con la funzione \texttt{connect} si è specificato solo
810 indirizzo e porta del server, quindi solo una metà della socket pair; essendo
811 questa funzione usata nei client l'altra metà contentente indirizzo e porta
812 locale viene lasciata all'assegnazione automatica del kernel, e non è
813 necessario effettuare una \texttt{bind}.
816 \subsection{La funzione \texttt{listen}}
817 \label{sec:TCPel_func_listen}
819 La funzione \texttt{listen} è usata per usare un socket in modalità passiva,
820 cioè, come dice il nome, per metterlo in ascolto di eventuali connessioni; in
821 sostanza l'effetto della funzione è di portare il socket dallo stato
822 \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si chiama la funzione in
823 un server dopo le chiamate a \texttt{socket} e \texttt{bind} e prima della
824 chiamata ad \texttt{accept}. Il prototipo della funzione come definito dalla
827 \begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
828 La funzione pone il socket specificato da \texttt{sockfd} in modalità
829 passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
830 a \texttt{backlog}. La funzione si può applicare solo a socket di tipo
831 \texttt{SOCK\_STREAM} o \texttt{SOCK\_SEQPACKET}.
833 La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
834 codici di errore restituiti in \texttt{errno} sono i seguenti:
836 \item \texttt{EBADF} L'argomento \texttt{sockfd} non è un file descriptor
838 \item \texttt{ENOTSOCK} L'argomento \texttt{sockfd} non è un socket.
839 \item \texttt{EOPNOTSUPP} Il socket è di un tipo che non supporta questa
845 Il parametro \texttt{backlog} indica il numero massimo di connessioni pendenti
846 accettate; se esso viene ecceduto il client riceverà una errore di tipo
847 \texttt{ECONNREFUSED}, o se il protocollo, come nel caso del TCP, supporta la
848 ritrasmissione, la richiesta sarà ignorata in modo che la connessione possa
851 Per capire meglio il significato di tutto ciò occorre approfondire la modalità
852 con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
853 infatti vengono mantenute due code:
855 \item Una coda delle connessioni incomplete (\textit{incomplete connection
856 queue} che contiene una entrata per ciascun SYN arrivato per il quale si
857 sta attendendo la conclusione del three-way handshake. Questi socket sono
858 tutti nello stato \texttt{SYN\_RECV}.
859 \item Una coda delle connessioni complete (\textit{complete connection queue}
860 che contiene una entrata per ciascuna connessione per le quali il three-way
861 handshake è stato completato ma ancora \texttt{accept} non è ritornata.
864 Lo schema di funzionamento è descritto in \nfig, quando arriva un SYN da un
865 client il server crea una nuova entrata nella coda delle connessioni
866 incomplete, e poi risponde con il SYN$+$ACK. La entrata resterà nella coda
867 delle connessioni incomplete fino al ricevimento dell'ACK dal client o fino ad
868 un timeout. Nel caso di completamento del three-way handshake l'entrata viene
869 sostata nella coda delle connessioni complete. Quando il processo chiama la
870 funzione \texttt{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
871 entrata nella coda delle connessioni complete è passata al programma, o, se la
872 coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo della
873 prima connessione completa.
875 Storicamente il valore del parametro \texttt{backlog} era corrispondente al
876 massimo valore della somma del numero di entrate possibili per ciascuna di
877 dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
878 valore, e provvede una tabella con i risultati ottenuti con vari kernel,
879 compreso linux 2.0, che mostrano le differenze fra diverse implementazioni.
881 Ma in linux il significato di questo valore è cambiato a partire dal kernel
882 2.2 per prevenire l'attacco chiamato \texttt{syn flood}. Questo si basa
883 sull'emissione da parte dell'attaccante di un grande numero di pacchetti SYN
884 indirizzati verso una porta forgiati con indirizzo IP fasullo \footnote{con la
885 tecnica che viene detta \textit{ip spoofing}} così che i SYN$+$ACK vanno
886 perduti la coda delle connessioni incomplete viene saturata, impedendo di
887 fatto le connessioni.
889 Per ovviare a questo il significato del \texttt{backlog} è stato cambiato a
890 significare la lunghezza della coda delle connessioni complete. La lunghezza
891 della coda delle connessioni incomplete può essere ancora controllata usando
892 la \texttt{sysctl} o scrivendola direttamente in
893 \texttt{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
894 protezione dei syncookies però (con l'opzione da compilare nel kernel e da
895 attivare usando \texttt{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
896 viene ignorato e non esiste più un valore massimo.
898 La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
899 kernel non supportavano neanche valori superiori, ma la situazione corrente è
900 molto cambiata dagli anni '80 e con server web che possono sopportare diversi
901 milioni di connessioni al giorno un tale valore non è più adeguato. Non esiste
902 comunque una risposta univoca per la scelta del valore, per questo non
903 conviene specificare questo valore con una costante (il cui cambiamento
904 richiederebbe la ricompilazione del server) ma usare piuttosto una variabile
905 di ambiente (vedi \secref{sec:xxx_env_var}). Lo Stevens tratta accuratamente
906 questo argomento, con esempi presi da casi reali su web server, ed in
907 particolare evidenzia come non sia più vero che la ragione della coda è quella
908 di gestire il caso in cui il server è occupato fra chiamate successive alla
909 \texttt{accept} (per cui la coda più occupata sarebbe quella delle connessioni
910 compeltate), ma è invece necessaria a gestire la presenza di un gran numero di
911 SYN in attesa di completare il three-way handshake.
913 Come accennato nel caso del TCP se un SYN arriva con tutte le code piene, il
914 pacchetto sarà ignorato. Questo viene fatto perché la condizione delle code
915 piene è transitoria, e se il client ristrasmette il SYN è probabile che
916 passato un po' di tempo possa trovare lo spazio per una nuova connessione. Se
917 invece si rispondesse con un RST la \texttt{connect} del client ritornerebbe
918 con una condizione di errore, mentre questo è il tipico caso in cui è si può
919 lasciare la gestione della connessione alla ritrasmissione prevista dal
923 \subsection{La funzione \texttt{accept}}
924 \label{sec:TCPel_func_accept}
926 La funzione \texttt{accept} è chiamata da un server TCP per gestire la
927 connessione una volta che sia stato completato il three way handshake, la
928 funzione restituisce un nuovo socket descriptor su cui si potrà operare per
929 effettuare la comunicazione. Se non ci sono connessioni completate il processo
930 viene messo in attesa. Il prototipo della funzione è il seguente:
932 \begin{prototype}{sys/socket.h}
933 {int listen(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
934 La funzione estrae la prima connessione relativa al socket \texttt{sockfd}
935 in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
936 con le stesse caratteristiche di \texttt{sockfd} (restituito dalla funzione
937 stessa). Il socket originale non viene toccato. Nella struttura
938 \texttt{addr} e nella variabile \texttt{addrlen} vengono restituiti
939 indirizzo e relativa lunghezza del client che si è connesso.
941 La funzione restituisce un numero di socket descriptor positivo in caso di
942 successo e -1 in caso di errore, nel qual caso la variabile \texttt{errno}
943 viene settata ai seguenti valori:
946 \item \texttt{EBADF} L'argomento \texttt{sockfd} non è un file descriptor
948 \item \texttt{ENOTSOCK} L'argomento \texttt{sockfd} non è un socket.
949 \item \texttt{EOPNOTSUPP} Il socket è di un tipo che non supporta questa
951 \item \texttt{EAGAIN} or \item \texttt{EWOULDBLOCK} Il socket è stato
952 settato come non bloccante, e non ci sono connessioni in attesa di essere
954 \item \texttt{EFAULT} The addr parameter is not in a writable part of the
956 \item \texttt{EPERM} Firewall rules forbid connection.
958 \item \texttt{ENOBUFS, ENOMEM} Not enough free memory. This often means
959 that the memory allocation is limited by the socket buffer limits, not by
962 Inoltre possono essere restituiti gli errori di rete relativi al nuovo
963 socket come: \texttt{EMFILE}, \texttt{EINVAL}, \texttt{ENOSR},
964 \texttt{ENOBUFS}, \texttt{EPERM}, \texttt{ECONNABORTED},
965 \texttt{ESOCKTNOSUPPORT}, \texttt{EPROTONOSUPPORT}, \texttt{ETIMEDOUT},
966 \texttt{ERESTARTSYS}.
971 La funzione può essere usata solo con socket che supportino la connessione
972 (cioè di tipo \texttt{SOCK\_STREAM}, \texttt{SOCK\_SEQPACKET} o
973 \texttt{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
974 esplicita della connessione, (attualmenente in linux solo DECnet ha questo
975 comportamento), la funzione opera solo l'estrazione dalla coda delle
976 connessioni, la conferma della connessione viene fatta implicitamente dalla
977 prima chiamata ad una \texttt{read} o una \texttt{write} mentre il rifiuto
978 della connessione viene fatta con la funzione \texttt{close}.
980 E da chiarire che linux presenta un comportamento diverso nella gestione degli
981 errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
982 \texttt{accept} passa gli errori di rete pendenti sul nuovo socket come codici
983 di errore per \texttt{accept}. Inoltre la funzione non fa ereditare ai nuovi
984 socket flag come \texttt{O_NONBLOCK}, che devono essere rispecificati volta
985 volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
986 deve essere tenuto in conto per scrivere programmi portabili.
988 I due parametri \texttt{cliaddr} e \texttt{addrlen} (si noti che quest'ultimo
989 è passato per indirizzo per avere indietro il valore) sono usati per ottenere
990 l'indirizzo del client da cui proviene la connessione. Prima della chiamata
991 \texttt{addrlen} deve essere inizializzato alle dimensioni della struttura il
992 cui indirizzo è passato come parametro in \texttt{cliaddr}, al ritorno della
993 funzione \texttt{addrlen} conterrà il numero di bytes scritti dentro
994 \texttt{cliaddr}. Se questa informazione non interessa basterà inizializzare a
995 \texttt{NULL} detti puntatori.
997 Se la funzione ha successo restituisce il descrittore di un nuovo socket
998 creato dal kernel (detto \textit{connected socket}) a cui viene associata la
999 prima connessione completa (estratta dalla relativa coda, vedi
1000 \secref{sec:TCPel_func_listen}) che il client TCP ha effettuato verso il
1001 socket \texttt{sockfd}. Quest'ultimo (detto \textit{listening socket}) è
1002 quello creato all'inizio e messo in ascolto con \texttt{listen}, e non viene
1003 toccato dalla funzione.
1005 Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
1006 il processo\footnote{a meno che non si sia settato il socket per essere
1007 non-bloccante, nel qual caso ritorna con l'errore \texttt{EAGAIN},
1008 torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
1009 fintanto che non ne arriva una.
1011 Questo meccanismo è essenziale per capire il funzionamento di un server, in
1012 generale infatti c'è sempre un solo socket in ascolto, che resta per tutto il
1013 tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai
1014 nuovi socket ritornati da \texttt{accept} che sono posti automaticamente nello
1015 stato \texttt{ESTABLISHED} e utilizzati fino alla chiusura della connessione
1016 che avviene su di essi. Si può riconoscere questo schema anche nell'esempio
1017 elementare in \figref{fig:net_serv_code} dove per ogni connessione il socket
1018 creato da \texttt{accept} viene chiuso dopo l'invio dei dati.
1021 \section{Un server concorrente su TCP}
1022 \label{sec:TCPel_cunc_serv}
projects / gapil.git / blob