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