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