Ancora reindicizzazioni
[gapil.git] / tcpsock.tex
1 bg%% tcpsock.tex
2 %%
3 %% Copyright (C) 2000-2015 Simone Piccardi.  Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Un preambolo",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts.  A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
9 %% License".
10 %%
11
12 \chapter{I socket TCP}
13 \label{cha:TCP_socket}
14
15 In questo capitolo tratteremo le basi dei socket TCP, iniziando con una
16 descrizione delle principali caratteristiche del funzionamento di una
17 connessione TCP; vedremo poi le varie funzioni che servono alla creazione di
18 una connessione fra client e server, fornendo alcuni esempi elementari, e
19 finiremo prendendo in esame l'uso dell'I/O multiplexing.
20
21
22 \section{Il funzionamento di una connessione TCP}
23 \label{sec:TCP_connession}
24
25 Prima di entrare nei dettagli delle singole funzioni usate nelle applicazioni
26 che utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del
27 funzionamento del protocollo, poiché questa conoscenza è essenziale per
28 comprendere il comportamento di dette funzioni per questo tipo di socket, ed
29 il relativo modello di programmazione.
30
31 Si ricordi che il protocollo TCP serve a creare degli \textit{stream socket},
32 cioè una forma di canale di comunicazione che stabilisce una connessione
33 stabile fra due stazioni, in modo che queste possano scambiarsi dei dati. In
34 questa sezione ci concentreremo sulle modalità con le quali il protocollo dà
35 inizio e conclude una connessione e faremo inoltre un breve accenno al
36 significato di alcuni dei vari \textsl{stati} ad essa associati.
37
38
39 \subsection{La creazione della connessione: il \textit{three way handshake}}
40 \label{sec:TCP_conn_cre}
41
42 \itindbeg{three~way~handshake} 
43 Il processo che porta a creare una connessione TCP è chiamato \textit{three
44   way handshake}; la successione tipica degli eventi (e dei
45 \textsl{segmenti}\footnote{si ricordi che il segmento è l'unità elementare di
46   dati trasmessa dal protocollo TCP al livello successivo; tutti i segmenti
47   hanno un header che contiene le informazioni che servono allo \textit{stack
48     TCP} (così viene di solito chiamata la parte del kernel che implementa il
49   protocollo) per realizzare la comunicazione, fra questi dati ci sono una
50   serie di flag usati per gestire la connessione, come SYN, ACK, URG, FIN,
51   alcuni di essi, come SYN (che sta per \textit{syncronize}) corrispondono a
52   funzioni particolari del protocollo e danno il nome al segmento, (per
53   maggiori dettagli vedere sez.~\ref{sec:tcp_protocol}).}  di dati che vengono
54 scambiati) che porta alla creazione di una connessione è la seguente:
55  
56 \begin{enumerate}
57 \item Il server deve essere preparato per accettare le connessioni in arrivo;
58   il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
59   \textit{passive open}). Questo viene fatto chiamando la sequenza di funzioni
60   \func{socket}, \func{bind} e \func{listen}. Completata l'apertura passiva il
61   server chiama la funzione \func{accept} e il processo si blocca in attesa di
62   connessioni.
63   
64 \item Il client richiede l'inizio della connessione usando la funzione
65   \func{connect}, attraverso un procedimento che viene chiamato
66   \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
67   \func{connect} blocca il processo e causa l'invio da parte del client di un
68   segmento SYN, in sostanza viene inviato al server un pacchetto IP che
69   contiene solo gli header IP e TCP (con il numero di sequenza iniziale e il
70   flag SYN) e le opzioni di TCP.
71   
72 \item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del
73   client, inoltre anche il server deve inviare il suo SYN al client (e
74   trasmettere il suo numero di sequenza iniziale) questo viene fatto
75   ritrasmettendo un singolo segmento in cui sono impostati entrambi i flag SYN
76   e ACK.
77   
78 \item una volta che il client ha ricevuto l'acknowledge dal server la funzione
79   \func{connect} ritorna, l'ultimo passo è dare il ricevuto del SYN del
80   server inviando un ACK. Alla ricezione di quest'ultimo la funzione
81   \func{accept} del server ritorna e la connessione è stabilita.
82 \end{enumerate} 
83
84 Il procedimento viene chiamato \textit{three way handshake} dato che per
85 realizzarlo devono essere scambiati tre segmenti.  In fig.~\ref{fig:TCP_TWH}
86 si è rappresentata graficamente la sequenza di scambio dei segmenti che
87 stabilisce la connessione.
88
89 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
90 % sistema del telefono. La funzione \func{socket} può essere considerata
91 % l'equivalente di avere un telefono. La funzione \func{bind} è analoga al
92 % dire alle altre persone qual è il proprio numero di telefono perché possano
93 % chiamare. La funzione \func{listen} è accendere il campanello del telefono
94 % per sentire le chiamate in arrivo.  La funzione \func{connect} richiede di
95 % conoscere il numero di chi si vuole chiamare. La funzione \func{accept} è
96 % quando si risponde al telefono.
97
98 \begin{figure}[!htb]
99   \centering \includegraphics[width=10cm]{img/three_way_handshake}  
100   \caption{Il \textit{three way handshake} del TCP.}
101   \label{fig:TCP_TWH}
102 \end{figure}
103
104 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
105 riportati in fig.~\ref{fig:TCP_TWH}): per gestire una connessione affidabile
106 infatti il protocollo TCP prevede nell'header la presenza di un numero a 32
107 bit (chiamato appunto \textit{sequence number}) che identifica a quale byte
108 nella sequenza del flusso corrisponde il primo byte della sezione dati
109 contenuta nel segmento.
110
111 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
112 \textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
113 all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
114 ciascun segmento viene effettuato dall'altro capo della connessione impostando
115 il flag ACK e restituendo nell'apposito campo dell'header un
116 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
117 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
118 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
119 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
120 varrà anche (vedi fig.~\ref{fig:TCP_close}) per l'acknowledgement di un FIN.
121
122 \itindend{three~way~handshake}
123
124
125 \subsection{Le opzioni TCP.}
126 \label{sec:TCP_TCP_opt}
127
128 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP,
129 le cosiddette \textit{TCP options},\footnote{da non confondere con le opzioni
130   dei socket TCP che tratteremo in sez.~\ref{sec:sock_tcp_udp_options}, in
131   questo caso si tratta delle opzioni che vengono trasmesse come parte di un
132   pacchetto TCP, non delle funzioni che consentono di impostare i relativi
133   valori.} che vengono inserite fra l'header e i dati, e che servono a
134 comunicare all'altro capo una serie di parametri utili a regolare la
135 connessione.  Normalmente vengono usate le seguenti opzioni:
136
137 \begin{itemize}
138 \item \textit{MSS option}, dove MMS sta per
139   \itindex{Maximum~Segment~Size~(MSS)} \textit{Maximum Segment Size}, con
140   questa opzione ciascun capo della connessione annuncia all'altro il massimo
141   ammontare di dati che vorrebbe accettare per ciascun segmento nella
142   connessione corrente. È possibile leggere e scrivere questo valore
143   attraverso l'opzione del socket \const{TCP\_MAXSEG} (vedi
144   sez.~\ref{sec:sock_tcp_udp_options}).
145   
146 \item \textit{window scale option}, il protocollo TCP implementa il controllo
147   di flusso attraverso una \textit{advertised window} (la ``\textsl{finestra
148     annunciata}'', vedi sez.~\ref{sec:tcp_protocol_xxx}) con la quale ciascun
149   capo della comunicazione dichiara quanto spazio disponibile ha in memoria
150   per i dati.  Questo è un numero a 16 bit dell'header, che così può indicare
151   un massimo di 65535 byte;\footnote{in Linux il massimo è 32767 per evitare
152     problemi con alcune implementazioni che usano l'aritmetica con segno per
153     implementare lo stack TCP.} ma alcuni tipi di connessione come quelle ad
154   alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi ritardi nel
155   cammino dei pacchetti (come i satelliti) richiedono una finestra più grande
156   per poter ottenere il massimo dalla trasmissione. Per questo esiste questa
157   opzione che indica un fattore di scala da applicare al valore della finestra
158   annunciata\footnote{essendo una nuova opzione per garantire la compatibilità
159     con delle vecchie implementazioni del protocollo la procedura che la
160     attiva prevede come negoziazione che l'altro capo della connessione
161     riconosca esplicitamente l'opzione inserendola anche lui nel suo SYN di
162     risposta dell'apertura della connessione.} per la connessione corrente
163   (espresso come numero di bit cui spostare a sinistra il valore della
164   finestra annunciata inserito nel pacchetto). Con Linux è possibile indicare
165   al kernel di far negoziare il fattore di scala in fase di creazione di una
166   connessione tramite la \textit{sysctl} \itindex{TCP~window~scaling}
167   \texttt{tcp\_window\_scaling} (vedi
168   sez.~\ref{sec:sock_ipv4_sysctl}).\footnote{per poter usare questa
169     funzionalità è comunque necessario ampliare le dimensioni dei buffer di
170     ricezione e spedizione, cosa che può essere fatta sia a livello di sistema
171     con le opportune \textit{sysctl} (vedi sez.~\ref{sec:sock_ipv4_sysctl})
172     che a livello di singoli socket con le relative opzioni (vedi
173     sez.~\ref{sec:sock_tcp_udp_options}).}
174
175 \item \textit{timestamp option}, è anche questa una nuova opzione necessaria
176   per le connessioni ad alta velocità per evitare possibili corruzioni di dati
177   dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
178   la precedente.
179
180 \end{itemize}
181
182 La MSS \itindex{Maximum~Segment~Size~(MSS)} è generalmente supportata da quasi
183 tutte le implementazioni del protocollo, le ultime due opzioni (trattate
184 nell'\href{http://www.ietf.org/rfc/rfc1323.txt}{RFC~1323}) sono meno comuni;
185 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
186 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
187 elevati. In ogni caso Linux supporta pienamente entrambe le opzioni.
188
189
190 \subsection{La terminazione della connessione}
191 \label{sec:TCP_conn_term}
192
193 Mentre per la creazione di una connessione occorre un interscambio di tre
194 segmenti, la procedura di chiusura ne richiede normalmente quattro. In questo
195 caso la successione degli eventi è la seguente:
196
197 \begin{enumerate}
198 \item Un processo ad uno dei due capi chiama la funzione \func{close}, dando
199   l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o
200   \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
201   serve ad indicare che si è finito con l'invio dei dati sulla connessione.
202   
203 \item L'altro capo della connessione riceve il FIN e dovrà eseguire la
204   \textsl{chiusura passiva} (o \textit{passive close}). Al FIN, come ad ogni
205   altro pacchetto, viene risposto con un ACK, inoltre il ricevimento del FIN
206   viene segnalato al processo che ha aperto il socket (dopo che ogni altro
207   eventuale dato rimasto in coda è stato ricevuto) come un end-of-file sulla
208   lettura: questo perché il ricevimento di un FIN significa che non si
209   riceveranno altri dati sulla connessione.
210   
211 \item Una volta rilevata l'end-of-file anche il secondo processo chiamerà la
212   funzione \func{close} sul proprio socket, causando l'emissione di un altro
213   segmento FIN.
214
215 \item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
216   con un ACK.
217 \end{enumerate}
218
219 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
220 normalmente i segmenti scambiati sono quattro.  Questo non è vero sempre
221 giacché in alcune situazioni il FIN del passo 1) è inviato insieme a dei dati.
222 Inoltre è possibile che i segmenti inviati nei passi 2 e 3 dal capo che
223 effettua la chiusura passiva, siano accorpati in un singolo segmento. In
224 fig.~\ref{fig:TCP_close} si è rappresentato graficamente lo sequenza di
225 scambio dei segmenti che conclude la connessione.
226
227 \begin{figure}[!htb]
228   \centering \includegraphics[width=10cm]{img/tcp_close}  
229   \caption{La chiusura di una connessione TCP.}
230   \label{fig:TCP_close}
231 \end{figure}
232
233 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
234 l'ACK riporterà un \textit{acknowledge number} incrementato di uno. 
235
236 Si noti che, nella sequenza di chiusura, fra i passi 2 e 3, è in teoria
237 possibile che si mantenga un flusso di dati dal capo della connessione che
238 deve ancora eseguire la chiusura passiva a quello che sta eseguendo la
239 chiusura attiva.  Nella sequenza indicata i dati verrebbero persi, dato che si
240 è chiuso il socket dal lato che esegue la chiusura attiva; esistono tuttavia
241 situazioni in cui si vuole poter sfruttare questa possibilità, usando una
242 procedura che è chiamata \itindex{half-close} \textit{half-close}; torneremo
243 su questo aspetto e su come utilizzarlo in sez.~\ref{sec:TCP_shutdown}, quando
244 parleremo della funzione \func{shutdown}.
245
246 La emissione del FIN avviene quando il socket viene chiuso, questo però non
247 avviene solo per la chiamata esplicita della funzione \func{close}, ma anche
248 alla terminazione di un processo, quando tutti i file vengono chiusi.  Questo
249 comporta ad esempio che se un processo viene terminato da un segnale tutte le
250 connessioni aperte verranno chiuse.
251
252 Infine occorre sottolineare che, benché nella figura (e nell'esempio che
253 vedremo più avanti in sez.~\ref{sec:TCP_echo}) sia stato il client ad eseguire
254 la chiusura attiva, nella realtà questa può essere eseguita da uno qualunque
255 dei due capi della comunicazione (come nell'esempio di
256 fig.~\ref{fig:TCP_daytime_iter_server_code}), e anche se il caso più comune
257 resta quello del client, ci sono alcuni servizi, il principale dei quali è
258 l'HTTP, per i quali è il server ad effettuare la chiusura attiva.
259
260
261 \subsection{Un esempio di connessione}
262 \label{sec:TCP_conn_dia}
263
264 Come abbiamo visto le operazioni del TCP nella creazione e conclusione di una
265 connessione sono piuttosto complesse, ed abbiamo esaminato soltanto quelle
266 relative ad un andamento normale.  In sez.~\ref{sec:TCP_states} vedremo con
267 maggiori dettagli che una connessione può assumere vari stati, che ne
268 caratterizzano il funzionamento, e che sono quelli che vengono riportati dal
269 comando \cmd{netstat}, per ciascun socket TCP aperto, nel campo
270 \textit{State}.
271
272 Non possiamo affrontare qui una descrizione completa del funzionamento del
273 protocollo; un approfondimento sugli aspetti principali si trova in
274 sez.~\ref{sec:tcp_protocol}, ma per una trattazione completa il miglior
275 riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un
276 semplice esempio di connessione e le transizioni che avvengono nei due casi
277 appena citati (creazione e terminazione della connessione).
278
279 In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
280 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
281 diventa \texttt{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
282 emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
283 finale in cui avviene la gran parte del trasferimento dei dati.
284
285 Dal lato server in genere invece il passaggio che si opera con l'apertura
286 passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
287 stato \texttt{LISTEN} in cui vengono accettate le connessioni.
288
289 Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
290 chiama la funzione \func{close} prima di aver ricevuto un
291 \textit{end-of-file} (chiusura attiva) la transizione è verso lo stato
292 \texttt{FIN\_WAIT\_1}; se invece l'applicazione riceve un FIN nello stato
293 \texttt{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato
294 \texttt{CLOSE\_WAIT}.
295
296 In fig.~\ref{fig:TCP_conn_example} è riportato lo schema dello scambio dei
297 pacchetti che avviene per una un esempio di connessione, insieme ai vari stati
298 che il protocollo viene ad assumere per i due lati, server e client.
299
300 \begin{figure}[!htb]
301   \centering \includegraphics[width=9cm]{img/tcp_connection}  
302   \caption{Schema dello scambio di pacchetti per un esempio di connessione.}
303   \label{fig:TCP_conn_example}
304 \end{figure}
305
306 La connessione viene iniziata dal client che annuncia una
307 \itindex{Maximum~Segment~Size~(MSS)} MSS di 1460, un valore tipico con Linux
308 per IPv4 su Ethernet, il server risponde con lo stesso valore (ma potrebbe
309 essere anche un valore diverso).
310
311 Una volta che la connessione è stabilita il client scrive al server una
312 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
313 1460 byte annunciati dal server), quest'ultimo riceve la richiesta e
314 restituisce una risposta (che di nuovo supponiamo stare in un singolo
315 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
316 risposta: questo viene chiamato \textit{piggybacking} ed avviene tutte le
317 volte che il server è sufficientemente veloce a costruire la risposta; in
318 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
319 risposta.
320
321 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
322 secondo quanto visto in sez.~\ref{sec:TCP_conn_term}; si noti che il capo della
323 connessione che esegue la chiusura attiva entra nello stato
324 \texttt{TIME\_WAIT}, sul cui significato torneremo fra poco.
325
326 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
327 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
328 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
329 costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
330 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
331 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
332 trasporto all'interno dell'applicazione.
333
334 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
335 si hanno in una applicazione di rete, perché non è detto che TCP sia la
336 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
337 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
338 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
339 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
340 dati rispondono meglio alle esigenze che devono essere affrontate.
341
342 \subsection{Lo stato \texttt{TIME\_WAIT}}
343 \label{sec:TCP_time_wait}
344
345 Come riportato da Stevens in \cite{UNP1} lo stato \texttt{TIME\_WAIT} è
346 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
347 comune trovare domande su come sia possibile evitare che un'applicazione resti
348 in questo stato lasciando attiva una connessione ormai conclusa; la risposta è
349 che non deve essere fatto, ed il motivo cercheremo di spiegarlo adesso.
350
351 Come si è visto nell'esempio precedente (vedi fig.~\ref{fig:TCP_conn_example})
352 \texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che
353 esegue la chiusura attiva resta prima di passare alla chiusura definitiva
354 della connessione. Il tempo in cui l'applicazione resta in questo stato deve
355 essere due volte la MSL (\textit{Maximum Segment Lifetime}).
356
357 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
358 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
359 ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
360 Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
361 IP (per maggiori dettagli vedi sez.~\ref{sec:ip_protocol}), e viene
362 decrementato ad ogni passaggio da un router; quando si annulla il pacchetto
363 viene scartato.  Siccome il numero è ad 8 bit il numero massimo di
364 ``\textsl{salti}'' è di 255, pertanto anche se il TTL (da \textit{time to
365   live}) non è propriamente un limite sul tempo di vita, si stima che un
366 pacchetto IP non possa restare nella rete per più di MSL secondi.
367
368 Ogni implementazione del TCP deve scegliere un valore per la MSL
369 (l'\href{http://www.ietf.org/rfc/rfc1122.txt}{RFC~1122} raccomanda 2 minuti,
370 Linux usa 30 secondi), questo comporta una durata dello stato
371 \texttt{TIME\_WAIT} che a seconda delle implementazioni può variare fra 1 a 4
372 minuti.  Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due
373 motivi principali:
374 \begin{enumerate}
375 \item implementare in maniera affidabile la terminazione della connessione
376   in entrambe le direzioni.
377 \item consentire l'eliminazione dei segmenti duplicati dalla rete. 
378 \end{enumerate}
379
380 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
381 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
382 capisce il perché della scelta di un tempo pari al doppio della MSL come
383 durata di questo stato.
384
385 Il primo dei due motivi precedenti si può capire tornando a
386 fig.~\ref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza
387 (quello del capo che ha eseguito la chiusura attiva) venga perso, chi esegue
388 la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per
389 questo motivo chi esegue la chiusura attiva deve mantenere lo stato della
390 connessione per essere in grado di reinviare l'ACK e chiuderla correttamente.
391 Se non fosse così la risposta sarebbe un RST (un altro tipo si segmento) che
392 verrebbe interpretato come un errore.
393
394 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
395 connessione allora deve essere in grado di affrontare la perdita di uno
396 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
397 motivo un socket deve rimanere attivo nello stato \texttt{TIME\_WAIT} anche
398 dopo l'invio dell'ultimo ACK, per potere essere in grado di gestirne
399 l'eventuale ritrasmissione, in caso esso venga perduto.
400
401 Il secondo motivo è più complesso da capire, e necessita di una spiegazione
402 degli scenari in cui può accadere che i pacchetti TCP si possano perdere nella
403 rete o restare intrappolati, per poi riemergere in un secondo tempo.
404
405 Il caso più comune in cui questo avviene è quello di anomalie
406 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
407 una connessione fra due router si interrompa. In questo caso i protocolli di
408 instradamento dei pacchetti possono impiegare diverso tempo (anche dell'ordine
409 dei minuti) prima di trovare e stabilire un percorso alternativo per i
410 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
411 pacchetti verso un altro e quest'ultimo li rispedisce indietro, o li manda ad
412 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
413 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
414
415 Se uno di questi pacchetti intrappolati è un segmento TCP, chi l'ha inviato,
416 non ricevendo un ACK in risposta, provvederà alla ritrasmissione e se nel
417 frattempo sarà stata stabilita una strada alternativa il pacchetto ritrasmesso
418 giungerà a destinazione.
419
420 Ma se dopo un po' di tempo (che non supera il limite dell'MSL, dato che
421 altrimenti verrebbe ecceduto il TTL) l'anomalia viene a cessare, il circolo di
422 instradamento viene spezzato i pacchetti intrappolati potranno essere inviati
423 alla destinazione finale, con la conseguenza di avere dei pacchetti duplicati;
424 questo è un caso che il TCP deve essere in grado di gestire.
425
426 Allora per capire la seconda ragione per l'esistenza dello stato
427 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
428 connessione fra l'IP \texttt{195.110.112.236} porta 1550 e l'IP
429 \texttt{192.84.145.100} porta 22 (affronteremo il significato delle porte
430 nella prossima sezione), che questa venga chiusa e che poco dopo si
431 ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte
432 (quella che viene detta, essendo gli stessi porte e numeri IP, una nuova
433 \textsl{incarnazione} della connessione precedente); in questo caso ci si
434 potrebbe trovare con dei pacchetti duplicati relativi alla precedente
435 connessione che riappaiono nella nuova.
436
437 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
438 creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
439 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
440 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
441 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
442 sicuri che lo stesso avvenga per le risposte nella direzione opposta.
443
444 In questo modo, prima che venga creata una nuova connessione, il protocollo
445 TCP si assicura che tutti gli eventuali segmenti residui di una precedente
446 connessione, che potrebbero causare disturbi, siano stati eliminati dalla
447 rete.
448
449
450 \subsection{I numeri di porta}
451 \label{sec:TCP_port_num}
452
453 In un ambiente multitasking in un dato momento più processi devono poter usare
454 sia UDP che TCP, e ci devono poter essere più connessioni in contemporanea.
455 Per poter tenere distinte le diverse connessioni entrambi i protocolli usano i
456 \textsl{numeri di porta}, che fanno parte, come si può vedere in
457 sez.~\ref{sec:sock_sa_ipv4} e sez.~\ref{sec:sock_sa_ipv6} pure delle strutture
458 degli indirizzi del socket.
459
460 Quando un client contatta un server deve poter identificare con quale dei vari
461 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
462 di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
463 identificano una serie di servizi noti (ad esempio la porta 22 identifica il
464 servizio SSH) effettuati da appositi server che rispondono alle connessioni
465 verso tali porte.
466
467 D'altra parte un client non ha necessità di usare un numero di porta
468 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
469   effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
470 nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
471 creazione della connessione. Queste sono dette effimere in quanto vengono
472 usate solo per la durata della connessione, e l'unico requisito che deve
473 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
474
475 La lista delle porte conosciute è definita
476 dall'\href{http://www.ietf.org/rfc/rfc1700.txt}{RFC~1700} che contiene
477 l'elenco delle porte assegnate dalla IANA (la \textit{Internet Assigned Number
478   Authority}) ma l'elenco viene costantemente aggiornato e pubblicato su
479 internet (una versione aggiornata si può trovare all'indirizzo
480 \url{http://www.iana.org/assignments/port-numbers}); inoltre in un sistema
481 unix-like un analogo elenco viene mantenuto nel file \conffile{/etc/services},
482 con la corrispondenza fra i vari numeri di porta ed il nome simbolico del
483 servizio.  I numeri sono divisi in tre intervalli:
484
485 \begin{enumerate*}
486 \item \textsl{le porte note}. I numeri da 0 a 1023. Queste sono controllate e
487   assegnate dalla IANA. Se è possibile la stessa porta è assegnata allo stesso
488   servizio sia su UDP che su TCP (ad esempio la porta 22 è assegnata a SSH su
489   entrambi i protocolli, anche se viene usata solo dal TCP).
490   
491 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
492   sono controllate dalla IANA, che però registra ed elenca chi usa queste
493   porte come servizio agli utenti. Come per le precedenti si assegna una porta
494   ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
495   solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
496   anche se il protocollo è implementato solo tramite TCP.
497   
498 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
499   65535. La IANA non dice nulla riguardo a queste porte che pertanto
500   sono i candidati naturali ad essere usate come porte effimere.
501 \end{enumerate*}
502
503 In realtà rispetto a quanto indicato
504 nell'\href{http://www.ietf.org/rfc/rfc1700.txt}{RFC~1700} i vari sistemi hanno
505 fatto scelte diverse per le porte effimere, in particolare in
506 fig.~\ref{fig:TCP_port_alloc} sono riportate quelle di BSD e Linux.
507
508 \begin{figure}[!htb]
509   \centering \includegraphics[width=13cm]{img/port_alloc}  
510   \caption{Allocazione dei numeri di porta.}
511   \label{fig:TCP_port_alloc}
512 \end{figure}
513
514 I sistemi Unix hanno inoltre il concetto di \textsl{porte riservate} (che
515 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
516 \textsl{porte note}). La loro caratteristica è che possono essere assegnate a
517 un socket solo da un processo con i privilegi di amministratore, per far sì
518 che solo l'amministratore possa allocare queste porte per far partire i
519 relativi servizi.
520
521 Le \textsl{glibc} definiscono in \headfile{netinet/in.h}
522 \const{IPPORT\_RESERVED} e \const{IPPORT\_USERRESERVED}, in cui la prima (che
523 vale 1024) indica il limite superiore delle porte riservate, e la seconda (che
524 vale 5000) il limite inferiore delle porte a disposizione degli utenti.  La
525 convenzione vorrebbe che le porte \textsl{effimere} siano allocate fra questi
526 due valori. Nel caso di Linux questo è vero solo in uno dei due casi di
527 fig.~\ref{fig:TCP_port_alloc}, e la scelta fra i due possibili intervalli
528 viene fatta dinamicamente dal kernel a seconda della memoria disponibile per
529 la gestione delle relative tabelle.
530
531 Si tenga conto poi che ci sono alcuni client, in particolare \cmd{rsh} e
532 \cmd{rlogin}, che richiedono una connessione su una porta riservata anche dal
533 lato client come parte dell'autenticazione, contando appunto sul fatto che
534 solo l'amministratore può usare queste porte. Data l'assoluta inconsistenza in
535 termini di sicurezza di un tale metodo, al giorno d'oggi esso è in completo
536 disuso.
537
538 Data una connessione TCP si suole chiamare \textit{socket pair}\footnote{da
539   non confondere con la coppia di socket della omonima funzione
540   \func{socketpair} che fanno riferimento ad una coppia di socket sulla stessa
541   macchina, non ai capi di una connessione TCP.} la combinazione dei quattro
542 numeri che definiscono i due capi della connessione e cioè l'indirizzo IP
543 locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota.
544 Questa combinazione, che scriveremo usando una notazione del tipo
545 (\texttt{195.110.112.152:22}, \texttt{192.84.146.100:20100}), identifica
546 univocamente una connessione su internet.  Questo concetto viene di solito
547 esteso anche a UDP, benché in questo caso non abbia senso parlare di
548 connessione. L'utilizzo del programma \cmd{netstat} permette di visualizzare
549 queste informazioni nei campi \textit{Local Address} e \textit{Foreing
550   Address}.
551
552
553 \subsection{Le porte ed il modello client/server}
554 \label{sec:TCP_port_cliserv}
555
556 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
557 che fare con un'applicazione client/server (come quelle che descriveremo in
558 sez.~\ref{sec:TCP_daytime_application} e sez.~\ref{sec:TCP_echo_application})
559 esamineremo cosa accade con le connessioni nel caso di un server TCP che deve
560 gestire connessioni multiple.
561
562 Se eseguiamo un \cmd{netstat} su una macchina di prova (il cui indirizzo sia
563 \texttt{195.110.112.152}) potremo avere un risultato del tipo:
564 \begin{verbatim}
565 Active Internet connections (servers and established)
566 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
567 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
568 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
569 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
570 \end{verbatim}
571 essendo presenti e attivi un server SSH, un server di posta e un DNS per il
572 caching locale.
573
574 Questo ci mostra ad esempio che il server SSH ha compiuto un'apertura passiva,
575 mettendosi in ascolto sulla porta 22 riservata a questo servizio, e che si è
576 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
577 associati alle interfacce locali. La notazione \texttt{0.0.0.0} usata da
578 \cmd{netstat} è equivalente all'asterisco utilizzato per il numero di porta,
579 indica il valore generico, e corrisponde al valore \const{INADDR\_ANY}
580 definito in \headfiled{arpa/inet.h} (vedi \ref{tab:TCP_ipv4_addr}).
581
582 Inoltre si noti come la porta e l'indirizzo di ogni eventuale connessione
583 esterna non sono specificati; in questo caso la \textit{socket pair} associata
584 al socket potrebbe essere indicata come (\texttt{*:22}, \texttt{*:*}), usando
585 anche per gli indirizzi l'asterisco come carattere che indica il valore
586 generico.
587
588 Dato che in genere una macchina è associata ad un solo indirizzo IP, ci si può
589 chiedere che senso abbia l'utilizzo dell'indirizzo generico per specificare
590 l'indirizzo locale; ma a parte il caso di macchine che hanno più di un
591 indirizzo IP (il cosiddetto \textit{multihoming}) esiste sempre anche
592 l'indirizzo di loopback, per cui con l'uso dell'indirizzo generico si possono
593 accettare connessioni indirizzate verso uno qualunque degli indirizzi IP
594 presenti. Ma, come si può vedere nell'esempio con il DNS che è in ascolto
595 sulla porta 53, è possibile anche restringere l'accesso ad uno specifico
596 indirizzo, cosa che nel caso è fatta accettando solo connessioni che arrivino
597 sull'interfaccia di loopback.
598
599 Una volta che ci si vorrà collegare a questa macchina da un'altra, per esempio
600 quella con l'indirizzo \texttt{192.84.146.100}, si dovrà lanciare su
601 quest'ultima un client \cmd{ssh} per creare una connessione, e il kernel gli
602 assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà
603 espressa dalla socket pair (\texttt{192.84.146.100:21100},
604 \texttt{195.110.112.152:22}).
605
606 Alla ricezione della richiesta dal client il server creerà un processo figlio
607 per gestire la connessione, se a questo punto eseguiamo nuovamente il
608 programma \cmd{netstat} otteniamo come risultato:
609 \begin{verbatim}
610 Active Internet connections (servers and established)
611 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
612 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
613 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
614 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
615 tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
616 \end{verbatim}
617
618 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
619 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che utilizza anch'esso
620 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
621 il processo figlio gestisce la connessione mentre il padre resta in ascolto
622 sul socket originale.
623
624 Se a questo punto lanciamo un'altra volta il client \cmd{ssh} per una seconda
625 connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
626 genere:
627 \begin{verbatim}
628 Active Internet connections (servers and established)
629 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
630 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
631 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
632 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
633 tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
634 tcp        0      0 195.110.112.152:22      192.84.146.100:21101    ESTABLISHED
635 \end{verbatim}
636 cioè il client effettuerà la connessione usando un'altra porta effimera: con
637 questa sarà aperta la connessione, ed il server creerà un altro processo
638 figlio per gestirla.
639
640 Tutto ciò mostra come il TCP, per poter gestire le connessioni con un server
641 concorrente, non può suddividere i pacchetti solo sulla base della porta di
642 destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
643 compresa la porta dell'indirizzo remoto.  E se andassimo a vedere quali sono i
644 processi\footnote{ad esempio con il comando \cmd{fuser}, o con \cmd{lsof}, o
645   usando l'opzione \texttt{-p}.} a cui fanno riferimento i vari socket
646 vedremmo che i pacchetti che arrivano dalla porta remota 21100 vanno al primo
647 figlio e quelli che arrivano alla porta 21101 al secondo.
648
649
650 \section{Le funzioni di base per la gestione dei socket}
651 \label{sec:TCP_functions}
652
653 In questa sezione descriveremo in maggior dettaglio le varie funzioni che
654 vengono usate per la gestione di base dei socket TCP, non torneremo però sulla
655 funzione \func{socket}, che è già stata esaminata accuratamente nel capitolo
656 precedente in sez.~\ref{sec:sock_creation}.
657
658
659 \subsection{La funzione \func{bind}}
660 \label{sec:TCP_func_bind}
661
662 La funzione \funcd{bind} assegna un indirizzo locale ad un
663 socket.\footnote{nel nostro caso la utilizzeremo per socket TCP, ma la
664   funzione è generica e deve essere usata per qualunque tipo di socket
665   \const{SOCK\_STREAM} prima che questo possa accettare connessioni.} È usata
666 cioè per specificare la prima parte dalla socket pair.  Viene usata sul lato
667 server per specificare la porta (e gli eventuali indirizzi locali) su cui poi
668 ci si porrà in ascolto. Il prototipo della funzione è il seguente:
669 \begin{prototype}{sys/socket.h}
670 {int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)}
671   
672   Assegna un indirizzo ad un socket.
673   
674   \bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore;
675     in caso di errore la variabile \var{errno} viene impostata secondo i
676     seguenti codici di errore:
677   \begin{errlist}
678   \item[\errcode{EBADF}] il file descriptor non è valido.
679   \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato.
680   \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
681   \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
682     sufficienti privilegi.
683   \item[\errcode{EADDRNOTAVAIL}] il tipo di indirizzo specificato non è
684     disponibile.
685   \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
686   \end{errlist}
687   ed anche \errval{EFAULT} e per i socket di tipo \const{AF\_UNIX},
688   \errval{ENOTDIR}, \errval{ENOENT}, \errval{ENOMEM}, \errval{ELOOP},
689   \errval{ENOSR} e \errval{EROFS}.}
690 \end{prototype}
691
692 Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
693 \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
694 l'indirizzo (locale) del socket e la dimensione della struttura che lo
695 contiene, secondo quanto già trattato in sez.~\ref{sec:sock_sockaddr}. 
696
697 Con i socket TCP la chiamata \func{bind} permette di specificare l'indirizzo,
698 la porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
699 nota che assegnano all'avvio, se questo non viene fatto è il kernel a
700 scegliere una porta effimera quando vengono eseguite la funzioni
701 \func{connect} o \func{listen}, ma se questo è normale per il client non lo è
702 per il server\footnote{un'eccezione a tutto ciò sono i server che usano RPC.
703   In questo caso viene fatta assegnare dal kernel una porta effimera che poi
704   viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
705   demone che deve essere contattato dai client per ottenere la porta effimera
706   su cui si trova il server.} che in genere viene identificato dalla porta su
707 cui risponde (l'elenco di queste porte, e dei relativi servizi, è in
708 \conffile{/etc/services}).
709
710 Con \func{bind} si può assegnare un indirizzo IP specifico ad un socket,
711 purché questo appartenga ad una interfaccia della macchina.  Per un client TCP
712 questo diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati
713 sul socket, mentre per un server TCP questo restringerà l'accesso al socket
714 solo alle connessioni che arrivano verso tale indirizzo.
715
716 Normalmente un client non specifica mai l'indirizzo di un socket, ed il kernel
717 sceglie l'indirizzo di origine quando viene effettuata la connessione, sulla
718 base dell'interfaccia usata per trasmettere i pacchetti, (che dipenderà dalle
719 regole di instradamento usate per raggiungere il server).  Se un server non
720 specifica il suo indirizzo locale il kernel userà come indirizzo di origine
721 l'indirizzo di destinazione specificato dal SYN del client.
722
723 Per specificare un indirizzo generico, con IPv4 si usa il valore
724 \const{INADDR\_ANY}, il cui valore, come accennato in
725 sez.~\ref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
726 fig.~\ref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione
727 immediata del tipo: \includecodesnip{listati/serv_addr_sin_addr.c}
728
729 Si noti che si è usato \func{htonl} per assegnare il valore
730 \const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
731 inutile.  Si tenga presente comunque che tutte le costanti \val{INADDR\_}
732 (riportate in tab.~\ref{tab:TCP_ipv4_addr}) sono definite secondo
733 l'\textit{endianness} della macchina, ed anche se esse possono essere
734 invarianti rispetto all'ordinamento dei bit, è comunque buona norma usare
735 sempre la funzione \func{htonl}.
736
737 \begin{table}[htb]
738   \centering
739   \footnotesize
740   \begin{tabular}[c]{|l|l|}
741     \hline
742     \textbf{Costante} & \textbf{Significato} \\
743     \hline
744     \hline
745     \const{INADDR\_ANY}      & Indirizzo generico (\texttt{0.0.0.0})\\
746     \const{INADDR\_BROADCAST}& Indirizzo di \textit{broadcast}.\\ 
747     \const{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback}
748                                (\texttt{127.0.0.1}).\\ 
749     \const{INADDR\_NONE}     & Indirizzo errato.\\
750     \hline    
751   \end{tabular}
752   \caption{Costanti di definizione di alcuni indirizzi generici per IPv4.}
753   \label{tab:TCP_ipv4_addr}
754 \end{table}
755
756 L'esempio precedente funziona correttamente con IPv4 poiché che l'indirizzo è
757 rappresentabile anche con un intero a 32 bit; non si può usare lo stesso
758 metodo con IPv6, in cui l'indirizzo deve necessariamente essere specificato
759 con una struttura, perché il linguaggio C non consente l'uso di una struttura
760 costante come operando a destra in una assegnazione.
761
762 Per questo motivo nell'header \headfile{netinet/in.h} è definita una variabile
763 \macro{in6addr\_any} (dichiarata come \dirct{extern}, ed inizializzata dal
764 sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
765 assegnazione del tipo: \includecodesnip{listati/serv_addr_sin6_addr.c} in
766 maniera analoga si può utilizzare la variabile \macro{in6addr\_loopback} per
767 indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata
768 staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}.
769
770
771 \subsection{La funzione \func{connect}}
772 \label{sec:TCP_func_connect}
773
774 La funzione \funcd{connect} è usata da un client TCP per stabilire la
775 connessione con un server TCP,\footnote{di nuovo la funzione è generica e
776   supporta vari tipi di socket, la differenza è che per socket senza
777   connessione come quelli di tipo \const{SOCK\_DGRAM} la sua chiamata si
778   limiterà ad impostare l'indirizzo dal quale e verso il quale saranno inviati
779   e ricevuti i pacchetti, mentre per socket di tipo \const{SOCK\_STREAM} o
780   \const{SOCK\_SEQPACKET}, essa attiverà la procedura di avvio (nel caso del
781   TCP il \itindex{three~way~handshake} \textit{three way handshake}) della
782   connessione.}  il prototipo della funzione è il seguente:
783 \begin{prototype}{sys/socket.h}
784   {int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t
785     addrlen)}
786   
787   Stabilisce una connessione fra due socket.
788   
789   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
790     errore, nel qual caso \var{errno} assumerà i valori:
791   \begin{errlist}
792   \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
793     remoto.
794   \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
795     connessione.
796   \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
797   \item[\errcode{EINPROGRESS}] il socket è non bloccante (vedi
798     sez.~\ref{sec:file_noblocking}) e la connessione non può essere conclusa
799     immediatamente.
800   \item[\errcode{EALREADY}] il socket è non bloccante (vedi
801     sez.~\ref{sec:file_noblocking}) e un tentativo precedente di connessione
802     non si è ancora concluso.
803   \item[\errcode{EAGAIN}] non ci sono più porte locali libere. 
804   \item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
805     corretta nel relativo campo.
806   \item[\errcode{EACCES}, \errcode{EPERM}] si è tentato di eseguire una
807     connessione ad un indirizzo \textit{broadcast} senza che il socket fosse
808     stato abilitato per il \textit{broadcast}.
809   \end{errlist}
810   altri errori possibili sono: \errval{EFAULT}, \errval{EBADF},
811   \errval{ENOTSOCK}, \errval{EISCONN} e \errval{EADDRINUSE}.}
812 \end{prototype}
813
814 Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
815 \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
816 l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
817 socket, già descritta in sez.~\ref{sec:sock_sockaddr}.
818
819 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
820 numero di porta del server a cui ci si vuole connettere, come mostrato
821 nell'esempio sez.~\ref{sec:TCP_daytime_client}, usando le funzioni illustrate
822 in sez.~\ref{sec:sock_addr_func}.
823
824 Nel caso di socket TCP la funzione \func{connect} avvia il
825 \itindex{three~way~handshake} \textit{three way handshake}, e ritorna solo
826 quando la connessione è stabilita o si è verificato un errore. Le possibili
827 cause di errore sono molteplici (ed i relativi codici riportati sopra), quelle
828 che però dipendono dalla situazione della rete e non da errori o problemi
829 nella chiamata della funzione sono le seguenti:
830 \begin{enumerate}
831 \item Il client non riceve risposta al SYN: l'errore restituito è
832   \errcode{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla
833   chiamata di \func{connect}, un altro dopo 6 secondi, un terzo dopo 24
834   secondi, se dopo 75 secondi non ha ricevuto risposta viene ritornato
835   l'errore. Linux invece ripete l'emissione del SYN ad intervalli di 30
836   secondi per un numero di volte che può essere stabilito dall'utente. Questo
837   può essere fatto a livello globale con una opportuna
838   \func{sysctl},\footnote{o più semplicemente scrivendo il valore voluto in
839     \sysctlfile{net/ipv4/tcp\_syn\_retries}, vedi
840     sez.~\ref{sec:sock_ipv4_sysctl}.} e a livello di singolo socket con
841   l'opzione \const{TCP\_SYNCNT} (vedi sez.~\ref{sec:sock_tcp_udp_options}). Il
842   valore predefinito per la ripetizione dell'invio è di 5 volte, che comporta
843   un timeout dopo circa 180 secondi.
844
845 \item Il client riceve come risposta al SYN un RST significa che non c'è
846   nessun programma in ascolto per la connessione sulla porta specificata (il
847   che vuol dire probabilmente che o si è sbagliato il numero della porta o che
848   non è stato avviato il server), questo è un errore fatale e la funzione
849   ritorna non appena il RST viene ricevuto riportando un errore
850   \errcode{ECONNREFUSED}.
851   
852   Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
853   dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
854   quando arriva un SYN per una porta che non ha nessun server in ascolto,
855   quando il TCP abortisce una connessione in corso, quando TCP riceve un
856   segmento per una connessione che non esiste.
857   
858 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
859   destinazione non raggiungibile. In questo caso dato che il messaggio può
860   essere dovuto ad una condizione transitoria si ripete l'emissione dei SYN
861   come nel caso precedente, fino al timeout, e solo allora si restituisce il
862   codice di errore dovuto al messaggio ICMP, che da luogo ad un
863   \errcode{ENETUNREACH}.
864    
865 \end{enumerate}
866
867 Se si fa riferimento al diagramma degli stati del TCP riportato in
868 fig.~\ref{fig:TCP_state_diag} la funzione \func{connect} porta un socket
869 dallo stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket
870 appena creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento del
871 ACK, nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il
872 socket non è più utilizzabile e deve essere chiuso.
873
874 Si noti infine che con la funzione \func{connect} si è specificato solo
875 indirizzo e porta del server, quindi solo una metà della socket pair; essendo
876 questa funzione usata nei client l'altra metà contenente indirizzo e porta
877 locale viene lasciata all'assegnazione automatica del kernel, e non è
878 necessario effettuare una \func{bind}.
879
880
881 \subsection{La funzione \func{listen}}
882 \label{sec:TCP_func_listen}
883
884 La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
885 come dice il nome, per metterlo in ascolto di eventuali
886 connessioni;\footnote{questa funzione può essere usata con socket che
887   supportino le connessioni, cioè di tipo \const{SOCK\_STREAM} o
888   \const{SOCK\_SEQPACKET}.} in sostanza l'effetto della funzione è di portare
889 il socket dallo stato \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si
890 chiama la funzione in un server dopo le chiamate a \func{socket} e \func{bind}
891 e prima della chiamata ad \func{accept}. Il prototipo della funzione, come
892 definito dalla pagina di manuale, è:
893 \begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
894   Pone un socket in attesa di una connessione.
895   
896   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
897     errore. I codici di errore restituiti in \var{errno} sono i seguenti:
898   \begin{errlist}
899   \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
900     valido.
901   \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
902   \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
903     operazione.
904   \end{errlist}}
905 \end{prototype}
906
907 La funzione pone il socket specificato da \param{sockfd} in modalità passiva e
908 predispone una coda per le connessioni in arrivo di lunghezza pari a
909 \param{backlog}. La funzione si può applicare solo a socket di tipo
910 \const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}.
911
912 L'argomento \param{backlog} indica il numero massimo di connessioni pendenti
913 accettate; se esso viene ecceduto il client al momento della richiesta della
914 connessione riceverà un errore di tipo \errcode{ECONNREFUSED}, o se il
915 protocollo, come accade nel caso del TCP, supporta la ritrasmissione, la
916 richiesta sarà ignorata in modo che la connessione possa venire ritentata.
917
918 Per capire meglio il significato di tutto ciò occorre approfondire la modalità
919 con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
920 infatti vengono mantenute due code:
921 \begin{enumerate}
922 \item La coda delle connessioni incomplete (\textit{incomplete connection
923     queue}) che contiene un riferimento per ciascun socket per il quale è
924   arrivato un SYN ma il \itindex{three~way~handshake} \textit{three way
925     handshake} non si è ancora concluso.  Questi socket sono tutti nello stato
926   \texttt{SYN\_RECV}.
927 \item La coda delle connessioni complete (\textit{complete connection queue})
928   che contiene un ingresso per ciascun socket per il quale il
929   \itindex{three~way~handshake} \textit{three way handshake} è stato
930   completato ma ancora \func{accept} non è ritornata.  Questi socket sono
931   tutti nello stato \texttt{ESTABLISHED}.
932 \end{enumerate}
933
934 Lo schema di funzionamento è descritto in fig.~\ref{fig:TCP_listen_backlog}:
935 quando arriva un SYN da un client il server crea una nuova voce nella coda
936 delle connessioni incomplete, e poi risponde con il SYN$+$ACK. La voce resterà
937 nella coda delle connessioni incomplete fino al ricevimento dell'ACK dal
938 client o fino ad un timeout. Nel caso di completamento del
939 \itindex{three~way~handshake} \textit{three way handshake} la voce viene
940 spostata nella coda delle connessioni complete.  Quando il processo chiama la
941 funzione \func{accept} (vedi sez.~\ref{sec:TCP_func_accept}) la prima voce
942 nella coda delle connessioni complete è passata al programma, o, se la coda è
943 vuota, il processo viene posto in attesa e risvegliato all'arrivo della prima
944 connessione completa.
945
946 \begin{figure}[!htb]
947   \centering \includegraphics[width=11cm]{img/tcp_listen_backlog}  
948   \caption{Schema di funzionamento delle code delle connessioni complete ed
949     incomplete.}
950   \label{fig:TCP_listen_backlog}
951 \end{figure}
952
953 Storicamente il valore dell'argomento \param{backlog} era corrispondente al
954 massimo valore della somma del numero di voci possibili per ciascuna delle due
955 code. Stevens in \cite{UNP1} riporta che BSD ha sempre applicato un fattore di
956 1.5 a detto valore, e fornisce una tabella con i risultati ottenuti con vari
957 kernel, compreso Linux 2.0, che mostrano le differenze fra diverse
958 implementazioni.
959
960 In Linux il significato di questo valore è cambiato a partire dal kernel 2.2
961 per prevenire l'attacco chiamato \itindex{SYN~flood} \textit{SYN
962   flood}. Questo si basa sull'emissione da parte dell'attaccante di un grande
963 numero di pacchetti SYN indirizzati verso una porta, forgiati con indirizzo IP
964 fasullo\footnote{con la tecnica che viene detta \textit{ip spoofing}.} così
965 che i SYN$+$ACK vanno perduti e la coda delle connessioni incomplete viene
966 saturata, impedendo di fatto ulteriori connessioni.
967
968 Per ovviare a questo il significato del \param{backlog} è stato cambiato a
969 indicare la lunghezza della coda delle connessioni complete. La lunghezza
970 della coda delle connessioni incomplete può essere ancora controllata usando
971 la funzione \func{sysctl} con il parametro \const{NET\_TCP\_MAX\_SYN\_BACKLOG}
972 o scrivendola direttamente in \sysctlfile{net/ipv4/tcp\_max\_syn\_backlog}.
973 Quando si attiva la protezione dei syncookies però (con l'opzione da compilare
974 nel kernel e da attivare usando \sysctlfile{net/ipv4/tcp\_syncookies}) questo
975 valore viene ignorato e non esiste più un valore massimo.  In ogni caso in
976 Linux il valore di \param{backlog} viene troncato ad un massimo di
977 \const{SOMAXCONN} se è superiore a detta costante (che di default vale
978 128).\footnote{il valore di questa costante può essere controllato con un
979   altro parametro di \func{sysctl}, vedi sez.~\ref{sec:sock_ioctl_IP}.}
980
981 La scelta storica per il valore di questo parametro era di 5, e alcuni vecchi
982 kernel non supportavano neanche valori superiori, ma la situazione corrente è
983 molto cambiata per via della presenza di server web che devono gestire un gran
984 numero di connessioni per cui un tale valore non è più adeguato. Non esiste
985 comunque una risposta univoca per la scelta del valore, per questo non
986 conviene specificarlo con una costante (il cui cambiamento richiederebbe la
987 ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi
988 sez.~\ref{sec:proc_environ}).
989
990 Stevens tratta accuratamente questo argomento in \cite{UNP1}, con esempi presi
991 da casi reali su web server, ed in particolare evidenzia come non sia più vero
992 che il compito principale della coda sia quello di gestire il caso in cui il
993 server è occupato fra chiamate successive alla \func{accept} (per cui la coda
994 più occupata sarebbe quella delle connessioni completate), ma piuttosto quello
995 di gestire la presenza di un gran numero di SYN in attesa di concludere il
996 \itindex{three~way~handshake} \textit{three way handshake}.
997
998 Infine va messo in evidenza che, nel caso di socket TCP, quando un SYN arriva
999 con tutte le code piene, il pacchetto deve essere ignorato. Questo perché la
1000 condizione in cui le code sono piene è ovviamente transitoria, per cui se il
1001 client ritrasmette il SYN è probabile che passato un po' di tempo possa
1002 trovare nella coda lo spazio per una nuova connessione. Se invece si
1003 rispondesse con un RST, per indicare l'impossibilità di effettuare la
1004 connessione, la chiamata a \func{connect} nel client ritornerebbe con una
1005 condizione di errore, costringendo a inserire nell'applicazione la gestione
1006 dei tentativi di riconnessione, che invece può essere effettuata in maniera
1007 trasparente dal protocollo TCP.
1008
1009
1010 \subsection{La funzione \func{accept}}
1011 \label{sec:TCP_func_accept}
1012
1013 La funzione \funcd{accept} è chiamata da un server per gestire la connessione
1014 una volta che sia stato completato il \itindex{three~way~handshake}
1015 \textit{three way handshake},\footnote{la funzione è comunque generica ed è
1016   utilizzabile su socket di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET}
1017   e \const{SOCK\_RDM}.} la funzione restituisce un nuovo socket descriptor su
1018 cui si potrà operare per effettuare la comunicazione. Se non ci sono
1019 connessioni completate il processo viene messo in attesa. Il prototipo della
1020 funzione è il seguente:
1021 \begin{prototype}{sys/socket.h}
1022 {int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)} 
1023  
1024   Accetta una connessione sul socket specificato.
1025   
1026   \bodydesc{La funzione restituisce un numero di socket descriptor positivo in
1027     caso di successo e -1 in caso di errore, nel qual caso \var{errno} viene
1028     impostata ai seguenti valori:
1029
1030   \begin{errlist}
1031   \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1032     valido.
1033   \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1034   \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
1035     operazione.
1036   \item[\errcode{EAGAIN} o \errcode{EWOULDBLOCK}] il socket è stato impostato
1037     come non bloccante (vedi sez.~\ref{sec:file_noblocking}), e non ci sono
1038     connessioni in attesa di essere accettate.
1039   \item[\errcode{EPERM}] le regole del firewall non consentono la connessione.
1040   \item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che
1041     l'allocazione della memoria è limitata dai limiti sui buffer dei socket,
1042     non dalla memoria di sistema.
1043   \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
1044   \end{errlist}
1045   Inoltre possono essere restituiti gli errori di rete relativi al nuovo
1046   socket, diversi a secondo del protocollo, come: \errval{EMFILE},
1047   \errval{EINVAL}, \errval{ENOSR}, \errval{ENOBUFS}, \errval{EFAULT},
1048   \errval{EPERM}, \errval{ECONNABORTED}, \errval{ESOCKTNOSUPPORT},
1049   \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT}, \errval{ERESTARTSYS}.}
1050 \end{prototype}
1051
1052 La funzione estrae la prima connessione relativa al socket \param{sockfd} in
1053 attesa sulla coda delle connessioni complete, che associa ad nuovo socket con
1054 le stesse caratteristiche di \param{sockfd}.  Il socket originale non viene
1055 toccato e resta nello stato di \texttt{LISTEN}, mentre il nuovo socket viene
1056 posto nello stato \texttt{ESTABLISHED}. Nella struttura \param{addr} e nella
1057 variabile \param{addrlen} vengono restituiti indirizzo e relativa lunghezza
1058 del client che si è connesso.
1059
1060 I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è
1061 passato per indirizzo per avere indietro il valore) sono usati per ottenere
1062 l'indirizzo del client da cui proviene la connessione. Prima della chiamata
1063 \param{addrlen} deve essere inizializzato alle dimensioni della struttura il
1064 cui indirizzo è passato come argomento in \param{addr}; al ritorno della
1065 funzione \param{addrlen} conterrà il numero di byte scritti dentro
1066 \param{addr}. Se questa informazione non interessa basterà inizializzare a
1067 \val{NULL} detti puntatori.
1068
1069 Se la funzione ha successo restituisce il descrittore di un nuovo socket
1070 creato dal kernel (detto \textit{connected socket}) a cui viene associata la
1071 prima connessione completa (estratta dalla relativa coda, vedi
1072 sez.~\ref{sec:TCP_func_listen}) che il client ha effettuato verso il socket
1073 \param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato
1074 all'inizio e messo in ascolto con \func{listen}, e non viene toccato dalla
1075 funzione.  Se non ci sono connessioni pendenti da accettare la funzione mette
1076 in attesa il processo\footnote{a meno che non si sia impostato il socket per
1077   essere non bloccante (vedi sez.~\ref{sec:file_noblocking}), nel qual caso
1078   ritorna con l'errore \errcode{EAGAIN}.  Torneremo su questa modalità di
1079   operazione in sez.~\ref{sec:TCP_sock_multiplexing}.}  fintanto che non ne
1080 arriva una.
1081
1082 La funzione può essere usata solo con socket che supportino la connessione
1083 (cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
1084 \const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
1085 esplicita della connessione,\footnote{attualmente in Linux solo DECnet ha
1086   questo comportamento.} la funzione opera solo l'estrazione dalla coda delle
1087 connessioni, la conferma della connessione viene eseguita implicitamente dalla
1088 prima chiamata ad una \func{read} o una \func{write}, mentre il rifiuto della
1089 connessione viene eseguito con la funzione \func{close}.
1090
1091 È da chiarire che Linux presenta un comportamento diverso nella gestione degli
1092 errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
1093 \func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
1094 di errore per \func{accept}, per cui l'applicazione deve tenerne conto ed
1095 eventualmente ripetere la chiamata alla funzione come per l'errore di
1096 \errcode{EAGAIN} (torneremo su questo in sez.~\ref{sec:TCP_echo_critical}).
1097 Un'altra differenza con BSD è che la funzione non fa ereditare al nuovo socket
1098 i flag del socket originale, come \const{O\_NONBLOCK},\footnote{ed in generale
1099   tutti quelli che si possono impostare con \func{fcntl}, vedi
1100   sez.~\ref{sec:file_fcntl_ioctl}.} che devono essere rispecificati ogni
1101 volta. Tutto questo deve essere tenuto in conto se si devono scrivere
1102 programmi portabili.
1103
1104 Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
1105 funzionamento di un server: in generale infatti c'è sempre un solo socket in
1106 ascolto, detto per questo \textit{listening socket}, che resta per tutto il
1107 tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai
1108 nuovi socket, detti \textit{connected socket}, ritornati da \func{accept}, che
1109 si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono
1110 utilizzati per lo scambio dei dati, che avviene su di essi, fino alla chiusura
1111 della connessione.  Si può riconoscere questo schema anche nell'esempio
1112 elementare di fig.~\ref{fig:TCP_daytime_iter_server_code}, dove per ogni
1113 connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei
1114 dati.
1115
1116
1117 \subsection{Le funzioni \func{getsockname} e \func{getpeername}}
1118 \label{sec:TCP_get_names}
1119
1120 Oltre a tutte quelle viste finora, dedicate all'utilizzo dei socket, esistono
1121 alcune funzioni ausiliarie che possono essere usate per recuperare alcune
1122 informazioni relative ai socket ed alle connessioni ad essi associate. Le due
1123 funzioni più elementari sono queste, che vengono usate per ottenere i dati
1124 relativi alla socket pair associata ad un certo socket.
1125
1126 La prima funzione è \funcd{getsockname} e serve ad ottenere l'indirizzo locale
1127 associato ad un socket; il suo prototipo è:
1128 \begin{prototype}{sys/socket.h}
1129   {int getsockname(int sockfd, struct sockaddr *name, socklen\_t *namelen)}
1130   Legge l'indirizzo locale di un socket.
1131
1132 \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1133   errore. I codici di errore restituiti in \var{errno} sono i seguenti:
1134   \begin{errlist}
1135   \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1136     valido.
1137   \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1138   \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
1139     eseguire l'operazione.
1140   \item[\errcode{EFAULT}] l'indirizzo \param{name} non è valido.
1141   \end{errlist}}
1142 \end{prototype}
1143
1144 La funzione restituisce la struttura degli indirizzi del socket \param{sockfd}
1145 nella struttura indicata dal puntatore \param{name} la cui lunghezza è
1146 specificata tramite l'argomento \param{namlen}. Quest'ultimo viene passato
1147 come indirizzo per avere indietro anche il numero di byte effettivamente
1148 scritti nella struttura puntata da \param{name}. Si tenga presente che se si è
1149 utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà
1150 troncato.
1151
1152 La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un
1153 socket; ad esempio può essere usata da un client (che usualmente non chiama
1154 \func{bind}) per ottenere numero IP e porta locale associati al socket
1155 restituito da una \func{connect}, o da un server che ha chiamato \func{bind}
1156 su un socket usando 0 come porta locale per ottenere il numero di porta
1157 effimera assegnato dal kernel.
1158
1159 Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se
1160 chiamata dopo il completamento di una connessione sul socket restituito da
1161 \func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
1162 quella connessione.
1163
1164 Tutte le volte che si vuole avere l'indirizzo remoto di un socket si usa la
1165 funzione \funcd{getpeername}, il cui prototipo è:
1166 \begin{prototype}{sys/socket.h}
1167   {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
1168   Legge l'indirizzo remoto di un socket.
1169   
1170   \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
1171     errore. I codici di errore restituiti in \var{errno} sono i seguenti:
1172   \begin{errlist}
1173   \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1174     valido.
1175   \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1176   \item[\errcode{ENOTCONN}] il socket non è connesso.
1177   \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
1178     eseguire l'operazione.
1179   \item[\errcode{EFAULT}] l'argomento \param{name} punta al di fuori dello
1180     spazio di indirizzi del processo.
1181   \end{errlist}}
1182 \end{prototype}
1183
1184 La funzione è identica a \func{getsockname}, ed usa la stessa sintassi, ma
1185 restituisce l'indirizzo remoto del socket, cioè quello associato all'altro
1186 capo della connessione.  Ci si può chiedere a cosa serva questa funzione dato
1187 che dal lato client l'indirizzo remoto è sempre noto quando si esegue la
1188 \func{connect} mentre dal lato server si possono usare, come vedremo in
1189 fig.~\ref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di
1190 \func{accept}.
1191
1192 Il fatto è che in generale quest'ultimo caso non è sempre possibile.  In
1193 particolare questo avviene quando il server, invece di gestire la connessione
1194 direttamente in un processo figlio, come vedremo nell'esempio di server
1195 concorrente di sez.~\ref{sec:TCP_daytime_cunc_server}, lancia per ciascuna
1196 connessione un altro programma, usando \func{exec}.\footnote{questa ad esempio
1197   è la modalità con cui opera il \textsl{super-server} \cmd{inetd}, che può
1198   gestire tutta una serie di servizi diversi, eseguendo su ogni connessione
1199   ricevuta sulle porte tenute sotto controllo, il relativo server.}
1200
1201 In questo caso benché il processo figlio abbia una immagine della memoria che
1202 è copia di quella del processo padre (e contiene quindi anche la struttura
1203 ritornata da \func{accept}), all'esecuzione di \func{exec} verrà caricata in
1204 memoria l'immagine del programma eseguito, che a questo punto perde ogni
1205 riferimento ai valori tornati da \func{accept}.  Il socket descriptor però
1206 resta aperto, e se si è seguita una opportuna convenzione per rendere noto al
1207 programma eseguito qual è il socket connesso, \footnote{ad esempio il solito
1208   \cmd{inetd} fa sempre in modo che i file descriptor 0, 1 e 2 corrispondano
1209   al socket connesso.} quest'ultimo potrà usare la funzione \func{getpeername}
1210 per determinare l'indirizzo remoto del client.
1211
1212 Infine è da chiarire (si legga la pagina di manuale) che, come per
1213 \func{accept}, il terzo argomento, che è specificato dallo standard POSIX.1g
1214 come di tipo \code{socklen\_t *} in realtà deve sempre corrispondere ad un
1215 \ctyp{int *} come prima dello standard perché tutte le implementazioni dei
1216 socket BSD fanno questa assunzione.
1217
1218
1219 \subsection{La funzione \func{close}}
1220 \label{sec:TCP_func_close}
1221
1222 La funzione standard Unix \func{close} (vedi sez.~\ref{sec:file_open_close})
1223 che si usa sui file può essere usata con lo stesso effetto anche sui file
1224 descriptor associati ad un socket.
1225
1226 L'azione di questa funzione quando applicata a socket è di marcarlo come
1227 chiuso e ritornare immediatamente al processo. Una volta chiamata il socket
1228 descriptor non è più utilizzabile dal processo e non può essere usato come
1229 argomento per una \func{write} o una \func{read} (anche se l'altro capo della
1230 connessione non avesse chiuso la sua parte).  Il kernel invierà comunque tutti
1231 i dati che ha in coda prima di iniziare la sequenza di chiusura.
1232
1233 Vedremo più avanti in sez.~\ref{sec:sock_generic_options} come sia possibile
1234 cambiare questo comportamento, e cosa può essere fatto perché il processo
1235 possa assicurarsi che l'altro capo abbia ricevuto tutti i dati.
1236
1237 Come per tutti i file descriptor anche per i socket viene mantenuto un numero
1238 di riferimenti, per cui se più di un processo ha lo stesso socket aperto
1239 l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
1240 fintanto che il numero di riferimenti non si annulla, questo si applica, come
1241 visto in sez.~\ref{sec:file_shared_access}, sia ai file descriptor duplicati
1242 che a quelli ereditati dagli eventuali processi figli, ed è il comportamento
1243 che ci si aspetta in una qualunque applicazione client/server.
1244
1245 Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura
1246 descritta in sez.~\ref{sec:TCP_conn_term}, si può invece usare la funzione
1247 \func{shutdown} su cui torneremo in seguito (vedi
1248 sez.~\ref{sec:TCP_shutdown}).
1249
1250
1251
1252 \section{Un esempio elementare: il servizio \textit{daytime}}
1253 \label{sec:TCP_daytime_application}
1254
1255 Avendo introdotto le funzioni di base per la gestione dei socket, potremo
1256 vedere in questa sezione un primo esempio di applicazione elementare che
1257 implementa il servizio \textit{daytime} su TCP, secondo quanto specificato
1258 dall'\href{http://www.ietf.org/rfc/rfc867.txt}{RFC~867}.  Prima di passare
1259 agli esempi del client e del server, inizieremo riesaminando con maggiori
1260 dettagli una peculiarità delle funzioni di I/O, già accennata in
1261 sez.~\ref{sec:file_read} e sez.~\ref{sec:file_write}, che nel caso dei socket è
1262 particolarmente rilevante.  Passeremo poi ad illustrare gli esempi
1263 dell'implementazione, sia dal lato client, che dal lato server, che si è
1264 realizzato sia in forma iterativa che concorrente.
1265
1266
1267 \subsection{Il comportamento delle funzioni di I/O}
1268 \label{sec:sock_io_behav}
1269
1270 Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
1271 le funzioni di input/output non sempre hanno lo stesso comportamento che
1272 avrebbero con i normali file di dati (in particolare questo accade per i
1273 socket di tipo stream).
1274
1275 Infatti con i socket è comune che funzioni come \func{read} o \func{write}
1276 possano restituire in input o scrivere in output un numero di byte minore di
1277 quello richiesto. Come già accennato in sez.~\ref{sec:file_read} questo è un
1278 comportamento normale per le funzioni di I/O, ma con i normali file di dati il
1279 problema si avverte solo in lettura, quando si incontra la fine del file. In
1280 generale non è così, e con i socket questo è particolarmente evidente.
1281
1282
1283 \begin{figure}[!htbp]
1284   \footnotesize \centering
1285   \begin{minipage}[c]{\codesamplewidth}
1286     \includecodesample{listati/FullRead.c}
1287   \end{minipage} 
1288   \normalsize
1289   \caption{La funzione \func{FullRead}, che legge esattamente \var{count} byte
1290     da un file descriptor, iterando opportunamente le letture.}
1291   \label{fig:sock_FullRead_code}
1292 \end{figure}
1293
1294 Quando ci si trova ad affrontare questo comportamento tutto quello che si deve
1295 fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di
1296 byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non
1297 sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
1298 \const{PIPE\_BUF} byte in una \textit{pipe} (si riveda quanto detto in
1299 sez.~\ref{sec:ipc_pipes}).
1300
1301 Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono
1302 definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono
1303 lettura e scrittura tenendo conto di questa caratteristica, ed in grado di
1304 ritornare solo dopo avere letto o scritto esattamente il numero di byte
1305 specificato; il sorgente è riportato rispettivamente in
1306 fig.~\ref{fig:sock_FullRead_code} e fig.~\ref{fig:sock_FullWrite_code} ed è
1307 disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
1308 \file{FullWrite.c}.
1309
1310 \begin{figure}[!htbp]
1311   \centering
1312   \footnotesize \centering
1313   \begin{minipage}[c]{\codesamplewidth}
1314     \includecodesample{listati/FullWrite.c}
1315   \end{minipage} 
1316   \normalsize
1317   \caption{La funzione \func{FullWrite}, che scrive esattamente \var{count}
1318     byte su un file descriptor, iterando opportunamente le scritture.}
1319   \label{fig:sock_FullWrite_code}
1320 \end{figure}
1321
1322 Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo
1323 fino all'esaurimento del numero di byte richiesti, in caso di errore viene
1324 controllato se questo è \errcode{EINTR} (cioè un'interruzione della
1325 \textit{system call} dovuta ad un segnale), nel qual caso l'accesso viene
1326 ripetuto, altrimenti l'errore viene ritornato al programma chiamante,
1327 interrompendo il ciclo.
1328
1329 Nel caso della lettura, se il numero di byte letti è zero, significa che si è
1330 arrivati alla fine del file (per i socket questo significa in genere che
1331 l'altro capo è stato chiuso, e quindi non sarà più possibile leggere niente) e
1332 pertanto si ritorna senza aver concluso la lettura di tutti i byte
1333 richiesti. Entrambe le funzioni restituiscono 0 in caso di successo, ed un
1334 valore negativo in caso di errore, \func{FullRead} restituisce il numero di
1335 byte non letti in caso di end-of-file prematuro.
1336
1337
1338 \subsection{Il client \textit{daytime}}
1339 \label{sec:TCP_daytime_client}
1340
1341 Il primo esempio di applicazione delle funzioni di base illustrate in
1342 sez.~\ref{sec:TCP_functions} è relativo alla creazione di un client elementare
1343 per il servizio \textit{daytime}, un servizio elementare, definito
1344 nell'\href{http://www.ietf.org/rfc/rfc867.txt}{RFC~867}, che restituisce
1345 l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
1346 alla porta 13.
1347
1348 In fig.~\ref{fig:TCP_daytime_client_code} è riportata la sezione principale
1349 del codice del nostro client. Il sorgente completo del programma
1350 (\texttt{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una
1351 funzione per stampare un messaggio di aiuto) è allegato alla guida nella
1352 sezione dei codici sorgente e può essere compilato su una qualunque macchina
1353 GNU/Linux.
1354
1355 \begin{figure}[!htbp]
1356   \footnotesize \centering
1357   \begin{minipage}[c]{\codesamplewidth}
1358     \includecodesample{listati/TCP_daytime.c}
1359   \end{minipage} 
1360   \normalsize
1361   \caption{Esempio di codice di un client elementare per il servizio
1362     \textit{daytime}.} 
1363   \label{fig:TCP_daytime_client_code}
1364 \end{figure}
1365
1366 Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari;
1367 dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
1368 tutta la parte relativa al trattamento degli argomenti passati dalla linea di
1369 comando (effettuata con le apposite funzioni illustrate in
1370 sez.~\ref{sec:proc_opt_handling}).
1371
1372 Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo
1373 \const{SOCK\_STREAM} e di famiglia \const{AF\_INET}). La funzione
1374 \func{socket} ritorna il descrittore che viene usato per identificare il
1375 socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
1376 stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce
1377 (\texttt{\small 17}) con un codice di errore.
1378
1379 Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
1380 struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
1381 il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è
1382 inizializzare tutto a zero, per poi inserire il tipo di indirizzo
1383 (\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima
1384 la funzione \func{htons} per convertire il formato dell'intero usato dal
1385 computer a quello usato nella rete, infine (\texttt{\small 23--27}) si può
1386 utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico
1387 passato dalla linea di comando.
1388
1389 A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul
1390 socket creato in precedenza (\texttt{\small 29}) si può stabilire la
1391 connessione con il server. Per questo si deve utilizzare come secondo
1392 argomento la struttura preparata in precedenza con il relativo indirizzo; si
1393 noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast.
1394 Un valore di ritorno della funzione negativo implica il fallimento della
1395 connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si
1396 ritorna (\texttt{\small 31}).
1397
1398 Completata con successo la connessione il passo successivo (\texttt{\small
1399   34--40}) è leggere la data dal socket; il protocollo prevede che il server
1400 invii sempre una stringa alfanumerica, il formato della stringa non è
1401 specificato dallo standard, per cui noi useremo il formato usato dalla
1402 funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè
1403 qualcosa del tipo:
1404 \begin{verbatim}
1405 Wed Apr 4 00:53:00 2001\r\n
1406 \end{verbatim}
1407 questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read}
1408 in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small
1409   35}) con il solito carattere nullo per poter essere stampata (\texttt{\small
1410   36}) sullo standard output con l'uso di \func{fputs}.
1411
1412 Come si è già spiegato in sez.~\ref{sec:sock_io_behav} la risposta dal socket
1413 potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel
1414 caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte.  Per
1415 questo nel caso generale non si può mai assumere che tutti i dati arrivino con
1416 una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo
1417 in cui si continui a leggere fintanto che la funzione \func{read} non ritorni
1418 uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero
1419 minore di zero (che significa un errore nella connessione).
1420
1421 Si noti come in questo caso la fine dei dati sia specificata dal server che
1422 chiude la connessione (anche questo è quanto richiesto dal protocollo); questa
1423 è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma
1424 ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco
1425 di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed),
1426 mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il
1427 punto essenziale è che TCP non provvede nessuna indicazione che permetta di
1428 marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il
1429 programma stesso.
1430
1431 Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene
1432   fornito direttamente dal \textsl{superdemone} \cmd{inetd}, pertanto basta
1433   assicurarsi che esso sia abilitato nel relativo file di configurazione.}
1434 possiamo verificare il funzionamento del nostro client, avremo allora:
1435 \begin{verbatim}
1436 [piccardi@gont sources]$ ./daytime 127.0.0.1
1437 Mon Apr 21 20:46:11 2003
1438 \end{verbatim}%$
1439 e come si vede tutto funziona regolarmente.
1440
1441
1442 \subsection{Un server \textit{daytime} iterativo}
1443 \label{sec:TCP_daytime_iter_server}
1444
1445 Dopo aver illustrato il client daremo anche un esempio di un server
1446 elementare, che sia anche in grado di rispondere al precedente client. Come
1447 primo esempio realizzeremo un server iterativo, in grado di fornire una sola
1448 risposta alla volta. Il codice del programma è nuovamente mostrato in
1449 fig.~\ref{fig:TCP_daytime_iter_server_code}, il sorgente completo
1450 (\texttt{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli
1451 esempi.
1452
1453 \begin{figure}[!htbp]
1454   \footnotesize \centering
1455   \begin{minipage}[c]{\codesamplewidth}
1456     \includecodesample{listati/TCP_iter_daytimed.c}
1457   \end{minipage} 
1458   \normalsize
1459   \caption{Esempio di codice di un semplice server per il servizio daytime.}
1460   \label{fig:TCP_daytime_iter_server_code}
1461 \end{figure}
1462
1463 Come per il client si includono (\texttt{\small 1--9}) gli header necessari a
1464 cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small
1465   14--18}) alcune costanti e le variabili necessarie in seguito. Come nel caso
1466 precedente si sono omesse le parti relative al trattamento delle opzioni da
1467 riga di comando.
1468
1469 La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente,
1470 come pure l'inizializzazione (\texttt{\small 25--29}) della struttura
1471 \struct{sockaddr\_in}.  Anche in questo caso (\texttt{\small 28}) si usa la
1472 porta standard del servizio daytime, ma come indirizzo IP si usa
1473 (\texttt{\small 27}) il valore predefinito \const{INET\_ANY}, che corrisponde
1474 all'indirizzo generico.
1475
1476 Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind}
1477 che permette di associare la precedente struttura al socket, in modo che
1478 quest'ultimo possa essere usato per accettare connessioni su una qualunque
1479 delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small
1480   31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il
1481 programma.
1482
1483 Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``\textsl{in
1484   ascolto}'' il socket; questo viene fatto (\texttt{\small 36}) con la
1485 funzione \func{listen} che dice al kernel di accettare connessioni per il
1486 socket che abbiamo creato; la funzione indica inoltre, con il secondo
1487 argomento, il numero massimo di connessioni che il kernel accetterà di mettere
1488 in coda per il suddetto socket. Di nuovo in caso di errore si stampa
1489 (\texttt{\small 37}) un messaggio, e si esce (\texttt{\small 38})
1490 immediatamente.
1491
1492 La chiamata a \func{listen} completa la preparazione del socket per l'ascolto
1493 (che viene chiamato anche \textit{listening descriptor}) a questo punto si può
1494 procedere con il ciclo principale (\texttt{\small 40--53}) che viene eseguito
1495 indefinitamente. Il primo passo (\texttt{\small 42}) è porsi in attesa di
1496 connessioni con la chiamata alla funzione \func{accept}, come in precedenza in
1497 caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce
1498 (\texttt{\small 44}).
1499
1500 Il processo resterà in stato di \textit{sleep} fin quando non arriva e viene
1501 accettata una connessione da un client; quando questo avviene \func{accept}
1502 ritorna, restituendo un secondo descrittore, che viene chiamato
1503 \textit{connected descriptor}, e che è quello che verrà usato dalla successiva
1504 chiamata alla \func{write} per scrivere la risposta al client.
1505
1506 Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente
1507 con una chiamata a \texttt{time}, con il quale si potrà opportunamente
1508 costruire (\texttt{\small 47}) la stringa con la data da trasmettere
1509 (\texttt{\small 48}) con la chiamata a \func{write}. Completata la
1510 trasmissione il nuovo socket viene chiuso (\texttt{\small 52}).  A questo
1511 punto il ciclo si chiude ricominciando da capo in modo da poter ripetere
1512 l'invio della data in risposta ad una successiva connessione.
1513
1514 È importante notare che questo server è estremamente elementare, infatti, a
1515 parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado
1516 di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un
1517 \textsl{server iterativo}. Inoltre è scritto per essere lanciato da linea di
1518 comando, se lo si volesse utilizzare come demone occorrerebbero le opportune
1519 modifiche\footnote{come una chiamata a \func{daemon} prima dell'inizio del
1520   ciclo principale.} per tener conto di quanto illustrato in
1521 sez.~\ref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma
1522 di gestione della terminazione del processo, dato che tutti i file descriptor
1523 vengono chiusi automaticamente alla sua uscita, e che, non generando figli,
1524 non è necessario preoccuparsi di gestire la loro terminazione.
1525
1526
1527 \subsection{Un server \textit{daytime} concorrente}
1528 \label{sec:TCP_daytime_cunc_server}
1529
1530 Il server \texttt{daytime} dell'esempio in
1531 sez.~\ref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo,
1532 in cui viene servita una richiesta alla volta; in generale però, specie se il
1533 servizio è più complesso e comporta uno scambio di dati più sostanzioso di
1534 quello in questione, non è opportuno bloccare un server nel servizio di un
1535 client per volta; per questo si ricorre alle capacità di multitasking del
1536 sistema.
1537
1538 Come spiegato in sez.~\ref{sec:proc_fork} una delle modalità più comuni di
1539 funzionamento da parte dei server è quella di usare la funzione \func{fork}
1540 per creare, ad ogni richiesta da parte di un client, un processo figlio che si
1541 incarichi della gestione della comunicazione.  Si è allora riscritto il server
1542 \textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche
1543 una opzione per la stampa degli indirizzi delle connessioni ricevute.
1544
1545 In fig.~\ref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del
1546 codice, in cui si sono tralasciati il trattamento delle opzioni e le parti
1547 rimaste invariate rispetto al precedente esempio (cioè tutta la parte
1548 riguardante l'apertura passiva del socket). Al solito il sorgente completo del
1549 server, nel file \texttt{TCP\_cunc\_daytimed.c}, è allegato insieme ai
1550 sorgenti degli altri esempi.
1551
1552 \begin{figure}[!htbp]
1553   \footnotesize \centering
1554   \begin{minipage}[c]{\codesamplewidth}
1555     \includecodesample{listati/TCP_cunc_daytimed.c}
1556   \end{minipage} 
1557   \normalsize
1558   \caption{Esempio di codice di un server concorrente elementare per il 
1559     servizio daytime.}
1560   \label{fig:TCP_daytime_cunc_server_code}
1561 \end{figure}
1562
1563 Stavolta (\texttt{\small 21--26}) la funzione \func{accept} è chiamata
1564 fornendo una struttura di indirizzi in cui saranno ritornati l'indirizzo IP e
1565 la porta da cui il client effettua la connessione, che in un secondo tempo,
1566 (\texttt{\small 40--44}), se il logging è abilitato, stamperemo sullo standard
1567 output.
1568
1569 Quando \func{accept} ritorna il server chiama la funzione \func{fork}
1570 (\texttt{\small 27--31}) per creare il processo figlio che effettuerà
1571 (\texttt{\small 32--46}) tutte le operazioni relative a quella connessione,
1572 mentre il padre proseguirà l'esecuzione del ciclo principale in attesa di
1573 ulteriori connessioni.
1574
1575 Si noti come il figlio operi solo sul socket connesso, chiudendo
1576 immediatamente (\texttt{\small 33}) il socket \var{list\_fd}; mentre il padre
1577 continua ad operare solo sul socket in ascolto chiudendo (\texttt{\small 48})
1578 \var{conn\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in
1579 sez.~\ref{sec:TCP_func_close} nessuna delle due chiamate a \func{close} causa
1580 l'innesco della sequenza di chiusura perché il numero di riferimenti al file
1581 descriptor non si è annullato.
1582
1583 Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e
1584 lo stesso vale per \var{conn\_fd} dopo il ritorno di \func{accept}, ma dopo la
1585 \func{fork} i descrittori vengono duplicati nel padre e nel figlio per cui
1586 entrambi i socket si trovano con due referenze. Questo fa si che quando il
1587 padre chiude \var{sock\_fd} esso resta con una referenza da parte del figlio,
1588 e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato
1589 le sue operazioni, chiamerà (\texttt{\small 45}) la funzione \func{close}.
1590
1591 In realtà per il figlio non sarebbe necessaria nessuna chiamata a
1592 \func{close}, in quanto con la \func{exit} finale (\texttt{\small 45}) tutti i
1593 file descriptor, quindi anche quelli associati ai socket, vengono
1594 automaticamente chiusi.  Tuttavia si è preferito effettuare esplicitamente le
1595 chiusure per avere una maggiore chiarezza del codice, e per evitare eventuali
1596 errori, prevenendo ad esempio un uso involontario del \textit{listening
1597   descriptor}.
1598
1599 Si noti invece come sia essenziale che il padre chiuda ogni volta il socket
1600 connesso dopo la \func{fork}; se così non fosse nessuno di questi socket
1601 sarebbe effettivamente chiuso dato che alla chiusura da parte del figlio
1602 resterebbe ancora un riferimento nel padre. Si avrebbero così due effetti: il
1603 padre potrebbe esaurire i descrittori disponibili (che sono un numero limitato
1604 per ogni processo) e soprattutto nessuna delle connessioni con i client
1605 verrebbe chiusa.
1606
1607 Come per ogni server iterativo il lavoro di risposta viene eseguito
1608 interamente dal processo figlio. Questo si incarica (\texttt{\small 34}) di
1609 chiamare \func{time} per leggere il tempo corrente, e di stamparlo
1610 (\texttt{\small 35}) sulla stringa contenuta in \var{buffer} con l'uso di
1611 \func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small
1612   36--39}) sul socket, controllando che non ci siano errori. Anche in questo
1613 caso si è evitato il ricorso a \func{FullWrite} in quanto la stringa è
1614 estremamente breve e verrà senz'altro scritta in un singolo segmento.
1615
1616 Inoltre nel caso sia stato abilitato il \textit{logging} delle connessioni, si
1617 provvede anche (\texttt{\small 40--43}) a stampare sullo standard output
1618 l'indirizzo e la porta da cui il client ha effettuato la connessione, usando i
1619 valori contenuti nelle strutture restituite da \func{accept}, eseguendo le
1620 opportune conversioni con \func{inet\_ntop} e \func{ntohs}.
1621
1622 Ancora una volta l'esempio è estremamente semplificato, si noti come di nuovo
1623 non si sia gestita né la terminazione del processo né il suo uso come demone,
1624 che tra l'altro sarebbe stato incompatibile con l'uso della opzione di logging
1625 che stampa gli indirizzi delle connessioni sullo standard output. Un altro
1626 aspetto tralasciato è la gestione della terminazione dei processi figli,
1627 torneremo su questo più avanti quando tratteremo alcuni esempi di server più
1628 complessi.
1629
1630
1631
1632 \section{Un esempio più completo: il servizio \textit{echo}}
1633 \label{sec:TCP_echo_application}
1634
1635 L'esempio precedente, basato sul servizio \textit{daytime}, è un esempio molto
1636 elementare, in cui il flusso dei dati va solo nella direzione dal server al
1637 client. In questa sezione esamineremo un esempio di applicazione client/server
1638 un po' più complessa, che usi i socket TCP per una comunicazione in entrambe
1639 le direzioni.
1640
1641 Ci limiteremo a fornire una implementazione elementare, che usi solo le
1642 funzioni di base viste finora, ma prenderemo in esame, oltre al comportamento
1643 in condizioni normali, anche tutti i possibili scenari particolari (errori,
1644 sconnessione della rete, crash del client o del server durante la connessione)
1645 che possono avere luogo durante l'impiego di un'applicazione di rete, partendo
1646 da una versione primitiva che dovrà essere rimaneggiata di volta in volta per
1647 poter tenere conto di tutte le evenienze che si possono manifestare nella vita
1648 reale di un'applicazione di rete, fino ad arrivare ad un'implementazione
1649 completa.
1650
1651
1652 \subsection{Il servizio \textit{echo}}
1653 \label{sec:TCP_echo}
1654
1655
1656 Nella ricerca di un servizio che potesse fare da esempio per una comunicazione
1657 bidirezionale, si è deciso, seguendo la scelta di Stevens in \cite{UNP1}, di
1658 usare il servizio \textit{echo}, che si limita a restituire in uscita quanto
1659 immesso in ingresso. Infatti, nonostante la sua estrema semplicità, questo
1660 servizio costituisce il prototipo ideale per una generica applicazione di rete
1661 in cui un server risponde alle richieste di un client.  Nel caso di una
1662 applicazione più complessa quello che si potrà avere in più è una elaborazione
1663 dell'input del client, che in molti casi viene interpretato come un comando,
1664 da parte di un server che risponde fornendo altri dati in uscita.
1665
1666 Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
1667 direttamente dal superserver \cmd{inetd}, ed è definito
1668 dall'\href{http://www.ietf.org/rfc/rfc862.txt}{RFC~862}. Come dice il nome il
1669 servizio deve riscrivere indietro sul socket i dati che gli vengono inviati in
1670 ingresso. L'RFC descrive le specifiche del servizio sia per TCP che UDP, e per
1671 il primo stabilisce che una volta stabilita la connessione ogni dato in
1672 ingresso deve essere rimandato in uscita fintanto che il chiamante non ha
1673 chiude la connessione. Al servizio è assegnata la porta riservata 7.
1674
1675 Nel nostro caso l'esempio sarà costituito da un client che legge una linea di
1676 caratteri dallo standard input e la scrive sul server. A sua volta il server
1677 leggerà la linea dalla connessione e la riscriverà immutata all'indietro. Sarà
1678 compito del client leggere la risposta del server e stamparla sullo standard
1679 output.
1680
1681
1682 \subsection{Il client \textit{echo}: prima versione}
1683 \label{sec:TCP_echo_client}
1684
1685 Il codice della prima versione del client per il servizio \textit{echo},
1686 disponibile nel file \texttt{TCP\_echo\_first.c}, è riportato in
1687 fig.~\ref{fig:TCP_echo_client_1}. Esso ricalca la struttura del precedente
1688 client per il servizio \textit{daytime} (vedi
1689 sez.~\ref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27})
1690 è sostanzialmente identica, a parte l'uso di una porta diversa.
1691
1692 \begin{figure}[!htbp]
1693   \footnotesize \centering
1694   \begin{minipage}[c]{\codesamplewidth}
1695     \includecodesample{listati/TCP_echo_first.c}
1696   \end{minipage} 
1697   \normalsize
1698   \caption{Codice della prima versione del client \textit{echo}.}
1699   \label{fig:TCP_echo_client_1}
1700 \end{figure}
1701
1702 Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a
1703 riga di comando.  Una volta dichiarate le variabili, si prosegue
1704 (\texttt{\small 10--13}) con della creazione del socket con l'usuale controllo
1705 degli errori, alla preparazione (\texttt{\small 14--17}) della struttura
1706 dell'indirizzo, che stavolta usa la porta 7 riservata al servizio
1707 \textit{echo}, infine si converte (\texttt{\small 18--22}) l'indirizzo
1708 specificato a riga di comando.  A questo punto (\texttt{\small 23--27}) si può
1709 eseguire la connessione al server secondo la stessa modalità usata in
1710 sez.~\ref{sec:TCP_daytime_client}.
1711
1712 Completata la connessione, per gestire il funzionamento del protocollo si usa
1713 la funzione \code{ClientEcho}, il cui codice si è riportato a parte in
1714 fig.~\ref{fig:TCP_client_echo_sub}. Questa si preoccupa di gestire tutta la
1715 comunicazione, leggendo una riga alla volta dallo standard input \file{stdin},
1716 scrivendola sul socket e ristampando su \file{stdout} quanto ricevuto in
1717 risposta dal server. Al ritorno dalla funzione (\texttt{\small 30--31}) anche
1718 il programma termina.
1719
1720 La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per
1721 gestire i dati inviati e letti sul socket.  La comunicazione viene gestita
1722 all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla
1723 connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets},
1724 che legge una linea di testo (terminata da un \texttt{CR} e fino al massimo di
1725 \const{MAXLINE} caratteri) e la salva sul buffer di invio.
1726
1727 Si usa poi (\texttt{\small 6}) la funzione \func{FullWrite}, vista in
1728 sez.~\ref{sec:sock_io_behav}, per scrivere i dati sul socket, gestendo
1729 automaticamente l'invio multiplo qualora una singola \func{write} non sia
1730 sufficiente.  I dati vengono riletti indietro (\texttt{\small 7}) con una
1731 \func{read}\footnote{si è fatta l'assunzione implicita che i dati siano
1732   contenuti tutti in un solo segmento, così che la chiamata a \func{read} li
1733   restituisca sempre tutti; avendo scelto una dimensione ridotta per il buffer
1734   questo sarà sempre vero, vedremo più avanti come superare il problema di
1735   rileggere indietro tutti e soli i dati disponibili, senza bloccarsi.} sul
1736 buffer di ricezione e viene inserita (\texttt{\small 8}) la terminazione della
1737 stringa e per poter usare (\texttt{\small 9}) la funzione \func{fputs} per
1738 scriverli su \file{stdout}.
1739
1740 \begin{figure}[!htbp]
1741   \footnotesize \centering
1742   \begin{minipage}[c]{\codesamplewidth}
1743     \includecodesample{listati/ClientEcho_first.c}
1744   \end{minipage} 
1745   \normalsize
1746   \caption{Codice della prima versione della funzione \texttt{ClientEcho} per 
1747     la gestione del servizio \textit{echo}.}
1748   \label{fig:TCP_client_echo_sub}
1749 \end{figure}
1750
1751 Quando si concluderà l'invio di dati mandando un end-of-file sullo standard
1752 input si avrà il ritorno di \func{fgets} con un puntatore nullo (si riveda
1753 quanto spiegato in sez.~\ref{sec:file_line_io}) e la conseguente uscita dal
1754 ciclo; al che la subroutine ritorna ed il nostro programma client termina.
1755
1756 Si può effettuare una verifica del funzionamento del client abilitando il
1757 servizio \textit{echo} nella configurazione di \cmd{initd} sulla propria
1758 macchina ed usandolo direttamente verso di esso in locale, vedremo in
1759 dettaglio più avanti (in sez.~\ref{sec:TCP_echo_startup}) il funzionamento del
1760 programma, usato però con la nostra versione del server \textit{echo}, che
1761 illustriamo immediatamente.
1762
1763
1764 \subsection{Il server \textit{echo}: prima versione}
1765 \label{sec:TCPsimp_server_main}
1766
1767 La prima versione del server, contenuta nel file \texttt{TCP\_echod\_first.c},
1768 è riportata in fig.~\ref{fig:TCP_echo_server_first_code}. Come abbiamo fatto
1769 per il client anche il server è stato diviso in un corpo principale,
1770 costituito dalla funzione \code{main}, che è molto simile a quello visto nel
1771 precedente esempio per il server del servizio \textit{daytime} di
1772 sez.~\ref{sec:TCP_daytime_cunc_server}, e da una funzione ausiliaria
1773 \code{ServEcho} che si cura della gestione del servizio.
1774
1775 \begin{figure}[!htbp]
1776   \footnotesize \centering
1777   \begin{minipage}[c]{\codesamplewidth}
1778     \includecodesample{listati/TCP_echod_first.c}
1779   \end{minipage} 
1780   \normalsize
1781   \caption{Codice del corpo principale della prima versione del server
1782     per il servizio \textit{echo}.}
1783   \label{fig:TCP_echo_server_first_code}
1784 \end{figure}
1785
1786 In questo caso però, rispetto a quanto visto nell'esempio di
1787 fig.~\ref{fig:TCP_daytime_cunc_server_code} si è preferito scrivere il server
1788 curando maggiormente alcuni dettagli, per tenere conto anche di alcune
1789 esigenze generali (che non riguardano direttamente la rete), come la
1790 possibilità di lanciare il server anche in modalità interattiva e la cessione
1791 dei privilegi di amministratore non appena questi non sono più necessari.
1792
1793 La sezione iniziale del programma (\texttt{\small 8--21}) è la stessa del
1794 server di sez.~\ref{sec:TCP_daytime_cunc_server}, ed ivi descritta in
1795 dettaglio: crea il socket, inizializza l'indirizzo e esegue \func{bind}; dato
1796 che quest'ultima funzione viene usata su una porta riservata, il server dovrà
1797 essere eseguito da un processo con i privilegi di amministratore, pena il
1798 fallimento della chiamata.
1799
1800 Una volta eseguita la funzione \func{bind} però i privilegi di amministratore
1801 non sono più necessari, per questo è sempre opportuno rilasciarli, in modo da
1802 evitare problemi in caso di eventuali vulnerabilità del server.  Per questo
1803 prima (\texttt{\small 22--26}) si esegue \func{setgid} per assegnare il
1804 processo ad un gruppo senza privilegi,\footnote{si è usato il valore 65534,
1805   ovvero -1 per il formato \ctyp{short}, che di norma in tutte le
1806   distribuzioni viene usato per identificare il gruppo \texttt{nogroup} e
1807   l'utente \texttt{nobody}, usati appunto per eseguire programmi che non
1808   richiedono nessun privilegio particolare.} e poi si ripete (\texttt{\small
1809   27--30}) l'operazione usando \func{setuid} per cambiare anche
1810 l'utente.\footnote{si tenga presente che l'ordine in cui si eseguono queste
1811   due operazioni è importante, infatti solo avendo i privilegi di
1812   amministratore si può cambiare il gruppo di un processo ad un altro di cui
1813   non si fa parte, per cui chiamare prima \func{setuid} farebbe fallire una
1814   successiva chiamata a \func{setgid}.  Inoltre si ricordi (si riveda quanto
1815   esposto in sez.~\ref{sec:proc_perms}) che usando queste due funzioni il
1816   rilascio dei privilegi è irreversibile.}  Infine (\texttt{\small 30--36}),
1817 qualora sia impostata la variabile \var{demonize}, prima (\texttt{\small 31})
1818 si apre il sistema di logging per la stampa degli errori, e poi
1819 (\texttt{\small 32--35}) si invoca \func{daemon} per eseguire in background il
1820 processo come demone.
1821
1822 A questo punto il programma riprende di nuovo lo schema già visto usato dal
1823 server per il servizio \textit{daytime}, con l'unica differenza della chiamata
1824 alla funzione \code{PrintErr}, riportata in fig.~\ref{fig:TCP_PrintErr}, al
1825 posto di \func{perror} per la stampa degli errori. 
1826
1827 Si inizia con il porre (\texttt{\small 37--41}) in ascolto il socket, e poi si
1828 esegue indefinitamente il ciclo principale (\texttt{\small 42--59}).
1829 All'interno di questo si ricevono (\texttt{\small 43--47}) le connessioni,
1830 creando (\texttt{\small 48--51}) un processo figlio per ciascuna di esse.
1831 Quest'ultimo (\texttt{\small 52--56}), chiuso (\texttt{\small 53}) il
1832 \textit{listening socket}, esegue (\texttt{\small 54}) la funzione di gestione
1833 del servizio \code{ServEcho}, ed al ritorno di questa esce (\texttt{\small
1834   55}).
1835
1836 Il padre invece si limita (\texttt{\small 57}) a chiudere il \textit{connected
1837   socket} per ricominciare da capo il ciclo in attesa di nuove connessioni. In
1838 questo modo si ha un server concorrente. La terminazione del padre non è
1839 gestita esplicitamente, e deve essere effettuata inviando un segnale al
1840 processo.
1841
1842 Avendo trattato direttamente la gestione del programma come demone, si è
1843 dovuto anche provvedere alla necessità di poter stampare eventuali messaggi di
1844 errore attraverso il sistema del \textit{syslog} trattato in
1845 sez.~\ref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando
1846 come \textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato
1847 in fig.~\ref{fig:TCP_PrintErr}.
1848
1849 In essa ci si limita a controllare (\texttt{\small 2}) se è stato impostato
1850 (valore attivo per default) l'uso come demone, nel qual caso (\texttt{\small
1851   3}) si usa \func{syslog} (vedi sez.~\ref{sec:sess_daemon}) per stampare il
1852 messaggio di errore fornito come argomento sui log di sistema. Se invece si è
1853 in modalità interattiva (attivabile con l'opzione \texttt{-i}) si usa
1854 (\texttt{\small 5}) semplicemente la funzione \func{perror} per stampare sullo
1855 standard error.
1856
1857 \begin{figure}[!htbp]
1858   \footnotesize \centering
1859   \begin{minipage}[c]{\codesamplewidth}
1860     \includecodesample{listati/PrintErr.c}
1861   \end{minipage} 
1862   \normalsize
1863   \caption{Codice della funzione \code{PrintErr} per la
1864     generalizzazione della stampa degli errori sullo standard input o
1865     attraverso il \texttt{syslog}.}
1866   \label{fig:TCP_PrintErr}
1867 \end{figure}
1868
1869 La gestione del servizio \textit{echo} viene effettuata interamente nella
1870 funzione \code{ServEcho}, il cui codice è mostrato in
1871 fig.~\ref{fig:TCP_ServEcho_first}, e la comunicazione viene gestita all'interno
1872 di un ciclo (\texttt{\small 6--13}).  I dati inviati dal client vengono letti
1873 (\texttt{\small 6}) dal socket con una semplice \func{read}, di cui non si
1874 controlla lo stato di uscita, assumendo che ritorni solo in presenza di dati
1875 in arrivo. La riscrittura (\texttt{\small 7}) viene invece gestita dalla
1876 funzione \func{FullWrite} (descritta in fig.~\ref{fig:sock_FullWrite_code}) che
1877 si incarica di tenere conto automaticamente della possibilità che non tutti i
1878 dati di cui è richiesta la scrittura vengano trasmessi con una singola
1879 \func{write}.
1880
1881 \begin{figure}[!htbp] 
1882   \footnotesize \centering
1883   \begin{minipage}[c]{\codesamplewidth}
1884     \includecodesample{listati/ServEcho_first.c}
1885   \end{minipage} 
1886   \normalsize
1887   \caption{Codice della prima versione della funzione \code{ServEcho} per la
1888     gestione del servizio \textit{echo}.}
1889   \label{fig:TCP_ServEcho_first}
1890 \end{figure}
1891
1892 In caso di errore di scrittura (si ricordi che \func{FullWrite} restituisce un
1893 valore nullo in caso di successo) si provvede (\texttt{\small 8--10}) a
1894 stampare il relativo messaggio con \func{PrintErr}.  Quando il client chiude
1895 la connessione il ricevimento del FIN fa ritornare la \func{read} con un
1896 numero di byte letti pari a zero, il che causa l'uscita dal ciclo e il ritorno
1897 (\texttt{\small 12}) della funzione, che a sua volta causa la terminazione del
1898 processo figlio.
1899
1900
1901 \subsection{L'avvio e il funzionamento normale}
1902 \label{sec:TCP_echo_startup}
1903
1904 Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà
1905 di considerare in dettaglio le varie problematiche che si possono incontrare
1906 nello scrivere un'applicazione di rete. Infatti attraverso l'esame delle sue
1907 modalità di funzionamento normali, all'avvio e alla terminazione, e di quello
1908 che avviene nelle varie situazioni limite, da una parte potremo approfondire
1909 la comprensione del protocollo TCP/IP e dall'altra ricavare le indicazioni
1910 necessarie per essere in grado di scrivere applicazioni robuste, in grado di
1911 gestire anche i casi limite.
1912
1913 Il primo passo è compilare e lanciare il server (da root, per poter usare la
1914 porta 7 che è riservata), alla partenza esso eseguirà l'apertura passiva con
1915 la sequenza delle chiamate a \func{socket}, \func{bind}, \func{listen} e poi
1916 si bloccherà nella \func{accept}. A questo punto si potrà controllarne lo
1917 stato con \cmd{netstat}:
1918 \begin{verbatim}
1919 [piccardi@roke piccardi]$ netstat -at
1920 Active Internet connections (servers and established)
1921 Proto Recv-Q Send-Q Local Address           Foreign Address         State 
1922 ...
1923 tcp        0      0 *:echo                  *:*                     LISTEN
1924 ...
1925 \end{verbatim} %$
1926 che ci mostra come il socket sia in ascolto sulla porta richiesta, accettando
1927 connessioni da qualunque indirizzo e da qualunque porta e su qualunque
1928 interfaccia locale.
1929
1930 A questo punto si può lanciare il client, esso chiamerà \func{socket} e
1931 \func{connect}; una volta completato il \itindex{three~way~handshake}
1932 \textit{three way handshake} la connessione è stabilita; la \func{connect}
1933 ritornerà nel client\footnote{si noti che è sempre la \func{connect} del
1934   client a ritornare per prima, in quanto questo avviene alla ricezione del
1935   secondo segmento (l'ACK del server) del \itindex{three~way~handshake}
1936   \textit{three way handshake}, la \func{accept} del server ritorna solo dopo
1937   un altro mezzo RTT quando il terzo segmento (l'ACK del client) viene
1938   ricevuto.}  e la \func{accept} nel server, ed usando di nuovo \cmd{netstat}
1939 otterremmo che:
1940 \begin{verbatim}
1941 Active Internet connections (servers and established)
1942 Proto Recv-Q Send-Q Local Address           Foreign Address         State
1943 tcp        0      0 *:echo                  *:*                     LISTEN
1944 tcp        0      0 roke:echo               gont:32981              ESTABLISHED
1945 \end{verbatim}
1946 mentre per quanto riguarda l'esecuzione dei programmi avremo che:
1947 \begin{itemize}
1948 \item il client chiama la funzione \code{ClientEcho} che si blocca sulla
1949   \func{fgets} dato che non si è ancora scritto nulla sul terminale.
1950 \item il server eseguirà una \func{fork} facendo chiamare al processo figlio
1951   la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read}
1952   dal socket sul quale ancora non sono presenti dati.
1953 \item il processo padre del server chiamerà di nuovo \func{accept}
1954   bloccandosi fino all'arrivo di un'altra connessione.
1955 \end{itemize}
1956 e se usiamo il comando \cmd{ps} per esaminare lo stato dei processi otterremo
1957 un risultato del tipo:
1958 \begin{verbatim}
1959 [piccardi@roke piccardi]$ ps ax
1960   PID TTY      STAT   TIME COMMAND
1961  ...  ...      ...    ...  ...
1962  2356 pts/0    S      0:00 ./echod
1963  2358 pts/1    S      0:00 ./echo 127.0.0.1
1964  2359 pts/0    S      0:00 ./echod
1965 \end{verbatim} %$
1966 (dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di
1967 tre processi, tutti in stato di \textit{sleep} (vedi
1968 tab.~\ref{tab:proc_proc_states}).
1969
1970 Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso
1971 niente fin tanto che non si prema il tasto di a capo (si ricordi quanto detto
1972 in sez.~\ref{sec:file_line_io} a proposito dell'I/O su terminale), solo allora
1973 \func{fgets} ritornerà ed il client scriverà quanto immesso sul socket, per
1974 poi passare a rileggere quanto gli viene inviato all'indietro dal server, che
1975 a sua volta sarà inviato sullo standard output, che nel caso ne provoca
1976 l'immediata stampa a video.
1977
1978
1979 \subsection{La conclusione normale}
1980 \label{sec:TCP_echo_conclusion}
1981
1982 Tutto quello che scriveremo sul client sarà rimandato indietro dal server e
1983 ristampato a video fintanto che non concluderemo l'immissione dei dati; una
1984 sessione tipica sarà allora del tipo: 
1985 \begin{verbatim}
1986 [piccardi@roke sources]$ ./echo 127.0.0.1
1987 Questa e` una prova
1988 Questa e` una prova
1989 Ho finito
1990 Ho finito
1991 \end{verbatim} %$
1992 che termineremo inviando un EOF dal terminale (usando la combinazione di tasti
1993 ctrl-D, che non compare a schermo); se eseguiamo un \cmd{netstat} a questo
1994 punto avremo:
1995 \begin{verbatim}
1996 [piccardi@roke piccardi]$ netstat -at 
1997 tcp        0      0 *:echo                  *:*                     LISTEN
1998 tcp        0      0 localhost:33032         localhost:echo          TIME_WAIT
1999 \end{verbatim} %$
2000 con il client che entra in \texttt{TIME\_WAIT}.
2001
2002 Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
2003 terminazione normale della connessione, che ci servirà poi da riferimento
2004 quando affronteremo il comportamento in caso di conclusioni anomale:
2005
2006 \begin{enumerate}
2007 \item inviando un carattere di EOF da terminale la \func{fgets} ritorna
2008   restituendo un puntatore nullo che causa l'uscita dal ciclo di \code{while},
2009   così la funzione \code{ClientEcho} ritorna.
2010 \item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e
2011   come parte del processo di terminazione tutti i file descriptor vengono chiusi
2012   (si ricordi quanto detto in sez.~\ref{sec:proc_term_conclusion}); questo
2013   causa la chiusura del socket di comunicazione; il client allora invierà un
2014   FIN al server a cui questo risponderà con un ACK.  A questo punto il client
2015   verrà a trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato
2016   \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in
2017   sez.~\ref{sec:TCP_conn_term}).
2018 \item quando il server riceve il FIN la \func{read} del processo figlio che
2019   gestisce la connessione ritorna restituendo 0 causando così l'uscita dal
2020   ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio
2021   termina chiamando \func{exit}.
2022 \item all'uscita del figlio tutti i file descriptor vengono chiusi, la
2023   chiusura del socket connesso fa sì che venga effettuata la sequenza finale
2024   di chiusura della connessione, viene emesso un FIN dal server che riceverà
2025   un ACK dal client, a questo punto la connessione è conclusa e il client
2026   resta nello stato \texttt{TIME\_WAIT}.
2027 \end{enumerate}
2028
2029
2030 \subsection{La gestione dei processi figli}
2031 \label{sec:TCP_child_hand}
2032
2033 Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
2034 del procedimento di chiusura del processo figlio nel server (si veda quanto
2035 esaminato in sez.~\ref{sec:proc_termination}). In questo caso avremo l'invio
2036 del segnale \signal{SIGCHLD} al padre, ma dato che non si è installato un
2037 gestore e che l'azione predefinita per questo segnale è quella di essere
2038 ignorato, non avendo predisposto la ricezione dello stato di terminazione,
2039 otterremo che il processo figlio entrerà nello stato di \textit{zombie} (si
2040 riveda quanto illustrato in sez.~\ref{sec:sig_sigchld}), come risulterà
2041 ripetendo il comando \cmd{ps}:
2042 \begin{verbatim}
2043  2356 pts/0    S      0:00 ./echod
2044  2359 pts/0    Z      0:00 [echod <defunct>]
2045 \end{verbatim}
2046
2047 Dato che non è il caso di lasciare processi \textit{zombie}, occorrerà
2048 ricevere opportunamente lo stato di terminazione del processo (si veda
2049 sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \signal{SIGCHLD}
2050 secondo quanto illustrato in sez.~\ref{sec:sig_sigchld}. Una prima modifica al
2051 nostro server è pertanto quella di inserire la gestione della terminazione dei
2052 processi figli attraverso l'uso di un gestore.  Per questo useremo la funzione
2053 \code{Signal} (che abbiamo illustrato in fig.~\ref{fig:sig_Signal_code}), per
2054 installare il gestore che riceve i segnali dei processi figli terminati già
2055 visto in fig.~\ref{fig:sig_sigchld_handl}.  Basterà allora aggiungere il
2056 seguente codice: \includecodesnip{listati/sigchildhand.c}
2057 \noindent
2058 all'esempio illustrato in fig.~\ref{fig:TCP_echo_server_first_code}.
2059
2060 In questo modo però si introduce un altro problema. Si ricordi infatti che,
2061 come spiegato in sez.~\ref{sec:sig_gen_beha}, quando un programma si trova in
2062 stato di \texttt{sleep} durante l'esecuzione di una \textit{system call},
2063 questa viene interrotta alla ricezione di un segnale. Per questo motivo, alla
2064 fine dell'esecuzione del gestore del segnale, se questo ritorna, il programma
2065 riprenderà l'esecuzione ritornando dalla \textit{system call} interrotta con
2066 un errore di \errcode{EINTR}.
2067
2068 Vediamo allora cosa comporta tutto questo nel nostro caso: quando si chiude il
2069 client, il processo figlio che gestisce la connessione terminerà, ed il padre,
2070 per evitare la creazione di \textit{zombie}, riceverà il segnale
2071 \signal{SIGCHLD} eseguendo il relativo gestore. Al ritorno del gestore però
2072 l'esecuzione nel padre ripartirà subito con il ritorno della funzione
2073 \func{accept} (a meno di un caso fortuito in cui il segnale arriva durante
2074 l'esecuzione del programma in risposta ad una connessione) con un errore di
2075 \errcode{EINTR}. Non avendo previsto questa eventualità il programma considera
2076 questo un errore fatale terminando a sua volta con un messaggio del tipo:
2077 \begin{verbatim}
2078 [root@gont sources]# ./echod -i
2079 accept error: Interrupted system call
2080 \end{verbatim}%#
2081
2082 Come accennato in sez.~\ref{sec:sig_gen_beha} le conseguenze di questo
2083 comportamento delle \textit{system call} possono essere superate in due modi
2084 diversi, il più semplice è quello di modificare il codice di \func{Signal} per
2085 richiedere il riavvio automatico delle \textit{system call} interrotte secondo
2086 la semantica di BSD, usando l'opzione \const{SA\_RESTART} di \func{sigaction};
2087 rispetto a quanto visto in fig.~\ref{fig:sig_Signal_code}. Definiremo allora
2088 la nuova funzione \func{SignalRestart}\footnote{anche questa è definita,
2089   insieme alle altre funzioni riguardanti la gestione dei segnali, nel file
2090   \file{SigHand.c}, il cui contento completo può essere trovato negli esempi
2091   allegati.} come mostrato in fig.~\ref{fig:sig_SignalRestart_code}, ed
2092 installeremo il gestore usando quest'ultima.
2093
2094 \begin{figure}[!htbp]
2095   \footnotesize \centering
2096   \begin{minipage}[c]{\codesamplewidth}
2097     \includecodesample{listati/SignalRestart.c}
2098   \end{minipage}  
2099   \normalsize 
2100   \caption{La funzione \func{SignalRestart}, che installa un gestore di
2101     segnali in semantica BSD per il riavvio automatico delle \textit{system
2102       call} interrotte.}
2103   \label{fig:sig_SignalRestart_code}
2104 \end{figure}
2105
2106 Come si può notare questa funzione è identica alla precedente \func{Signal},
2107 illustrata in fig.~\ref{fig:sig_Signal_code}, solo che in questo caso invece
2108 di inizializzare a zero il campo \var{sa\_flags} di \struct{sigaction}, lo si
2109 inizializza (\texttt{\small 5}) al valore \const{SA\_RESTART}. Usando questa
2110 funzione al posto di \func{Signal} nel server non è necessaria nessuna altra
2111 modifica: le \textit{system call} interrotte saranno automaticamente
2112 riavviate, e l'errore \errcode{EINTR} non si manifesterà più.
2113
2114 La seconda soluzione è più invasiva e richiede di controllare tutte le volte
2115 l'errore restituito dalle varie \textit{system call}, ripetendo la chiamata
2116 qualora questo corrisponda ad \errcode{EINTR}. Questa soluzione ha però il
2117 pregio della portabilità, infatti lo standard POSIX dice che la funzionalità
2118 di riavvio automatico delle \textit{system call}, fornita da
2119 \const{SA\_RESTART}, è opzionale, per cui non è detto che essa sia disponibile
2120 su qualunque sistema.  Inoltre in certi casi,\footnote{Stevens in \cite{UNP1}
2121   accenna che la maggior parte degli Unix derivati da BSD non fanno ripartire
2122   \func{select}; altri non riavviano neanche \func{accept} e \func{recvfrom},
2123   cosa che invece nel caso di Linux viene sempre fatta.} anche quando questa è
2124 presente, non è detto possa essere usata con \func{accept}.
2125
2126
2127 La portabilità nella gestione dei segnali però viene al costo di una
2128 riscrittura parziale del server, la nuova versione di questo, in cui si sono
2129 introdotte una serie di nuove opzioni che ci saranno utili per il debug, è
2130 mostrata in fig.~\ref{fig:TCP_echo_server_code_second}, dove si sono riportate
2131 la sezioni di codice modificate nella seconda versione del programma, il
2132 codice completo di quest'ultimo si trova nel file
2133 \texttt{TCP\_echod\_second.c} dei sorgenti allegati alla guida.
2134
2135 La prima modifica effettuata è stata quella di introdurre una nuova opzione a
2136 riga di comando, \texttt{-c}, che permette di richiedere il comportamento
2137 compatibile nella gestione di \signal{SIGCHLD} al posto della semantica BSD
2138 impostando la variabile \var{compat} ad un valore non nullo. Questa è
2139 preimpostata al valore nullo, cosicché se non si usa questa opzione il
2140 comportamento di default del server è di usare la semantica BSD. 
2141
2142 Una seconda opzione aggiunta è quella di inserire un tempo di attesa fisso
2143 specificato in secondi fra il ritorno della funzione \func{listen} e la
2144 chiamata di \func{accept}, specificabile con l'opzione \texttt{-w}, che
2145 permette di impostare la variabile \var{waiting}.  Infine si è introdotta una
2146 opzione \texttt{-d} per abilitare il debugging che imposta ad un valore non
2147 nullo la variabile \var{debugging}. Al solito si è omessa da
2148 fig.~\ref{fig:TCP_echo_server_code_second} la sezione di codice relativa alla
2149 gestione di tutte queste opzioni, che può essere trovata nel sorgente del
2150 programma.
2151
2152 \begin{figure}[!htbp]
2153   \footnotesize \centering
2154   \begin{minipage}[c]{\codesamplewidth}
2155     \includecodesample{listati/TCP_echod_second.c}
2156   \end{minipage} 
2157   \normalsize
2158   \caption{La sezione nel codice della seconda versione del server
2159     per il servizio \textit{echo} modificata per tener conto dell'interruzione
2160     delle \textit{system call}.}
2161   \label{fig:TCP_echo_server_code_second}
2162 \end{figure}
2163
2164 Vediamo allora come è cambiato il nostro server; una volta definite le
2165 variabili e trattate le opzioni il primo passo (\texttt{\small 9--13}) è
2166 verificare la semantica scelta per la gestione di \signal{SIGCHLD}, a seconda
2167 del valore di \var{compat} (\texttt{\small 9}) si installa il gestore con la
2168 funzione \func{Signal} (\texttt{\small 10}) o con \texttt{SignalRestart}
2169 (\texttt{\small 12}), essendo quest'ultimo il valore di default.
2170
2171 Tutta la sezione seguente, che crea il socket, cede i privilegi di
2172 amministratore ed eventualmente lancia il programma come demone, è rimasta
2173 invariata e pertanto è stata omessa in
2174 fig.~\ref{fig:TCP_echo_server_code_second}; l'unica modifica effettuata prima
2175 dell'entrata nel ciclo principale è stata quella di aver introdotto, subito
2176 dopo la chiamata (\texttt{\small 17--20}) alla funzione \func{listen}, una
2177 eventuale pausa con una condizione (\texttt{\small 21}) sulla variabile
2178 \var{waiting}, che viene inizializzata, con l'opzione \texttt{-w Nsec}, al
2179 numero di secondi da aspettare (il valore preimpostato è nullo).
2180
2181 Si è potuto lasciare inalterata tutta la sezione di creazione del socket
2182 perché nel server l'unica chiamata ad una \textit{system call} lenta, che può
2183 essere interrotta dall'arrivo di \signal{SIGCHLD}, è quella ad \func{accept},
2184 che è l'unica funzione che può mettere il processo padre in stato di sleep nel
2185 periodo in cui un figlio può terminare; si noti infatti come le altre
2186 \index{system~call~lente} \textit{system call} lente (si ricordi la
2187 distinzione fatta in sez.~\ref{sec:sig_gen_beha}) o sono chiamate prima di
2188 entrare nel ciclo principale, quando ancora non esistono processi figli, o
2189 sono chiamate dai figli stessi e non risentono di \signal{SIGCHLD}.
2190
2191 Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small
2192   23--42}), rispetto precedente versione di fig.~\ref{fig:TCP_ServEcho_first},
2193 è nella sezione (\texttt{\small 25--31}) in cui si effettua la chiamata di
2194 \func{accept}.  Quest'ultima viene effettuata (\texttt{\small 26--27})
2195 all'interno di un ciclo di \code{while}\footnote{la sintassi del C relativa a
2196   questo ciclo può non essere del tutto chiara. In questo caso infatti si è
2197   usato un ciclo vuoto che non esegue nessuna istruzione, in questo modo
2198   quello che viene ripetuto con il ciclo è soltanto il codice che esprime la
2199   condizione all'interno del \code{while}.}  che la ripete indefinitamente
2200 qualora in caso di errore il valore di \var{errno} sia \errcode{EINTR}. Negli
2201 altri casi si esce in caso di errore effettivo (\texttt{\small 27--29}),
2202 altrimenti il programma prosegue.
2203
2204 Si noti che in questa nuova versione si è aggiunta una ulteriore sezione
2205 (\texttt{\small 32--40}) di aiuto per il debug del programma, che eseguita con
2206 un controllo (\texttt{\small 33}) sul valore della variabile \var{debugging}
2207 impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come
2208 preimpostato, non accade nulla. altrimenti (\texttt{\small 33}) l'indirizzo
2209 ricevuto da \var{accept} viene convertito in una stringa che poi
2210 (\texttt{\small 34--39}) viene opportunamente stampata o sullo schermo o nei
2211 log.
2212
2213 Infine come ulteriore miglioria si è perfezionata la funzione \code{ServEcho},
2214 sia per tenere conto della nuova funzionalità di debugging, che per effettuare
2215 un controllo in caso di errore; il codice della nuova versione è mostrato in
2216 fig.~\ref{fig:TCP_ServEcho_second}.
2217
2218 \begin{figure}[!htbp] 
2219   \footnotesize \centering
2220   \begin{minipage}[c]{\codesamplewidth}
2221     \includecodesample{listati/ServEcho_second.c}
2222   \end{minipage} 
2223   \normalsize
2224   \caption{Codice della seconda versione della funzione \code{ServEcho} per la
2225     gestione del servizio \textit{echo}.}
2226   \label{fig:TCP_ServEcho_second}
2227 \end{figure}
2228
2229 Rispetto alla precedente versione di fig.~\ref{fig:TCP_ServEcho_first} in
2230 questo caso si è provveduto a controllare (\texttt{\small 7--10}) il valore di
2231 ritorno di \func{read} per rilevare un eventuale errore, in modo da stampare
2232 (\texttt{\small 8}) un messaggio di errore e ritornare (\texttt{\small 9})
2233 concludendo la connessione.
2234
2235 Inoltre qualora sia stata attivata la funzionalità di debug (avvalorando
2236 \var{debugging} tramite l'apposita opzione \texttt{-d}) si provvederà a
2237 stampare (tenendo conto della modalità di invocazione del server, se
2238 interattiva o in forma di demone) il numero di byte e la stringa letta dal
2239 client (\texttt{\small 16--24}).
2240
2241
2242 \section{I vari scenari critici}
2243 \label{sec:TCP_echo_critical}
2244
2245 Con le modifiche viste in sez.~\ref{sec:TCP_child_hand} il nostro esempio
2246 diventa in grado di affrontare la gestione ordinaria delle connessioni, ma un
2247 server di rete deve tenere conto che, al contrario di quanto avviene per i
2248 server che operano nei confronti di processi presenti sulla stessa macchina,
2249 la rete è di sua natura inaffidabile, per cui è necessario essere in grado di
2250 gestire tutta una serie di situazioni critiche che non esistono per i processi
2251 locali.
2252
2253
2254 \subsection{La terminazione precoce della connessione}
2255 \label{sec:TCP_conn_early_abort}
2256
2257 La prima situazione critica è quella della terminazione precoce, causata da un
2258 qualche errore sulla rete, della connessione effettuata da un client. Come
2259 accennato in sez.~\ref{sec:TCP_func_accept} la funzione \func{accept} riporta
2260 tutti gli eventuali errori di rete pendenti su una connessione sul
2261 \textit{connected socket}. Di norma questo non è un problema, in quanto non
2262 appena completata la connessione, \func{accept} ritorna e l'errore sarà
2263 rilevato in seguito, dal processo che gestisce la connessione, alla prima
2264 chiamata di una funzione che opera sul socket.
2265
2266 È però possibile, dal punto di vista teorico, incorrere anche in uno scenario
2267 del tipo di quello mostrato in fig.~\ref{fig:TCP_early_abort}, in cui la
2268 connessione viene abortita sul lato client per un qualche errore di rete con
2269 l'invio di un segmento RST, prima che nel server sia stata chiamata la
2270 funzione \func{accept}.
2271
2272 \begin{figure}[!htb]
2273   \centering \includegraphics[width=10cm]{img/tcp_client_early_abort}  
2274   \caption{Un possibile caso di terminazione precoce della connessione.}
2275   \label{fig:TCP_early_abort}
2276 \end{figure}
2277
2278 Benché questo non sia un fatto comune, un evento simile può essere osservato
2279 con dei server molto occupati. In tal caso, con una struttura del server
2280 simile a quella del nostro esempio, in cui la gestione delle singole
2281 connessioni è demandata a processi figli, può accadere che il \textit{three
2282   way handshake} \itindex{three~way~handshake} venga completato e la relativa
2283 connessione abortita subito dopo, prima che il padre, per via del carico della
2284 macchina, abbia fatto in tempo ad eseguire la chiamata ad \func{accept}. Di
2285 nuovo si ha una situazione analoga a quella illustrata in
2286 fig.~\ref{fig:TCP_early_abort}, in cui la connessione viene stabilita, ma
2287 subito dopo si ha una condizione di errore che la chiude prima che essa sia
2288 stata accettata dal programma.
2289
2290 Questo significa che, oltre alla interruzione da parte di un segnale, che
2291 abbiamo trattato in sez.~\ref{sec:TCP_child_hand} nel caso particolare di
2292 \signal{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
2293 \func{accept}, che come nel caso precedente, necessitano semplicemente la
2294 ripetizione della chiamata senza che si debba uscire dal programma. In questo
2295 caso anche la versione modificata del nostro server non sarebbe adatta, in
2296 quanto uno di questi errori causerebbe la terminazione dello stesso. In Linux
2297 i possibili errori di rete non fatali, riportati sul socket connesso al
2298 ritorno di \func{accept}, sono \errcode{ENETDOWN}, \errcode{EPROTO},
2299 \errcode{ENOPROTOOPT}, \errcode{EHOSTDOWN}, \errcode{ENONET},
2300 \errcode{EHOSTUNREACH}, \errcode{EOPNOTSUPP} e \errcode{ENETUNREACH}.
2301
2302 Si tenga presente che questo tipo di terminazione non è riproducibile
2303 terminando il client prima della chiamata ad \func{accept}, come si potrebbe
2304 fare usando l'opzione \texttt{-w} per introdurre una pausa dopo il lancio del
2305 demone, in modo da poter avere il tempo per lanciare e terminare una
2306 connessione usando il programma client. In tal caso infatti, alla terminazione
2307 del client, il socket associato alla connessione viene semplicemente chiuso,
2308 attraverso la sequenza vista in sez.~\ref{sec:TCP_conn_term}, per cui la
2309 \func{accept} ritornerà senza errori, e si avrà semplicemente un end-of-file
2310 al primo accesso al socket. Nel caso di Linux inoltre, anche qualora si
2311 modifichi il client per fargli gestire l'invio di un segmento di RST alla
2312 chiusura dal socket (usando l'opzione \const{SO\_LINGER}, vedi
2313 sez.~\ref{sec:sock_options_main}), non si ha nessun errore al ritorno di
2314 \func{accept}, quanto un errore di \errcode{ECONNRESET} al primo tentativo di
2315 accesso al socket.
2316
2317
2318
2319 \subsection{La terminazione precoce del server}
2320 \label{sec:TCP_server_crash}
2321
2322 Un secondo caso critico è quello in cui si ha una terminazione precoce del
2323 server, ad esempio perché il programma ha un crash. In tal caso si suppone che
2324 il processo termini per un errore fatale, cosa che potremo simulare
2325 inviandogli un segnale di terminazione. La conclusione del processo comporta
2326 la chiusura di tutti i file descriptor aperti, compresi tutti i socket
2327 relativi a connessioni stabilite; questo significa che al momento del crollo
2328 del servizio il client riceverà un FIN dal server in corrispondenza della
2329 chiusura del socket.
2330
2331 Vediamo allora cosa succede nel nostro caso, facciamo partire una connessione
2332 con il server e scriviamo una prima riga, poi terminiamo il server con un
2333 \texttt{C-c}. A questo punto scriviamo una seconda riga e poi un'altra riga
2334 ancora. Il risultato finale della sessione è il seguente:
2335 \begin{verbatim}
2336 [piccardi@gont sources]$ ./echo 192.168.1.141
2337 Prima riga
2338 Prima riga
2339 Seconda riga dopo il C-c
2340 Altra riga
2341 [piccardi@gont sources]$
2342 \end{verbatim}
2343
2344 Come si vede il nostro client, nonostante la connessione sia stata interrotta
2345 prima dell'invio della seconda riga, non solo accetta di inviarla, ma prende
2346 anche un'altra riga prima di terminare senza riportare nessun
2347 errore. 
2348
2349 Per capire meglio cosa è successo conviene analizzare il flusso dei pacchetti
2350 utilizzando un analizzatore di traffico come \cmd{tcpdump}. Il comando
2351 permette di selezionare, nel traffico di rete generato su una macchina, i
2352 pacchetti che interessano, stampando a video (o salvando su disco) il loro
2353 contenuto. Non staremo qui ad entrare nei dettagli dell'uso del programma, che
2354 sono spiegati dalla pagina di manuale; per l'uso che vogliamo farne quello che
2355 ci interessa è, posizionandosi sulla macchina che fa da client, selezionare
2356 tutti i pacchetti che sono diretti o provengono dalla macchina che fa da
2357 server. In questo modo (posto che non ci siano altre connessioni col server,
2358 cosa che avremo cura di evitare) tutti i pacchetti rilevati apparterranno alla
2359 nostra sessione di interrogazione del servizio. 
2360
2361 Il comando \cmd{tcpdump} permette selezioni molto complesse, basate sulle
2362 interfacce su cui passano i pacchetti, sugli indirizzi IP, sulle porte, sulle
2363 caratteristiche ed il contenuto dei pacchetti stessi, inoltre permette di
2364 combinare fra loro diversi criteri di selezione con degli operatori logici;
2365 quando un pacchetto che corrisponde ai criteri di selezione scelti viene
2366 rilevato i suoi dati vengono stampati sullo schermo (anche questi secondo un
2367 formato configurabile in maniera molto precisa).  
2368
2369 Lanciando il comando prima di ripetere la sessione di lavoro mostrata
2370 nell'esempio precedente potremo allora catturare tutti pacchetti scambiati fra
2371 il client ed il server; i risultati\footnote{in realtà si è ridotta la
2372   lunghezza dell'output rispetto al reale tagliando alcuni dati non necessari
2373   alla comprensione del flusso.} prodotti in questa occasione da \cmd{tcpdump}
2374 sono allora i seguenti:
2375 \begin{verbatim}
2376 [root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
2377 tcpdump: listening on eth0
2378 gont.34559 > anarres.echo: S 800922320:800922320(0) win 5840 
2379 anarres.echo > gont.34559: S 511689719:511689719(0) ack 800922321 win 5792 
2380 gont.34559 > anarres.echo: . ack 1 win 5840 
2381 gont.34559 > anarres.echo: P 1:12(11) ack 1 win 5840 
2382 anarres.echo > gont.34559: . ack 12 win 5792 
2383 anarres.echo > gont.34559: P 1:12(11) ack 12 win 5792 
2384 gont.34559 > anarres.echo: . ack 12 win 5840 
2385 anarres.echo > gont.34559: F 12:12(0) ack 12 win 5792 
2386 gont.34559 > anarres.echo: . ack 13 win 5840 
2387 gont.34559 > anarres.echo: P 12:37(25) ack 13 win 5840 
2388 anarres.echo > gont.34559: R 511689732:511689732(0) win 0 
2389 \end{verbatim}
2390
2391 Le prime tre righe vengono prodotte al momento in cui lanciamo il nostro
2392 client, e corrispondono ai tre pacchetti del \itindex{three~way~handshake}
2393 \textit{three way handshake}.  L'output del comando riporta anche i numeri di
2394 sequenza iniziali, mentre la lettera \texttt{S} indica che per quel pacchetto
2395 si aveva il SYN flag attivo.  Si noti come a partire dal secondo pacchetto sia
2396 sempre attivo il campo \texttt{ack}, seguito dal numero di sequenza per il
2397 quale si da il ricevuto; quest'ultimo, a partire dal terzo pacchetto, viene
2398 espresso in forma relativa per maggiore compattezza.  Il campo \texttt{win} in
2399 ogni riga indica la \textit{advertised window} di cui parlavamo in
2400 sez.~\ref{sec:TCP_TCP_opt}.  Allora si può verificare dall'output del comando
2401 come venga appunto realizzata la sequenza di pacchetti descritta in
2402 sez.~\ref{sec:TCP_conn_cre}: prima viene inviato dal client un primo pacchetto
2403 con il SYN che inizia la connessione, a cui il server risponde dando il
2404 ricevuto con un secondo pacchetto, che a sua volta porta un SYN, cui il client
2405 risponde con un il terzo pacchetto di ricevuto.
2406
2407 Ritorniamo allora alla nostra sessione con il servizio echo: dopo le tre righe
2408 del \itindex{three~way~handshake} \textit{three way handshake} non avremo
2409 nulla fin tanto che non scriveremo una prima riga sul client; al momento in
2410 cui facciamo questo si genera una sequenza di altri quattro pacchetti. Il
2411 primo, dal client al server, contraddistinto da una lettera \texttt{P} che
2412 significa che il flag PSH è impostato, contiene la nostra riga (che è appunto
2413 di 11 caratteri), e ad esso il server risponde immediatamente con un pacchetto
2414 vuoto di ricevuto. Poi tocca al server riscrivere indietro quanto gli è stato
2415 inviato, per cui sarà lui a mandare indietro un terzo pacchetto con lo stesso
2416 contenuto appena ricevuto, e a sua volta riceverà dal client un ACK nel quarto
2417 pacchetto.  Questo causerà la ricezione dell'eco nel client che lo stamperà a
2418 video.
2419
2420 A questo punto noi procediamo ad interrompere l'esecuzione del server con un
2421 \texttt{C-c} (cioè con l'invio di \signal{SIGTERM}): nel momento in cui
2422 facciamo questo vengono immediatamente generati altri due pacchetti. La
2423 terminazione del processo infatti comporta la chiusura di tutti i suoi file
2424 descriptor, il che comporta, per il socket che avevamo aperto, l'inizio della
2425 sequenza di chiusura illustrata in sez.~\ref{sec:TCP_conn_term}.  Questo
2426 significa che dal server partirà un FIN, che è appunto il primo dei due
2427 pacchetti, contraddistinto dalla lettera \texttt{F}, cui seguirà al solito un
2428 ACK da parte del client.  
2429
2430 A questo punto la connessione dalla parte del server è chiusa, ed infatti se
2431 usiamo \cmd{netstat} per controllarne lo stato otterremo che sul server si ha:
2432 \begin{verbatim}
2433 anarres:/home/piccardi# netstat -ant
2434 Active Internet connections (servers and established)
2435 Proto Recv-Q Send-Q Local Address           Foreign Address         State
2436 ...      ...    ... ...                     ...                     ...
2437 tcp        0      0 192.168.1.141:7         192.168.1.2:34626       FIN_WAIT2
2438 \end{verbatim}
2439 cioè essa è andata nello stato \texttt{FIN\_WAIT2}, che indica l'avvenuta
2440 emissione del segmento FIN, mentre sul client otterremo che essa è andata
2441 nello stato \texttt{CLOSE\_WAIT}:
2442 \begin{verbatim}
2443 [root@gont gapil]# netstat -ant
2444 Active Internet connections (servers and established)
2445 Proto Recv-Q Send-Q Local Address           Foreign Address         State
2446 ...      ...    ... ...                     ...                     ...
2447 tcp        1      0 192.168.1.2:34582       192.168.1.141:7         CLOSE_WAIT 
2448 \end{verbatim}
2449
2450 Il problema è che in questo momento il client è bloccato dentro la funzione
2451 \texttt{ClientEcho} nella chiamata a \func{fgets}, e sta attendendo dell'input
2452 dal terminale, per cui non è in grado di accorgersi di nulla. Solo quando
2453 inseriremo la seconda riga il comando uscirà da \func{fgets} e proverà a
2454 scriverla sul socket. Questo comporta la generazione degli ultimi due
2455 pacchetti riportati da \cmd{tcpdump}: il primo, inviato dal client contenente
2456 i 25 caratteri della riga appena letta, e ad esso la macchina server
2457 risponderà, non essendoci più niente in ascolto sulla porta 7, con un segmento
2458 di RST, contraddistinto dalla lettera \texttt{R}, che causa la conclusione
2459 definitiva della connessione anche nel client, dove non comparirà più
2460 nell'output di \cmd{netstat}.
2461
2462 Come abbiamo accennato in sez.~\ref{sec:TCP_conn_term} e come vedremo più
2463 avanti in sez.~\ref{sec:TCP_shutdown} la chiusura di un solo capo di un socket
2464 è una operazione lecita, per cui la nostra scrittura avrà comunque successo
2465 (come si può constatare lanciando usando \cmd{strace}\footnote{il comando
2466   \cmd{strace} è un comando di debug molto utile che prende come argomento un
2467   altro comando e ne stampa a video tutte le invocazioni di una \textit{system
2468     call}, coi relativi argomenti e valori di ritorno, per cui usandolo in
2469   questo contesto potremo verificare che effettivamente la \func{write} ha
2470   scritto la riga, che in effetti è stata pure trasmessa via rete.}), in
2471 quanto il nostro programma non ha a questo punto alcun modo di sapere che
2472 dall'altra parte non c'è più nessuno processo in grado di leggere quanto
2473 scriverà. Questo sarà chiaro solo dopo il tentativo di scrittura, e la
2474 ricezione del segmento RST di risposta che indica che dall'altra parte non si
2475 è semplicemente chiuso un capo del socket, ma è completamente terminato il
2476 programma.
2477
2478 Per questo motivo il nostro client proseguirà leggendo dal socket, e dato che
2479 questo è stato chiuso avremo che, come spiegato in
2480 sez.~\ref{sec:TCP_conn_term}, la funzione \func{read} ritorna normalmente con
2481 un valore nullo. Questo comporta che la seguente chiamata a \func{fputs} non
2482 ha effetto (viene stampata una stringa nulla) ed il client si blocca di nuovo
2483 nella successiva chiamata a \func{fgets}. Per questo diventa possibile
2484 inserire una terza riga e solo dopo averlo fatto si avrà la terminazione del
2485 programma.
2486
2487 Per capire come questa avvenga comunque, non avendo inserito nel codice nessun
2488 controllo di errore, occorre ricordare che, a parte la bidirezionalità del
2489 flusso dei dati, dal punto di vista del funzionamento nei confronti delle
2490 funzioni di lettura e scrittura, i socket sono del tutto analoghi a delle
2491 \textit{pipe}. Allora, da quanto illustrato in sez.~\ref{sec:ipc_pipes},
2492 sappiamo che tutte le volte che si cerca di scrivere su una \textit{pipe} il
2493 cui altro capo non è aperto il lettura il processo riceve un segnale di
2494 \signal{SIGPIPE}, e questo è esattamente quello che avviene in questo caso, e
2495 siccome non abbiamo un gestore per questo segnale, viene eseguita l'azione
2496 preimpostata, che è quella di terminare il processo.
2497
2498 Per gestire in maniera più corretta questo tipo di evento dovremo allora
2499 modificare il nostro client perché sia in grado di trattare le varie tipologie
2500 di errore, per questo dovremo riscrivere la funzione \func{ClientEcho}, in
2501 modo da controllare gli stati di uscita delle varie chiamate. Si è riportata
2502 la nuova versione della funzione in fig.~\ref{fig:TCP_ClientEcho_second}.
2503
2504 \begin{figure}[!htbp]
2505   \footnotesize \centering
2506   \begin{minipage}[c]{\codesamplewidth}
2507     \includecodesample{listati/ClientEcho_second.c}
2508   \end{minipage} 
2509   \normalsize
2510   \caption{La sezione nel codice della seconda versione della funzione
2511     \func{ClientEcho} usata dal client per il servizio \textit{echo}
2512     modificata per tener conto degli eventuali errori.}
2513   \label{fig:TCP_ClientEcho_second}
2514 \end{figure}
2515
2516 Come si può vedere in questo caso si controlla il valore di ritorno di tutte
2517 le funzioni, ed inoltre si verifica la presenza di un eventuale end of file in
2518 caso di lettura. Con questa modifica il nostro client echo diventa in grado di
2519 accorgersi della chiusura del socket da parte del server, per cui ripetendo la
2520 sequenza di operazioni precedenti stavolta otterremo che:
2521 \begin{verbatim}
2522 [piccardi@gont sources]$ ./echo 192.168.1.141
2523 Prima riga
2524 Prima riga
2525 Seconda riga dopo il C-c
2526 EOF sul socket
2527 \end{verbatim}%$
2528 ma di nuovo si tenga presente che non c'è modo di accorgersi della chiusura
2529 del socket fin quando non si esegue la scrittura della seconda riga; il
2530 protocollo infatti prevede che ci debba essere una scrittura prima di ricevere
2531 un RST che confermi la chiusura del file, e solo alle successive scritture si
2532 potrà ottenere un errore.
2533
2534 Questa caratteristica dei socket ci mette di fronte ad un altro problema
2535 relativo al nostro client, e che cioè esso non è in grado di accorgersi di
2536 nulla fintanto che è bloccato nella lettura del terminale fatta con
2537 \func{gets}. In questo caso il problema è minimo, ma esso riemergerà più
2538 avanti, ed è quello che si deve affrontare tutte le volte quando si ha a che
2539 fare con la necessità di lavorare con più descrittori, nel qual caso diventa
2540 si pone la questione di come fare a non restare bloccati su un socket quando
2541 altri potrebbero essere liberi. Vedremo come affrontare questa problematica in
2542 sez.~\ref{sec:TCP_sock_multiplexing}.
2543  
2544
2545 \subsection{Altri scenari di terminazione della connessione}
2546 \label{sec:TCP_conn_crash}
2547
2548 La terminazione del server è solo uno dei possibili scenari di terminazione
2549 della connessione, un altro caso è ad esempio quello in cui si ha un crollo
2550 della rete, cosa che potremo simulare facilmente staccando il cavo di rete.
2551 Un'altra condizione è quella di un blocco della macchina completo della su cui
2552 gira il server che deve essere riavviata, cosa che potremo simulare sia
2553 premendo il bottone di reset,\footnote{un normale shutdown non va bene; in tal
2554   caso infatti il sistema provvede a terminare tutti i processi, per cui la
2555   situazione sarebbe sostanzialmente identica alla precedente.} che, in
2556 maniera più gentile, riavviando la macchina dopo aver interrotto la
2557 connessione di rete.
2558
2559 Cominciamo ad analizzare il primo caso, il crollo della rete. Ripetiamo la
2560 nostra sessione di lavoro precedente, lanciamo il client, scriviamo una prima
2561 riga, poi stacchiamo il cavo e scriviamo una seconda riga. Il risultato che
2562 otterremo è:
2563 \begin{verbatim}
2564 [piccardi@gont sources]$ ./echo 192.168.1.141
2565 Prima riga
2566 Prima riga
2567 Seconda riga dopo l'interruzione
2568 Errore in lettura: No route to host
2569 \end{verbatim}%$
2570
2571 Quello che succede in questo è che il programma, dopo aver scritto la seconda
2572 riga, resta bloccato per un tempo molto lungo, prima di dare l'errore
2573 \errcode{EHOSTUNREACH}.  Se andiamo ad osservare con \cmd{strace} cosa accade
2574 nel periodo in cui il programma è bloccato vedremo che stavolta, a differenza
2575 del caso precedente, il programma è bloccato nella lettura dal socket.
2576
2577 Se poi, come nel caso precedente, usiamo l'accortezza di analizzare il
2578 traffico di rete fra client e server con \cmd{tcpdump}, otterremo il seguente
2579 risultato:
2580 \begin{verbatim}
2581 [root@gont sources]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
2582 tcpdump: listening on eth0
2583 gont.34685 > anarres.echo: S 1943495663:1943495663(0) win 5840
2584 anarres.echo > gont.34685: S 1215783131:1215783131(0) ack 1943495664 win 5792 
2585 gont.34685 > anarres.echo: . ack 1 win 5840
2586 gont.34685 > anarres.echo: P 1:12(11) ack 1 win 5840 
2587 anarres.echo > gont.34685: . ack 12 win 5792 
2588 anarres.echo > gont.34685: P 1:12(11) ack 12 win 5792 
2589 gont.34685 > anarres.echo: . ack 12 win 5840 
2590 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2591 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2592 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2593 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2594 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2595 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2596 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2597 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2598 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840 
2599 arp who-has anarres tell gont
2600 arp who-has anarres tell gont
2601 arp who-has anarres tell gont
2602 arp who-has anarres tell gont
2603 arp who-has anarres tell gont
2604 arp who-has anarres tell gont
2605 ...
2606 \end{verbatim}
2607
2608 In questo caso l'andamento dei primi sette pacchetti è esattamente lo stesso
2609 di prima. Solo che stavolta, non appena inviata la seconda riga, il programma
2610 si bloccherà nella successiva chiamata a \func{read}, non ottenendo nessuna
2611 risposta. Quello che succede è che nel frattempo il kernel provvede, come
2612 richiesto dal protocollo TCP, a tentare la ritrasmissione della nostra riga un
2613 certo numero di volte, con tempi di attesa crescente fra un tentativo ed il
2614 successivo, per tentare di ristabilire la connessione.
2615
2616 Il risultato finale qui dipende dall'implementazione dello stack TCP, e nel
2617 caso di Linux anche dall'impostazione di alcuni dei parametri di sistema che
2618 si trovano in \file{/proc/sys/net/ipv4}, che ne controllano il comportamento:
2619 in questo caso in particolare da \sysctlrelfile{net/ipv4}{tcp\_retries2} (vedi
2620 sez.~\ref{sec:sock_ipv4_sysctl}). Questo parametro infatti specifica il numero
2621 di volte che deve essere ritentata la ritrasmissione di un pacchetto nel mezzo
2622 di una connessione prima di riportare un errore di timeout.  Il valore
2623 preimpostato è pari a 15, il che comporterebbe 15 tentativi di ritrasmissione,
2624 ma nel nostro caso le cose sono andate diversamente, dato che le
2625 ritrasmissioni registrate da \cmd{tcpdump} sono solo 8; inoltre l'errore
2626 riportato all'uscita del client non è stato \errcode{ETIMEDOUT}, come dovrebbe
2627 essere in questo caso, ma \errcode{EHOSTUNREACH}.
2628
2629 Per capire l'accaduto continuiamo ad analizzare l'output di \cmd{tcpdump}:
2630 esso ci mostra che a un certo punto i tentativi di ritrasmissione del
2631 pacchetto sono cessati, per essere sostituiti da una serie di richieste di
2632 protocollo ARP in cui il client richiede l'indirizzo del server.
2633
2634 Come abbiamo accennato in sez.~\ref{sec:net_tcpip_general} ARP è il protocollo
2635 che si incarica di trovare le corrispondenze fra indirizzo IP e indirizzo
2636 hardware sulla scheda di rete. È evidente allora che nel nostro caso, essendo
2637 client e server sulla stessa rete, è scaduta la voce nella \textit{ARP
2638   cache}\footnote{la \textit{ARP cache} è una tabella mantenuta internamente
2639   dal kernel che contiene tutte le corrispondenze fra indirizzi IP e indirizzi
2640   fisici, ottenute appunto attraverso il protocollo ARP; le voci della tabella
2641   hanno un tempo di vita limitato, passato il quale scadono e devono essere
2642   nuovamente richieste.} relativa ad \texttt{anarres}, ed il nostro client ha
2643 iniziato ad effettuare richieste ARP sulla rete per sapere l'IP di
2644 quest'ultimo, che essendo scollegato non poteva rispondere. Anche per questo
2645 tipo di richieste esiste un timeout, per cui dopo un certo numero di tentativi
2646 il meccanismo si è interrotto, e l'errore riportato al programma a questo
2647 punto è stato \errcode{EHOSTUNREACH}, in quanto non si era più in grado di
2648 contattare il server.
2649
2650 Un altro errore possibile in questo tipo di situazione, che si può avere
2651 quando la macchina è su una rete remota, è \errcode{ENETUNREACH}; esso viene
2652 riportato alla ricezione di un pacchetto ICMP di \textit{destination
2653   unreachable} da parte del router che individua l'interruzione della
2654 connessione. Di nuovo anche qui il risultato finale dipende da quale è il
2655 meccanismo più veloce ad accorgersi del problema.
2656
2657 Se però agiamo sui parametri del kernel, e scriviamo in \file{tcp\_retries2}
2658 un valore di tentativi più basso, possiamo evitare la scadenza della
2659 \textit{ARP cache} e vedere cosa succede. Così se ad esempio richiediamo 4
2660 tentativi di ritrasmissione, l'analisi di \cmd{tcpdump} ci riporterà il
2661 seguente scambio di pacchetti:
2662 \begin{verbatim}
2663 [root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
2664 tcpdump: listening on eth0
2665 gont.34752 > anarres.echo: S 3646972152:3646972152(0) win 5840
2666 anarres.echo > gont.34752: S 2735190336:2735190336(0) ack 3646972153 win 5792 
2667 gont.34752 > anarres.echo: . ack 1 win 5840 
2668 gont.34752 > anarres.echo: P 1:12(11) ack 1 win 5840
2669 anarres.echo > gont.34752: . ack 12 win 5792 
2670 anarres.echo > gont.34752: P 1:12(11) ack 12 win 5792 
2671 gont.34752 > anarres.echo: . ack 12 win 5840 
2672 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840 
2673 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840 
2674 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840 
2675 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840 
2676 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840 
2677 \end{verbatim}
2678 e come si vede in questo caso i tentativi di ritrasmissione del pacchetto
2679 iniziale sono proprio 4 (per un totale di 5 voci con quello trasmesso la prima
2680 volta), ed in effetti, dopo un tempo molto più breve rispetto a prima ed in
2681 corrispondenza dell'invio dell'ultimo tentativo, quello che otterremo come
2682 errore all'uscita del client sarà diverso, e cioè:
2683 \begin{verbatim}
2684 [piccardi@gont sources]$ ./echo 192.168.1.141
2685 Prima riga
2686 Prima riga
2687 Seconda riga dopo l'interruzione
2688 Errore in lettura: Connection timed out
2689 \end{verbatim}%$
2690 che corrisponde appunto, come ci aspettavamo, alla ricezione di un
2691 \errcode{ETIMEDOUT}.
2692
2693 Analizziamo ora il secondo scenario, in cui si ha un crollo della macchina che
2694 fa da server. Al solito lanciamo il nostro client, scriviamo una prima riga
2695 per verificare che sia tutto a posto, poi stacchiamo il cavo e riavviamo il
2696 server. A questo punto, ritornato attivo il server, scriviamo una seconda
2697 riga. Quello che otterremo in questo caso è:
2698 \begin{verbatim}
2699 [piccardi@gont sources]$ ./echo 192.168.1.141
2700 Prima riga
2701 Prima riga
2702 Seconda riga dopo l'interruzione
2703 Errore in lettura Connection reset by peer
2704 \end{verbatim}%$
2705 e l'errore ricevuti da \func{read} stavolta è \errcode{ECONNRESET}. Se al
2706 solito riportiamo l'analisi dei pacchetti effettuata con \cmd{tcpdump},
2707 avremo:
2708 \begin{verbatim}
2709 [root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
2710 tcpdump: listening on eth0
2711 gont.34756 > anarres.echo: S 904864257:904864257(0) win 5840 
2712 anarres.echo > gont.34756: S 4254564871:4254564871(0) ack 904864258 win 5792
2713 gont.34756 > anarres.echo: . ack 1 win 5840 
2714 gont.34756 > anarres.echo: P 1:12(11) ack 1 win 5840
2715 anarres.echo > gont.34756: . ack 12 win 5792 
2716 anarres.echo > gont.34756: P 1:12(11) ack 12 win 5792
2717 gont.34756 > anarres.echo: . ack 12 win 5840 
2718 gont.34756 > anarres.echo: P 12:45(33) ack 12 win 5840
2719 anarres.echo > gont.34756: R 4254564883:4254564883(0) win 0 
2720 \end{verbatim}
2721
2722 Ancora una volta i primi sette pacchetti sono gli stessi; ma in questo caso
2723 quello che succede dopo lo scambio iniziale è che, non avendo inviato nulla
2724 durante il periodo in cui si è riavviato il server, il client è del tutto
2725 ignaro dell'accaduto per cui quando effettuerà una scrittura, dato che la
2726 macchina server è stata riavviata e che tutti gli stati relativi alle
2727 precedenti connessioni sono completamente persi, anche in presenza di una
2728 nuova istanza del server echo non sarà possibile consegnare i dati in arrivo,
2729 per cui alla loro ricezione il kernel risponderà con un segmento di RST.
2730
2731 Il client da parte sua, dato che neanche in questo caso non è stato emesso un
2732 FIN, dopo aver scritto verrà bloccato nella successiva chiamata a \func{read},
2733 che però adesso ritornerà immediatamente alla ricezione del segmento RST,
2734 riportando appunto come errore \errcode{ECONNRESET}. Occorre precisare che se
2735 si vuole che il client sia in grado di accorgersi del crollo del server anche
2736 quando non sta effettuando uno scambio di dati, è possibile usare una
2737 impostazione speciale del socket (ci torneremo in
2738 sez.~\ref{sec:sock_generic_options}) che provvede all'esecuzione di questo
2739 controllo.
2740
2741
2742 \section{L'uso dell'I/O multiplexing}
2743 \label{sec:TCP_sock_multiplexing}
2744
2745 Affronteremo in questa sezione l'utilizzo dell'I/O multiplexing, affrontato in
2746 sez.~\ref{sec:file_multiplexing}, nell'ambito delle applicazioni di rete. Già
2747 in sez.~\ref{sec:TCP_server_crash} era emerso il problema relativo al client
2748 del servizio echo che non era in grado di accorgersi della terminazione
2749 precoce del server, essendo bloccato nella lettura dei dati immessi da
2750 tastiera.
2751
2752 Abbiamo visto in sez.~\ref{sec:file_multiplexing} quali sono le funzionalità
2753 del sistema che ci permettono di tenere sotto controllo più file descriptor in
2754 contemporanea; in quella occasione non abbiamo fatto esempi, in quanto quando
2755 si tratta con file normali questa tipologia di I/O normalmente non viene
2756 usata, è invece un caso tipico delle applicazioni di rete quello di dover
2757 gestire varie connessioni da cui possono arrivare dati comuni in maniera
2758 asincrona, per cui riprenderemo l'argomento in questa sezione.
2759
2760
2761 \subsection{Il comportamento della funzione \func{select} con i socket.}
2762 \label{sec:TCP_sock_select}
2763
2764 Iniziamo con la prima delle funzioni usate per l'I/O multiplexing,
2765 \func{select}; il suo funzionamento è già stato descritto in dettaglio in
2766 sez.~\ref{sec:file_multiplexing} e non staremo a ripetere quanto detto lì; 
2767 sappiamo che la funzione ritorna quando uno o più dei file descriptor messi
2768 sotto controllo è pronto per la relativa operazione.
2769
2770 In quell'occasione non abbiamo però definito cosa si intende per pronto,
2771 infatti per dei normali file, o anche per delle \textit{pipe}, la condizione
2772 di essere pronti per la lettura o la scrittura è ovvia; invece lo è molto meno
2773 nel caso dei socket, visto che possono intervenire tutte una serie di
2774 possibili condizioni di errore dovute alla rete. Occorre allora specificare
2775 chiaramente quali sono le condizioni per cui un socket risulta essere
2776 ``\textsl{pronto}'' quando viene passato come membro di uno dei tre
2777 \textit{file descriptor set} usati da \func{select}.
2778
2779 Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
2780 che un socket (che sarà riportato nel primo insieme di file descriptor) è
2781 pronto per la lettura sono le seguenti:
2782 \begin{itemize*}
2783 \item nel buffer di ricezione del socket sono arrivati dei dati in quantità
2784   sufficiente a superare il valore di una \textsl{soglia di basso livello} (il
2785   cosiddetto \textit{low watermark}). Questo valore è espresso in numero di
2786   byte e può essere impostato con l'opzione del socket \const{SO\_RCVLOWAT}
2787   (tratteremo l'uso di questa opzione in sez.~\ref{sec:sock_generic_options});
2788   il suo valore di default è 1 per i socket TCP e UDP. In questo caso una
2789   operazione di lettura avrà successo e leggerà un numero di byte maggiore di
2790   zero.
2791 \item il lato in lettura della connessione è stato chiuso; si è cioè ricevuto
2792   un segmento FIN (si ricordi quanto illustrato in
2793   sez.~\ref{sec:TCP_conn_term}) sulla connessione. In questo caso una
2794   operazione di lettura avrà successo, ma non risulteranno presenti dati (in
2795   sostanza \func{read} ritornerà con un valore nullo) per indicare la
2796   condizione di end-of-file.
2797 \item c'è stato un errore sul socket. In questo caso una operazione di lettura
2798   non si bloccherà ma restituirà una condizione di errore (ad esempio
2799   \func{read} restituirà -1) e imposterà la variabile \var{errno} al relativo
2800   valore. Vedremo in sez.~\ref{sec:sock_generic_options} come sia possibile
2801   estrarre e cancellare gli errori pendenti su un socket senza usare
2802   \func{read} usando l'opzione \const{SO\_ERROR}.
2803 \item quando si sta utilizzando un \textit{listening socket} ed ci sono delle
2804   connessioni completate. In questo caso la funzione \func{accept} non si
2805   bloccherà.\footnote{in realtà questo non è sempre vero, come accennato in
2806     sez.~\ref{sec:TCP_conn_early_abort} una connessione può essere abortita
2807     dalla ricezione di un segmento RST una volta che è stata completata,
2808     allora se questo avviene dopo che \func{select} è ritornata, ma prima
2809     della chiamata ad \func{accept}, quest'ultima, in assenza di altre
2810     connessioni, potrà bloccarsi.}
2811 \end{itemize*}
2812
2813 Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
2814 che un socket (che sarà riportato nel secondo insieme di file descriptor) è
2815 pronto per la scrittura sono le seguenti:
2816 \begin{itemize*}
2817 \item nel buffer di invio è disponibile una quantità di spazio superiore al
2818   valore della \textsl{soglia di basso livello} in scrittura ed inoltre o il
2819   socket è già connesso o non necessita (ad esempio è UDP) di connessione.  Il
2820   valore della soglia è espresso in numero di byte e può essere impostato con
2821   l'opzione del socket \const{SO\_SNDLOWAT} (trattata in
2822   sez.~\ref{sec:sock_generic_options}); il suo valore di default è 2048 per i
2823   socket TCP e UDP. In questo caso una operazione di scrittura non si
2824   bloccherà e restituirà un valore positivo pari al numero di byte accettati
2825   dal livello di trasporto.
2826 \item il lato in scrittura della connessione è stato chiuso. In questo caso
2827   una operazione di scrittura sul socket genererà il segnale \signal{SIGPIPE}.
2828 \item c'è stato un errore sul socket. In questo caso una operazione di
2829   scrittura non si bloccherà ma restituirà una condizione di errore ed
2830   imposterà opportunamente la variabile \var{errno}. Vedremo in
2831   sez.~\ref{sec:sock_generic_options} come sia possibile estrarre e cancellare
2832   errori pendenti su un socket usando l'opzione \const{SO\_ERROR}.
2833 \end{itemize*}
2834
2835 Infine c'è una sola condizione che fa si che \func{select} ritorni segnalando
2836 che un socket (che sarà riportato nel terzo insieme di file descriptor) ha una
2837 condizione di eccezione pendente, e cioè la ricezione sul socket di
2838 \textsl{dati urgenti} (o \itindex{out-of-band} \textit{out-of-band}), una
2839 caratteristica specifica dei socket TCP su cui torneremo in
2840 sez.~\ref{sec:TCP_urgent_data}.
2841
2842 Si noti come nel caso della lettura \func{select} si applichi anche ad
2843 operazioni che non hanno nulla a che fare con l'I/O di dati come il
2844 riconoscimento della presenza di connessioni pronte, in modo da consentire
2845 anche l'utilizzo di \func{accept} in modalità non bloccante. Si noti infine
2846 come in caso di errore un socket venga sempre riportato come pronto sia per la
2847 lettura che per la scrittura.
2848
2849 Lo scopo dei due valori di soglia per i buffer di ricezione e di invio è
2850 quello di consentire maggiore flessibilità nell'uso di \func{select} da parte
2851 dei programmi, se infatti si sa che una applicazione non è in grado di fare
2852 niente fintanto che non può ricevere o inviare una certa quantità di dati, si
2853 possono utilizzare questi valori per far si che \func{select} ritorni solo
2854 quando c'è la certezza di avere dati a sufficienza.\footnote{questo tipo di
2855   controllo è utile di norma solo per la lettura, in quanto in genere le
2856   operazioni di scrittura sono già controllate dall'applicazione, che sa
2857   sempre quanti dati invia, mentre non è detto possa conoscere la quantità di
2858   dati in ricezione; per cui, nella situazione in cui si conosce almeno un
2859   valore minimo, per evitare la penalizzazione dovuta alla ripetizione delle
2860   operazioni di lettura per accumulare dati sufficienti, si può lasciare al
2861   kernel il compito di impostare un minimo al di sotto del quale il socket,
2862   pur avendo disponibili dei dati, non viene dato per pronto in lettura.}
2863
2864
2865
2866 \subsection{Un esempio di I/O multiplexing}
2867 \label{sec:TCP_multiplex_example}
2868
2869 Abbiamo incontrato la problematica tipica che conduce all'uso dell'I/O
2870 multiplexing nella nostra analisi degli errori in
2871 sez.~\ref{sec:TCP_conn_early_abort}, quando il nostro client non era in grado
2872 di rendersi conto di errori sulla connessione essendo impegnato nella attesa
2873 di dati in ingresso dallo standard input.
2874
2875 In questo caso il problema è quello di dover tenere sotto controllo due
2876 diversi file descriptor, lo standard input, da cui viene letto il testo che
2877 vogliamo inviare al server, e il socket connesso con il server su cui detto
2878 testo sarà scritto e dal quale poi si vorrà ricevere la risposta. L'uso
2879 dell'I/O multiplexing consente di tenere sotto controllo entrambi, senza
2880 restare bloccati.
2881
2882 Nel nostro caso quello che ci interessa è non essere bloccati in lettura sullo
2883 standard input in caso di errori sulla connessione o chiusura della stessa da
2884 parte del server. Entrambi questi casi possono essere rilevati usando
2885 \func{select}, per quanto detto in sez.~\ref{sec:TCP_sock_select}, mettendo
2886 sotto osservazione i file descriptor per la condizione di essere pronti in
2887 lettura: sia infatti che si ricevano dati, che la connessione sia chiusa
2888 regolarmente (con la ricezione di un segmento FIN) che si riceva una
2889 condizione di errore (con un segmento RST) il socket connesso sarà pronto in
2890 lettura (nell'ultimo caso anche in scrittura, ma questo non è necessario ai
2891 nostri scopi).
2892
2893 \begin{figure}[!htbp]
2894   \footnotesize \centering
2895   \begin{minipage}[c]{\codesamplewidth}
2896     \includecodesample{listati/ClientEcho_third.c}
2897   \end{minipage} 
2898   \normalsize
2899   \caption{La sezione nel codice della terza versione della funzione
2900     \func{ClientEcho} usata dal client per il servizio \textit{echo}
2901     modificata per l'uso di \func{select}.}
2902   \label{fig:TCP_ClientEcho_third}
2903 \end{figure}
2904
2905 Riprendiamo allora il codice del client, modificandolo per l'uso di
2906 \func{select}. Quello che dobbiamo modificare è la funzione \func{ClientEcho}
2907 di fig.~\ref{fig:TCP_ClientEcho_second}, dato che tutto il resto, che riguarda
2908 le modalità in cui viene stabilita la connessione con il server, resta
2909 assolutamente identico. La nostra nuova versione di \func{ClientEcho}, la
2910 terza della serie, è riportata in fig.~\ref{fig:TCP_ClientEcho_third}, il
2911 codice completo si trova nel file \file{TCP\_echo\_third.c} dei sorgenti
2912 allegati alla guida.
2913
2914 In questo caso la funzione comincia (\texttt{\small 8--9}) con l'azzeramento
2915 del \textit{file descriptor set} \var{fset} e l'impostazione del valore
2916 \var{maxfd}, da passare a \func{select} come massimo per il numero di file
2917 descriptor. Per determinare quest'ultimo si usa la macro \code{max} definita
2918 nel nostro file \file{macro.h} che raccoglie una collezione di macro di
2919 preprocessore di varia utilità.
2920
2921 La funzione prosegue poi (\texttt{\small 10--41}) con il ciclo principale, che
2922 viene ripetuto indefinitamente. Per ogni ciclo si reinizializza
2923 (\texttt{\small 11--12}) il \textit{file descriptor set}, impostando i valori
2924 per il file descriptor associato al socket \var{socket} e per lo standard
2925 input (il cui valore si recupera con la funzione \func{fileno}). Questo è
2926 necessario in quanto la successiva (\texttt{\small 13}) chiamata a
2927 \func{select} comporta una modifica dei due bit relativi, che quindi devono
2928 essere reimpostati all'inizio di ogni ciclo.
2929
2930 Si noti come la chiamata a \func{select} venga eseguita usando come primo
2931 argomento il valore di \var{maxfd}, precedentemente calcolato, e passando poi
2932 il solo \textit{file descriptor set} per il controllo dell'attività in
2933 lettura, negli altri argomenti sono passati tutti puntatori nulli, non
2934 interessando né il controllo delle altre attività, né l'impostazione di un
2935 valore di timeout.
2936
2937 Al ritorno di \func{select} si provvede a controllare quale dei due file
2938 descriptor presenta attività in lettura, cominciando (\texttt{\small 14--24})
2939 con il file descriptor associato allo standard input. In caso di attività
2940 (quando cioè \macro{FD\_ISSET} ritorna una valore diverso da zero) si esegue
2941 (\texttt{\small 15}) una \func{fgets} per leggere gli eventuali dati presenti;
2942 se non ve ne sono (e la funzione restituisce pertanto un puntatore nullo) si
2943 ritorna immediatamente (\texttt{\small 16}) dato che questo significa che si è
2944 chiuso lo standard input e quindi concluso l'utilizzo del client; altrimenti
2945 (\texttt{\small 18--22}) si scrivono i dati appena letti sul socket,
2946 prevedendo una uscita immediata in caso di errore di scrittura.
2947
2948 Controllato lo standard input si passa a controllare (\texttt{\small 25--40})
2949 il socket connesso, in caso di attività (\texttt{\small 26}) si esegue subito
2950 una \func{read} di cui si controlla il valore di ritorno; se questo è negativo
2951 (\texttt{\small 27--30}) si è avuto un errore e pertanto si esce
2952 immediatamente segnalandolo, se è nullo (\texttt{\small 31--34}) significa che
2953 il server ha chiuso la connessione, e di nuovo si esce con stampando prima un
2954 messaggio di avviso, altrimenti (\texttt{\small 35--39}) si effettua la
2955 terminazione della stringa e la si stampa a sullo standard output (uscendo in
2956 caso di errore), per ripetere il ciclo da capo.
2957
2958 Con questo meccanismo il programma invece di essere bloccato in lettura sullo
2959 standard input resta bloccato sulla \func{select}, che ritorna soltanto quando
2960 viene rilevata attività su uno dei due file descriptor posti sotto controllo.
2961 Questo di norma avviene solo quando si è scritto qualcosa sullo standard
2962 input, o quando si riceve dal socket la risposta a quanto si era appena
2963 scritto. Ma adesso il client diventa capace di accorgersi immediatamente della
2964 terminazione del server; in tal caso infatti il server chiuderà il socket
2965 connesso, ed alla ricezione del FIN la funzione \func{select} ritornerà (come
2966 illustrato in sez.~\ref{sec:TCP_sock_select}) segnalando una condizione di end
2967 of file, per cui il nostro client potrà uscire immediatamente.
2968
2969 Riprendiamo la situazione affrontata in sez.~\ref{sec:TCP_server_crash},
2970 terminando il server durante una connessione, in questo caso quello che
2971 otterremo, una volta scritta una prima riga ed interrotto il server con un
2972 \texttt{C-c}, sarà:
2973 \begin{verbatim}
2974 [piccardi@gont sources]$ ./echo 192.168.1.1
2975 Prima riga
2976 Prima riga
2977 EOF sul socket
2978 \end{verbatim}%$
2979 dove l'ultima riga compare immediatamente dopo aver interrotto il server. Il
2980 nostro client infatti è in grado di accorgersi immediatamente che il socket
2981 connesso è stato chiuso ed uscire immediatamente.
2982
2983 Veniamo allora agli altri scenari di terminazione anomala visti in
2984 sez.~\ref{sec:TCP_conn_crash}. Il primo di questi è l'interruzione fisica della
2985 connessione; in questo caso avremo un comportamento analogo al precedente, in
2986 cui si scrive una riga e non si riceve risposta dal server e non succede
2987 niente fino a quando non si riceve un errore di \errcode{EHOSTUNREACH} o
2988 \errcode{ETIMEDOUT} a seconda dei casi.
2989
2990 La differenza è che stavolta potremo scrivere più righe dopo l'interruzione,
2991 in quanto il nostro client dopo aver inviato i dati non si bloccherà più nella
2992 lettura dal socket, ma nella \func{select}; per questo potrà accettare
2993 ulteriore dati che scriverà di nuovo sul socket, fintanto che c'è spazio sul
2994 buffer di uscita (ecceduto il quale si bloccherà in scrittura). Si ricordi
2995 infatti che il client non ha modo di determinare se la connessione è attiva o
2996 meno (dato che in molte situazioni reali l'inattività può essere temporanea).
2997 Tra l'altro se si ricollega la rete prima della scadenza del timeout, potremo
2998 anche verificare come tutto quello che si era scritto viene poi effettivamente
2999 trasmesso non appena la connessione ridiventa attiva, per cui otterremo
3000 qualcosa del tipo:
3001 \begin{verbatim}
3002 [piccardi@gont sources]$ ./echo 192.168.1.1
3003 Prima riga
3004 Prima riga
3005 Seconda riga dopo l'interruzione
3006 Terza riga
3007 Quarta riga
3008 Seconda riga dopo l'interruzione
3009 Terza riga
3010 Quarta riga
3011 \end{verbatim}
3012 in cui, una volta riconnessa la rete, tutto quello che abbiamo scritto durante
3013 il periodo di disconnessione restituito indietro e stampato immediatamente.
3014
3015 Lo stesso comportamento visto in sez.~\ref{sec:TCP_server_crash} si riottiene
3016 nel caso di un crollo completo della macchina su cui sta il server. In questo
3017 caso di nuovo il client non è in grado di accorgersi di niente dato che si
3018 suppone che il programma server non venga terminato correttamente, ma si
3019 blocchi tutto senza la possibilità di avere l'emissione di un segmento FIN che
3020 segnala la terminazione della connessione. Di nuovo fintanto che la
3021 connessione non si riattiva (con il riavvio della macchina del server) il
3022 client non è in grado di fare altro che accettare dell'input e tentare di
3023 inviarlo. La differenza in questo caso è che non appena la connessione
3024 ridiventa attiva i dati verranno sì trasmessi, ma essendo state perse tutte le
3025 informazioni relative alle precedenti connessioni ai tentativi di scrittura
3026 del client sarà risposto con un segmento RST che provocherà il ritorno di
3027 \func{select} per la ricezione di un errore di \errcode{ECONNRESET}.
3028
3029
3030 \subsection{La funzione \func{shutdown}}
3031 \label{sec:TCP_shutdown}
3032
3033 Come spiegato in sez.~\ref{sec:TCP_conn_term} il procedimento di chiusura di un
3034 socket TCP prevede che da entrambe le parti venga emesso un segmento FIN. È
3035 pertanto del tutto normale dal punto di vista del protocollo che uno dei due
3036 capi chiuda la connessione, quando l'altro capo la lascia
3037 aperta.\footnote{abbiamo incontrato questa situazione nei vari scenari critici
3038   di sez.~\ref{sec:TCP_echo_critical}.}
3039
3040 È pertanto possibile avere una situazione in cui un capo della connessione non
3041 avendo più nulla da scrivere, possa chiudere il socket, segnalando così
3042 l'avvenuta terminazione della trasmissione (l'altro capo riceverà infatti un
3043 end-of-file in lettura) mentre dall'altra parte si potrà proseguire la
3044 trasmissione dei dati scrivendo sul socket che da quel lato è ancora aperto.
3045 Questa è quella situazione in cui si dice che il socket è \textit{half
3046   closed}.
3047
3048 Il problema che si pone è che se la chiusura del socket è effettuata con la
3049 funzione \func{close}, come spiegato in sez.~\ref{sec:TCP_func_close}, si perde
3050 ogni possibilità di poter rileggere quanto l'altro capo può continuare a
3051 scrivere. Per poter permettere allora di segnalare che si è concluso con la
3052 scrittura, continuando al contempo a leggere quanto può provenire dall'altro
3053 capo del socket si può allora usare la funzione \funcd{shutdown}, il cui
3054 prototipo è:
3055 \begin{prototype}{sys/socket.h}
3056 {int shutdown(int sockfd, int how)}
3057
3058 Chiude un lato della connessione fra due socket.
3059   
3060   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
3061     errore, nel qual caso \var{errno} assumerà i valori:
3062   \begin{errlist}
3063   \item[\errcode{ENOTSOCK}] il file descriptor non corrisponde a un socket.
3064   \item[\errcode{ENOTCONN}] il socket non è connesso.
3065   \end{errlist}
3066   ed inoltre \errval{EBADF}.}
3067 \end{prototype}
3068
3069 La funzione prende come primo argomento il socket \param{sockfd} su cui si
3070 vuole operare e come secondo argomento un valore intero \param{how} che indica
3071 la modalità di chiusura del socket, quest'ultima può prendere soltanto tre
3072 valori: 
3073 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
3074 \item[\const{SHUT\_RD}] chiude il lato in lettura del socket, non sarà più
3075   possibile leggere dati da esso, tutti gli eventuali dati trasmessi
3076   dall'altro capo del socket saranno automaticamente scartati dal kernel, che,
3077   in caso di socket TCP, provvederà comunque ad inviare i relativi segmenti di
3078   ACK.
3079 \item[\const{SHUT\_WR}] chiude il lato in scrittura del socket, non sarà più
3080   possibile scrivere dati su di esso. Nel caso di socket TCP la chiamata causa
3081   l'emissione di un segmento FIN, secondo la procedura chiamata
3082   \itindex{half-close} \textit{half-close}. Tutti i dati presenti nel buffer
3083   di scrittura prima della chiamata saranno inviati, seguiti dalla sequenza di
3084   chiusura illustrata in sez.~\ref{sec:TCP_conn_term}.
3085 \item[\const{SHUT\_RDWR}] chiude sia il lato in lettura che quello in
3086   scrittura del socket. È equivalente alla chiamata in sequenza con
3087   \const{SHUT\_RD} e \const{SHUT\_WR}.
3088 \end{basedescript}
3089
3090 Ci si può chiedere quale sia l'utilità di avere introdotto \const{SHUT\_RDWR}
3091 quando questa sembra rendere \funcd{shutdown} del tutto equivalente ad una
3092 \func{close}. In realtà non è così, esiste infatti un'altra differenza con
3093 \func{close}, più sottile. Finora infatti non ci siamo presi la briga di
3094 sottolineare in maniera esplicita che, come per i file e le fifo, anche per i
3095 socket possono esserci più riferimenti contemporanei ad uno stesso socket. Per
3096 cui si avrebbe potuto avere l'impressione che sia una corrispondenza univoca
3097 fra un socket ed il file descriptor con cui vi si accede. Questo non è
3098 assolutamente vero, (e lo abbiamo già visto nel codice del server di
3099 fig.~\ref{fig:TCP_echo_server_first_code}), ed è invece assolutamente normale
3100 che, come per gli altri oggetti, ci possano essere più file descriptor che
3101 fanno riferimento allo stesso socket.
3102
3103 Allora se avviene uno di questi casi quello che succederà è che la chiamata a
3104 \func{close} darà effettivamente avvio alla sequenza di chiusura di un socket
3105 soltanto quando il numero di riferimenti a quest'ultimo diventerà nullo.
3106 Fintanto che ci sono file descriptor che fanno riferimento ad un socket l'uso
3107 di \func{close} si limiterà a deallocare nel processo corrente il file
3108 descriptor utilizzato, ma il socket resterà pienamente accessibile attraverso
3109 tutti gli altri riferimenti. Se torniamo all'esempio originale del server di
3110 fig.~\ref{fig:TCP_echo_server_first_code} abbiamo infatti che ci sono due
3111 \func{close}, una sul socket connesso nel padre, ed una sul socket in ascolto
3112 nel figlio, ma queste non effettuano nessuna chiusura reale di detti socket,
3113 dato che restano altri riferimenti attivi, uno al socket connesso nel figlio
3114 ed uno a quello in ascolto nel padre.
3115
3116 Questo non avviene affatto se si usa \func{shutdown} con argomento
3117 \const{SHUT\_RDWR} al posto di \func{close}; in questo caso infatti la
3118 chiusura del socket viene effettuata immediatamente, indipendentemente dalla
3119 presenza di altri riferimenti attivi, e pertanto sarà efficace anche per tutti
3120 gli altri file descriptor con cui, nello stesso o in altri processi, si fa
3121 riferimento allo stesso socket.
3122
3123 Il caso più comune di uso di \func{shutdown} è comunque quello della chiusura
3124 del lato in scrittura, per segnalare all'altro capo della connessione che si è
3125 concluso l'invio dei dati, restando comunque in grado di ricevere quanto
3126 questi potrà ancora inviarci. Questo è ad esempio l'uso che ci serve per
3127 rendere finalmente completo il nostro esempio sul servizio \textit{echo}. Il
3128 nostro client infatti presenta ancora un problema, che nell'uso che finora ne
3129 abbiamo fatto non è emerso, ma che ci aspetta dietro l'angolo non appena
3130 usciamo dall'uso interattivo e proviamo ad eseguirlo redirigendo standard
3131 input e standard output. Così se eseguiamo:
3132 \begin{verbatim}
3133 [piccardi@gont sources]$ ./echo 192.168.1.1 < ../fileadv.tex  > copia
3134 \end{verbatim}%$
3135 vedremo che il file \texttt{copia} risulta mancare della parte finale.
3136
3137 Per capire cosa avviene in questo caso occorre tenere presente come avviene la
3138 comunicazione via rete; quando redirigiamo lo standard input il nostro client
3139 inizierà a leggere il contenuto del file \texttt{../fileadv.tex} a blocchi di
3140 dimensione massima pari a \texttt{MAXLINE} per poi scriverlo, alla massima
3141 velocità consentitagli dalla rete, sul socket. Dato che la connessione è con
3142 una macchina remota occorre un certo tempo perché i pacchetti vi arrivino,
3143 vengano processati, e poi tornino indietro. Considerando trascurabile il tempo
3144 di processo, questo tempo è quello impiegato nella trasmissione via rete, che
3145 viene detto RTT (dalla denominazione inglese \itindex{Round~Trip~Time~(RTT)}
3146 \textit{Round Trip Time}) ed è quello che viene stimato con l'uso del comando
3147 \cmd{ping}.
3148
3149 A questo punto, se torniamo al codice mostrato in
3150 fig.~\ref{fig:TCP_ClientEcho_third}, possiamo vedere che mentre i pacchetti
3151 sono in transito sulla rete il client continua a leggere e a scrivere fintanto
3152 che il file in ingresso finisce. Però non appena viene ricevuto un end-of-file
3153 in ingresso il nostro client termina. Nel caso interattivo, in cui si
3154 inviavano brevi stringhe una alla volta, c'era sempre il tempo di eseguire la
3155 lettura completa di quanto il server rimandava indietro. In questo caso
3156 invece, quando il client termina, essendo la comunicazione saturata e a piena
3157 velocità, ci saranno ancora pacchetti in transito sulla rete che devono
3158 arrivare al server e poi tornare indietro, ma siccome il client esce
3159 immediatamente dopo la fine del file in ingresso, questi non faranno a tempo a
3160 completare il percorso e verranno persi.
3161
3162 Per evitare questo tipo di problema, invece di uscire una volta completata la
3163 lettura del file in ingresso, occorre usare \func{shutdown} per effettuare la
3164 chiusura del lato in scrittura del socket. In questo modo il client segnalerà
3165 al server la chiusura del flusso dei dati, ma potrà continuare a leggere
3166 quanto il server gli sta ancora inviando indietro, fino a quando anch'esso,
3167 riconosciuta la chiusura del socket in scrittura da parte del client,
3168 effettuerà la chiusura dalla sua parte. Solo alla ricezione della chiusura del
3169 socket da parte del server il client potrà essere sicuro della ricezione di
3170 tutti i dati e della terminazione effettiva della connessione.
3171
3172 \begin{figure}[!htbp]
3173   \footnotesize \centering
3174   \begin{minipage}[c]{\codesamplewidth}
3175     \includecodesample{listati/ClientEcho.c}
3176   \end{minipage} 
3177   \normalsize
3178   \caption{La sezione nel codice della versione finale della funzione
3179     \func{ClientEcho}, che usa \func{shutdown} per una conclusione corretta
3180     della connessione.}
3181   \label{fig:TCP_ClientEcho}
3182 \end{figure}
3183
3184 Si è allora riportato in fig.~\ref{fig:TCP_ClientEcho} la versione finale
3185 della nostra funzione \func{ClientEcho}, in grado di gestire correttamente
3186 l'intero flusso di dati fra client e server. Il codice completo del client,
3187 comprendente la gestione delle opzioni a riga di comando e le istruzioni per
3188 la creazione della connessione, si trova nel file
3189 \texttt{TCP\_echo\_fourth.c}, distribuito coi sorgenti allegati alla guida.
3190
3191 La nuova versione è molto simile alla precedente di
3192 fig.~\ref{fig:TCP_ClientEcho_third}; la prima differenza è l'introduzione
3193 (\texttt{\small 7}) della variabile \var{eof}, inizializzata ad un valore
3194 nullo, che serve a mantenere traccia dell'avvenuta conclusione della lettura
3195 del file in ingresso.
3196
3197 La seconda modifica (\texttt{\small 12--15}) è stata quella di rendere
3198 subordinato ad un valore nullo di \var{eof} l'impostazione del file descriptor
3199 set per l'osservazione dello standard input. Se infatti il valore di \var{eof}
3200 è non nullo significa che si è già raggiunta la fine del file in ingresso ed è
3201 pertanto inutile continuare a tenere sotto controllo lo standard input nella
3202 successiva (\texttt{\small 16}) chiamata a \func{select}.
3203
3204 Le maggiori modifiche rispetto alla precedente versione sono invece nella
3205 gestione (\texttt{\small 18--22}) del caso in cui la lettura con \func{fgets}
3206 restituisce un valore nullo, indice della fine del file. Questa nella
3207 precedente versione causava l'immediato ritorno della funzione; in questo caso
3208 prima (\texttt{\small 19}) si imposta opportunamente \var{eof} ad un valore
3209 non nullo, dopo di che (\texttt{\small 20}) si effettua la chiusura del lato
3210 in scrittura del socket con \func{shutdown}. Infine (\texttt{\small 21}) si
3211 usa la macro \macro{FD\_CLR} per togliere lo standard input dal \textit{file
3212   descriptor set}.
3213
3214 In questo modo anche se la lettura del file in ingresso è conclusa, la
3215 funzione non esce dal ciclo principale (\texttt{\small 11--50}), ma continua
3216 ad eseguirlo ripetendo la chiamata a \func{select} per tenere sotto controllo
3217 soltanto il socket connesso, dal quale possono arrivare altri dati, che
3218 saranno letti (\texttt{\small 31}), ed opportunamente trascritti
3219 (\texttt{\small 44--48}) sullo standard output.
3220
3221 Il ritorno della funzione, e la conseguente terminazione normale del client,
3222 viene invece adesso gestito all'interno (\texttt{\small 30--49}) della lettura
3223 dei dati dal socket; se infatti dalla lettura del socket si riceve una
3224 condizione di end-of-file, la si tratterà (\texttt{\small 36--43}) in maniera
3225 diversa a seconda del valore di \var{eof}. Se infatti questa è diversa da zero
3226 (\texttt{\small 37--39}), essendo stata completata la lettura del file in
3227 ingresso, vorrà dire che anche il server ha concluso la trasmissione dei dati
3228 restanti, e si potrà uscire senza errori, altrimenti si stamperà
3229 (\texttt{\small 40--42}) un messaggio di errore per la chiusura precoce della
3230 connessione.
3231
3232
3233 \subsection{Un server basato sull'I/O multiplexing}
3234 \label{sec:TCP_serv_select}
3235
3236 Seguendo di nuovo le orme di Stevens in \cite{UNP1} vediamo ora come con
3237 l'utilizzo dell'I/O multiplexing diventi possibile riscrivere completamente il
3238 nostro server \textit{echo} con una architettura completamente diversa, in
3239 modo da evitare di dover creare un nuovo processo tutte le volte che si ha una
3240 connessione.\footnote{ne faremo comunque una implementazione diversa rispetto
3241   a quella presentata da Stevens in \cite{UNP1}.}
3242
3243 La struttura del nuovo server è illustrata in
3244 fig.~\ref{fig:TCP_echo_multiplex}, in questo caso avremo un solo processo che
3245 ad ogni nuova connessione da parte di un client sul socket in ascolto si
3246 limiterà a registrare l'entrata in uso di un nuovo file descriptor ed
3247 utilizzerà \func{select} per rilevare la presenza di dati in arrivo su tutti i
3248 file descriptor attivi, operando direttamente su ciascuno di essi.
3249
3250 \begin{figure}[!htb]
3251   \centering \includegraphics[width=13cm]{img/TCPechoMult}
3252   \caption{Schema del nuovo server echo basato sull'I/O multiplexing.}
3253   \label{fig:TCP_echo_multiplex}
3254 \end{figure}
3255
3256 La sezione principale del codice del nuovo server è illustrata in
3257 fig.~\ref{fig:TCP_SelectEchod}. Si è tralasciata al solito la gestione delle
3258 opzioni, che è identica alla versione precedente. Resta invariata anche tutta
3259 la parte relativa alla gestione dei segnali, degli errori, e della cessione
3260 dei privilegi, così come è identica la gestione della creazione del socket (si
3261 può fare riferimento al codice già illustrato in
3262 sez.~\ref{sec:TCPsimp_server_main}); al solito il codice completo del server è
3263 disponibile coi sorgenti allegati nel file \texttt{select\_echod.c}.
3264
3265 \begin{figure}[!htbp]
3266   \footnotesize \centering
3267   \begin{minipage}[c]{\codesamplewidth}
3268     \includecodesample{listati/select_echod.c}
3269   \end{minipage} 
3270   \normalsize
3271   \caption{La sezione principale del codice della nuova versione di server
3272     \textit{echo} basati sull'uso della funzione \func{select}.}
3273   \label{fig:TCP_SelectEchod}
3274 \end{figure}
3275
3276 In questo caso, una volta aperto e messo in ascolto il socket, tutto quello
3277 che ci servirà sarà chiamare \func{select} per rilevare la presenza di nuove
3278 connessioni o di dati in arrivo, e processarli immediatamente. Per
3279 implementare lo schema mostrato in fig.~\ref{fig:TCP_echo_multiplex}, il
3280 programma usa una tabella dei socket connessi mantenuta nel vettore
3281 \var{fd\_open} dimensionato al valore di \const{FD\_SETSIZE}, ed una variabile
3282 \var{max\_fd} per registrare il valore più alto dei file descriptor aperti.
3283
3284 Prima di entrare nel ciclo principale (\texttt{\small 6--56}) la nostra
3285 tabella viene inizializzata (\texttt{\small 2}) a zero (valore che
3286 utilizzeremo come indicazione del fatto che il relativo file descriptor non è
3287 aperto), mentre il valore massimo (\texttt{\small 3}) per i file descriptor
3288 aperti viene impostato a quello del socket in ascolto,\footnote{in quanto esso
3289   è l'unico file aperto, oltre i tre standard, e pertanto avrà il valore più
3290   alto.} che verrà anche (\texttt{\small 4}) inserito nella tabella.
3291
3292 La prima sezione (\texttt{\small 7--10}) del ciclo principale esegue la
3293 costruzione del \textit{file descriptor set} \var{fset} in base ai socket
3294 connessi in un certo momento; all'inizio ci sarà soltanto il socket in
3295 ascolto, ma nel prosieguo delle operazioni, verranno utilizzati anche tutti i
3296 socket connessi registrati nella tabella \var{fd\_open}.  Dato che la chiamata
3297 di \func{select} modifica il valore del \textit{file descriptor set}, è
3298 necessario ripetere (\texttt{\small 7}) ogni volta il suo azzeramento, per poi
3299 procedere con il ciclo (\texttt{\small 8--10}) in cui si impostano i socket
3300 trovati attivi.
3301
3302 Per far questo si usa la caratteristica dei file descriptor, descritta in
3303 sez.~\ref{sec:file_open_close}, per cui il kernel associa sempre ad ogni nuovo
3304 file il file descriptor con il valore più basso disponibile. Questo fa sì che
3305 si possa eseguire il ciclo (\texttt{\small 8}) a partire da un valore minimo,
3306 che sarà sempre quello del socket in ascolto, mantenuto in \var{list\_fd},
3307 fino al valore massimo di \var{max\_fd} che dovremo aver cura di tenere
3308 aggiornato.  Dopo di che basterà controllare (\texttt{\small 9}) nella nostra
3309 tabella se il file descriptor è in uso o meno,\footnote{si tenga presente che
3310   benché il kernel assegni sempre il primo valore libero, dato che nelle
3311   operazioni i socket saranno aperti e chiusi in corrispondenza della
3312   creazione e conclusione delle connessioni, si potranno sempre avere dei
3313   \textsl{buchi} nella nostra tabella.} e impostare \var{fset} di conseguenza.
3314
3315 Una volta inizializzato con i socket aperti il nostro \textit{file descriptor
3316   set} potremo chiamare \func{select} per fargli osservare lo stato degli
3317 stessi (in lettura, presumendo che la scrittura sia sempre consentita). Come
3318 per il precedente esempio di sez.~\ref{sec:TCP_child_hand}, essendo questa
3319 l'unica funzione che può bloccarsi, ed essere interrotta da un segnale, la
3320 eseguiremo (\texttt{\small 11--12}) all'interno di un ciclo di \code{while}
3321 che la ripete indefinitamente qualora esca con un errore di \errcode{EINTR}.
3322 Nel caso invece di un errore normale si provvede (\texttt{\small 13--16}) ad
3323 uscire stampando un messaggio di errore.
3324
3325 Se invece la funzione ritorna normalmente avremo in \var{n} il numero di
3326 socket da controllare. Nello specifico si danno due possibili casi diversi per
3327 cui \func{select} può essere ritornata: o si è ricevuta una nuova connessione
3328 ed è pronto il socket in ascolto, sul quale si può eseguire \func{accept} o
3329 c'è attività su uno dei socket connessi, sui quali si può eseguire
3330 \func{read}.
3331
3332 Il primo caso viene trattato immediatamente (\texttt{\small 17--26}): si
3333 controlla (\texttt{\small 17}) che il socket in ascolto sia fra quelli attivi,
3334 nel qual caso anzitutto (\texttt{\small 18}) se ne decrementa il numero in
3335 \var{n}; poi, inizializzata (\texttt{\small 19}) la lunghezza della struttura
3336 degli indirizzi, si esegue \func{accept} per ottenere il nuovo socket connesso
3337 controllando che non ci siano errori (\texttt{\small 20--23}). In questo caso
3338 non c'è più la necessità di controllare per interruzioni dovute a segnali, in
3339 quanto siamo sicuri che \func{accept} non si bloccherà. Per completare la
3340 trattazione occorre a questo punto aggiungere (\texttt{\small 24}) il nuovo
3341 file descriptor alla tabella di quelli connessi, ed inoltre, se è il caso,
3342 aggiornare (\texttt{\small 25}) il valore massimo in \var{max\_fd}.
3343
3344 Una volta controllato l'arrivo di nuove connessioni si passa a verificare se
3345 vi sono dati sui socket connessi, per questo si ripete un ciclo
3346 (\texttt{\small 29--55}) fintanto che il numero di socket attivi \var{n} resta
3347 diverso da zero; in questo modo se l'unico socket con attività era quello
3348 connesso, avendo opportunamente decrementato il contatore, il ciclo verrà
3349 saltato, e si ritornerà immediatamente (ripetuta l'inizializzazione del
3350 \textit{file descriptor set} con i nuovi valori nella tabella) alla chiamata
3351 di \func{accept}. Se il socket attivo non è quello in ascolto, o ce ne sono
3352 comunque anche altri, il valore di \var{n} non sarà nullo ed il controllo sarà
3353 eseguito. Prima di entrare nel ciclo comunque si inizializza (\texttt{\small
3354   28}) il valore della variabile \var{i} che useremo come indice nella tabella
3355 \var{fd\_open} al valore minimo, corrispondente al file descriptor del socket
3356 in ascolto.
3357
3358 Il primo passo (\texttt{\small 30}) nella verifica è incrementare il valore
3359 dell'indice \var{i} per posizionarsi sul primo valore possibile per un file
3360 descriptor associato ad un eventuale socket connesso, dopo di che si controlla
3361 (\texttt{\small 31}) se questo è nella tabella dei socket connessi, chiedendo
3362 la ripetizione del ciclo in caso contrario. Altrimenti si passa a verificare
3363 (\texttt{\small 32}) se il file descriptor corrisponde ad uno di quelli
3364 attivi, e nel caso si esegue (\texttt{\small 33}) una lettura, uscendo con un
3365 messaggio in caso di errore (\texttt{\small 34--38}).
3366
3367 Se (\texttt{\small 39}) il numero di byte letti \var{nread} è nullo si è in
3368 presenza del caso di un \textit{end-of-file}, indice che una connessione che
3369 si è chiusa, che deve essere trattato (\texttt{\small 39--48}) opportunamente.
3370 Il primo passo è chiudere (\texttt{\small 40}) anche il proprio capo del
3371 socket e rimuovere (\texttt{\small 41}) il file descriptor dalla tabella di
3372 quelli aperti, inoltre occorre verificare (\texttt{\small 42}) se il file
3373 descriptor chiuso è quello con il valore più alto, nel qual caso occorre
3374 trovare (\texttt{\small 42--46}) il nuovo massimo, altrimenti (\texttt{\small
3375   47}) si può ripetere il ciclo da capo per esaminare (se ne restano)
3376 ulteriori file descriptor attivi.
3377
3378 Se però è stato chiuso il file descriptor più alto, dato che la scansione dei
3379 file descriptor attivi viene fatta a partire dal valore più basso, questo
3380 significa che siamo anche arrivati alla fine della scansione, per questo
3381 possiamo utilizzare direttamente il valore dell'indice \var{i} con un ciclo
3382 all'indietro (\texttt{\small 43}) che trova il primo valore per cui la tabella
3383 presenta un file descriptor aperto, e lo imposta (\texttt{\small 44}) come
3384 nuovo massimo, per poi tornare (\texttt{\small 44}) al ciclo principale con un
3385 \code{break}, e rieseguire \func{select}.
3386
3387 Se infine si sono effettivamente letti dei dati dal socket (ultimo caso
3388 rimasto) si potrà invocare immediatamente (\texttt{\small 49})
3389 \func{FullWrite} per riscriverli indietro sul socket stesso, avendo cura di
3390 uscire con un messaggio in caso di errore (\texttt{\small 50--53}). Si noti
3391 che nel ciclo si esegue una sola lettura, contrariamente a quanto fatto con la
3392 precedente versione (si riveda il codice di fig.~\ref{fig:TCP_ServEcho_second})
3393 in cui si continuava a leggere fintanto che non si riceveva un
3394 \textit{end-of-file}, questo perché usando l'\textit{I/O multiplexing} non si
3395 vuole essere bloccati in lettura.  L'uso di \func{select} ci permette di
3396 trattare automaticamente anche il caso in cui la \func{read} non è stata in
3397 grado di leggere tutti i dati presenti sul socket, dato che alla iterazione
3398 successiva \func{select} ritornerà immediatamente segnalando l'ulteriore
3399 disponibilità.
3400
3401 Il nostro server comunque soffre di una vulnerabilità per un attacco di tipo
3402 \itindex{Denial~of~Service~(DoS)} \textit{Denial of Service}. Il problema è
3403 che in caso di blocco di una qualunque delle funzioni di I/O, non avendo usato
3404 processi separati, tutto il server si ferma e non risponde più a nessuna
3405 richiesta. Abbiamo scongiurato questa evenienza per l'I/O in ingresso con
3406 l'uso di \func{select}, ma non vale altrettanto per l'I/O in uscita. Il
3407 problema pertanto può sorgere qualora una delle chiamate a \func{write}
3408 effettuate da \func{FullWrite} si blocchi. Con il funzionamento normale questo
3409 non accade in quanto il server si limita a scrivere quanto riceve in ingresso,
3410 ma qualora venga utilizzato un client malevolo che esegua solo scritture e non
3411 legga mai indietro l'\textsl{eco} del server, si potrebbe giungere alla
3412 saturazione del buffer di scrittura, ed al conseguente blocco del server su di
3413 una \func{write}.
3414
3415 Le possibili soluzioni in questo caso sono quelle di ritornare ad eseguire il
3416 ciclo di risposta alle richieste all'interno di processi separati, utilizzare
3417 un timeout per le operazioni di scrittura, o eseguire queste ultime in
3418 modalità non bloccante, concludendo le operazioni qualora non vadano a buon
3419 fine.
3420
3421
3422
3423 \subsection{I/O multiplexing con \func{poll}}
3424 \label{sec:TCP_serv_poll}
3425
3426 Finora abbiamo trattato le problematiche risolubili con l'I/O multiplexing
3427 impiegando la funzione \func{select}; questo è quello che avviene nella
3428 maggior parte dei casi, in quanto essa è nata sotto BSD proprio per affrontare
3429 queste problematiche con i socket.  Abbiamo però visto in
3430 sez.~\ref{sec:file_multiplexing} come la funzione \func{poll} possa costituire
3431 una alternativa a \func{select}, con alcuni vantaggi.\footnote{non soffrendo
3432   delle limitazioni dovute all'uso dei \textit{file descriptor set}.}
3433
3434 Ancora una volta in sez.~\ref{sec:file_poll} abbiamo trattato la funzione in
3435 maniera generica, parlando di file descriptor, ma come per \func{select}
3436 quando si ha a che fare con dei socket il concetto di essere \textsl{pronti}
3437 per l'I/O deve essere specificato nei dettagli, per tener conto delle
3438 condizioni della rete. Inoltre deve essere specificato come viene classificato
3439 il traffico nella suddivisione fra dati normali e prioritari. In generale
3440 pertanto:
3441 \begin{itemize}
3442 \item i dati inviati su un socket vengono considerati traffico normale,
3443   pertanto vengono rilevati alla loro ricezione sull'altro capo da una
3444   selezione effettuata con \const{POLLIN} o \const{POLLRDNORM};
3445 \item i dati urgenti \itindex{out-of-band} \textit{out-of-band} (vedi
3446   sez.~\ref{sec:TCP_urgent_data}) su un socket TCP vengono considerati
3447   traffico prioritario e vengono rilevati da una condizione \const{POLLIN},
3448   \const{POLLPRI} o \const{POLLRDBAND}.
3449 \item la chiusura di una connessione (cioè la ricezione di un segmento FIN)
3450   viene considerato traffico normale, pertanto viene rilevato da una
3451   condizione \const{POLLIN} o \const{POLLRDNORM}, ma una conseguente chiamata
3452   a \func{read} restituirà 0.
3453 \item la disponibilità di spazio sul socket per la scrittura di dati viene
3454   segnalata con una condizione \const{POLLOUT}.
3455 \item quando uno dei due capi del socket chiude un suo lato della connessione
3456   con \func{shutdown} si riceve una condizione di \const{POLLHUP}.
3457 \item la presenza di un errore sul socket (sia dovuta ad un segmento RST che a
3458   timeout) viene considerata traffico normale, ma viene segnalata anche dalla
3459   condizione \const{POLLERR}.
3460 \item la presenza di una nuova connessione su un socket in ascolto può essere
3461   considerata sia traffico normale che prioritario, nel caso di Linux
3462   l'implementazione la classifica come normale.
3463 \end{itemize}
3464
3465 Come esempio dell'uso di \func{poll} proviamo allora a reimplementare il
3466 server \textit{echo} secondo lo schema di fig.~\ref{fig:TCP_echo_multiplex}
3467 usando \func{poll} al posto di \func{select}. In questo caso dovremo fare
3468 qualche modifica, per tenere conto della diversa sintassi delle due funzioni,
3469 ma la struttura del programma resta sostanzialmente la stessa.
3470
3471
3472 \begin{figure}[!htbp]
3473   \footnotesize \centering
3474   \begin{minipage}[c]{\codesamplewidth}
3475     \includecodesample{listati/poll_echod.c}
3476   \end{minipage} 
3477   \normalsize
3478   \caption{La sezione principale del codice della nuova versione di server
3479     \textit{echo} basati sull'uso della funzione \func{poll}.}
3480   \label{fig:TCP_PollEchod}
3481 \end{figure}
3482
3483 In fig.~\ref{fig:TCP_PollEchod} è riportata la sezione principale della nuova
3484 versione del server, la versione completa del codice è riportata nel file
3485 \texttt{poll\_echod.c} dei sorgenti allegati alla guida. Al solito nella
3486 figura si sono tralasciate la gestione delle opzioni, la creazione del socket
3487 in ascolto, la cessione dei privilegi e le operazioni necessarie a far
3488 funzionare il programma come demone, privilegiando la sezione principale del
3489 programma.
3490
3491 Come per il precedente server basato su \func{select} il primo passo
3492 (\texttt{\small 2--8}) è quello di inizializzare le variabili necessarie. Dato
3493 che in questo caso dovremo usare un vettore di strutture occorre anzitutto
3494 (\texttt{\small 2}) allocare la memoria necessaria utilizzando il numero
3495 massimo \var{n} di socket osservabili, che viene impostato attraverso
3496 l'opzione \texttt{-n} ed ha un valore di default di 256. 
3497
3498 Dopo di che si preimposta (\texttt{\small 3}) il valore \var{max\_fd} del file
3499 descriptor aperto con valore più alto a quello del socket in ascolto (al
3500 momento l'unico), e si provvede (\texttt{\small 4--7}) ad inizializzare le
3501 strutture, disabilitando (\texttt{\small 5}) l'osservazione con un valore
3502 negativo del campo \var{fd} ma predisponendo (\texttt{\small 6}) il campo
3503 \var{events} per l'osservazione dei dati normali con \const{POLLRDNORM}.
3504 Infine (\texttt{\small 8}) si attiva l'osservazione del socket in ascolto
3505 inizializzando la corrispondente struttura. Questo metodo comporta, in
3506 modalità interattiva, lo spreco di tre strutture (quelle relative a standard
3507 input, output ed error) che non vengono mai utilizzate in quanto la prima è
3508 sempre quella relativa al socket in ascolto.
3509
3510 Una volta completata l'inizializzazione tutto il lavoro viene svolto
3511 all'interno del ciclo principale \texttt{\small 10--55}) che ha una struttura
3512 sostanzialmente identica a quello usato per il precedente esempio basato su
3513 \func{select}. La prima istruzione (\texttt{\small 11--12}) è quella di
3514 eseguire \func{poll} all'interno di un ciclo che la ripete qualora venisse
3515 interrotta da un segnale, da cui si esce soltanto quando la funzione ritorna,
3516 restituendo nella variabile \var{n} il numero di file descriptor trovati
3517 attivi.  Qualora invece si sia ottenuto un errore si procede (\texttt{\small
3518   13--16}) alla terminazione immediata del processo provvedendo a stampare una
3519 descrizione dello stesso.
3520
3521 Una volta ottenuta dell'attività su un file descriptor si hanno di nuovo due
3522 possibilità. La prima possibilità è che ci sia attività sul socket in ascolto,
3523 indice di una nuova connessione, nel qual caso si controlla (\texttt{\small
3524   17}) se il campo \var{revents} della relativa struttura è attivo; se è così
3525 si provvede (\texttt{\small 18}) a decrementare la variabile \var{n} (che
3526 assume il significato di numero di file descriptor attivi rimasti da
3527 controllare) per poi (\texttt{\small 19--23}) effettuare la chiamata ad
3528 \func{accept}, terminando il processo in caso di errore. Se la chiamata ad
3529 \func{accept} ha successo si procede attivando (\texttt{\small 24}) la
3530 struttura relativa al nuovo file descriptor da essa ottenuto, modificando
3531 (\texttt{\small 24}) infine quando necessario il valore massimo dei file
3532 descriptor aperti mantenuto in \var{max\_fd}.