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